/// <summary>
/// 获取cit文件的数据块的开始位置、结束位置
/// </summary>
/// <param name="citFile">cit文件路径</param>
/// <returns>cit文件的数据块的开始位置结束位置double数组</returns>
public long[] GetPositons(string citFile)
{
try
{
List <DataChannelInfo> cdList = new List <DataChannelInfo>();
FileStream fs = new FileStream(citFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
BinaryReader br = new BinaryReader(fs, Encoding.Default);
br.BaseStream.Position = 0;
DataHeadInfo fi = GetDataInfoHead(br.ReadBytes(DataOffset.DataHeadLength));
cdList = GetDataChannelInfoHead(citFile);
//开始位置
//long startPosition = br.BaseStream.Position = FileDataOffset.GetSamplePointStartOffset(fi.iChannelNumber, BitConverter.ToInt32(br.ReadBytes(DataOffset.ExtraLength), 0));
long startPosition = br.BaseStream.Position = DataOffset.DataHeadLength + DataOffset.DataChannelLength * fi.iChannelNumber + DataOffset.ExtraLength;
//结束位置
long endPosition = br.BaseStream.Length;
long[] positions = new long[2];
positions[0] = startPosition;
positions[1] = endPosition;
return(positions);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// 获取所有通道数据
/// </summary>
/// <param name="citFile">cit文件路径</param>
/// <param name="startFilePos">开始位置</param>
/// <param name="sampleNum">采样点个数</param>
/// <param name="endFilePos">采样点结束的位置</param>
/// <returns>指定范围的所有通道数据</returns>
public List <double[]> GetAllChannelDataInRange(string citFile, long startFilePos, int sampleNum, ref long endFilePos)
{
try
{
FileStream fs = new FileStream(citFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
BinaryReader br = new BinaryReader(fs, Encoding.Default);
br.BaseStream.Position = 0;
DataHeadInfo fi = GetDataInfoHead(br.ReadBytes(DataOffset.DataHeadLength));
List <DataChannelInfo> cdList = GetDataChannelInfoHead(citFile);
int iChannelNumberSize = BytesOfOneSamplePoint(fi.iChannelNumber);
byte[] b = new byte[iChannelNumberSize];
br.BaseStream.Position = startFilePos;
endFilePos = startFilePos + sampleNum * iChannelNumberSize;
br.Close();
fs.Close();
var allList = GetAllChannelDataInRange(citFile, startFilePos, endFilePos);
return(allList);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// 读取cit文件头中的文件信息信息，并返回文件头信息结构体
/// </summary>
/// <param name="bDataInfo">文件头中包含文件信息的120个字节 </param>
/// <returns>文件信息结构体</returns>
private DataHeadInfo GetDataInfoHead(byte[] bDataInfo)
{
DataHeadInfo dhi = new DataHeadInfo();
StringBuilder sbDataVersion = new StringBuilder();
StringBuilder sbTrackCode = new StringBuilder();
StringBuilder sbTrackName = new StringBuilder();
StringBuilder sbTrain = new StringBuilder();
StringBuilder sbDate = new StringBuilder();
StringBuilder sbTime = new StringBuilder();
dhi.iDataType = BitConverter.ToInt32(bDataInfo, 0);
//1+20个字节，数据版本
for (int i = 1; i <= (int)bDataInfo[DataHeadOffset.DataVersion]; i++)
{
sbDataVersion.Append(UnicodeEncoding.Default.GetString(bDataInfo, DataHeadOffset.DataVersion + i, 1));
}
//1+4个字节，线路代码
for (int i = 1; i <= (int)bDataInfo[DataHeadOffset.TrackCode]; i++)
{
sbTrackCode.Append(UnicodeEncoding.Default.GetString(bDataInfo, DataHeadOffset.TrackCode + i, 1));
}
//1+20个字节，线路名
for (int i = 1; i <= (int)bDataInfo[DataHeadOffset.TrackName]; i++, i++)
{
sbTrackName.Append(UnicodeEncoding.Default.GetString(bDataInfo, DataHeadOffset.TrackName + i, 1));
}
dhi.iDir = BitConverter.ToInt32(bDataInfo, DataHeadOffset.Dir);
//1+20个字节，检测车号
for (int i = 1; i <= (int)bDataInfo[DataHeadOffset.TrainCode]; i++)
{
sbTrain.Append(UnicodeEncoding.Default.GetString(bDataInfo, DataHeadOffset.TrainCode + i, 1));
}
//1+10个字节，检测日期
for (int i = 1; i <= (int)bDataInfo[DataHeadOffset.Date]; i++)
{
sbDate.Append(UnicodeEncoding.Default.GetString(bDataInfo, DataHeadOffset.Date + i, 1));
}
//1+8个字节，检测时间
for (int i = 1; i <= (int)bDataInfo[DataHeadOffset.Time]; i++)
{
sbTime.Append(UnicodeEncoding.Default.GetString(bDataInfo, DataHeadOffset.Time + i, 1));
}
dhi.iRunDir = BitConverter.ToInt32(bDataInfo, DataHeadOffset.RunDir);
dhi.iKmInc = BitConverter.ToInt32(bDataInfo, DataHeadOffset.KmInc);
dhi.fkmFrom = BitConverter.ToSingle(bDataInfo, DataHeadOffset.KmFrom);
dhi.fkmTo = BitConverter.ToSingle(bDataInfo, DataHeadOffset.KmTo);
dhi.iSmaleRate = BitConverter.ToInt32(bDataInfo, DataHeadOffset.SmaleRate);
dhi.iChannelNumber = BitConverter.ToInt32(bDataInfo, DataHeadOffset.ChannelNumber);
dhi.sDataVersion = sbDataVersion.ToString();
dhi.sDate = DateTime.Parse(sbDate.ToString()).ToString("yyyy-MM-dd");
dhi.sTime = DateTime.Parse(sbTime.ToString()).ToString("HH:mm:ss");
dhi.sTrackCode = sbTrackCode.ToString();
dhi.sTrackName = sbTrackName.ToString();
dhi.sTrain = sbTrain.ToString();
return(dhi);
}
public long GetCurrentPosition(string citFile, float mile)
{
try
{
long position = 0;
FileStream fs = new FileStream(citFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
BinaryReader br = new BinaryReader(fs);
DataHeadInfo fi = GetDataInfoHead(br.ReadBytes(DataOffset.DataHeadLength));
br.BaseStream.Position = GetSamplePointStartOffset(fi.iChannelNumber, DataOffset.ExtraLength);
int iChannelNumberSize = BytesOfOneSamplePoint(fi.iChannelNumber);
byte[] b = new byte[iChannelNumberSize];
long iArray = (br.BaseStream.Length - br.BaseStream.Position) / iChannelNumberSize;
for (int i = 0; i < iArray; i++)
{
position = br.BaseStream.Position;
b = br.ReadBytes(iChannelNumberSize);
if (Encryption.IsEncryption(fi.sDataVersion))
{
b = Encryption.Translate(b);
}
short km = BitConverter.ToInt16(b, 0);
short m = BitConverter.ToInt16(b, 2);
float currentMile = km * 1000 + m / (float)fi.iSmaleRate;
//增里程
if (fi.iKmInc == 0)
{
if (mile <= currentMile)
{
break;
}
}
//减里程
if (fi.iKmInc == 1)
{
if (mile >= currentMile)
{
break;
}
}
}
br.Close();
fs.Close();
return(position);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 获取补充信息（附加信息）,返回值是字节流，客户负责解析附加信息到具体的类型
/// </summary>
/// <param name="citFilePath"></param>
/// <returns></returns>
public byte[] GetExtraInfo(string citFilePath)
{
FileStream fs = new FileStream(citFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
BinaryReader br = new BinaryReader(fs, Encoding.Default);
DataHeadInfo m_dhi = GetDataInfoHead(br.ReadBytes(DataOffset.DataHeadLength));
br.BaseStream.Position = DataOffset.DataHeadLength + m_dhi.iChannelNumber * DataOffset.DataChannelLength;
//br.ReadBytes(120);
//br.ReadBytes(65 * m_dhi.iChannelNumber);
byte[] extraByte = br.ReadBytes(BitConverter.ToInt32(br.ReadBytes(DataOffset.ExtraLength), 0));
return(extraByte);
}
/// <summary>
/// 获取指定通道数据---指定范围内
/// </summary>
/// <param name="sSourceFile">cit文件</param>
/// <param name="iChannelNumber">通道号（从1开始的）</param>
/// <param name="startPos">起始文件指针</param>
/// <param name="endPos">结束文件指针</param>
/// <returns>通道数据</returns>
public double[] GetSingleChannelData(string sSourceFile, int iChannelNumber, long startPos, long endPos)
{
try
{
List <DataChannelInfo> m_dcil = GetDataChannelInfoHead(sSourceFile);
FileStream fs = new FileStream(sSourceFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
BinaryReader br = new BinaryReader(fs, Encoding.Default);
br.BaseStream.Position = 0;
DataHeadInfo m_dhi = GetDataInfoHead(br.ReadBytes(DataOffset.DataHeadLength));
br.ReadBytes(DataOffset.DataChannelLength * m_dhi.iChannelNumber);
br.ReadBytes(BitConverter.ToInt32(br.ReadBytes(DataOffset.ExtraLength), 0));
int iChannelNumberSize = m_dhi.iChannelNumber * 2;
byte[] b = new byte[iChannelNumberSize];
br.BaseStream.Position = startPos;
long iArray = (endPos - br.BaseStream.Position) / iChannelNumberSize;
double[] fReturnArray = new double[iArray];
for (int i = 0; i < iArray; i++)
{
b = br.ReadBytes(iChannelNumberSize);
if (m_dhi.sDataVersion.StartsWith("3."))
{
b = ByteXORByte(b);
}
double fGL = (BitConverter.ToInt16(b, (iChannelNumber - 1) * 2) / m_dcil[iChannelNumber - 1].fScale + m_dcil[iChannelNumber - 1].fOffset);
fReturnArray[i] = fGL;
}
br.Close();
fs.Close();
return(fReturnArray);
}
catch (Exception ex)
{
return(new double[1]);
}
}
/// <summary>
/// 获取cit文件中的所有公里标---注意：是cit文件里的
/// </summary>
/// <param name="citFilePath">cit文件名</param>
/// <returns>cit文件中的里程--单位为公里</returns>
public float[] GetMilesDataFloat(String citFilePath)
{
float[] retVal = null;
DataHeadInfo m_dhi = GetDataInfoHead(citFilePath);
dhi = m_dhi;
try
{
FileStream fs = new FileStream(citFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
BinaryReader br = new BinaryReader(fs, Encoding.Default);
br.BaseStream.Position = 0;
br.ReadBytes(DataOffset.DataHeadLength);
br.ReadBytes(DataOffset.DataChannelLength * m_dhi.iChannelNumber);
br.ReadBytes(BitConverter.ToInt32(br.ReadBytes(DataOffset.ExtraLength), 0));
int iChannelNumberSize = m_dhi.iChannelNumber * 2;
byte[] b = new byte[iChannelNumberSize];
long iArray = (br.BaseStream.Length - br.BaseStream.Position) / iChannelNumberSize;
retVal = new float[iArray];
for (int i = 0; i < iArray; i++)
{
b = br.ReadBytes(iChannelNumberSize);
if (m_dhi.sDataVersion.StartsWith("3."))
{
b = ByteXORByte(b);
}
short km = BitConverter.ToInt16(b, 0);
short m = BitConverter.ToInt16(b, 2);
float fGL = km + (float)m / m_dhi.iSmaleRate / 1000;//单位为公里
retVal[i] = fGL;
}
br.Close();
fs.Close();
}
catch (Exception ex)
{
}
return(retVal);
}
public bool WriteCitFile(string citFile, DataHeadInfo fi, List <DataChannelInfo> channelList, string extraInfo, List <double[]> arrayDone)
{
try
{
int iChannelNumberSize = fi.iChannelNumber * 2;
byte[] dataArray = new byte[iChannelNumberSize];
List <Byte[]> dataList = new List <Byte[]>();
short tmpRmsData = 0;
Byte[] tmpDataBytes = new Byte[2];
long iArrayLen = arrayDone[0].Length;
for (int k = 0; k < iArrayLen; k++)
{
if (Encryption.IsEncryption(fi.sDataVersion))
{
for (int iTmp = 0; iTmp < channelList.Count; iTmp++)
{
tmpRmsData = (short)((arrayDone[iTmp][k] - channelList[iTmp].fOffset) * channelList[iTmp].fScale);
tmpDataBytes = Encryption.Translate(BitConverter.GetBytes(tmpRmsData));
dataList.Add(tmpDataBytes);
}
}
else
{
for (int iTmp = 0; iTmp < channelList.Count; iTmp++)
{
tmpRmsData = (short)((arrayDone[iTmp][k] - channelList[iTmp].fOffset) * channelList[iTmp].fScale);
dataList.Add(BitConverter.GetBytes(tmpRmsData));
}
}
}
bool isOk = WriteCitFile(citFile, fi, channelList, extraInfo, dataList);
return(isOk);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public List <double[]> GetAllChannelDataInRange(string citFile)
{
try
{
FileStream fs = new FileStream(citFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
BinaryReader br = new BinaryReader(fs, Encoding.Default);
br.BaseStream.Position = 0;
DataHeadInfo fi = GetDataInfoHead(br.ReadBytes(DataOffset.DataHeadLength));
List <DataChannelInfo> cdList = GetDataChannelInfoHead(citFile);
int iChannelNumberSize = BytesOfOneSamplePoint(fi.iChannelNumber);
byte[] b = new byte[iChannelNumberSize];
long[] startAndEndPostion = GetPositons(citFile);
long startFilePos = startAndEndPostion[0];
long endFilePos = startAndEndPostion[1];
br.BaseStream.Position = startFilePos;
long iArray = (endFilePos - br.BaseStream.Position) / iChannelNumberSize;
double[] fReturnArray = new double[iArray];
List <double[]> allList = new List <double[]>();
for (int i = 0; i < fi.iChannelNumber; i++)
{
double[] array = new double[iArray];
allList.Add(array);
}
for (int i = 0; i < iArray; i++)
{
b = br.ReadBytes(iChannelNumberSize);
if (Encryption.IsEncryption(fi.sDataVersion))
{
b = Encryption.Translate(b);
}
for (int channelId = 1; channelId < fi.iChannelNumber + 1; channelId++)
{
int value = (BitConverter.ToInt16(b, (channelId - 1) * 2));
float fScale = cdList[channelId - 1].fScale;
double fGL = (BitConverter.ToInt16(b, (channelId - 1) * 2) / cdList[channelId - 1].fScale + cdList[channelId - 1].fOffset);
allList[channelId - 1][i] = fGL;
}
}
br.Close();
fs.Close();
return(allList);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// 获取文件信息的文件版本号
/// </summary>
/// <param name="citFile"></param>
/// <returns>文件版本号</returns>
public string GetHeadDataVersion(string citFile)
{
DataHeadInfo headInfo = GetDataInfoHead(citFile);
return(headInfo.sDataVersion);
}
/// <summary>
/// 获取文件信息的检测起始时间：HH:mm:ss
/// </summary>
/// <param name="citFile"></param>
/// <returns>检测起始时间：HH:mm:ss</returns>
public string GetHeadTime(string citFile)
{
DataHeadInfo headInfo = GetDataInfoHead(citFile);
return(headInfo.sTime);
}
/// <summary>
/// 获取文件信息的检测方向，正0，反1
/// </summary>
/// <param name="citFile"></param>
/// <returns>检测方向，正0，反1</returns>
public int GetHeadRunDir(string citFile)
{
DataHeadInfo headInfo = GetDataInfoHead(citFile);
return(headInfo.iRunDir);
}
/// <summary>
/// 把反方向检测转换为正方向检测
/// </summary>
/// <param name="citFileName"></param>
public void ModifyCitReverseToForward(String citFileName)
{
DataHeadInfo m_dhi = GetDataInfoHead(citFileName);
List <DataChannelInfo> m_dciL = GetDataChannelInfoHead(citFileName);
//左高低与右高低对调
ChannelExchange(m_dciL, "L_Prof_SC", "R_Prof_SC", false);
ChannelExchange(m_dciL, "L_Prof_SC_70", "R_Prof_SC_70", false);
ChannelExchange(m_dciL, "L_Prof_SC_120", "R_Prof_SC_120", false);
DataChannelInfo m_dci_a = new DataChannelInfo();
//左轨向与右轨向对调，然后幅值*（-1）
ChannelExchange(m_dciL, "L_Align_SC", "R_Align_SC", true);
ChannelExchange(m_dciL, "L_Align_SC_70", "R_Align_SC_70", true);
ChannelExchange(m_dciL, "L_Align_SC_120", "R_Align_SC_120", true);
//水平、超高、三角坑、曲率、曲率变化率*（-1）
for (int i = 0; i < m_dciL.Count; i++)
{
if (m_dciL[i].sNameEn.Equals("Crosslevel"))
{
m_dci_a = m_dciL[i];
m_dci_a.fScale = m_dci_a.fScale * (-1);
m_dciL[i] = m_dci_a;
}
if (m_dciL[i].sNameEn.Equals("Superelevation"))
{
m_dci_a = m_dciL[i];
m_dci_a.fScale = m_dci_a.fScale * (-1);
m_dciL[i] = m_dci_a;
}
if (m_dciL[i].sNameEn.Equals("Short_Twist"))
{
m_dci_a = m_dciL[i];
m_dci_a.fScale = m_dci_a.fScale * (-1);
m_dciL[i] = m_dci_a;
}
if (m_dciL[i].sNameEn.Equals("Curvature"))
{
m_dci_a = m_dciL[i];
m_dci_a.fScale = m_dci_a.fScale * (-1);
m_dciL[i] = m_dci_a;
}
if (m_dciL[i].sNameEn.Equals("Curvature_Rate"))
{
m_dci_a = m_dciL[i];
m_dci_a.fScale = m_dci_a.fScale * (-1);
m_dciL[i] = m_dci_a;
}
}
try
{
#region 存取文件
FileStream fsRead = new FileStream(citFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
FileStream fsWrite = new FileStream(citFileName + ".bak", FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
BinaryReader br = new BinaryReader(fsRead, Encoding.UTF8);
BinaryWriter bw1 = new BinaryWriter(fsWrite, Encoding.UTF8);
byte[] bHead = br.ReadBytes(120);
byte[] bChannels = br.ReadBytes(65 * m_dhi.iChannelNumber);
byte[] bData = new byte[m_dhi.iChannelNumber * 2];
byte[] bDataNew = new byte[m_dhi.iChannelNumber * 2];
byte[] bTail = br.ReadBytes(BitConverter.ToInt32(br.ReadBytes(4), 0));
//bw1.Write(bHead);
bw1.Write(GetBytesFromDataHeadInfo(m_dhi));//文件头
//反向--转换为正向
if (m_dhi.iRunDir == 0)
{
bw1.Write(bChannels);
}
else
{
bw1.Write(GetBytesFromChannelDataInfoList(m_dciL));
}
bw1.Write(bTail.Length);
bw1.Write(bTail);
long startPos = br.BaseStream.Position;//记录数据开始位置的文件指针
while (br.BaseStream.Position < br.BaseStream.Length)
{
bw1.Write(br.ReadBytes(m_dhi.iChannelNumber * 2));
//br.BaseStream.Position += m_dhi.iChannelNumber * 2;
}
//
bw1.Close();
br.Close();
fsWrite.Close();
fsRead.Close();
//删除bak
Application.DoEvents();
File.Delete(citFileName);
Application.DoEvents();
File.Move(citFileName + ".bak", citFileName);
Application.DoEvents();
#endregion
}
catch (System.Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
return;
}
/// <summary>
/// 把单行线都统一为增里程(包括正方向和反方向)
/// </summary>
/// <param name="citFileName"></param>
public void ModifyCitMergeKmInc(string citFileName)
{
dhi = GetDataInfoHead(citFileName);
bool isKmInc = true;
bool bVal = IsCitKmInc(citFileName, ref isKmInc);
if (!bVal)
{
return;
}
//文件头中指示为增里程，且文件中确实为增里程，则不需要处理，直接返回。
if (dhi.iKmInc == 0 && isKmInc == true)
{
return;
}
//以下情况：有可能是文件头指示错误或是实际文件确实为减里程
//统一为增里程
if (dhi.iKmInc != 0)
{
dhi.iKmInc = 0;
}
try
{
#region 存取文件
FileStream fsRead = new FileStream(citFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
FileStream fsWrite = new FileStream(citFileName + ".bak", FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
BinaryReader br = new BinaryReader(fsRead, Encoding.UTF8);
BinaryWriter bw1 = new BinaryWriter(fsWrite, Encoding.UTF8);
byte[] bHead = br.ReadBytes(120);
byte[] bChannels = br.ReadBytes(65 * dhi.iChannelNumber);
byte[] bData = new byte[dhi.iChannelNumber * 2];
byte[] bDataNew = new byte[dhi.iChannelNumber * 2];
byte[] bTail = br.ReadBytes(BitConverter.ToInt32(br.ReadBytes(4), 0));
//bw1.Write(bHead);
bw1.Write(GetBytesFromDataHeadInfo(dhi));//文件头
DataHeadInfo mmdhi = GetDataInfoHead(GetBytesFromDataHeadInfo(dhi));
bw1.Write(bChannels);
bw1.Write(bTail.Length);
bw1.Write(bTail);
long startPos = br.BaseStream.Position;//记录数据开始位置的文件指针
//增里程时，不反转
if (isKmInc == true)
{
while (br.BaseStream.Position < br.BaseStream.Length)
{
bw1.Write(br.ReadBytes(dhi.iChannelNumber * 2));
//br.BaseStream.Position += m_dhi.iChannelNumber * 2;
}
}
else
{
br.BaseStream.Position = br.BaseStream.Length - dhi.iChannelNumber * 2;
while (br.BaseStream.Position >= startPos)
{
bw1.Write(br.ReadBytes(dhi.iChannelNumber * 2));
br.BaseStream.Position -= dhi.iChannelNumber * 2 * 2; //liyang: 这块怎么乘以4了 ？
}
}
//
bw1.Close();
br.Close();
fsWrite.Close();
fsRead.Close();
//删除bak
Application.DoEvents();
File.Delete(citFileName);
Application.DoEvents();
File.Move(citFileName + ".bak", citFileName);
Application.DoEvents();
#endregion
}
catch (System.Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
}
/// <summary>
/// 获取文件信息的文件类型
/// </summary>
/// <param name="citFile"></param>
/// <returns>文件类型</returns>
public int GetHeadDataType(string citFile)
{
DataHeadInfo headInfo = GetDataInfoHead(citFile);
return(headInfo.iDataType);
}
/// <summary>
/// 获取文件信息的数据块中通道总数
/// </summary>
/// <param name="citFile"></param>
/// <returns>数据块中通道总数</returns>
public int GetHeadChannelNumber(string citFile)
{
DataHeadInfo headInfo = GetDataInfoHead(citFile);
return(headInfo.iChannelNumber);
}
/// <summary>
/// 获取文件信息的采样数，（距离采样>0, 时间采样<0）
/// </summary>
/// <param name="citFile"></param>
/// <returns>采样数，（距离采样>0, 时间采样<0）</returns>
public int GetHeadSmaleRate(string citFile)
{
DataHeadInfo headInfo = GetDataInfoHead(citFile);
return(headInfo.iSmaleRate);
}
/// <summary>
/// 获取文件信息的结束里程，检测结束后更新
/// </summary>
/// <param name="citFile">结束里程，检测结束后更新</param>
/// <returns></returns>
public float GetHeadKmTo(string citFile)
{
DataHeadInfo headInfo = GetDataInfoHead(citFile);
return(headInfo.fkmTo);
}
/// <summary>
/// 获取文件信息的增里程0，减里程1
/// </summary>
/// <param name="citFile"></param>
/// <returns>增里程0，减里程1</returns>
public int GetHeadKmInc(string citFile)
{
DataHeadInfo headInfo = GetDataInfoHead(citFile);
return(headInfo.iKmInc);
}
