1426 lines
36 KiB
C++
1426 lines
36 KiB
C++
#pragma warning( push ,0)
|
||
#include"LisConvertor.h"
|
||
#include <QFileDialog>
|
||
#include <QTextStream>
|
||
|
||
#include "CStringType.h"
|
||
#include "MemRdWt.h"/*..\..\Slfio\*/
|
||
#include "BaseFun.h"
|
||
// #include "WellBaseInfo.h"
|
||
#include "DepthProgress.h"
|
||
#include "sub.h"
|
||
#include "qdir.h"
|
||
#define IREEL 0x0084
|
||
#define ITAPE 0x0082 //130
|
||
#define IFILE 0x0080 //128
|
||
#define IFORM 0x0040 //64
|
||
#define IDATA 0x0000
|
||
#define IFAIL 0x0081 //129
|
||
#define ITRAIL 0x0083 //131
|
||
#define IRAIL 0x0085 //133
|
||
#define ISL 0x42FF //17151
|
||
#define IDEP1 0x4954 //18772
|
||
#define IDEP2 0x454D // 17741
|
||
|
||
//20201216 GZL add
|
||
#define EACHCALNUM 1
|
||
//132 Vol.(REEL)_HEADER information
|
||
//133 Vol.(REEL)_TRAIL information
|
||
//130 TAPE_HEADER information
|
||
//131 TAPE_TRAIL information
|
||
//128 FILE_HEADER information
|
||
//129 FILE_TRAIL information
|
||
//232 COMMENT record information
|
||
//34 INFORMATION record information
|
||
//64 FORMAT SPECIFICATION record information
|
||
//0 data
|
||
float rlev,dep,sdep,edep;
|
||
char curvnms[3000][5],units[3000][5],depunit[5],levunit[5];
|
||
int ircodes[3000],npoints[3000],nsamps[3000],ipost[3000],iexst[3000],ndim[3000];
|
||
int ncurvs,lframe,nframe,modep;
|
||
FILE *fp;
|
||
int Numlog;
|
||
int skip,TapeRlev;
|
||
int neofbyte,ngapbyte;
|
||
unsigned char buff[400000];
|
||
float value[100000];
|
||
WELL_DYNAMIC_INFO *mWellDynamicInfo;
|
||
#pragma warning( pop)
|
||
BEGIN_OSGGRAPHICS_NAMESPACE;
|
||
#define GetLisConvertorTypeID() "{75B4CBA4-AF9D-4FEF-AA81-49CE697E158C}"
|
||
|
||
Slf_FILE_MESSAGE FILE_MESSAGE={};
|
||
|
||
BEGIN_REGISTER_ID_DESCRIPTION()
|
||
ID_ITEM_DATA(GetLisConvertorTypeID(),"LisConvertor")
|
||
END_REGISTER_ID_DESCRIPTION();
|
||
|
||
int intMax(int *arr, int arrnum){
|
||
int maxTemp = 0;
|
||
for(int i; i < arrnum; i++)
|
||
if (maxTemp < arr[i])
|
||
maxTemp = arr[i];
|
||
return maxTemp;
|
||
}
|
||
|
||
template<typename T1, typename T2>
|
||
void removeRedunant(T1& r_v, const T2 Re_v)
|
||
{
|
||
if(Re_v == 0) return;
|
||
bool isNeg = (r_v < 0) ? true : false;
|
||
r_v = float(int(abs(r_v) * Re_v + 0.5)) / Re_v;
|
||
r_v = (isNeg) ? -r_v : r_v;
|
||
}
|
||
|
||
template<typename OT1, typename IT2>
|
||
bool cal_SaveNumInf(const OT1 outsdep,const OT1 outedep,const OT1 outrlev, OT1 eachStartDep,IT2& value2Index,IT2& realSaveNum,OT1& saveStartDep)
|
||
{
|
||
removeRedunant(eachStartDep, 1000);
|
||
|
||
if(eachStartDep >outsdep-outrlev && eachStartDep <outedep+outrlev) //处于输出范围内
|
||
{
|
||
const int temp_MaxSaveNum = abs((outedep - eachStartDep) / outrlev) + 1.5; //最大容纳点数
|
||
realSaveNum = (realSaveNum > temp_MaxSaveNum) ? temp_MaxSaveNum : realSaveNum; //本轮可容纳点数
|
||
value2Index = 0; //从起始位置即可
|
||
saveStartDep = eachStartDep;
|
||
|
||
return true;
|
||
}
|
||
else if(eachStartDep < outsdep) //处于输出范围前侧
|
||
{
|
||
value2Index = abs((outsdep - eachStartDep) / outrlev); //范围内位置
|
||
|
||
if(value2Index <= realSaveNum) //包含有效数据
|
||
{
|
||
realSaveNum = realSaveNum - value2Index;
|
||
saveStartDep = outsdep;
|
||
|
||
return true;
|
||
}
|
||
else //不包含有效数据
|
||
{
|
||
realSaveNum = 0;
|
||
saveStartDep = outsdep;
|
||
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
CLisConvertor::CLisConvertor()
|
||
{
|
||
m_thisModuleName="LisConvertor";
|
||
isSpLis = false;
|
||
m_CurveData.Curve_Num=0;
|
||
m_CurveData.Curve_Step=0.0;
|
||
m_CurveData.Curve_StartDepth=0.0;
|
||
m_CurveData.Curver_EndDepth=0.0;
|
||
m_CurveData.Curver_MaxDim=0;
|
||
InitFormatSuffixName();
|
||
}
|
||
CLisConvertor::~CLisConvertor()
|
||
{
|
||
}
|
||
QVector<QString> CLisConvertor::GetSupportFileExtensions()
|
||
{
|
||
return m_vFileFormatSuffixName;
|
||
}
|
||
|
||
void CLisConvertor::InitFormatSuffixName()
|
||
{
|
||
m_vFileFormatSuffixName.clear();
|
||
m_vFileFormatSuffixName.push_back("lis");
|
||
m_vFileFormatSuffixName.push_back("dat");
|
||
m_vFileFormatSuffixName.push_back("nti");
|
||
QVector<QString> suffixname=InterIConvertor::GetSupportFileExtensions();
|
||
m_vFileFormatSuffixName+=suffixname;
|
||
}
|
||
|
||
int CLisConvertor::ScanLogFile(char *FileName,char *Message,char **CurveName,char **CurveUnit)
|
||
{
|
||
isSpLis = false;
|
||
char szTemp[128];
|
||
strcpy(szTemp, "[LIS]");
|
||
int pos1=GetBeginPosit(FileName,szTemp);
|
||
mWellDynamicInfo=&WellDynamicInfo;
|
||
if((fp=fopen(FileName,"rb"))==NULL) {
|
||
QMessageBox::information(NULL,FileName,"Open Not File:",QMessageBox::Ok);
|
||
return 0;
|
||
}
|
||
char path[256];
|
||
//CString TempPath=GetBinDir(path);;
|
||
CString TempPath=GetLogdataPath();
|
||
TempPath=TempPath+"\\Temp";
|
||
|
||
QDir *temp=new QDir;
|
||
bool bWorking=temp->exists(TempPath.GetString());
|
||
if(!bWorking)
|
||
{
|
||
bWorking=temp->mkdir(TempPath.GetString());
|
||
CString aaa;
|
||
aaa.Format("创建临时文件路径%s失败",TempPath);
|
||
if(!bWorking)
|
||
{
|
||
AfxMessageBox(aaa);
|
||
fclose(fp);
|
||
return -1;
|
||
}
|
||
}
|
||
delete temp;
|
||
CString te="\\";
|
||
TempPath+=te;
|
||
char filename[128];
|
||
sprintf(filename,"%stemp",TempPath.GetString());
|
||
//FILE *out;
|
||
//out=fopen(filename,"w+t");
|
||
int maxrl=8196 ;
|
||
float abstrv=-999.25;
|
||
|
||
char mbuf[5000];
|
||
//float value[100000];
|
||
int len=maxrl,idrt,lrtype;
|
||
//whp add 2019.8.6 for:后缀为dat的数据很多，首先根据LIS数据特征精确判断是否为LIS数据
|
||
QString ext;
|
||
ext=QString(QLatin1String(FileName));
|
||
ext=ext.toUpper();
|
||
if(ext.endsWith(".DAT"))
|
||
{
|
||
len=fread(buff,336,1,fp);
|
||
if(len<=0){
|
||
fclose(fp);
|
||
return -1;
|
||
}
|
||
int i1=-1,i2=-1,i3=-1;
|
||
for(int i=0;i<336;i++)
|
||
{
|
||
if(buff[i]=='\/')
|
||
{
|
||
i1=i;break;
|
||
}
|
||
}
|
||
if(i1<30){
|
||
fclose(fp);
|
||
return -1;
|
||
}
|
||
for(int i=0;i<336;i++)
|
||
{
|
||
if(buff[i]>=48&&buff[i]<=57)
|
||
{
|
||
i2=i;break;
|
||
}
|
||
}
|
||
if(i2<0){
|
||
fclose(fp);
|
||
return -1;
|
||
}
|
||
for(int i=i1-30;i<336;i++)
|
||
{
|
||
if(buff[i]==128)
|
||
{
|
||
i3=i;break;
|
||
}
|
||
}
|
||
if(i3<0){
|
||
fclose(fp);
|
||
return -1;
|
||
}
|
||
if(((buff[4] >= 65 && buff[4] <= 122) ||buff[4]==32) && ((buff[5] >= 65 && buff[5] <= 122)||buff[5]==32))
|
||
{
|
||
fclose(fp);
|
||
return -1;
|
||
}
|
||
fseek(fp,0L,0);
|
||
}
|
||
BOOL HaveFileTailRec=0;//有的文件没有文件尾记录
|
||
//add end
|
||
int istat=fread(buff,len,1,fp);
|
||
for(int i=0;i<maxrl-5;i++)
|
||
{
|
||
int lprl=buff[i]*256+buff[i+1];
|
||
int k=i+4;
|
||
lrcls(buff[k],&idrt,&lrtype);
|
||
if(lrtype==132||lrtype==130||lrtype==128)
|
||
{
|
||
if(lprl<=maxrl&&lprl>0)
|
||
{
|
||
//特殊lis检查
|
||
int lrtypeSp;
|
||
lrcls(buff[k+2],&idrt,&lrtypeSp);
|
||
if(lrtype==128 && lrtypeSp == 128){
|
||
i+=2;
|
||
ngapbyteSpFirst = i;
|
||
isSpLis = true;
|
||
}
|
||
|
||
ngapbyte=i;
|
||
neofbyte=ngapbyte;
|
||
goto L10;
|
||
}
|
||
}
|
||
}
|
||
L10:skip=0,TapeRlev=0;
|
||
if(neofbyte==22)//&&strstr(buff,"FORWARD TAPE IMAGE")) this is FORWARD TAPE IMAGE
|
||
{
|
||
TapeRlev=8;
|
||
skip=22-8;
|
||
ngapbyte=TapeRlev;
|
||
}
|
||
//for 进度条
|
||
fseek(fp,0,SEEK_END);
|
||
DWORD fl=ftell(fp);
|
||
DWORD FileLength=fl;
|
||
//MyDepthProgress.CreatProgress(0,fl/100000,"扫描LIS格式文件");
|
||
|
||
if(m_pDepthProgress) m_pDepthProgress->SetShowName("格式类型:LIS",0);
|
||
if(m_pDepthProgress) {
|
||
m_pDepthProgress->CreatProgress(0,100,"信息提取..",1);//m_pDepthProgress->CreatProgress(0,fl,"信息提取..",1);
|
||
m_pDepthProgress->SetDepth(0,1);
|
||
}
|
||
|
||
fseek(fp,skip,0);//跳过字节数，如forward下载的lis文件就有22个字符的说明信息
|
||
int ntbyte=0;
|
||
int lrtype0=-99;
|
||
int nlr=0;
|
||
int nfile=0;
|
||
// read a logical record (many physical record).
|
||
int lbuff,istats,nbyte;
|
||
float rlevfc,depfc,rlevd,vsdep,vedep;
|
||
int ifged=0,ifgst=0,irec=0,nlrdat=0;
|
||
CString str;
|
||
strcpy(Message,"\r\n---------------------SCHLUMBERGER LIS 格式文件信息---------------------------\r\n");
|
||
ncurvs=0;
|
||
int rec=0;
|
||
while(1)
|
||
{
|
||
rec++;
|
||
int f=ftell(fp);
|
||
if(f<0) break;
|
||
rdbuf(fp,buff,&lbuff,&lrtype,&istats,maxrl,&nbyte,ngapbyte);
|
||
|
||
//20210115 GZL ADD
|
||
if(isSpLis)ngapbyte=8;
|
||
int percent=(float)f*100./(float)FileLength;
|
||
if(m_pDepthProgress)
|
||
{
|
||
if(!(m_pDepthProgress->SetDepth(percent,1))) {
|
||
fclose(fp);
|
||
return -1;//if(!(m_pDepthProgress->SetDepth(f,1))) return -1;
|
||
}
|
||
}
|
||
if(istats<=0)break;
|
||
if(lrtype!=lrtype0)
|
||
{
|
||
//str.Format("lbuff,lrtype,nrecs=%d,%d,%d\r\n",lbuff,lrtype,nlr);
|
||
//sprintf(Message,"%s%s",Message,str);
|
||
//AfxMessageBox(str);
|
||
str="";
|
||
}
|
||
lrtype0=lrtype;
|
||
// write vol.(reel)_header information.
|
||
if(lrtype==132)
|
||
{
|
||
str=reelhd((char *)buff);
|
||
}
|
||
// write vol.(reel)_trail information.
|
||
else if(lrtype==133)
|
||
{
|
||
|
||
strncpy(mbuf,(char *)&buff[2],lbuff-3+1);
|
||
mbuf[lbuff-3+1]=0;
|
||
str.Format("*** reel trail *** %s",mbuf);
|
||
// skip vol.(reel) trail bytes (2 eof)
|
||
len=neofbyte*2;
|
||
if(len>0)
|
||
{
|
||
istat=fread(buff,len,1,fp);
|
||
if(istat<=0) break;
|
||
}
|
||
ntbyte=ntbyte+neofbyte*2;
|
||
sprintf(mbuf,"ntbytes = %d\r\n two eof \r\n",ntbyte);
|
||
str+=CharToCstring(mbuf,strlen(mbuf));
|
||
}
|
||
// write tape_header information.
|
||
else if(lrtype==130)
|
||
{
|
||
str=tapehd((char *)buff);
|
||
// skip eof(file end) bytes(a eof).
|
||
len=neofbyte;
|
||
if(len>0) {
|
||
istat=fread(buff,len,1,fp);
|
||
if(istat<=0)break;
|
||
}
|
||
ntbyte=ntbyte+neofbyte;
|
||
str.Format(str.GetString(),"ntbytes = %d\r\n a eof \r\n",str,ntbyte);
|
||
}
|
||
// write tape_trail information.
|
||
else if(lrtype==131)
|
||
{
|
||
|
||
strncpy(mbuf,(char *)&buff[2],lbuff-3+1);
|
||
mbuf[lbuff-3+1]=0;
|
||
str.Format("*** tape trail *** %s\r\n",mbuf);
|
||
}
|
||
// write file_header information.
|
||
else if(lrtype==128)
|
||
{
|
||
nfile=nfile+1;
|
||
str.Format("\r\n *** file number:%d\r\n",nfile);
|
||
str+=CString("\r\n *** file header ***\r\n\r\n-----------------------------------\r\n")+filehd((char *)buff,&maxrl);
|
||
// str.Format("%s maxrl=%d\r\n",str,maxrl) ;
|
||
// AfxMessageBox(str);
|
||
}
|
||
// write file_trail information.
|
||
else if(lrtype==129)
|
||
{
|
||
HaveFileTailRec=1;
|
||
rlev=rlev*rlevfc;
|
||
rlevd=(vedep-vsdep)/float(ifged-ifgst);
|
||
if(fabs(rlev-rlevd)>0.0001&&fabs(rlev)<0.0001)
|
||
{
|
||
rlev=rlevd;
|
||
}
|
||
|
||
//20220815
|
||
if(rlev<0)
|
||
rlev=float(int((rlevd-0.000005)*100000))/100000;
|
||
else
|
||
{
|
||
float temp_rlev = float(int((rlevd+0.000005)*100000))/100000;
|
||
if(temp_rlev != float(int(rlevd*100000)/100000) && temp_rlev > rlev)
|
||
{
|
||
rlev = temp_rlev;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
//3???modep=0时，space没赋值，rlev就不能满足条件if(fabs(rlev-rlevd)>0.0001&&fabs(rlev)<0.0001)，所以得到的rlev值是不正确的
|
||
//whp add
|
||
if(modep==0&&rlev<-9999)
|
||
{
|
||
rlev=rlevd;
|
||
float del=fabs(fabs(rlev)-0.1);
|
||
if(del<0.001)rlev=0.1;
|
||
}//add end
|
||
sdep=vsdep;
|
||
edep=vedep;
|
||
// str.Format(("irec,nlrdat=%d %d\r\nvsdep,vedep=%f% f\r\nifgst,ifged=%d %d\r\nsdep,edep,rlev=%f %f %f\r\n"),irec,nlrdat,vsdep,vedep,ifgst,ifged,sdep,edep,rlev);
|
||
|
||
strncpy(mbuf,(char *)&buff[2],lbuff-3+1);
|
||
|
||
str+=CString("\r\n\r\n*** file trail ***\r\n\r\n----------------------------------\r\n");
|
||
str+=filehd((char *)buff,&maxrl);
|
||
// skip eof (file end) bytes(a eof).
|
||
len=neofbyte;
|
||
if(len>0)
|
||
{
|
||
istat=fread(buff,len,1,fp);
|
||
if(istat<=0)break;
|
||
}
|
||
ntbyte=ntbyte+neofbyte;
|
||
str+=CString("\r\na eof !\r\na eof !\r\n");
|
||
}
|
||
// write comment record information.
|
||
else if(lrtype==232)
|
||
{
|
||
//strncpy(mbuf,(char *)&buff[2],lbuff-3+1);
|
||
//str.Format("*** comment: ***%s",mbuf);
|
||
}
|
||
// write information record information.
|
||
else if(lrtype==34)
|
||
{
|
||
//iswinft=1;
|
||
// infrec(nu,buff,lbuff,iswinft);
|
||
str=infrec((char *)buff,lbuff,0);
|
||
str="";
|
||
}
|
||
// write format specification record information.
|
||
else if(lrtype==64)
|
||
{
|
||
str=formsp((char*)buff,lbuff,1);
|
||
depfc=unitfactor(depunit,4);
|
||
rlevfc=unitfactor(levunit,4);
|
||
}
|
||
else if(lrtype==0)
|
||
{
|
||
nlrdat=nlrdat+1;
|
||
int nfrm=(lbuff-2)/lframe;
|
||
if(nfrm!=nframe)
|
||
{
|
||
nframe=nfrm;
|
||
CString ss;
|
||
ss.Format(("nrecs,lbuff,nframe=%d %d %d\r\n"),lrtype,lbuff-2,nframe);
|
||
str+=ss;
|
||
}
|
||
else str="";
|
||
float dep0;//whp add
|
||
for(int i=0;i<nframe;i++)
|
||
{
|
||
if(modep==1) //无深度曲线
|
||
{
|
||
int ips=3;
|
||
int nsamp=1;
|
||
int icode=ircodes[ncurvs];
|
||
convrt(&value[0],(unsigned char *)buff,lbuff,ips,icode,nsamp);
|
||
dep=value[0]*depfc+rlev*(i)*rlevfc;
|
||
}
|
||
else //有深度曲线
|
||
{
|
||
int ips=2+ipost[ncurvs]+i*lframe;
|
||
int nsamp=1;
|
||
int icode=ircodes[ncurvs] ;
|
||
convrt(&value[0],(unsigned char *)buff,lbuff,ips,icode,nsamp);
|
||
dep=value[0]*depfc ;
|
||
|
||
}
|
||
irec=irec+1;
|
||
if(abs(dep+abstrv)>0.01&&ifgst==0&&fabs(dep+9999.)>0.01)
|
||
{
|
||
ifgst=irec;
|
||
vsdep=dep;
|
||
if(irec!=1)
|
||
{
|
||
CString ss;
|
||
ss.Format("irec=%d,warning! depth track value error.",irec);
|
||
AfxMessageBox(ss);
|
||
}
|
||
}
|
||
if(abs(dep+abstrv)>0.01&&abs(dep+9999.)>0.01)
|
||
{
|
||
ifged=irec ;
|
||
vedep=dep;
|
||
}
|
||
}
|
||
}
|
||
sprintf(Message,"%s%s",Message,str.GetString());
|
||
}
|
||
Numlog=ncurvs;//+1;
|
||
sprintf(&Message[strlen(Message)],"\r\n曲线条数：%d\r\n\r\n起始深度:%g 终止深度:%g \r\n采样间隔:%g\r\n\r\n",Numlog,sdep,edep,rlev);
|
||
fclose(fp);
|
||
//whp add 2019.8.8 for 有的文件没有文件尾记录
|
||
if(HaveFileTailRec==0)//如果没有文件尾记录
|
||
{
|
||
AfxMessageBox("该文件没有文件尾记录");
|
||
rlev=rlev*rlevfc;
|
||
rlevd=(vedep-vsdep)/float(ifged-ifgst);
|
||
double gg=fabs(rlev-rlevd);
|
||
if(fabs(rlev-rlevd)>0.0000000001&&fabs(rlev)<0.1)
|
||
{
|
||
rlev=rlevd;
|
||
}
|
||
//20210115 GZL ADD
|
||
if(1)
|
||
if(rlev<0)
|
||
rlev=float(int((rlevd-0.000005)*100000))/100000;
|
||
else
|
||
rlev=float(int((rlevd+0.000005)*100000))/100000;
|
||
|
||
//modep=0时，space没赋值，rlev就不能满足条件if(fabs(rlev-rlevd)>0.0001&&fabs(rlev)<0.0001)，所以得到的rlev值是不正确的
|
||
if(modep==0&&rlev<-9999)
|
||
{
|
||
rlev=rlevd;
|
||
float del=fabs(fabs(rlev)-0.1);
|
||
if(del<0.001)rlev=0.1;
|
||
}
|
||
sdep=vsdep;
|
||
edep=vedep;
|
||
if(sdep>edep)
|
||
{
|
||
float temp=sdep;
|
||
sdep=edep;
|
||
edep=temp;
|
||
}
|
||
str.Format(("\r\n\r\n曲线条数=%d\r\n起始深度:%g 终止深度:%g \r\n采样间隔:%g\r\n\r\n"),ncurvs,sdep,edep,rlev);
|
||
str+="\r\na eof !\r\na eof !\r\n";
|
||
sprintf(Message,"%s%s",Message,str.GetString());
|
||
for(int i=0;i<ncurvs;i++)
|
||
{
|
||
strcpy(CurveName[Numlog+i],curvnms[i]);
|
||
strcpy(CurveUnit[Numlog+i],units[i]);
|
||
}
|
||
}
|
||
//add end
|
||
//调用该函数，向解编信息中压入深度信息
|
||
|
||
for(int i=0;i<Numlog;i++)
|
||
{
|
||
strcpy(CurveName[i],curvnms[i]);
|
||
strcpy(CurveUnit[i],units[i]);
|
||
}
|
||
if(sdep>edep)
|
||
{
|
||
float temp=sdep;
|
||
sdep=edep;
|
||
edep=temp;
|
||
rlev=-1*fabs(rlev);
|
||
}
|
||
|
||
PutScanDepthMes(Message,sdep,edep);
|
||
//fclose(out);
|
||
return Numlog;
|
||
}
|
||
bool CLisConvertor::Transfer(char *FileName,char *outfile,int *OutCurveNo,char **OutCurve,char **strChineseName,char **strUnit,int dCurveNum)
|
||
{
|
||
if(HaveSameCurve(Numlog,OutCurveNo,OutCurve))
|
||
return 0;
|
||
|
||
removeRedunant(rlev, int(10000));
|
||
|
||
float xCoord = 0, yCoord = 0, outsdep = -99999, outedep = -99999, outrlev = rlev;
|
||
char *p;
|
||
p = outfile;
|
||
int len = strlen(p) + 1;
|
||
p += len;
|
||
GetTranMes(p, &xCoord, &yCoord, &outsdep, &outedep);
|
||
|
||
outsdep = (outsdep == -99999.) ? sdep : outsdep;
|
||
outedep = (outedep == -99999.) ? edep : outedep;
|
||
if(outsdep > outedep)
|
||
{
|
||
swap(outsdep, outedep);
|
||
}
|
||
|
||
CMemRdWt m_SlfFile(outfile);
|
||
if(m_SlfFile.mFile == NULL) return 0;
|
||
|
||
Slf_CURVE myCurve;
|
||
Slf_WAVE myWave;
|
||
Slf_CHANNEL m_Channel;
|
||
Slf_WAVE **tslfwave = NULL;
|
||
|
||
if(xCoord != -99999 && yCoord != -99999)
|
||
{
|
||
char buf[256];
|
||
QString strWellInfo= "井基本信息";
|
||
strcpy(buf, strWellInfo.toLocal8Bit().data());
|
||
int index = m_SlfFile.FindObjectIndex(buf);
|
||
int indexSTable = m_SlfFile.OpenSTATIC(buf);
|
||
|
||
m_SlfFile.WriteTable(indexSTable, 1, &WellStaticInfo);
|
||
m_SlfFile.CloseTable(indexSTable);
|
||
int indexDTable=m_SlfFile.OpenDYNAMIC(buf);
|
||
m_SlfFile.WriteTable(indexDTable, 1, &WellDynamicInfo);
|
||
m_SlfFile.CloseTable(indexDTable);
|
||
}
|
||
|
||
int pointnum = 0;
|
||
|
||
for(int i = 0; i < ncurvs; i++)
|
||
{
|
||
if(OutCurveNo[i] > -1)
|
||
{
|
||
#pragma region 获取name
|
||
char name[20];
|
||
strncpy(name, OutCurve[i], 16);
|
||
for(int ij = 1; ij < 16; ij++)
|
||
{
|
||
if(name[ij] == ' ')
|
||
name[ij] = '\0';
|
||
else
|
||
name[ij] = toupper(name[ij]);
|
||
}
|
||
#pragma endregion
|
||
|
||
#pragma region 初始化曲线进slf
|
||
if(ndim[i] <= 1)
|
||
{
|
||
int index = m_SlfFile.OpenCurve(name);
|
||
if(index < 0)
|
||
{
|
||
strcpy(myCurve.Name,name);
|
||
strcpy(myCurve.AliasName,strChineseName[i]);
|
||
strcpy(myCurve.Unit,strUnit[i]);
|
||
strcpy(myCurve.AliasUnit,strUnit[i]);
|
||
|
||
if(ircodes[i]==79) myCurve.RepCode=REPR_SHORT;
|
||
else if(ircodes[i]==73) myCurve.RepCode=REPR_INT;
|
||
else myCurve.RepCode=REPR_FLOAT;
|
||
|
||
myCurve.CodeLen=RepSize[myCurve.RepCode];
|
||
myCurve.MinValue=99999.0;
|
||
myCurve.MaxValue=-99999.0;
|
||
myCurve.DefVal=-9999;
|
||
myCurve.StartDepth=outsdep;
|
||
myCurve.EndDepth =outedep;
|
||
myCurve.DepLevel =fabs(rlev)/npoints[i];
|
||
strcpy(myCurve.DepthUnit,"m");
|
||
|
||
OutCurveNo[i] = m_SlfFile.OpenCurve((Slf_CURVE *)&myCurve);
|
||
}
|
||
else
|
||
OutCurveNo[i] = m_SlfFile.OpenCurve(name);
|
||
|
||
//pointnum 所需数据点个数
|
||
pointnum = (myCurve.EndDepth - myCurve.StartDepth) / myCurve.DepLevel + 1.5;
|
||
|
||
//仅为该曲线开空间 --> curvebuf
|
||
char *curvebuf = new char[myCurve.CodeLen * pointnum + 1];
|
||
memset(curvebuf, 0, myCurve.CodeLen * pointnum);
|
||
|
||
//先写假cur值0
|
||
if(OutCurveNo[i] > -1)
|
||
m_SlfFile.WriteCurve(OutCurveNo[i], outsdep, pointnum, (void *)curvebuf);
|
||
|
||
delete curvebuf;
|
||
|
||
}
|
||
else //ndim > 1
|
||
{
|
||
if(!tslfwave) {
|
||
tslfwave=new Slf_WAVE*[ncurvs];
|
||
for(int k=0;k<ncurvs;k++) tslfwave[k]=NULL;
|
||
}
|
||
tslfwave[i]=new Slf_WAVE;
|
||
memset(tslfwave[i],0,sizeof(Slf_WAVE));
|
||
int index = m_SlfFile.OpenWave(name);
|
||
if(index < 0)
|
||
{
|
||
strcpy(myWave.Name,name);
|
||
strcpy(myWave.AliasName,strChineseName[i]);
|
||
strcpy(myWave.Unit,strUnit[i]);
|
||
strcpy(myWave.AliasUnit,strUnit[i]);
|
||
myWave.CodeLen=lbytes(ircodes[i]);
|
||
|
||
if(ircodes[i]==79) myWave.RepCode=REPR_SHORT;
|
||
else if(ircodes[i]==73) myWave.RepCode=REPR_INT;
|
||
else myWave.RepCode=REPR_FLOAT;
|
||
|
||
myWave.MinValue=99999.0;
|
||
myWave.MaxValue=-99999.0;
|
||
myWave.DefVal=-9999;
|
||
myWave.StartDepth= outsdep;
|
||
myWave.EndDepth = outedep;
|
||
myWave.DepLevel = fabs(rlev) / (npoints[i] / ndim[i]);
|
||
strcpy(myWave.DepthUnit,"m");
|
||
myWave.StartTime=0;//从哪儿得到该信息?
|
||
myWave.TimeLevel=2;
|
||
myWave.TimeSamples=ndim[i];
|
||
strcpy(myWave.TimeUnit,"us");
|
||
|
||
OutCurveNo[i] = m_SlfFile.OpenWave((Slf_WAVE *)&myWave);
|
||
|
||
pointnum = (myWave.EndDepth - myWave.StartDepth) / myWave.DepLevel + 1.5;
|
||
memmove(tslfwave[i],&myWave,sizeof(Slf_WAVE));
|
||
char *curvebuf = new char[myWave.CodeLen * myWave.TimeSamples * pointnum + 1];
|
||
memset(curvebuf, 0, myWave.CodeLen * myWave.TimeSamples * pointnum);
|
||
if(OutCurveNo[i] > -1)
|
||
m_SlfFile.WriteWave(OutCurveNo[i], outsdep, pointnum, (void *)curvebuf);
|
||
|
||
delete curvebuf;
|
||
}
|
||
else
|
||
OutCurveNo[i] = m_SlfFile.OpenWave(name);
|
||
}
|
||
#pragma endregion
|
||
}
|
||
}
|
||
|
||
//char cchans[10000],tcurvnm[48];
|
||
char mbuf[5000];
|
||
// idir=0 orgin depth direction(decoded data depth)
|
||
// =1 up[small] - bottom[large] [depth]
|
||
//float sdepob[40],edepob[40],rlevob[40],nchans[40],lchanv[1000];
|
||
//int norg[1000],ncopy[1000],
|
||
int nele[6], lrecf[40], npfrmob[40];
|
||
float rlevfc,depfc,rlevd,vsdep,vedep;
|
||
//unsigned char buff[40000];
|
||
//float value[100000];
|
||
int idrt,lrtype,lbuff,istats,nbyte;;
|
||
int istat;
|
||
int idir=1;
|
||
int maxrl=1024;
|
||
float abstrv=-999.25;
|
||
int maxcurv=100;
|
||
// format spcification number
|
||
int nfmsp=0 ,nfrmob;
|
||
|
||
if((fp=fopen(FileName,"rb")) == NULL) {
|
||
QMessageBox::information(NULL,FileName,"Open Not File:",QMessageBox::Ok);
|
||
return 0;
|
||
}
|
||
|
||
char path[256];
|
||
|
||
//CString TempPath=GetBinDir(path);
|
||
CString TempPath = GetLogdataPath();
|
||
TempPath = TempPath+"Temp";
|
||
QDir *temp=new QDir;
|
||
bool bWorking=temp->exists(TempPath.GetString());
|
||
if(!bWorking)
|
||
{
|
||
bWorking=temp->mkdir(TempPath.GetString());
|
||
CString aaa;
|
||
aaa.Format("创建临时文件路径%s失败",TempPath);
|
||
if(!bWorking)
|
||
{
|
||
AfxMessageBox(aaa);
|
||
return -1;
|
||
}
|
||
}
|
||
delete temp;
|
||
TempPath+=CString("\\");
|
||
char filename[128];
|
||
sprintf(filename,"%slistraninfo.txt",TempPath.GetString());
|
||
// FILE *out;
|
||
// out=fopen(filename,"w+t");
|
||
int ntbyte=0;
|
||
int lrtype0=-99;
|
||
int nlr=0;
|
||
int nlrdat=0;
|
||
int irec=0;
|
||
int ifgst=0;
|
||
int ifged=0;
|
||
int ipfile=0;
|
||
int iprdfl=1;
|
||
fseek(fp, skip, 0);//跳过字节数，如forward下载的lis文件就有22个字符的说明信息
|
||
// CString str;
|
||
|
||
//当前仅适用于处理常规曲线
|
||
float **value2 = new float*[ncurvs];
|
||
for(int value2ColNum = 0; value2ColNum < ncurvs; value2ColNum++){
|
||
if(OutCurveNo[value2ColNum]>-1)
|
||
{
|
||
value2[value2ColNum] = new float [EACHCALNUM * npoints[value2ColNum] * 2+1000];
|
||
memset(value2[value2ColNum],0,EACHCALNUM * npoints[value2ColNum] * 2*sizeof(float));
|
||
}
|
||
}
|
||
char **value2forWave = new char*[ncurvs];
|
||
for(int value2ColNum = 0; value2ColNum < ncurvs; value2ColNum++){
|
||
if(ndim[value2ColNum] > 1&&OutCurveNo[value2ColNum]>-1)
|
||
{
|
||
value2forWave[value2ColNum] = new char [tslfwave[value2ColNum]->CodeLen * EACHCALNUM * (npoints[value2ColNum] + 1)];
|
||
memset(value2forWave[value2ColNum],0,tslfwave[value2ColNum]->CodeLen * EACHCALNUM * (npoints[value2ColNum] + 1));
|
||
}
|
||
}
|
||
int *eachCurdataNum = new int[ncurvs]; //记录每轮各个曲线保存在value2中的数值个数
|
||
for(int i = 0; i < ncurvs; i++){
|
||
eachCurdataNum[i] = 0;
|
||
}
|
||
float firstDep;
|
||
float eachStartDep;
|
||
float lastStartDep;
|
||
int rNum = 0;
|
||
|
||
DepthProgress MyDepthProgress;
|
||
MyDepthProgress.CreatProgress(outsdep,outedep,"解编LIS数据");
|
||
|
||
if(isSpLis)ngapbyte = ngapbyteSpFirst;
|
||
int nn=0;
|
||
while(1)
|
||
{
|
||
// read a logical record (many physical record).
|
||
DWORD f = ftell(fp);
|
||
rdbuf(fp,buff,&lbuff,&lrtype,&istats,maxrl,&nbyte,ngapbyte);
|
||
|
||
if(isSpLis)ngapbyte=8;
|
||
|
||
f = ftell(fp);
|
||
if(f < 0) {
|
||
break;
|
||
}
|
||
ntbyte = ntbyte + nbyte;
|
||
if(istats<=0) {
|
||
break;
|
||
}
|
||
// if(lrtype!=lrtype0) write(0,*) "lbuff,lrtype,nrecs=",lbuff,lrtype,nlr;
|
||
lrtype0=lrtype;
|
||
|
||
#pragma region write vol.(reel)_header information.
|
||
if(lrtype == 132)
|
||
{
|
||
// str=reelhd((char *)&buff[0]);
|
||
}
|
||
#pragma endregion
|
||
#pragma region write vol.(reel)_trail information.
|
||
else if(lrtype==133)
|
||
{
|
||
strncpy(mbuf,(char *)&buff[2],lbuff-3+1);
|
||
mbuf[lbuff-3+1]=0;
|
||
// str.Format("*** reel trail *** %s",mbuf);
|
||
// skip vol.(reel) trail bytes (2 eof)
|
||
len = neofbyte * 2;
|
||
if(len > 0)
|
||
{
|
||
istat = fread(buff, len, 1, fp);
|
||
if(istat<=0) {
|
||
break;
|
||
}
|
||
}
|
||
ntbyte=ntbyte+neofbyte*2;
|
||
sprintf(mbuf,"ntbytes = %d\r\n two eof \r\n",ntbyte);
|
||
// str+=CharToCstring(mbuf,strlen(mbuf));
|
||
// skip vol.(reel) trail bytes (2 eof)
|
||
len=neofbyte*2;
|
||
if(len>0)
|
||
{
|
||
istat=fread(buff,len,1,fp);
|
||
|
||
if(istat<=0) {
|
||
break;
|
||
}
|
||
}
|
||
ntbyte=ntbyte+neofbyte*2;
|
||
}
|
||
#pragma endregion
|
||
#pragma region write tape_header information.
|
||
else if(lrtype==130)
|
||
{
|
||
// str=
|
||
tapehd((char *)buff);
|
||
// skip eof(file end) bytes(a eof).
|
||
len=neofbyte;
|
||
if(len > 0) {
|
||
istat = fread(buff,len,1,fp);
|
||
|
||
if(istat<=0) {
|
||
break;
|
||
}
|
||
}
|
||
ntbyte=ntbyte+neofbyte;
|
||
// str.Format(str.GetString(),"ntbytes = %d\r\n a eof \r\n",str,ntbyte);
|
||
}
|
||
#pragma endregion
|
||
#pragma region write tape_trail information.
|
||
else if(lrtype == 131)
|
||
{
|
||
if(lbuff-3+1<5000)
|
||
{
|
||
strncpy(mbuf, (char *)&buff[2], lbuff - 3 + 1);
|
||
// str.Format("*** tape trail *** %s",mbuf);
|
||
}
|
||
}
|
||
#pragma endregion
|
||
#pragma region write file_header information.
|
||
else if(lrtype == 128)
|
||
{
|
||
ipfile = ipfile + 1;
|
||
if(ipfile > iprdfl)
|
||
break;
|
||
//str=CString(" *** file header ***\r\n-----------------------------------\r\n")+
|
||
filehd((char *)buff, &maxrl);
|
||
//str.Format("%s maxrl=%d\r\n",str,maxrl) ;
|
||
}
|
||
#pragma endregion
|
||
#pragma region write file_trail information.
|
||
else if(lrtype==129)
|
||
{//whp add
|
||
if(ipfile==iprdfl)
|
||
{
|
||
filehd((char *)buff,&maxrl);
|
||
}
|
||
// skip eof (file end) bytes(a eof).
|
||
len=neofbyte;
|
||
if(len>0)
|
||
{
|
||
istat=fread(buff,len,1,fp);
|
||
|
||
if(istat<=0) {
|
||
break;
|
||
}
|
||
}
|
||
ntbyte=ntbyte+neofbyte;
|
||
if(ipfile==iprdfl)break;
|
||
}
|
||
#pragma endregion
|
||
#pragma region write comment record information.
|
||
else if(lrtype==232)
|
||
{
|
||
if(ipfile!=iprdfl)continue;
|
||
if(lbuff-3+1<5000)
|
||
{
|
||
strncpy(mbuf,(char *)&buff[2],lbuff-3+1);
|
||
// str.Format("*** comment: ***%s",mbuf);
|
||
}
|
||
}
|
||
#pragma endregion
|
||
#pragma region write information record information.
|
||
else if(lrtype==34)
|
||
{
|
||
if(ipfile!=iprdfl)continue;
|
||
infrec((char *)buff,lbuff,0);
|
||
}
|
||
#pragma endregion
|
||
#pragma region write format specification record information.
|
||
else if(lrtype==64)
|
||
{
|
||
if(ipfile!=iprdfl) continue;
|
||
nfmsp=nfmsp+1;
|
||
if(nfmsp>1)continue;// goto L119;
|
||
int iswfmtb=0;
|
||
iswfmtb=1;
|
||
for(int i=0;i<ncurvs+1;i++)
|
||
{
|
||
if(nsamps[i]<=0) nsamps[i]=1;
|
||
}
|
||
// write channel object information.
|
||
nfrmob=0;
|
||
npfrmob[nfrmob]=nsamps[0];
|
||
for(int i=0;i<ncurvs;i++)
|
||
{
|
||
int infg=1;
|
||
for(int j=0;j<=nfrmob;j++)
|
||
{
|
||
if(nsamps[i]==npfrmob[j]) infg=0;
|
||
}
|
||
if(infg==1)
|
||
{
|
||
nfrmob=nfrmob+1;
|
||
npfrmob[nfrmob]=nsamps[i] ;
|
||
}
|
||
//if(iexst[i]==1)
|
||
{
|
||
int ivorg=0;
|
||
int ivcopy=0 ;
|
||
int ndim=1;
|
||
nele[0]=npoints[i]/nsamps[i];
|
||
}
|
||
}
|
||
depfc=unitfactor(depunit,4);
|
||
rlevfc=unitfactor(levunit,4);
|
||
strcpy(depunit,"m");
|
||
int ip=0;
|
||
int nn=0;
|
||
for(int i=0;i<=nfrmob;i++)
|
||
{
|
||
lrecf[i]=4*npfrmob[i];
|
||
for(int ioc=0;ioc<ncurvs;ioc++)
|
||
{
|
||
if(iexst[ioc]==1&&nsamps[ioc]==npfrmob[i])
|
||
{
|
||
int nsamp=npoints[ioc];
|
||
lrecf[i]=lrecf[i]+lwbytes(ircodes[ioc])*nsamp;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#pragma endregion
|
||
#pragma region lrtype==0
|
||
else if(lrtype == 0)
|
||
{
|
||
int ips, nsamp, icode, npbyte;
|
||
|
||
if(ipfile != iprdfl)
|
||
continue;
|
||
|
||
nlrdat = nlrdat + 1;
|
||
int nfrm = (lbuff - 2) / lframe;
|
||
if(nfrm>255) nfrm=255;
|
||
if(nfrm != nframe)
|
||
nframe = nfrm;
|
||
// nframe=buff[0]*0x100+buff[1];
|
||
for(int i = 0; i < nframe; i++)
|
||
{
|
||
#pragma region 深度值dep更新
|
||
if(modep == 1)
|
||
{
|
||
ips=3;
|
||
nsamp=1;
|
||
icode=ircodes[ncurvs] ;
|
||
convrt(&value[0], buff, lbuff, ips, icode, nsamp);
|
||
dep = value[0] * depfc + outrlev * i;
|
||
}
|
||
else
|
||
{
|
||
ips=2+ipost[ncurvs]+(i)*lframe;
|
||
nsamp=1;
|
||
icode=ircodes[ncurvs];
|
||
convrt(&value[0],buff,lbuff,ips,icode,nsamp);
|
||
dep=value[0]*depfc ;
|
||
}
|
||
irec=irec+1;
|
||
|
||
if(abs(dep + abstrv) > 0.01 && ifgst == 0 && abs(dep + 9999.) > 0.01)
|
||
{
|
||
ifgst = irec;
|
||
vsdep = dep;
|
||
if(irec != 1)
|
||
{
|
||
// CString ss;
|
||
// ss.Format("irec=d,warning! depth track value error.",irec);
|
||
}
|
||
}
|
||
|
||
if(abs(dep + abstrv) > 0.01 && abs(dep + 9999.) > 0.01)
|
||
{
|
||
ifged = irec;
|
||
vedep = dep;
|
||
}
|
||
#pragma endregion
|
||
|
||
if(outrlev < 0){
|
||
if(rNum == 0)
|
||
firstDep = dep;
|
||
rNum++;
|
||
if(rNum == EACHCALNUM)
|
||
eachStartDep = dep; //更新一次起始深度值
|
||
}
|
||
else if(outrlev > 0){
|
||
if(rNum == 0)
|
||
eachStartDep = dep;
|
||
rNum++;
|
||
if(rNum == EACHCALNUM)
|
||
firstDep = dep;
|
||
}
|
||
lastStartDep = dep;
|
||
|
||
for(int l = 0; l <= nfrmob; l++)
|
||
{
|
||
int ipw=4;
|
||
#pragma region write curve value to buft.
|
||
for(int j = 0; j < ncurvs; j++) //针对于每个曲线
|
||
{
|
||
if(OutCurveNo[j] > -1 && npfrmob[l] == nsamps[j])
|
||
{
|
||
if(modep==1)
|
||
ips = 6 + ipost[j] + (i) * lframe;
|
||
else
|
||
ips=2+ipost[j]+(i)*lframe;
|
||
|
||
nsamp=npoints[j];
|
||
icode=ircodes[j];
|
||
convrt(&value[0],buff,lbuff,ips,icode,nsamp);
|
||
nn++;
|
||
for(int k = 0; k < nsamp; k++)
|
||
{
|
||
if(abs(value[k]+9999.) < 0.001||
|
||
value[k]>=1.312924e+030||
|
||
fabs(value[k]+431602048.0)==0
|
||
||
|
||
value[0]>=1.1424783e+009
|
||
)
|
||
{
|
||
value[k]=-999.25;
|
||
}
|
||
}
|
||
if(nsamp > 1 && outrlev < 0)
|
||
{
|
||
#pragma region 存放curdata --> value[]
|
||
if(ndim[j]<=1)//curve
|
||
{
|
||
float *temp;
|
||
temp = new float[nsamp];
|
||
memcpy(&temp[0], &value[0], nsamp*sizeof(float));
|
||
for(int k = 0; k < nsamp; k++)
|
||
{
|
||
value[k] = temp[nsamp-k-1];
|
||
}
|
||
delete temp;
|
||
}
|
||
else if(ndim[j] > 1)//wave
|
||
{
|
||
int num = nsamp / ndim[j];
|
||
if(num > 1)
|
||
{
|
||
float *temp;
|
||
temp = new float[nsamp];
|
||
memcpy(&temp[0], &value[0], nsamp * sizeof(float));
|
||
for(int m=0;m<num;m++)
|
||
{
|
||
memcpy(&value[ndim[j] * m], &temp[nsamp-ndim[j]*(m+1)], ndim[j]*sizeof(float));
|
||
}
|
||
delete temp;
|
||
}
|
||
}
|
||
#pragma endregion
|
||
}
|
||
|
||
if(ndim[j]<1)
|
||
ndim[j] = 1;
|
||
|
||
float mrlev = outrlev / (npoints[j]/ndim[j]);
|
||
|
||
if(dep > edep || dep < sdep)
|
||
{
|
||
//sdep--edep在输出深度段外，无需操作
|
||
}
|
||
else
|
||
{
|
||
if(ndim[j] <= 1) //常规曲线
|
||
{
|
||
float StartDep = dep;
|
||
int NumPoint = nsamp, StartPoint = 0;
|
||
|
||
if(dep < sdep)
|
||
{
|
||
#pragma region 起始深度在段外
|
||
for(int m = 0; m < nsamp; m++)
|
||
{
|
||
if(dep + m * mrlev >= sdep)
|
||
{
|
||
StartDep += m * mrlev;
|
||
StartPoint = m;
|
||
NumPoint -= m;
|
||
break;
|
||
}
|
||
}
|
||
#pragma endregion
|
||
}
|
||
if(dep + (nsamp - 1) * mrlev > edep)
|
||
{
|
||
#pragma region 终止深度在段外
|
||
for(int m = 0; m < nsamp; m++)
|
||
{
|
||
if(dep + m * mrlev >= edep)
|
||
{
|
||
NumPoint = m + 1;
|
||
break;
|
||
}
|
||
}
|
||
#pragma endregion
|
||
}
|
||
//int po = (StartDep - myCurve.StartDepth) / myCurve.DepLevel + 0.5;
|
||
|
||
if(outrlev < 0)
|
||
{
|
||
for (int NumPointn = 0; NumPointn < NumPoint; NumPointn++)
|
||
{
|
||
if(NumPoint > 1)
|
||
value2[j][(EACHCALNUM - eachCurdataNum[j] - 1) * NumPoint + NumPointn] = value[StartPoint + NumPointn];
|
||
else
|
||
value2[j][EACHCALNUM - eachCurdataNum[j] - NumPointn - 1] = value[StartPoint + NumPointn];
|
||
}
|
||
eachCurdataNum[j] ++;
|
||
|
||
}
|
||
else
|
||
{
|
||
for (int NumPointn = 0; NumPointn < NumPoint; NumPointn++)
|
||
value2[j][ eachCurdataNum[j] * NumPoint + NumPointn ] = value[StartPoint + NumPointn];
|
||
|
||
eachCurdataNum[j] ++;
|
||
|
||
}
|
||
}
|
||
else //波列数据
|
||
{
|
||
int num = nsamp / ndim[j];
|
||
|
||
int lb=lbytes(ircodes[j]);
|
||
float StartDep=dep;
|
||
|
||
int po=(StartDep-myWave.StartDepth)/myWave.DepLevel+0.5;
|
||
|
||
int NumPoint=num,StartPoint=0;
|
||
if(dep<sdep)//起始深度在段外
|
||
{
|
||
for(int m=0;m<num;m++)
|
||
{
|
||
if(dep+m*mrlev>=sdep)
|
||
{
|
||
StartDep+=m*mrlev;
|
||
StartPoint=m;
|
||
NumPoint-=m;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if(dep + (num - 1) * mrlev > edep)//终止深度在段外
|
||
{
|
||
for(int m = 0; m < num; m++)
|
||
{
|
||
if(dep + m * mrlev >= edep)
|
||
{
|
||
NumPoint = m + 1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if(outrlev < 0){
|
||
for (int NumPointn = 0; NumPointn < num * ndim[j]; NumPointn++)
|
||
m_SlfFile.SetData(tslfwave[j]->RepCode,&value2forWave[j][tslfwave[j]->CodeLen*((EACHCALNUM - eachCurdataNum[j] - 1) * nsamp + NumPointn)],&value[StartPoint * ndim[j] + NumPointn]);
|
||
|
||
eachCurdataNum[j]++;
|
||
}
|
||
else{
|
||
for (int NumPointn = 0; NumPointn < num * ndim[j]; NumPointn++)
|
||
m_SlfFile.SetData(tslfwave[j]->RepCode,&value2forWave[j][tslfwave[j]->CodeLen*(eachCurdataNum[j] * nsamp + NumPointn) ],&value[StartPoint * ndim[j] + NumPointn]);
|
||
|
||
eachCurdataNum[j]++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#pragma endregion
|
||
|
||
int iprec = irec - ifgst + 1;
|
||
}
|
||
rNum=0;
|
||
if(rNum != EACHCALNUM);
|
||
// continue;
|
||
|
||
#pragma region 完成一轮次的数据获取，进行一轮次的录入
|
||
for(int j = 0; j < ncurvs; j++)
|
||
{
|
||
if(OutCurveNo[j] > -1 && ndim[j] <= 1) //常规数据
|
||
{
|
||
//实际所需录入个数计算
|
||
int realSaveNum = abs((firstDep - eachStartDep) / outrlev) + 1.5;
|
||
realSaveNum += 1; //补一个临点
|
||
/*
|
||
//补差
|
||
int cNum = realSaveNum - eachCurdataNum[j];
|
||
for(int c = 0; c < cNum; c++)
|
||
{
|
||
for(int cnpoints = 0; cnpoints < npoints[j]; cnpoints++)
|
||
{
|
||
int temp_newIndex = abs(eachCurdataNum[j] * npoints[j] + c * npoints[j] + cnpoints);
|
||
int temp_oldIndex = abs(eachCurdataNum[j] * npoints[j] - npoints[j] + cnpoints);
|
||
value2[j][temp_newIndex] = value2[j][temp_oldIndex];
|
||
}
|
||
}
|
||
*/
|
||
//录入
|
||
int value2Index = 0;
|
||
float saveStartDep = 0.0;
|
||
//if(cal_SaveNumInf(outsdep, outedep, outrlev, eachStartDep, value2Index, realSaveNum, saveStartDep))
|
||
{
|
||
if(npoints[j]>1)
|
||
{
|
||
m_SlfFile.WriteCurve(OutCurveNo[j], dep-rlev+rlev/npoints[j], npoints[j], &value2[j][value2Index * npoints[j]]);
|
||
}
|
||
else m_SlfFile.WriteCurve(OutCurveNo[j], dep, npoints[j], &value2[j][value2Index * npoints[j]]);
|
||
}
|
||
}
|
||
else if(OutCurveNo[j] > -1 && ndim[j] > 1) //波形数据
|
||
{
|
||
int num = npoints[j] / ndim[j];
|
||
int value2Index = 0;
|
||
float saveStartDep = 0.0;
|
||
int realSaveNum = eachCurdataNum[j];
|
||
|
||
//if(cal_SaveNumInf(outsdep, outedep, outrlev, eachStartDep, value2Index, realSaveNum, saveStartDep))
|
||
{
|
||
if(num>1)
|
||
{
|
||
m_SlfFile.WriteCurve(OutCurveNo[j], dep-rlev+rlev/num,eachCurdataNum[j] * num, &value2[j][value2Index * npoints[j]]);
|
||
}
|
||
else m_SlfFile.WriteWave(OutCurveNo[j], dep, eachCurdataNum[j] * num, (void*)&value2forWave[j][0]);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 初始化
|
||
for(int i = 0; i < ncurvs; i++)
|
||
eachCurdataNum[i] = 0;
|
||
rNum = 0;
|
||
|
||
//进度条刷新
|
||
if(outrlev < 0)
|
||
MyDepthProgress.SetDepth(outedep - eachStartDep + outsdep);
|
||
else
|
||
MyDepthProgress.SetDepth(dep);
|
||
#pragma endregion
|
||
}
|
||
}
|
||
#pragma endregion
|
||
|
||
nlr = nlr + 1; // skip vol trail
|
||
}
|
||
fclose(fp);
|
||
|
||
// 剩余数据录入
|
||
if(rNum != 0 && outrlev < 0)
|
||
{
|
||
for(int j = 0; j < ncurvs; j++)
|
||
{
|
||
if(OutCurveNo[j] <= -1) continue;
|
||
if(ndim[j] <= 1) //curve
|
||
{
|
||
int value2Index = 0, realSaveNum = eachCurdataNum[j];
|
||
float saveStartDep = 0.0;
|
||
|
||
if(cal_SaveNumInf(outsdep, outedep, outrlev, lastStartDep, value2Index, realSaveNum, saveStartDep))
|
||
{
|
||
value2Index = abs(EACHCALNUM - realSaveNum);
|
||
m_SlfFile.WriteCurve(OutCurveNo[j], saveStartDep, realSaveNum * npoints[j], &value2[j][value2Index * npoints[j]]);
|
||
}
|
||
|
||
}
|
||
else //wave
|
||
{
|
||
int num = npoints[j] / ndim[j];
|
||
int value2Index = 0, realSaveNum = eachCurdataNum[j];
|
||
float saveStartDep = 0.0;
|
||
|
||
if(cal_SaveNumInf(outsdep, outedep, outrlev, eachStartDep, value2Index, realSaveNum, saveStartDep))
|
||
{
|
||
value2Index = abs(EACHCALNUM - realSaveNum);
|
||
m_SlfFile.WriteWave(OutCurveNo[j], saveStartDep, realSaveNum * num, (void*)&value2forWave[j][tslfwave[j]->CodeLen * (value2Index * npoints[j])] );
|
||
}
|
||
//m_SlfFile.WriteWave(OutCurveNo[j], lastStartDep, eachCurdataNum[j]*num,(void*)&value2forWave[j][tslfwave[j]->CodeLen*((EACHCALNUM - eachCurdataNum[j]) * npoints[j])]);
|
||
}
|
||
}
|
||
}
|
||
else if(rNum != 0 && outrlev > 0)
|
||
{
|
||
for(int j = 0; j < ncurvs; j++)
|
||
{
|
||
if(OutCurveNo[j] <= -1) continue;
|
||
if(ndim[j] <= 1)
|
||
{
|
||
int value2Index = 0, realSaveNum = eachCurdataNum[j];
|
||
float saveStartDep = 0.0;
|
||
if(cal_SaveNumInf(outsdep, outedep, outrlev, eachStartDep, value2Index, realSaveNum, saveStartDep))
|
||
{
|
||
m_SlfFile.WriteCurve(OutCurveNo[j], saveStartDep, realSaveNum * npoints[j], &value2[j][value2Index * npoints[j]]);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
int num = npoints[j] / ndim[j];
|
||
int value2Index = 0;
|
||
float saveStartDep = 0.0;
|
||
int realSaveNum = eachCurdataNum[j];
|
||
|
||
if(cal_SaveNumInf(outsdep, outedep, outrlev, eachStartDep, value2Index, realSaveNum, saveStartDep))
|
||
m_SlfFile.WriteWave(OutCurveNo[j], saveStartDep, realSaveNum * num, (void*)&value2forWave[j][value2Index * npoints[j]]);
|
||
|
||
//m_SlfFile.WriteWave(OutCurveNo[j], eachStartDep, eachCurdataNum[j] * num, (void*)&value2forWave[j][0]);
|
||
}
|
||
}
|
||
}
|
||
|
||
delete eachCurdataNum;
|
||
|
||
for (int i = 0; i < ncurvs; i++)
|
||
{
|
||
if(OutCurveNo[i]>-1)
|
||
{
|
||
if(tslfwave&&tslfwave[i]) delete tslfwave[i];
|
||
delete[] value2[i];
|
||
}
|
||
}
|
||
delete[] value2;
|
||
if(tslfwave) delete[] tslfwave;
|
||
for (int i = 0; i < ncurvs; i++)
|
||
{
|
||
if(OutCurveNo[i] > -1 && ndim[i] > 1)
|
||
delete[] value2forWave[i];
|
||
}
|
||
delete[] value2forWave;
|
||
|
||
for(int j = 0; j < ncurvs; j++)
|
||
{
|
||
if(OutCurveNo[j] > -1)
|
||
if(ndim[j] <= 1)
|
||
m_SlfFile.CloseCurve(OutCurveNo[j]);
|
||
else
|
||
m_SlfFile.CloseWave(OutCurveNo[j]);
|
||
}
|
||
|
||
m_SlfFile.Close();
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
BEGIN_REGISTER_ICONVERTOR(CLisConvertor)
|
||
sConvertorKey(GetLisConvertorTypeID(),"Lis Well Log Convertor")
|
||
END_REGISTER_ICONVERTOR(CLisConvertor );
|
||
|
||
END_OSGGRAPHICS_NAMESPACE
|