#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;
        };
			
};