1516 lines
48 KiB
C++
1516 lines
48 KiB
C++
#pragma once
|
||
|
||
class XtfCvt
|
||
{
|
||
|
||
public:
|
||
int SystemCode;
|
||
|
||
CString findLetter(int nCode);
|
||
|
||
CString GetLetter(CString strText)
|
||
{
|
||
return strText;
|
||
};
|
||
|
||
short ToInt16(byte data[],int offset)
|
||
{
|
||
byte temp[2] ;
|
||
if (SystemCode == 1)
|
||
{
|
||
temp[0] = data[0 + offset];
|
||
temp[1] = data[1 + offset];
|
||
}
|
||
else
|
||
{
|
||
temp[0] = data[1 + offset];
|
||
temp[1] = data[0 + offset];
|
||
}
|
||
short result = *(short*)temp;
|
||
return result;
|
||
};
|
||
|
||
int ToInt32(byte data[], int offset)
|
||
{
|
||
byte temp[4];
|
||
if (SystemCode == 1)
|
||
{
|
||
temp[0] = data[0 + offset];
|
||
temp[1] = data[1 + offset];
|
||
temp[2] = data[2 + offset];
|
||
temp[3] = data[3 + offset];
|
||
}
|
||
else
|
||
{
|
||
temp[0] = data[3 + offset];
|
||
temp[1] = data[2 + offset];
|
||
temp[2] = data[1 + offset];
|
||
temp[3] = data[0 + offset];
|
||
}
|
||
int result = *(int*)temp;
|
||
return result;
|
||
};
|
||
|
||
long ToInt64(byte data[], int offset)
|
||
{
|
||
byte temp[8];// = new byte[8];
|
||
if (SystemCode == 1)
|
||
{
|
||
temp[0] = data[0 + offset];
|
||
temp[1] = data[1 + offset];
|
||
temp[2] = data[2 + offset];
|
||
temp[3] = data[3 + offset];
|
||
temp[4] = data[4 + offset];
|
||
temp[5] = data[5 + offset];
|
||
temp[6] = data[6 + offset];
|
||
temp[7] = data[7 + offset];
|
||
}
|
||
else
|
||
{
|
||
temp[0] = data[7 + offset];
|
||
temp[1] = data[6 + offset];
|
||
temp[2] = data[5 + offset];
|
||
temp[3] = data[4 + offset];
|
||
temp[4] = data[3 + offset];
|
||
temp[5] = data[2 + offset];
|
||
temp[6] = data[1 + offset];
|
||
temp[7] = data[0 + offset];
|
||
}
|
||
long result = *(long*)temp;
|
||
return result;
|
||
};
|
||
|
||
float ToFloat(byte data[], int offset)
|
||
{
|
||
byte temp[4];// = new byte[4];
|
||
if (SystemCode == 1)
|
||
{
|
||
temp[0] = data[0 + offset];
|
||
temp[1] = data[1 + offset];
|
||
temp[2] = data[2 + offset];
|
||
temp[3] = data[3 + offset];
|
||
}
|
||
else
|
||
{
|
||
temp[0] = data[3 + offset];
|
||
temp[1] = data[2 + offset];
|
||
temp[2] = data[1 + offset];
|
||
temp[3] = data[0 + offset];
|
||
}
|
||
float result = *(float*)temp;
|
||
return result;
|
||
};
|
||
|
||
double ToDouble(byte data[], int offset)
|
||
{
|
||
byte temp[8];// = new byte[8];
|
||
if (SystemCode == 1)
|
||
{
|
||
temp[0] = data[0 + offset];
|
||
temp[1] = data[1 + offset];
|
||
temp[2] = data[2 + offset];
|
||
temp[3] = data[3 + offset];
|
||
temp[4] = data[4 + offset];
|
||
temp[5] = data[5 + offset];
|
||
temp[6] = data[5 + offset];
|
||
temp[7] = data[6 + offset];
|
||
}
|
||
else
|
||
{
|
||
temp[0] = data[7 + offset];
|
||
temp[1] = data[6 + offset];
|
||
temp[2] = data[5 + offset];
|
||
temp[3] = data[4 + offset];
|
||
temp[4] = data[3 + offset];
|
||
temp[5] = data[2 + offset];
|
||
temp[6] = data[1 + offset];
|
||
temp[7] = data[0 + offset];
|
||
}
|
||
|
||
double result = *(double*)temp;
|
||
return result;
|
||
};
|
||
|
||
byte ToByte(byte data[], int offset)
|
||
{
|
||
byte temp = data[offset];
|
||
return temp;
|
||
};
|
||
|
||
CString ToCString(byte data[], int offset,int length)
|
||
{
|
||
char temp[4096]="";
|
||
|
||
for (int i = 0; i < length; i++)
|
||
{
|
||
temp[i] = (char)(data[i + offset]);
|
||
}
|
||
|
||
CString result =temp;
|
||
result.TrimLeft();
|
||
result.TrimRight();
|
||
|
||
return result;
|
||
};
|
||
|
||
|
||
int ToBytes(int data, byte bdata[], int offset)
|
||
{
|
||
byte temp[4];
|
||
byte result[4];
|
||
memcpy(temp,&data,4);
|
||
if (SystemCode == 1)
|
||
{
|
||
result[0] = temp[0];
|
||
result[1] = temp[1];
|
||
result[2] = temp[2];
|
||
result[3] = temp[3];
|
||
}
|
||
else
|
||
{
|
||
result[0] = temp[3];
|
||
result[1] = temp[2];
|
||
result[2] = temp[1];
|
||
result[3] = temp[0];
|
||
}
|
||
|
||
memcpy((void*)(bdata+offset),result,4);
|
||
|
||
return data;
|
||
};
|
||
|
||
byte ToBytes(byte data, byte bdata[], int offset)
|
||
{
|
||
bdata[offset]=data;
|
||
return data;
|
||
};
|
||
|
||
short ToBytes(short data, byte bdata[], int offset)
|
||
{
|
||
byte temp[2];
|
||
byte result[2];
|
||
memcpy(temp,&data,2);
|
||
if (SystemCode == 1)
|
||
{
|
||
result[0] = temp[0];
|
||
result[1] = temp[1];
|
||
}
|
||
else
|
||
{
|
||
|
||
result[0] = temp[1];
|
||
result[1] = temp[0];
|
||
}
|
||
|
||
memcpy((void*)(bdata+offset),result,2);
|
||
|
||
return data;
|
||
};
|
||
|
||
|
||
float ToBytes(float data, byte bdata[], int offset)
|
||
{
|
||
byte temp[4];
|
||
byte result[4];
|
||
memcpy(temp,&data,4);
|
||
|
||
if (SystemCode == 1)
|
||
{
|
||
result[0] = temp[0];
|
||
result[1] = temp[1];
|
||
result[2] = temp[2];
|
||
result[3] = temp[3];
|
||
}
|
||
else
|
||
{
|
||
result[0] = temp[3];
|
||
result[1] = temp[2];
|
||
result[2] = temp[1];
|
||
result[3] = temp[0];
|
||
}
|
||
|
||
memcpy((void*)(bdata+offset),result,4);
|
||
|
||
return data;
|
||
};
|
||
|
||
double ToBytes(double data, byte bdata[], int offset)
|
||
{
|
||
byte temp[8];
|
||
byte result[8];
|
||
memcpy(temp,&data,8);
|
||
|
||
|
||
if (SystemCode == 1)
|
||
{
|
||
result[0] = temp[0];
|
||
result[1] = temp[1];
|
||
result[2] = temp[2];
|
||
result[3] = temp[3];
|
||
result[4] = temp[4];
|
||
result[5] = temp[5];
|
||
result[6] = temp[6];
|
||
result[7] = temp[7];
|
||
}
|
||
else
|
||
{
|
||
result[0] = temp[7];
|
||
result[1] = temp[6];
|
||
result[2] = temp[5];
|
||
result[3] = temp[4];
|
||
result[4] = temp[3];
|
||
result[5] = temp[2];
|
||
result[6] = temp[1];
|
||
result[7] = temp[0];
|
||
}
|
||
|
||
memcpy((void*)(bdata+offset),result,8);
|
||
|
||
return data;
|
||
};
|
||
|
||
CString ToBytes(CString data, byte bdata[], int offset, int length)
|
||
{
|
||
int len=data.GetLength();
|
||
if(length<len)len=length;
|
||
for(int i=0;i<len;i++)
|
||
bdata[offset+i]=data.GetAt(i);
|
||
|
||
return data;
|
||
};
|
||
};
|
||
|
||
class CurveHeadInfo
|
||
{
|
||
public :
|
||
|
||
CString CurveName;
|
||
CString CurveUnit;
|
||
CString CurveRemark;
|
||
CString ServiceCompany;
|
||
CString ToolType;
|
||
CString CurveClass;
|
||
CString DepthUnit;
|
||
CString WaveTimeUnit;
|
||
CString StartTimeUnit;
|
||
CString OrinHeadRecord;
|
||
CString LogDirection; //???
|
||
|
||
float Step;
|
||
float Window;
|
||
float CBILAngle;
|
||
float TR_Distance;
|
||
float RR_Distance;
|
||
float OrinToSurface;
|
||
|
||
|
||
CString AIFName;
|
||
CString OCTName;
|
||
CString LisName;
|
||
CString ToolName;
|
||
float StartDepth;
|
||
float EndDepth;
|
||
float DepthLevel;
|
||
float MinValue;
|
||
float MaxValue;
|
||
float AvgValue;
|
||
float TimeValuesLevel;
|
||
float DACTimeOffset;
|
||
float StaticMeasureDepth;
|
||
float StandardDeviation;
|
||
|
||
double DoubleInitValues;
|
||
double DoubleStartDepth;
|
||
double DoubleEndDepth;
|
||
double DoubleDepthLevel;
|
||
int CreateDate;
|
||
int CreateTime;
|
||
int AccessDate;
|
||
int AccessTime;
|
||
int CurveHeadRecordNum;
|
||
int EndPosition;
|
||
float InitValues;
|
||
int SamplesNum;
|
||
short MajorVersion;
|
||
short MinorVersion;
|
||
short CurveIndex;
|
||
short CurveType;
|
||
short CurveDataType;
|
||
short CurveHorz;
|
||
short CurveVert;
|
||
short CurveDimNum;
|
||
short CurveE1Num;
|
||
short CurveE2Num;
|
||
short CurveE3Num;
|
||
|
||
short DataTypeFlag;
|
||
short HaveNegFlag;
|
||
short DataBitsNum;
|
||
short FixedWaveStartFlag;
|
||
short FixedWaveGain;
|
||
short WaveGainExp;
|
||
short GainMethod;
|
||
short GainApplyFlag;
|
||
short WaveLength;
|
||
short ToolNo;
|
||
short CurveSerialNo;
|
||
byte TranFillArea[24];//=new byte[24];
|
||
byte RecvFillArea[24];//=new byte[24];
|
||
byte SystemCode;
|
||
};
|
||
|
||
class MyXtfLib
|
||
{
|
||
|
||
public :
|
||
QFile *dataFile;
|
||
bool openFlag;
|
||
int fileOptions;
|
||
|
||
int BlockNum; //8
|
||
|
||
int CurveFlag[512]; //曲线处理标志,
|
||
|
||
|
||
//表1
|
||
byte HeadRecord[512];
|
||
CString FileExtation;
|
||
CString FilePath;
|
||
CString SystemDepthUnit;
|
||
CString AIFVersion;
|
||
|
||
byte SystemCode;
|
||
byte Version1;
|
||
byte Version2;//E;
|
||
int CurveNum;
|
||
int MaxCurveNum;
|
||
float FileStartDepth;
|
||
float FileEndDepth;
|
||
float FileDepthLevel;
|
||
|
||
//表2
|
||
byte BitmapHead; //头
|
||
byte BitmapRecords[4071];
|
||
byte BitmapValues[4];
|
||
byte BitmapFirst[4];
|
||
byte BitmapSecond[4];
|
||
byte BitmapPreview[4];
|
||
byte BitmapCurrent[4];
|
||
byte BitmapNext[4];
|
||
|
||
|
||
//表3
|
||
CString CurveName[512]; //曲线名
|
||
|
||
//表4
|
||
int CurveStartPos[512] ;//曲线开始位置
|
||
int CurveSampleNum[512] ; //曲线总采样点数
|
||
int CurveEndPos[512]; //曲线开始位置
|
||
|
||
//表5
|
||
short CurveDimNum[512]; //维数
|
||
short CurveE1Num[512]; //第1维数据个数
|
||
short CurveE2Num[512]; //第2维数据个数
|
||
short CurveE3Num[512]; //第3维数据个数
|
||
|
||
//表6
|
||
float CurveStartDepth[512];
|
||
float CurveEndDepth[512];
|
||
|
||
//表7
|
||
float CurveDepthLevel[512];
|
||
byte CurveType[512];
|
||
byte CurveDataType[512] ;
|
||
byte CurveHorz[512];
|
||
byte CurveVert[512] ;
|
||
|
||
//表8
|
||
CString WSI;
|
||
CString WellName;
|
||
CString OilFieldName;
|
||
CString CompanyName;
|
||
CString CountryName;
|
||
CString StatesName;
|
||
CString WellLocate;
|
||
float JingDu;
|
||
float WeiDu;
|
||
float HaiBa;
|
||
short SystemForM; //公英
|
||
float MagtCPJ; //磁偏角
|
||
|
||
|
||
//表9
|
||
CString CurveUnit[512];
|
||
|
||
CurveHeadInfo curveInfo[512];
|
||
|
||
int CreateDate;
|
||
int CreateTime;
|
||
int LastAccessDate;
|
||
int LastAccessTime;
|
||
|
||
XtfCvt XtfConvert;
|
||
|
||
MyXtfLib()//初始化所有变量
|
||
{
|
||
int i=0;
|
||
|
||
byte ByteArray[4096] = {0};
|
||
|
||
//表1
|
||
memset(ByteArray,0, 4096);
|
||
// HeadRecord = XtfConvert.ToCString(ByteArray, 0, 32);
|
||
FileExtation = XtfConvert.ToCString(ByteArray, 760, 4);
|
||
FileExtation.MakeLower();
|
||
FilePath = XtfConvert.ToCString(ByteArray, 764, 80);
|
||
SystemDepthUnit = XtfConvert.ToCString(ByteArray, 844, 8);
|
||
AIFVersion = XtfConvert.ToCString(ByteArray, 852, 8);
|
||
SystemCode = XtfConvert.ToByte(ByteArray, 948); //5=工作站，1=PC机，
|
||
|
||
XtfConvert.SystemCode = SystemCode;
|
||
|
||
Version1 = XtfConvert.ToByte(ByteArray, 950);
|
||
Version2 = XtfConvert.ToByte(ByteArray, 951);
|
||
CurveNum = XtfConvert.ToInt32(ByteArray, 996);
|
||
MaxCurveNum = XtfConvert.ToInt32(ByteArray, 1000);
|
||
FileStartDepth = XtfConvert.ToFloat(ByteArray, 2048);
|
||
FileEndDepth = XtfConvert.ToFloat(ByteArray, 2052);
|
||
FileDepthLevel = XtfConvert.ToFloat(ByteArray, 2056);
|
||
|
||
|
||
//表2
|
||
memset(ByteArray,0, 4096);
|
||
BitmapHead = ByteArray[0];
|
||
memcpy(BitmapRecords,ByteArray+1,4071);
|
||
memcpy(BitmapValues,ByteArray+4072,4);
|
||
|
||
//表3
|
||
memset(ByteArray,0, 4096);
|
||
for ( i = 0; i < 512; i++)
|
||
{
|
||
CurveName[i] = XtfConvert.ToCString(ByteArray, i * 8, 8);
|
||
}
|
||
|
||
//表4
|
||
memset(ByteArray,0, 4096);
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveStartPos[i] = XtfConvert.ToInt32(ByteArray, i * 8);
|
||
CurveStartPos[i+256] = XtfConvert.ToInt32(ByteArray, i * 8+4);
|
||
}
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveSampleNum[i] = XtfConvert.ToInt32(ByteArray, i * 8 + 2048);
|
||
CurveSampleNum[i + 256] = XtfConvert.ToInt32(ByteArray, i * 8 + 4 + 2048);
|
||
}
|
||
|
||
//表5
|
||
memset(ByteArray,0, 4096);
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveDimNum[i] = XtfConvert.ToInt16(ByteArray, i * 8);
|
||
CurveE1Num[i ] = XtfConvert.ToInt16(ByteArray, i * 8 + 2);
|
||
|
||
CurveDimNum[i + 256] = XtfConvert.ToInt16(ByteArray, i * 8 + 4);
|
||
CurveE1Num[i + 256] = XtfConvert.ToInt16(ByteArray, i * 8 + 6);
|
||
}
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveE2Num[i] = XtfConvert.ToInt16(ByteArray, i * 8 + 2048);
|
||
CurveE3Num[i] = XtfConvert.ToInt16(ByteArray, i * 8 + 2 + 2048);
|
||
|
||
CurveE2Num[i + 256] = XtfConvert.ToInt16(ByteArray, i * 8 + 4 + 2048);
|
||
CurveE3Num[i + 256] = XtfConvert.ToInt16(ByteArray, i * 8 + 6 + 2048);
|
||
}
|
||
|
||
//表6
|
||
memset(ByteArray,0, 4096);
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveStartDepth[i] = XtfConvert.ToFloat(ByteArray, i * 8);
|
||
CurveStartDepth[i + 256] = XtfConvert.ToFloat(ByteArray, i * 8 + 4);
|
||
}
|
||
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveEndDepth[i] = XtfConvert.ToFloat(ByteArray, i * 8 + 2048);
|
||
CurveEndDepth[i + 256] = XtfConvert.ToFloat(ByteArray, i * 8 + 4 + 2048);
|
||
}
|
||
|
||
//表7
|
||
memset(ByteArray,0, 4096);
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveDepthLevel[i] = XtfConvert.ToFloat(ByteArray, i * 8);
|
||
CurveDepthLevel[i + 256] = XtfConvert.ToFloat(ByteArray, i * 8 + 4);
|
||
}
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveType[i] = XtfConvert.ToByte(ByteArray, i * 8 + 2048);
|
||
CurveDataType[i] = XtfConvert.ToByte(ByteArray, i * 8 + 1 + 2048);
|
||
CurveHorz[i] = XtfConvert.ToByte(ByteArray, i * 8 + 2 + 2048);
|
||
CurveVert[i] = XtfConvert.ToByte(ByteArray, i * 8 + 3 + 2048);
|
||
|
||
CurveType[i + 256] = XtfConvert.ToByte(ByteArray, i * 8 + 4 + 2048);
|
||
CurveDataType[i + 256] = XtfConvert.ToByte(ByteArray, i * 8 + 5 + 2048);
|
||
CurveHorz[i + 256] = XtfConvert.ToByte(ByteArray, i * 8 + 6 + 2048);
|
||
CurveVert[i + 256] = XtfConvert.ToByte(ByteArray, i * 8 + 7 + 2048);
|
||
}
|
||
|
||
//表8
|
||
memset(ByteArray,0, 4096);
|
||
WSI = XtfConvert.ToCString(ByteArray, 0, 8);
|
||
WellName = XtfConvert.ToCString(ByteArray, 8, 80);
|
||
OilFieldName= XtfConvert.ToCString(ByteArray, 88, 80);
|
||
CompanyName = XtfConvert.ToCString(ByteArray, 168, 80);
|
||
CountryName = XtfConvert.ToCString(ByteArray, 248, 32);
|
||
// StatesName = XtfConvert.ToCString(ByteArray, 328, 32);
|
||
WellLocate = XtfConvert.ToCString(ByteArray, 336, 40);
|
||
JingDu = XtfConvert.ToFloat(ByteArray, 1024);
|
||
WeiDu = XtfConvert.ToFloat(ByteArray, 1028);
|
||
HaiBa = XtfConvert.ToFloat(ByteArray, 1040);
|
||
SystemForM = XtfConvert.ToInt16(ByteArray, 2060);
|
||
|
||
//扫描表9
|
||
|
||
// CreateDate = 0; //测井时间
|
||
// CreateTime = 0;
|
||
//whp change 2012.11.6
|
||
CreateDate=GetCurrentTime();
|
||
CreateTime = GetCurrentTime();
|
||
|
||
openFlag=false;
|
||
};
|
||
int Init()
|
||
{
|
||
int i=0;
|
||
byte aa[32768] ={0};
|
||
|
||
for( i=0;i<32;i++)
|
||
HeadRecord[i] = 0;
|
||
|
||
for ( i = 1; i <= 8; i++)
|
||
HeadRecord[i*4-1] = (byte)i;
|
||
|
||
WSI = "WSI";
|
||
SystemCode = 5; //？？？ //SUN
|
||
Version1 = 0x06;//4;
|
||
Version2 = 0x00;//E;
|
||
SystemForM = 0; //公制
|
||
SystemDepthUnit = "meters";
|
||
AIFVersion = "";
|
||
FileExtation = ".xtf";
|
||
|
||
|
||
CurveNum = 0;
|
||
MaxCurveNum = 512;
|
||
BlockNum = 8;
|
||
|
||
XtfConvert.SystemCode = SystemCode;
|
||
|
||
for ( i = 0; i < 512; i++)
|
||
{
|
||
CurveName[i] = "";
|
||
CurveStartPos[i] = 0;
|
||
CurveSampleNum[i] = 0;
|
||
CurveDimNum[i] = 0;
|
||
CurveE1Num[i] = 0;
|
||
CurveE2Num[i] = 0;
|
||
CurveE3Num[i] = 0;
|
||
|
||
CurveStartDepth[i] = 0;
|
||
CurveEndDepth[i] = 0;
|
||
|
||
CurveDepthLevel[i] = 0;
|
||
CurveType[i] = 0;
|
||
CurveDataType[i] = 0;
|
||
CurveHorz[i] = 0;
|
||
CurveVert[i] = 0;
|
||
|
||
CurveUnit[i] = "none";
|
||
SystemForM = 0;
|
||
|
||
CurveFlag[i]=0;
|
||
|
||
byte ccc[4096]={0};
|
||
CurveHeadGet(i,ccc);
|
||
|
||
|
||
memset(curveInfo[i].TranFillArea,0,24);
|
||
memset(curveInfo[i].RecvFillArea ,0,24);
|
||
}
|
||
return 0;
|
||
};
|
||
|
||
|
||
//method
|
||
|
||
int OpenDataFile(QString dataFileName, int nOpenFlags)
|
||
{
|
||
// srcFileFlag //nOpenFlags =0,Read,=1 Write,=2,readwrite;
|
||
Init();
|
||
|
||
if (openFlag)
|
||
{
|
||
dataFile->close();
|
||
openFlag = false;
|
||
}
|
||
//////////////////////////////////////////////////////////////////////////
|
||
///注释掉：是因为当再次打开别的文件时会提醒文件已经关闭的异常提示
|
||
//////////////////////////////////////////////////////////////////////////
|
||
{
|
||
dataFile=new QFile(dataFileName);
|
||
fileOptions = nOpenFlags;
|
||
if (fileOptions == 0)
|
||
{
|
||
dataFile->open(QIODevice::ReadOnly);
|
||
}
|
||
else if (fileOptions == 1)
|
||
{
|
||
dataFile->open(QIODevice::WriteOnly);
|
||
}
|
||
|
||
else if (fileOptions == 2)
|
||
{
|
||
dataFile->open(QIODevice::ReadWrite);
|
||
}
|
||
|
||
openFlag = true;
|
||
}
|
||
return 1;
|
||
|
||
};
|
||
|
||
int FileHead_Read()
|
||
{
|
||
int i=0;
|
||
int FileHead = 32*1024;
|
||
|
||
byte ByteArray[32768] = {0};
|
||
|
||
|
||
dataFile->seek(0);
|
||
|
||
//表1
|
||
dataFile->read((char*)&ByteArray[0], 4096);
|
||
// HeadRecord = XtfConvert.ToCString(ByteArray, 0, 32);
|
||
FileExtation = XtfConvert.ToCString(ByteArray, 760, 4);
|
||
FileExtation.MakeLower();
|
||
FilePath = XtfConvert.ToCString(ByteArray, 764, 80);
|
||
SystemDepthUnit = XtfConvert.ToCString(ByteArray, 844, 8);
|
||
AIFVersion = XtfConvert.ToCString(ByteArray, 852, 8);
|
||
SystemCode = XtfConvert.ToByte(ByteArray, 948); //5=工作站，1=PC机，
|
||
|
||
XtfConvert.SystemCode = SystemCode;
|
||
|
||
Version1 = XtfConvert.ToByte(ByteArray, 950);
|
||
Version2 = XtfConvert.ToByte(ByteArray, 951);
|
||
CurveNum = XtfConvert.ToInt32(ByteArray, 996);
|
||
MaxCurveNum = XtfConvert.ToInt32(ByteArray, 1000);
|
||
FileStartDepth = XtfConvert.ToFloat(ByteArray, 2048);
|
||
FileEndDepth = XtfConvert.ToFloat(ByteArray, 2052);
|
||
FileDepthLevel = XtfConvert.ToFloat(ByteArray, 2056);
|
||
|
||
|
||
//表2
|
||
dataFile->read((char*)&ByteArray[0], 4096);
|
||
BitmapHead = ByteArray[0];
|
||
memcpy(BitmapRecords,ByteArray+1,4071);
|
||
memcpy(BitmapValues,ByteArray+4072,4);
|
||
|
||
//表3
|
||
dataFile->read((char*)&ByteArray[0], 4096);
|
||
for ( i = 0; i < 512; i++)
|
||
{
|
||
CurveName[i] = XtfConvert.ToCString(ByteArray, i * 8, 8);
|
||
}
|
||
|
||
//表4
|
||
dataFile->read((char*)&ByteArray[0], 4096);
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveStartPos[i] = XtfConvert.ToInt32(ByteArray, i * 8);
|
||
CurveStartPos[i+256] = XtfConvert.ToInt32(ByteArray, i * 8+4);
|
||
}
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveSampleNum[i] = XtfConvert.ToInt32(ByteArray, i * 8 + 2048);
|
||
CurveSampleNum[i + 256] = XtfConvert.ToInt32(ByteArray, i * 8 + 4 + 2048);
|
||
}
|
||
|
||
//表5
|
||
dataFile->read((char*)&ByteArray[0], 4096);
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveDimNum[i] = XtfConvert.ToInt16(ByteArray, i * 8);
|
||
CurveE1Num[i ] = XtfConvert.ToInt16(ByteArray, i * 8 + 2);
|
||
|
||
CurveDimNum[i + 256] = XtfConvert.ToInt16(ByteArray, i * 8 + 4);
|
||
CurveE1Num[i + 256] = XtfConvert.ToInt16(ByteArray, i * 8 + 6);
|
||
}
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveE2Num[i] = XtfConvert.ToInt16(ByteArray, i * 8 + 2048);
|
||
CurveE3Num[i] = XtfConvert.ToInt16(ByteArray, i * 8 + 2 + 2048);
|
||
|
||
CurveE2Num[i + 256] = XtfConvert.ToInt16(ByteArray, i * 8 + 4 + 2048);
|
||
CurveE3Num[i + 256] = XtfConvert.ToInt16(ByteArray, i * 8 + 6 + 2048);
|
||
}
|
||
|
||
//表6
|
||
dataFile->read((char*)&ByteArray[0], 4096);
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveStartDepth[i] = XtfConvert.ToFloat(ByteArray, i * 8);
|
||
CurveStartDepth[i + 256] = XtfConvert.ToFloat(ByteArray, i * 8 + 4);
|
||
}
|
||
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveEndDepth[i] = XtfConvert.ToFloat(ByteArray, i * 8 + 2048);
|
||
CurveEndDepth[i + 256] = XtfConvert.ToFloat(ByteArray, i * 8 + 4 + 2048);
|
||
}
|
||
|
||
//表7
|
||
dataFile->read((char*)&ByteArray[0], 4096);
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveDepthLevel[i] = XtfConvert.ToFloat(ByteArray, i * 8);
|
||
CurveDepthLevel[i + 256] = XtfConvert.ToFloat(ByteArray, i * 8 + 4);
|
||
}
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
CurveType[i] = XtfConvert.ToByte(ByteArray, i * 8 + 2048);
|
||
CurveDataType[i] = XtfConvert.ToByte(ByteArray, i * 8 + 1 + 2048);
|
||
CurveHorz[i] = XtfConvert.ToByte(ByteArray, i * 8 + 2 + 2048);
|
||
CurveVert[i] = XtfConvert.ToByte(ByteArray, i * 8 + 3 + 2048);
|
||
|
||
CurveType[i + 256] = XtfConvert.ToByte(ByteArray, i * 8 + 4 + 2048);
|
||
CurveDataType[i + 256] = XtfConvert.ToByte(ByteArray, i * 8 + 5 + 2048);
|
||
CurveHorz[i + 256] = XtfConvert.ToByte(ByteArray, i * 8 + 6 + 2048);
|
||
CurveVert[i + 256] = XtfConvert.ToByte(ByteArray, i * 8 + 7 + 2048);
|
||
}
|
||
|
||
//表8
|
||
dataFile->read((char*)&ByteArray[0], 4096);
|
||
WSI = XtfConvert.ToCString(ByteArray, 0, 8);
|
||
WellName = XtfConvert.ToCString(ByteArray, 8, 80);
|
||
OilFieldName= XtfConvert.ToCString(ByteArray, 88, 80);
|
||
CompanyName = XtfConvert.ToCString(ByteArray, 168, 80);
|
||
CountryName = XtfConvert.ToCString(ByteArray, 248, 32);
|
||
// StatesName = XtfConvert.ToCString(ByteArray, 328, 32);
|
||
WellLocate = XtfConvert.ToCString(ByteArray, 336, 40);
|
||
JingDu = XtfConvert.ToFloat(ByteArray, 1024);
|
||
WeiDu = XtfConvert.ToFloat(ByteArray, 1028);
|
||
HaiBa = XtfConvert.ToFloat(ByteArray, 1040);
|
||
SystemForM = XtfConvert.ToInt16(ByteArray, 2060);
|
||
|
||
//扫描表9
|
||
for ( i = 0; i < CurveNum; i++)
|
||
{
|
||
long pos = (CurveStartPos[i] - 1) * 4096;
|
||
dataFile->seek(pos);
|
||
dataFile->read((char*)&ByteArray[0], 4096);
|
||
|
||
|
||
CurveHeadGet(i,ByteArray); //分析各个曲线头
|
||
|
||
CurveName[i] =curveInfo[i].CurveName;
|
||
CurveUnit[i] = curveInfo[i].CurveUnit;
|
||
CurveEndPos[i] = curveInfo[i].EndPosition;
|
||
|
||
}
|
||
CreateDate = curveInfo[0].CreateDate; //测井时间
|
||
CreateTime = curveInfo[0].CreateTime;
|
||
|
||
|
||
|
||
if (FileExtation != ".xtf" || MaxCurveNum != 512) // || UnixToPc.ToCString(head1.ExtendFileType) != ".XTF")
|
||
{
|
||
// MessageBox(" 不是EPLIPS5700 XTF格式的数据文件!");
|
||
|
||
return 0;
|
||
}
|
||
dataFile->seek(0);
|
||
|
||
return FileHead;
|
||
};
|
||
|
||
int FileHead_Write()
|
||
{
|
||
int i=0;
|
||
int FileHead = 32 * 1024;
|
||
|
||
Version1 = 0x06;
|
||
Version2 = 0x00;
|
||
|
||
// Version1 = 0x06;
|
||
// Version2 = 0x00;
|
||
|
||
SystemCode = 5; //5,new,输出固定为工作站模式
|
||
XtfConvert.SystemCode = SystemCode; //??????????????????????
|
||
////////////////////////////////////
|
||
|
||
byte ByteArray[32768] = {0};
|
||
dataFile->seek(0);
|
||
|
||
//表1
|
||
// HeadRecord="10002000300040005000600070008000";
|
||
for ( i = 0; i < 32; i++) ByteArray[i] = HeadRecord[i];
|
||
// XtfConvert.ToBytes(HeadRecord,ByteArray, 0,32);
|
||
|
||
FileExtation.MakeLower();
|
||
XtfConvert.ToBytes(FileExtation, ByteArray, 760, 4);
|
||
FilePath="/data1/data.xtf";
|
||
XtfConvert.ToBytes(FilePath, ByteArray, 764, 80);
|
||
XtfConvert.ToBytes(SystemDepthUnit, ByteArray, 844, 8);
|
||
XtfConvert.ToBytes(AIFVersion, ByteArray, 852, 8);
|
||
//whp add 2012.11.6 for SystemDepthUnit和AIFVersion不够8个字符的用空格填充
|
||
for ( i = 0; i < 16; i++)
|
||
{
|
||
if(ByteArray[844+i]==0)
|
||
{
|
||
ByteArray[844+i]=32;
|
||
}
|
||
}
|
||
XtfConvert.ToBytes(SystemCode, ByteArray, 948);
|
||
XtfConvert.ToBytes(Version1, ByteArray, 950);
|
||
XtfConvert.ToBytes(Version2, ByteArray, 952);
|
||
XtfConvert.ToBytes(CurveNum, ByteArray, 996);
|
||
XtfConvert.ToBytes(MaxCurveNum, ByteArray, 1000);
|
||
XtfConvert.ToBytes(FileStartDepth, ByteArray, 2048);
|
||
XtfConvert.ToBytes(FileEndDepth, ByteArray, 2052);
|
||
XtfConvert.ToBytes(FileDepthLevel, ByteArray, 2056);
|
||
//float temp_float = 0.00508f;
|
||
//XtfConvert.ToBytes(temp_float, ByteArray, 2056);
|
||
|
||
ByteArray[4094] = 0x0E;
|
||
ByteArray[4095] = 0xE0;
|
||
|
||
dataFile->write((char*)&ByteArray[0], 4096);
|
||
|
||
//表2
|
||
memset(ByteArray,0,4096); //清0；
|
||
|
||
int xx = BlockNum / 8;
|
||
int yy = BlockNum % 8;
|
||
for( i=0;i<xx;i++)ByteArray[i]=255;
|
||
ByteArray[xx]=0;
|
||
byte tt[8]={0x80,0x40,0x20,0x10,8,4,2,1};
|
||
for( i=0;i<yy;i++)
|
||
{
|
||
ByteArray[xx] |= tt[i];
|
||
}
|
||
|
||
xx = 0;
|
||
XtfConvert.ToBytes(xx, ByteArray, 4072); //旗标值
|
||
|
||
xx = 1;
|
||
XtfConvert.ToBytes(xx, ByteArray, 4076); //第一个
|
||
|
||
xx = 32576;
|
||
XtfConvert.ToBytes(xx, ByteArray, 4080); //第二个
|
||
|
||
xx = 0;
|
||
XtfConvert.ToBytes(xx, ByteArray, 4084); //前一个
|
||
|
||
xx = 2;
|
||
XtfConvert.ToBytes(xx, ByteArray, 4088); //当前记录数
|
||
|
||
xx = 0;
|
||
XtfConvert.ToBytes(xx, ByteArray, 4092); //下一个
|
||
|
||
dataFile->write((char*)&ByteArray[0], 4096);
|
||
|
||
|
||
//表3
|
||
memset(ByteArray,0,4096); //清0；
|
||
for ( i = 0; i < 512; i++)
|
||
{
|
||
// CurveName[i] = HzClass.Convert(CurveName[i]); //去除汉字
|
||
XtfConvert.ToBytes(CurveName[i],ByteArray,i * 8, 8);
|
||
}
|
||
//whp add 2012.11.6 for 曲线名用不够8个字符的用空格填充
|
||
for ( i = 0; i < 4096; i++)
|
||
{
|
||
if(ByteArray[i]==0)
|
||
{
|
||
ByteArray[i]=32;
|
||
}
|
||
}
|
||
dataFile->write((char*)&ByteArray[0], 4096);
|
||
|
||
//表4
|
||
memset(ByteArray, 0,4096); //清0；
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
XtfConvert.ToBytes(CurveStartPos[i], ByteArray, i * 8);
|
||
XtfConvert.ToBytes(CurveStartPos[i+256],ByteArray,i * 8+4);
|
||
}
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
XtfConvert.ToBytes(CurveSampleNum[i],ByteArray,i * 8 + 2048);
|
||
XtfConvert.ToBytes(CurveSampleNum[i+256],ByteArray,i * 8 + 4 + 2048);
|
||
}
|
||
dataFile->write((char*)&ByteArray[0], 4096);
|
||
|
||
//表5
|
||
memset(ByteArray,0, 4096); //清0；
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
XtfConvert.ToBytes(CurveDimNum[i], ByteArray, i * 8);
|
||
XtfConvert.ToBytes(CurveE1Num[i], ByteArray, i * 8 + 2);
|
||
|
||
XtfConvert.ToBytes(CurveDimNum[i+256], ByteArray, i * 8+4);
|
||
XtfConvert.ToBytes(CurveE1Num[i+256], ByteArray, i * 8 + 6);
|
||
}
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
XtfConvert.ToBytes(CurveE2Num[i], ByteArray, i * 8 + 2048);
|
||
XtfConvert.ToBytes(CurveE3Num[i], ByteArray, i * 8 + 2 + 2048);
|
||
|
||
XtfConvert.ToBytes(CurveE2Num[i + 256], ByteArray, i * 8 + 4 + 2048);
|
||
XtfConvert.ToBytes(CurveE3Num[i + 256], ByteArray, i * 8 + 6 + 2048);
|
||
}
|
||
dataFile->write((char*)&ByteArray[0], 4096);
|
||
|
||
//表6
|
||
memset(ByteArray,0,4096); //清0；
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
XtfConvert.ToBytes(CurveStartDepth[i], ByteArray, i * 8);
|
||
XtfConvert.ToBytes(CurveStartDepth[i + 256], ByteArray, i * 8 + 4);
|
||
}
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
XtfConvert.ToBytes(CurveEndDepth[i], ByteArray, i * 8 + 2048);
|
||
XtfConvert.ToBytes(CurveEndDepth[i + 256], ByteArray, i * 8 + 4 + 2048);
|
||
}
|
||
dataFile->write((char*)&ByteArray[0], 4096);
|
||
|
||
//表7
|
||
memset(ByteArray,0,4096); //清0；
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
XtfConvert.ToBytes(CurveDepthLevel[i], ByteArray, i * 8);
|
||
XtfConvert.ToBytes(CurveDepthLevel[i+256], ByteArray, i * 8+4);
|
||
}
|
||
for ( i = 0; i < 256; i++)
|
||
{
|
||
XtfConvert.ToBytes(CurveType[i], ByteArray, i * 8 + 2048);
|
||
XtfConvert.ToBytes(CurveDataType[i], ByteArray, i * 8 + 1 + 2048);
|
||
XtfConvert.ToBytes(CurveHorz[i], ByteArray, i * 8 + 2 + 2048);
|
||
XtfConvert.ToBytes(CurveVert[i], ByteArray, i * 8 + 3 + 2048);
|
||
|
||
XtfConvert.ToBytes(CurveType[i + 256], ByteArray, i * 8 + 4 + 2048);
|
||
XtfConvert.ToBytes(CurveDataType[i + 256], ByteArray, i * 8 + 5 + 2048);
|
||
XtfConvert.ToBytes(CurveHorz[i + 256], ByteArray, i * 8 + 6 + 2048);
|
||
XtfConvert.ToBytes(CurveVert[i + 256], ByteArray, i * 8 + 7 + 2048);
|
||
}
|
||
dataFile->write((char*)&ByteArray[0], 4096);
|
||
|
||
//表8
|
||
memset(ByteArray,0,4096); //清0；
|
||
for ( i = 0; i < 1024; i++) ByteArray[i] = 0x20;
|
||
|
||
WellName = XtfConvert.GetLetter(WellName);
|
||
OilFieldName = XtfConvert.GetLetter(OilFieldName);
|
||
CompanyName = XtfConvert.GetLetter(CompanyName);
|
||
CountryName = XtfConvert.GetLetter(CountryName);
|
||
WellLocate = XtfConvert.GetLetter(WellLocate);
|
||
|
||
XtfConvert.ToBytes(WSI, ByteArray, 0 ,8); //有效图头
|
||
XtfConvert.ToBytes(WellName, ByteArray, 8, 80); //井名
|
||
XtfConvert.ToBytes(OilFieldName, ByteArray, 88, 80); // 油田名
|
||
XtfConvert.ToBytes(CompanyName, ByteArray, 168, 80); //公司名
|
||
XtfConvert.ToBytes(CountryName, ByteArray, 248, 32); //国家名
|
||
XtfConvert.ToBytes(WellLocate, ByteArray, 336, 40); //井位
|
||
|
||
XtfConvert.ToBytes(JingDu, ByteArray, 336); //经度
|
||
XtfConvert.ToBytes(WeiDu, ByteArray, 1028); //维度
|
||
XtfConvert.ToBytes(HaiBa, ByteArray, 1040); //海拔
|
||
XtfConvert.ToBytes(SystemForM, ByteArray,2060); //系统制
|
||
dataFile->write((char*)&ByteArray[0], 4096);
|
||
|
||
|
||
dataFile->flush();
|
||
|
||
return FileHead;
|
||
};
|
||
|
||
int CloseDataFile()
|
||
{
|
||
if (openFlag)
|
||
{
|
||
dataFile->close();
|
||
openFlag = false;
|
||
}
|
||
return 0;
|
||
};
|
||
|
||
int CurveHeadGet(int CurveNo, byte ByteArray[])
|
||
{
|
||
curveInfo[CurveNo].CurveName = XtfConvert.ToCString(ByteArray, 0, 8); //曲线名称
|
||
|
||
curveInfo[CurveNo].CurveUnit = XtfConvert.ToCString(ByteArray, 8, 8); //曲线单位
|
||
|
||
curveInfo[CurveNo].CurveRemark = XtfConvert.ToCString(ByteArray, 16, 8); //曲线备注
|
||
|
||
curveInfo[CurveNo].ServiceCompany = XtfConvert.ToCString(ByteArray, 48, 8); //服务公司
|
||
|
||
curveInfo[CurveNo].ToolType = XtfConvert.ToCString(ByteArray, 48, 8); //仪器类型
|
||
|
||
curveInfo[CurveNo].CurveClass = XtfConvert.ToCString(ByteArray, 56, 8); //曲线类型
|
||
|
||
curveInfo[CurveNo].DepthUnit = XtfConvert.ToCString(ByteArray, 64, 8); //深度单位
|
||
|
||
curveInfo[CurveNo].WaveTimeUnit = XtfConvert.ToCString(ByteArray, 72, 8); //波列时间增量单位
|
||
|
||
//???
|
||
//???
|
||
curveInfo[CurveNo].LogDirection = XtfConvert.ToCString(ByteArray, 120, 8); //测井方向
|
||
|
||
curveInfo[CurveNo].AIFName = XtfConvert.ToCString(ByteArray, 128, 8); //AIF名
|
||
curveInfo[CurveNo].OCTName = XtfConvert.ToCString(ByteArray, 152, 8); //OCT名
|
||
curveInfo[CurveNo].ToolName = XtfConvert.ToCString(ByteArray, 152, 8); //仪器名
|
||
|
||
curveInfo[CurveNo].LisName = XtfConvert.ToCString(ByteArray, 224, 8); //LIS名
|
||
|
||
curveInfo[CurveNo].StartDepth = XtfConvert.ToFloat(ByteArray, 1024); //开始深度
|
||
curveInfo[CurveNo].EndDepth = XtfConvert.ToFloat(ByteArray, 1028); //结束深度
|
||
curveInfo[CurveNo].DepthLevel = XtfConvert.ToFloat(ByteArray, 1032); //深度采样间隔
|
||
curveInfo[CurveNo].MinValue = XtfConvert.ToFloat(ByteArray, 1036); //曲线最小值
|
||
curveInfo[CurveNo].MaxValue = XtfConvert.ToFloat(ByteArray, 1040); //曲线最大值
|
||
curveInfo[CurveNo].AvgValue = XtfConvert.ToFloat(ByteArray, 1044); //曲线平均值
|
||
|
||
curveInfo[CurveNo].TimeValuesLevel = XtfConvert.ToFloat(ByteArray, 1048); //基于时间曲线的时间增量
|
||
|
||
curveInfo[CurveNo].DACTimeOffset = XtfConvert.ToFloat(ByteArray, 1052); //DAC起始时间
|
||
|
||
curveInfo[CurveNo].StaticMeasureDepth = XtfConvert.ToFloat(ByteArray, 1056); //静态测量深度
|
||
|
||
curveInfo[CurveNo].Step = XtfConvert.ToFloat(ByteArray, 1068); //静态测量深度
|
||
curveInfo[CurveNo].Window = XtfConvert.ToFloat(ByteArray, 1072); //静态测量深度
|
||
curveInfo[CurveNo].CBILAngle = XtfConvert.ToFloat(ByteArray, 1076); //静态测量深度
|
||
curveInfo[CurveNo].TR_Distance = XtfConvert.ToFloat(ByteArray, 1080); //静态测量深度
|
||
curveInfo[CurveNo].RR_Distance = XtfConvert.ToFloat(ByteArray, 1084); //静态测量深度
|
||
curveInfo[CurveNo].OrinToSurface = XtfConvert.ToFloat(ByteArray, 1088); //静态测量深度
|
||
|
||
|
||
|
||
curveInfo[CurveNo].DoubleStartDepth = XtfConvert.ToDouble(ByteArray, 1544); //设备类型
|
||
curveInfo[CurveNo].DoubleEndDepth = XtfConvert.ToDouble(ByteArray, 1552); //设备类型
|
||
curveInfo[CurveNo].DoubleDepthLevel = XtfConvert.ToDouble(ByteArray, 1560); //设备类型
|
||
|
||
curveInfo[CurveNo].CreateDate = XtfConvert.ToInt32(ByteArray, 2048); //设备类型
|
||
curveInfo[CurveNo].CreateTime = XtfConvert.ToInt32(ByteArray, 2052); //设备类型
|
||
|
||
curveInfo[CurveNo].AccessDate = XtfConvert.ToInt32(ByteArray, 2056); //设备类型
|
||
curveInfo[CurveNo].AccessTime = XtfConvert.ToInt32(ByteArray, 2060); //设备类型
|
||
|
||
curveInfo[CurveNo].AccessTime = XtfConvert.ToInt32(ByteArray, 2060); //设备类型
|
||
|
||
curveInfo[CurveNo].CurveHeadRecordNum = XtfConvert.ToInt32(ByteArray, 2064); //设备类型
|
||
curveInfo[CurveNo].EndPosition = XtfConvert.ToInt32(ByteArray, 2068); //设备类型
|
||
curveInfo[CurveNo].SamplesNum = XtfConvert.ToInt32(ByteArray, 2076); //设备类型
|
||
|
||
curveInfo[CurveNo].CurveIndex = XtfConvert.ToInt16(ByteArray, 2564); //设备类型
|
||
|
||
curveInfo[CurveNo].CurveType = XtfConvert.ToInt16(ByteArray, 2566); //设备类型
|
||
curveInfo[CurveNo].CurveDataType = XtfConvert.ToInt16(ByteArray, 2568); //设备类型
|
||
curveInfo[CurveNo].CurveVert = XtfConvert.ToInt16(ByteArray, 2570); //设备类型
|
||
curveInfo[CurveNo].CurveHorz = XtfConvert.ToInt16(ByteArray, 2572); //设备类型
|
||
|
||
curveInfo[CurveNo].CurveDimNum = XtfConvert.ToInt16(ByteArray, 2574); //设备类型
|
||
curveInfo[CurveNo].CurveE1Num = XtfConvert.ToInt16(ByteArray, 2576); //设备类型
|
||
curveInfo[CurveNo].CurveE2Num = XtfConvert.ToInt16(ByteArray, 2578); //设备类型
|
||
curveInfo[CurveNo].CurveE3Num = XtfConvert.ToInt16(ByteArray, 2580); //设备类型
|
||
|
||
curveInfo[CurveNo].DataTypeFlag = XtfConvert.ToInt16(ByteArray, 2592); //设备类型
|
||
curveInfo[CurveNo].HaveNegFlag = XtfConvert.ToInt16(ByteArray, 2594); //设备类型
|
||
curveInfo[CurveNo].DataBitsNum = XtfConvert.ToInt16(ByteArray, 2596); //设备类型
|
||
curveInfo[CurveNo].FixedWaveStartFlag = XtfConvert.ToInt16(ByteArray, 2606); //设备类型
|
||
|
||
curveInfo[CurveNo].FixedWaveGain = XtfConvert.ToInt16(ByteArray, 2608); //设备类型
|
||
|
||
curveInfo[CurveNo].WaveGainExp = XtfConvert.ToInt16(ByteArray, 2610); //设备类型
|
||
|
||
curveInfo[CurveNo].GainMethod = XtfConvert.ToInt16(ByteArray, 2612); //设备类型
|
||
|
||
curveInfo[CurveNo].GainApplyFlag = XtfConvert.ToInt16(ByteArray, 2614); //设备类型
|
||
|
||
curveInfo[CurveNo].WaveLength = XtfConvert.ToInt16(ByteArray, 2616); //设备类型
|
||
|
||
curveInfo[CurveNo].ToolNo = XtfConvert.ToInt16(ByteArray, 2618); //设备类型
|
||
|
||
|
||
curveInfo[CurveNo].CurveSerialNo = XtfConvert.ToInt16(ByteArray, 2620); //设备类型
|
||
|
||
for (int i = 0; i < 24; i++)
|
||
{
|
||
curveInfo[CurveNo].TranFillArea[i] = XtfConvert.ToByte(ByteArray, 3072+i); //设备类型
|
||
|
||
curveInfo[CurveNo].RecvFillArea[i] = XtfConvert.ToByte(ByteArray, 3096+i); //设备类型
|
||
}
|
||
|
||
curveInfo[CurveNo].SystemCode = XtfConvert.ToByte(ByteArray, 4095); //设备类型
|
||
|
||
/* if (curveInfo[CurveNo].CurveName.Contains("TX"))
|
||
{
|
||
byte b1=ByteArray[0x668];
|
||
byte b2 = ByteArray[0x669];
|
||
byte b3 = ByteArray[0x66A];
|
||
|
||
byte c1 = ByteArray[0xA00];
|
||
byte c2 = ByteArray[0xA01];
|
||
byte c3 = ByteArray[0xA02];
|
||
byte c4 = ByteArray[0xA03];
|
||
|
||
byte d1 = ByteArray[0xD55];
|
||
byte d2 = ByteArray[0xD56];
|
||
|
||
}*/
|
||
|
||
return CurveNo;
|
||
};
|
||
|
||
|
||
int CurveHeadSet(int CurveNo, byte ByteArray[])
|
||
{
|
||
CString temp_str = "";
|
||
int temp_int = 0;
|
||
long temp_long = 0;
|
||
float temp_float = 0;
|
||
short temp_short = 0;
|
||
double temp_double = 0;
|
||
for (int i = 0; i < 1024; i++) ByteArray[i] = 0x20;
|
||
XtfConvert.ToBytes(CurveName[CurveNo], ByteArray, 0,8); //曲线名称
|
||
|
||
curveInfo[CurveNo].CurveName = CurveName[CurveNo];
|
||
curveInfo[CurveNo].CurveUnit = CurveUnit[CurveNo];
|
||
|
||
//单位变换
|
||
/* if (CurveUnit[CurveNo] == "") CurveUnit[CurveNo] = "raw";
|
||
if (CurveUnit[CurveNo].Contains("Ω")) CurveUnit[CurveNo] = CurveUnit[CurveNo].Replace("Ω", "ohm");
|
||
if (CurveUnit[CurveNo].Contains("℃")) CurveUnit[CurveNo] = CurveUnit[CurveNo].Replace("℃", "degC");
|
||
if (CurveUnit[CurveNo].Contains("^")) CurveUnit[CurveNo] = CurveUnit[CurveNo].Replace("^", "");
|
||
if (CurveUnit[CurveNo].Contains("度")) CurveUnit[CurveNo] = CurveUnit[CurveNo].Replace("度", "deg");
|
||
if (CurveUnit[CurveNo].Contains("°")) CurveUnit[CurveNo] = CurveUnit[CurveNo].Replace("°", "deg");
|
||
if (CurveUnit[CurveNo].Contains("%")) CurveUnit[CurveNo] = CurveUnit[CurveNo].Replace("%", "pu");
|
||
if (CurveUnit[CurveNo].Contains("mS/m")) CurveUnit[CurveNo] = CurveUnit[CurveNo].Replace("mS/m", "mmho/m");
|
||
if (CurveUnit[CurveNo].Contains("g/cm^3")) CurveUnit[CurveNo] = CurveUnit[CurveNo].Replace("g/cm^3", "g/cm3");
|
||
if (CurveUnit[CurveNo].Contains("CPS")) CurveUnit[CurveNo] = CurveUnit[CurveNo].Replace("CPS", "cts/s");
|
||
|
||
if (curveInfo[CurveNo].CurveName == "GR") CurveUnit[CurveNo] = "gAPI";
|
||
|
||
curveInfo[CurveNo].CurveUnit = CurveUnit[CurveNo];
|
||
|
||
if (CurveFlag[CurveNo] > 1)
|
||
{
|
||
if (curveInfo[CurveNo].CurveName.Contains("WV") || (curveInfo[CurveNo].CurveName.Contains("GN")) || (curveInfo[CurveNo].CurveName.Contains("ST")))
|
||
{
|
||
if (curveInfo[CurveNo].CurveName.Contains("TF"))
|
||
{
|
||
curveInfo[CurveNo].OrinToSurface = -5.334f;
|
||
curveInfo[CurveNo].TR_Distance = 3.6576f;
|
||
curveInfo[CurveNo].RR_Distance = 0.1524f;
|
||
curveInfo[CurveNo].StartTimeUnit = "us";
|
||
curveInfo[CurveNo].WaveTimeUnit = "us";
|
||
// curveInfo[CurveNo].TimeValuesLevel = 12;
|
||
|
||
curveInfo[CurveNo].FixedWaveStartFlag = 1;
|
||
curveInfo[CurveNo].FixedWaveGain = 1;
|
||
|
||
for (int i = 0; i < 8; i++)
|
||
{
|
||
curveInfo[CurveNo].TranFillArea[i] = (byte)0x01;//发射器填充区
|
||
curveInfo[CurveNo].RecvFillArea[i] = (byte)(0x01 + i);//接收器填充区
|
||
}
|
||
}
|
||
|
||
if (curveInfo[CurveNo].CurveName.Contains("TN"))
|
||
{
|
||
curveInfo[CurveNo].OrinToSurface = -5.7912f;
|
||
curveInfo[CurveNo].TR_Distance = 2.5908f;
|
||
curveInfo[CurveNo].RR_Distance = 0.1524f;
|
||
curveInfo[CurveNo].StartTimeUnit = "us";
|
||
curveInfo[CurveNo].WaveTimeUnit = "us";
|
||
// curveInfo[CurveNo].TimeValuesLevel = 8;
|
||
|
||
curveInfo[CurveNo].FixedWaveStartFlag = 1;
|
||
curveInfo[CurveNo].FixedWaveGain = 1;
|
||
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
curveInfo[CurveNo].TranFillArea[i] = (byte)0x02;//发射器填充区
|
||
curveInfo[CurveNo].RecvFillArea[i] = (byte)(0x01 + i);//接收器填充区
|
||
}
|
||
}
|
||
|
||
if (curveInfo[CurveNo].CurveName.Contains("TXX") || curveInfo[CurveNo].CurveName.Contains("TXY"))
|
||
{
|
||
curveInfo[CurveNo].OrinToSurface = -5.6388f;
|
||
curveInfo[CurveNo].TR_Distance = 3.2004f;
|
||
curveInfo[CurveNo].RR_Distance = 0.1524f;
|
||
curveInfo[CurveNo].StartTimeUnit = "us";
|
||
curveInfo[CurveNo].WaveTimeUnit = "us";
|
||
// curveInfo[CurveNo].TimeValuesLevel = 36;
|
||
|
||
curveInfo[CurveNo].FixedWaveStartFlag = 1;
|
||
curveInfo[CurveNo].FixedWaveGain = 1;
|
||
|
||
for (int i = 0; i < 8; i++)
|
||
{
|
||
curveInfo[CurveNo].TranFillArea[i] = (byte)0x03;//发射器填充区
|
||
curveInfo[CurveNo].RecvFillArea[i] = (byte)(0x01 + i);//接收器填充区
|
||
}
|
||
|
||
}
|
||
if (curveInfo[CurveNo].CurveName.Contains("TYX") || curveInfo[CurveNo].CurveName.Contains("TYY"))
|
||
{
|
||
curveInfo[CurveNo].OrinToSurface = -5.6388f;
|
||
curveInfo[CurveNo].TR_Distance = 3.2004f;
|
||
curveInfo[CurveNo].RR_Distance = 0.1524f;
|
||
curveInfo[CurveNo].StartTimeUnit = "us";
|
||
curveInfo[CurveNo].WaveTimeUnit = "us";
|
||
// curveInfo[CurveNo].TimeValuesLevel = 36;
|
||
|
||
curveInfo[CurveNo].FixedWaveStartFlag = 1;
|
||
curveInfo[CurveNo].FixedWaveGain = 1;
|
||
|
||
for (int i = 0; i < 8; i++)
|
||
{
|
||
curveInfo[CurveNo].TranFillArea[i] = (byte)0x04;//发射器填充区
|
||
curveInfo[CurveNo].RecvFillArea[i] = (byte)(0x01 + i);//接收器填充区
|
||
}
|
||
}
|
||
}
|
||
}*/
|
||
|
||
|
||
XtfConvert.ToBytes(CurveUnit[CurveNo], ByteArray, 8,8);
|
||
|
||
|
||
temp_str = "j727e03.aff";// CurveName[CurveNo];
|
||
XtfConvert.ToBytes(temp_str, ByteArray, 16, 24); //曲线备注
|
||
|
||
temp_str = "ATLAS";
|
||
XtfConvert.ToBytes(temp_str, ByteArray, 40, 8); //设备类型
|
||
|
||
|
||
temp_str = " ";
|
||
XtfConvert.ToBytes(temp_str, ByteArray, 48,8); //仪器类型
|
||
|
||
temp_str = "AFF";
|
||
XtfConvert.ToBytes(temp_str, ByteArray, 56,8); //曲线类型
|
||
|
||
temp_str = SystemDepthUnit;
|
||
XtfConvert.ToBytes(temp_str, ByteArray, 64, 8);
|
||
|
||
temp_str = "up";
|
||
XtfConvert.ToBytes(temp_str, ByteArray, 120, 8); //测井方向
|
||
|
||
XtfConvert.ToBytes(CurveName[CurveNo], ByteArray, 128, 4); //AIF
|
||
temp_str = "j727e";
|
||
XtfConvert.ToBytes(temp_str, ByteArray, 152, 8); //OCT
|
||
|
||
temp_str = "1515MA";
|
||
XtfConvert.ToBytes(temp_str, ByteArray, 160, 48); //仪器名字
|
||
|
||
XtfConvert.ToBytes(CurveName[CurveNo], ByteArray, 224, 4); //LIS
|
||
temp_str = " aff2xtf Rev 1.0";
|
||
XtfConvert.ToBytes(temp_str, ByteArray, 228, 796); //no use
|
||
|
||
XtfConvert.ToBytes(CurveStartDepth[CurveNo], ByteArray, 1024); //开始深度float
|
||
XtfConvert.ToBytes(CurveEndDepth[CurveNo], ByteArray, 1028); //结束深度float
|
||
XtfConvert.ToBytes(CurveDepthLevel[CurveNo], ByteArray, 1032); //深度间隔float
|
||
|
||
temp_float = -999999.;//0;
|
||
XtfConvert.ToBytes(temp_float, ByteArray, 1036); //min
|
||
temp_float = 999999.;//0;
|
||
XtfConvert.ToBytes(temp_float, ByteArray, 1040); //max
|
||
temp_float = 0;
|
||
XtfConvert.ToBytes(temp_float, ByteArray, 1044); //avg
|
||
|
||
|
||
temp_double = 1000000;
|
||
XtfConvert.ToBytes(temp_double, ByteArray, 1536); //start depth, double
|
||
temp_double = CurveStartDepth[CurveNo];
|
||
XtfConvert.ToBytes(temp_double, ByteArray, 1544); //start depth, double
|
||
temp_double = CurveEndDepth[CurveNo];
|
||
XtfConvert.ToBytes(temp_double, ByteArray, 1552); //end depth,double
|
||
temp_double = CurveDepthLevel[CurveNo];
|
||
XtfConvert.ToBytes(temp_double, ByteArray, 1560); //depth level,double
|
||
|
||
XtfConvert.ToBytes(CreateDate, ByteArray, 2048); //创建时间
|
||
XtfConvert.ToBytes(CreateTime, ByteArray, 2052); //创建时间
|
||
XtfConvert.ToBytes(CreateDate, ByteArray, 2056); //访问时间
|
||
XtfConvert.ToBytes(CreateTime, ByteArray, 2060); //访问时间
|
||
|
||
|
||
temp_int = 1;
|
||
XtfConvert.ToBytes(temp_int, ByteArray, 2064); //头记录数
|
||
|
||
temp_int = CurveEndPos[CurveNo];
|
||
XtfConvert.ToBytes(temp_int, ByteArray, 2068); //曲线结束记录位置
|
||
|
||
// temp_int = 0;
|
||
// XtfConvert.ToBytes(temp_int, ByteArray, 2072); //
|
||
|
||
temp_float = -9999.0f;
|
||
XtfConvert.ToBytes(temp_float, ByteArray, 2072); //浮点数初始值
|
||
|
||
temp_int = CurveSampleNum[CurveNo];
|
||
XtfConvert.ToBytes(temp_int, ByteArray, 2076); //曲线采样总点数
|
||
|
||
// temp_str = " ";
|
||
// XtfConvert.ToBytes(temp_str, ByteArray, 2088, 472); //no use
|
||
|
||
temp_short = (short)(CurveNo+1);
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2564); //曲线索引号
|
||
|
||
temp_short = (short)CurveType[CurveNo];
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2566); //曲线类型
|
||
|
||
temp_short = (short)CurveDataType[CurveNo];
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2568); //数据类型
|
||
|
||
temp_short = (short)CurveVert[CurveNo];
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2570); //垂直特性
|
||
|
||
temp_short = (short)CurveHorz[CurveNo];
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2572); //垂直特性
|
||
|
||
|
||
temp_short = (short)CurveDimNum[CurveNo];
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2574); //维数
|
||
|
||
temp_short = (short)CurveE1Num[CurveNo];
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2576); //第1维个数
|
||
|
||
temp_short = (short)CurveE2Num[CurveNo];
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2578); //第2维个数
|
||
|
||
temp_short = (short)CurveE3Num[CurveNo];
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2580); //第3维个数
|
||
|
||
temp_short = -32767;
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2590); //INT*2初始值
|
||
|
||
if (CurveDataType[CurveNo] == 2 || CurveDataType[CurveNo] == 9)
|
||
{
|
||
temp_short = 1;
|
||
}
|
||
else
|
||
{
|
||
temp_short = 2;
|
||
}
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2592); //数据类型旗标
|
||
|
||
|
||
temp_short = 1;
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2594); //有无负号标志，1有
|
||
|
||
if (CurveDataType[CurveNo] == 2 || CurveDataType[CurveNo] == 9)
|
||
temp_short = 16;
|
||
else
|
||
temp_short = 32;
|
||
XtfConvert.ToBytes(temp_short, ByteArray, 2596); //每个数据元素位数
|
||
|
||
if (CurveFlag[CurveNo] > 0)
|
||
{
|
||
XtfConvert.ToBytes(curveInfo[CurveNo].TR_Distance, ByteArray, 1080); //T-R距离
|
||
XtfConvert.ToBytes(curveInfo[CurveNo].RR_Distance, ByteArray, 1084); //R-R距离
|
||
XtfConvert.ToBytes(curveInfo[CurveNo].OrinToSurface, ByteArray, 1088); //R-R距离
|
||
|
||
for (int i = 0; i < 24; i++)
|
||
{
|
||
XtfConvert.ToBytes(curveInfo[CurveNo].TranFillArea[i], ByteArray, 3072 + i); //发射填充区
|
||
XtfConvert.ToBytes(curveInfo[CurveNo].RecvFillArea[i], ByteArray, 3096+i); //接收器填充区
|
||
}
|
||
|
||
XtfConvert.ToBytes(curveInfo[CurveNo].StartTimeUnit, ByteArray, 80,8); //开门时间
|
||
XtfConvert.ToBytes(curveInfo[CurveNo].WaveTimeUnit, ByteArray, 72,8); //波形时间
|
||
|
||
XtfConvert.ToBytes(curveInfo[CurveNo].FixedWaveStartFlag, ByteArray, 2606); //0：阵列声波固定开门时间
|
||
XtfConvert.ToBytes(curveInfo[CurveNo].FixedWaveGain, ByteArray, 2608); //0：阵列声波固定增益
|
||
//whp del 2016.6.2
|
||
//XtfConvert.ToBytes(curveInfo[CurveNo].TimeValuesLevel, ByteArray, 1048); //时间增量，时间采样间隔
|
||
}
|
||
//whp add 2016.6.2 for 转换阵列数据开始时间和时间间隔
|
||
XtfConvert.ToBytes(curveInfo[CurveNo].TimeValuesLevel, ByteArray, 1048); //时间增量，时间采样间隔
|
||
XtfConvert.ToBytes(curveInfo[CurveNo].DACTimeOffset, ByteArray, 1052); //DAC起始时间
|
||
//whp add end
|
||
ByteArray[2618] = 0x01; //仪器号
|
||
|
||
ByteArray[0xA00] = 0x00;
|
||
ByteArray[0xA01] = Version1;
|
||
ByteArray[0xA02] = 0x00;
|
||
ByteArray[0xA03] = Version2;
|
||
|
||
|
||
if(CurveFlag[CurveNo] > 1)
|
||
{
|
||
ByteArray[0xA1E] = 0x80; //0x00;//
|
||
ByteArray[0xA1F] = 0x01; //0x00;//
|
||
|
||
ByteArray[0x668] = 0xBF;
|
||
ByteArray[0x669] = 0xE3;
|
||
ByteArray[0x66A] = 0x82;
|
||
|
||
ByteArray[0xD55] = 0x88;
|
||
ByteArray[0xD56] = 0x44;
|
||
}
|
||
|
||
ByteArray[4095] = SystemCode;//系统码
|
||
// XtfConvert.ToBytes(SystemCode, ByteArray, 4095);
|
||
return CurveNo;
|
||
};
|
||
|
||
|
||
int CurveHead_Write(int CurveNo)
|
||
{
|
||
byte ByteArray[4096] = {0};
|
||
|
||
CurveHeadSet(CurveNo, ByteArray);
|
||
|
||
long pos = CurveStartPos[CurveNo] - 1;
|
||
|
||
dataFile->seek(pos * 4096);
|
||
dataFile->write((char*)&ByteArray[0], 4096);
|
||
dataFile->flush();
|
||
|
||
return CurveNo;
|
||
};
|
||
|
||
int CurveRecord_Write(byte buf[],int offset,int length)
|
||
{
|
||
dataFile->write((char*)&buf[offset], length);
|
||
|
||
return 0;
|
||
};
|
||
|
||
int CurveHead_Read(int CurveNo)
|
||
{
|
||
byte ByteArray[4096] = {0};
|
||
|
||
long pos = CurveStartPos[CurveNo] - 1;
|
||
|
||
dataFile->seek(pos * 4096);
|
||
dataFile->read((char*)&ByteArray[0], 4096);
|
||
|
||
CurveHeadGet(CurveNo, ByteArray);
|
||
|
||
return 0;
|
||
};
|
||
|
||
int CurveRecord_Read(byte buf[], int offset, int length)
|
||
{
|
||
dataFile->read((char*)&buf[offset], length);
|
||
|
||
return 0;
|
||
};
|
||
|
||
};
|
||
|