/// <summary>
/// 获取文件的Title
/// </summary>
/// <param name="fileData">文件数据</param>
/// <param name="fileSize">文件大小</param>
private static string GetFileTitle(byte[] fileData, int fileSize)
{
try
{
IntPtr retptr = IntPtr.Zero;
int datasize = 0;
if (CommonMethod.Is64BitVersion())
{
retptr = SPAGetFileTitle64(fileData, fileSize, ref datasize);
}
else
{
retptr = SPAGetFileTitle32(fileData, fileSize, ref datasize);
}
byte[] copybytes = CommonMethod.CopyDataArrayFromIntptrAndFree <byte>(ref retptr, datasize);
if (copybytes == null)
{
return(null);
}
return(CommonMethod.CovertByteArrayToString(copybytes, Encoding.Default));
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
private static byte[] CreateFile(SPAHeader xPara, InstrumentHeader instPara, double[] yDatas, string fileTitle, string instSN)
{
IntPtr retptr = IntPtr.Zero;
int datasize = 0;
try
{
byte[] titleBytes = null;
if (!string.IsNullOrWhiteSpace(fileTitle))
{
titleBytes = Encoding.Default.GetBytes(fileTitle);
}
if (CommonMethod.Is64BitVersion())
{
retptr = SPACreateFile64(ref xPara, ref instPara, yDatas, titleBytes, titleBytes == null ? 0 : titleBytes.Length, instSN, ref datasize);
}
else
{
retptr = SPACreateFile32(ref xPara, ref instPara, yDatas, titleBytes, titleBytes == null ? 0 : titleBytes.Length, instSN, ref datasize);
}
return(CommonMethod.CopyDataArrayFromIntptrAndFree <byte>(ref retptr, datasize));
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
/// <summary>
/// 获取文件的仪器序列号
/// </summary>
/// <param name="fileData">文件数据</param>
/// <param name="fileSize">文件大小</param>
private static string GetInstSN(byte[] fileData, int fileSize)
{
try
{
IntPtr retptr = IntPtr.Zero;
int datasize = 0;
if (CommonMethod.Is64BitVersion())
{
retptr = SPAGetInstSN64(fileData, fileSize, ref datasize);
}
else
{
retptr = SPAGetInstSN32(fileData, fileSize, ref datasize);
}
byte[] copybytes = CommonMethod.CopyDataArrayFromIntptrAndFree <byte>(ref retptr, datasize);
if (copybytes == null)
{
return(null);
}
return(Encoding.UTF8.GetString(copybytes));
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
/// <summary>
/// 创建光谱文件块
/// </summary>
/// <param name="sampleCode">样品编号</param>
/// <param name="index">光谱序号</param>
/// <param name="fileTime">光谱创建时间</param>
/// <param name="yDatas">y轴数据</param>
/// <param name="compDatas">浓度数据</param>
/// <returns></returns>
private static byte[] CreateFileData(string sampleCode, int index, DateTime fileTime, double[] yDatas, double[] compDatas)
{
try
{
IntPtr retptr = IntPtr.Zero;
UInt32 time = CreateFileDateTime(fileTime);
//处理样品编号
byte[] codeBytes = StringToBytesArray(sampleCode, SAMPLECODELEN);
byte[] IDBytes = StringToBytesArray(sampleCode, SAMPLEIDLEN); //因为样品编号位数比较少，因此在sampleID里面保存一份长的
int dataSize = 0;
if (CommonMethod.Is64BitVersion())
{
retptr = FossCreateFileData64(codeBytes, (UInt16)index, time, yDatas, (UInt32)yDatas.Length, compDatas, compDatas == null ? 0 : (UInt32)compDatas.Length, IDBytes, ref dataSize);
}
else
{
retptr = FossCreateFileData32(codeBytes, (UInt16)index, time, yDatas, (UInt32)yDatas.Length, compDatas, compDatas == null ? 0 : (UInt32)compDatas.Length, IDBytes, ref dataSize);
}
return(CommonMethod.CopyDataArrayFromIntptrAndFree <byte>(ref retptr, dataSize));
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
/// <summary>
/// 读取浓度数据
/// </summary>
/// <param name="fileData">文件数据</param>
/// <param name="index">光谱序号</param>
/// <returns>返回光谱浓度数据</returns>
public static double[] GetComponentData(byte[] fileData, int index)
{
try
{
IntPtr retptr = IntPtr.Zero;
int datasize = 0;
if (CommonMethod.Is64BitVersion())
{
retptr = FossGetComponentData64(fileData, fileData.Length, index, ref datasize);
}
else
{
retptr = FossGetComponentData32(fileData, fileData.Length, index, ref datasize);
}
double[] retDatas = CommonMethod.CopyDataArrayFromIntptrAndFree <double>(ref retptr, datasize);
if (retDatas == null)
{
ErrorString = CommonMethod.ErrorString;
return(null);
}
return(retDatas);
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
/// <summary>
/// 读取X轴数据
/// </summary>
private static double[] GetXData(byte[] fileData, int fileSize, int subIndex)
{
IntPtr retptr = IntPtr.Zero;
int datasize = 0;
if (CommonMethod.Is64BitVersion())
{
retptr = SPCGetXDatas64(fileData, fileSize, subIndex, ref datasize);
}
else
{
retptr = SPCGetXDatas32(fileData, fileSize, subIndex, ref datasize);
}
float[] tempdatas = CommonMethod.CopyDataArrayFromIntptrAndFree <float>(ref retptr, datasize);
if (tempdatas == null)
{
return(null);
}
double[] retdatas = new double[tempdatas.Length];
for (int i = 0; i < retdatas.Length; i++)
{
retdatas[i] = tempdatas[i];
}
return(retdatas);
}
/// <summary>
/// 创建SPC文件
/// </summary>
/// <param name="mainHeader">文件结构</param>
/// <param name="subTypes">子数据类型</param>
/// <param name="dataPoints">各数据的数量</param>
/// <param name="xDatas">X轴数据，可以为NULL</param>
/// <param name="yDatas">Y轴数据，一条或者多条，列=mainHeader->fnpts, 行=subTypes.Length</param>
/// <param name="logText">光谱采集参数</param>
/// <param name="logBinary">私有数据</param>
/// <returns>SPC内容</returns>
private static byte[] CreateCommonXFile(SPCHeader mainHeader, byte[] subTypes, int[] dataPoints, float[] xDatas, float[] yDatas, byte[] logText, byte[] logBinary)
{
//xDatas=NULL表示等间距X轴
if (xDatas == null && mainHeader.fnpts <= 0 || yDatas == null || logText == null || logText.Length == 0)
{
return(null);
}
if (xDatas == null) //没有X轴数据，就不能有dataPoints
{
dataPoints = null;
if (yDatas.Length != mainHeader.fnpts * mainHeader.fnsub) //Y轴数据必须与文件数量和每个文件的数据点数相符
{
return(null);
}
}
else
{
if (dataPoints == null) //如果没有dataPoints，表示只有一个xDatas，由所有Y轴共享
{
if (xDatas.Length != mainHeader.fnpts || yDatas.Length != mainHeader.fnpts * mainHeader.fnsub)
{
return(null);
}
}
else //每个Y都对应不同的X
{
mainHeader.fnpts = 0;
mainHeader.fnsub = (uint)dataPoints.Length;
int count = dataPoints.Sum();
if (xDatas.Length != count || yDatas.Length != count)
{
return(null);
}
}
}
IntPtr retptr = IntPtr.Zero;
int datasize = 0;
if (CommonMethod.Is64BitVersion())
{
retptr = SPCCreateFile64(ref mainHeader, subTypes, dataPoints, xDatas, yDatas, logText, logText == null ? 0 : logText.Length, logBinary, logBinary == null ? 0 : logBinary.Length, ref datasize);
}
else
{
retptr = SPCCreateFile32(ref mainHeader, subTypes, dataPoints, xDatas, yDatas, logText, logText == null ? 0 : logText.Length, logBinary, logBinary == null ? 0 : logBinary.Length, ref datasize);
}
return(CommonMethod.CopyDataArrayFromIntptrAndFree <byte>(ref retptr, datasize));
}
/// <summary>
/// 读取变量的数据
/// </summary>
/// <param name="fileData">文件数据</param>
/// <param name="variableInfo">需要读取的变量信息</param>
/// <returns>变量的数据</returns>
public static T[] GetVariableData <T>(byte[] fileData, MatVariableInfo variableInfo) where T : IComparable
{
if (fileData == null || fileData.Length == 0)
{
return(null);
}
try
{
IntPtr retptr = IntPtr.Zero;
int datasize = 0; //返回的是byte大小
if (CommonMethod.Is64BitVersion())
{
retptr = MATGetVariableData64(fileData, fileData.Length, ref variableInfo, ref datasize);
}
else
{
retptr = MATGetVariableData32(fileData, fileData.Length, ref variableInfo, ref datasize);
}
if (retptr == IntPtr.Zero)
{
return(null);
}
//按照数据类型来拷贝返回数据
int typesize = Marshal.SizeOf(typeof(T));
if ((datasize % typesize) != 0)
{
Marshal.FreeCoTaskMem(retptr);
return(null);
}
datasize = datasize / typesize;
return(CommonMethod.CopyDataArrayFromIntptrAndFree <T>(ref retptr, datasize));
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
/// <summary>
/// 读取Y轴数据
/// </summary>
/// <param name="fileData"></param>
/// <param name="fileSize"></param>
/// <returns></returns>
private static double[] GetYData(byte[] fileData, int fileSize)
{
try
{
IntPtr retptr = IntPtr.Zero;
int datasize = 0;
if (CommonMethod.Is64BitVersion())
{
retptr = SPAGetYDatas64(fileData, fileSize, ref datasize);
}
else
{
retptr = SPAGetYDatas32(fileData, fileSize, ref datasize);
}
return(CommonMethod.CopyDataArrayFromIntptrAndFree <double>(ref retptr, datasize));
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
/// <summary>
/// 创建光谱文件块
/// </summary>
/// <param name="fileCount">文件数量</param>
/// <param name="fileTime">光谱创建时间</param>
/// <param name="specCols">光谱数据点数量</param>
/// <param name="firstX">起始波数</param>
/// <param name="lastX">结束波数</param>
/// <param name="compNames">组分名称</param>
/// <param name="title">文件描述</param>
/// <param name="instrument">仪器名称</param>
/// <param name="serialNo">仪器序列号</param>
/// <returns></returns>
private static byte[] CreateMainHeader(int fileCount, DateTime fileTime, int specCols, double firstX, double lastX, string[] compNames, string title, string instrument, string serialNo)
{
try
{
IntPtr retptr = IntPtr.Zero;
int datasize = 0;
//创建主结构
UInt32 time = CreateFileDateTime(fileTime);
int compCount = compNames == null ? 0 : compNames.Length; //组分数量
if (CommonMethod.Is64BitVersion())
{
retptr = FossCreateMainHeader64((UInt32)fileCount, (UInt32)specCols, time, firstX, lastX, compCount, ref datasize);
}
else
{
retptr = FossCreateMainHeader32((UInt32)fileCount, (UInt32)specCols, time, firstX, lastX, compCount, ref datasize);
}
byte[] headerDatas = CommonMethod.CopyDataArrayFromIntptrAndFree <byte>(ref retptr, datasize);
if (headerDatas == null)
{
ErrorString = CommonMethod.ErrorString;
return(null);
}
//文件描述
if (!string.IsNullOrWhiteSpace(title))
{
if (AddMainHeaderInfo(headerDatas, MAIN_TITLE, Encoding.Default.GetBytes(title)) == false)
{
return(null);
}
}
//仪器描述
if (!string.IsNullOrWhiteSpace(instrument))
{
if (AddMainHeaderInfo(headerDatas, MAIN_INSTRUMENT, Encoding.Default.GetBytes(instrument)) == false)
{
return(null);
}
}
//仪器序列号
if (!string.IsNullOrWhiteSpace(serialNo))
{
if (AddMainHeaderInfo(headerDatas, MAIN_SERIALNO, Encoding.Default.GetBytes(serialNo)) == false)
{
return(null);
}
}
//组分信息
if (compNames != null && compNames.Length != 0)
{
byte[] compBytes = new byte[compNames.Length * CompNameLength]; //一个组分长度为CompNameLength
for (int i = 0; i < compNames.Length; i++)
{
var namebytes = StringToBytesArray(compNames[i], CompNameLength);
Array.Copy(namebytes, 0, compBytes, i * CompNameLength, CompNameLength);
}
if (AddMainHeaderInfo(headerDatas, MAIN_COMPONENT, compBytes) == false)
{
return(null);
}
}
return(headerDatas);
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
