/// <summary>
/// 从主机光谱中选择用于仪器校准的光谱
/// </summary>
/// <param name="masterData">主机光谱，一行一条光谱,第一行是X轴数据，后面是Y轴数据</param>
/// <param name="specRows">光谱数量</param>
/// <param name="specCols">每条光谱的数据点数</param>
/// <param name="selectNumber">需要选择多少条光谱</param>
/// <returns>选中光谱的序号(int)，大小=selectNumber</returns>
public static int[] SelectStandardSpectrum(double[] masterData, int specRows, int specCols, int selectNumber)
{
try
{
if (masterData == null || selectNumber < 1 || specRows < selectNumber || masterData.Length != specRows * specCols)
{
throw new Exception("Invalid parameters");
}
IntPtr retptr = IntPtr.Zero;
if (CommonMethod.Is64BitVersion())
{
retptr = SDSelectStandardSpectrum64(masterData, specRows, specCols, selectNumber);
}
else
{
retptr = SDSelectStandardSpectrum32(masterData, specRows, specCols, selectNumber);
}
if (retptr == IntPtr.Zero)
{
ErrorString = GetErrorMessage();
return(null);
}
return(CommonMethod.CopyDataArrayFromIntptrAndFree <int>(ref retptr, selectNumber));
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
/// <summary>
/// 通过欧式距离，使用KS算法选择有效光谱
/// </summary>
/// <param name="spectrumYDatas">主机光谱，一行一条Y轴数据</param>
/// <param name="specRows">光谱数量</param>
/// <param name="specCols">每条光谱的数据点数</param>
/// <param name="selectNumber">需要选择多少条光谱</param>
/// <returns>选中光谱的序号(int)，大小=selectNumber</returns>
public static int[] KSEuclideanSelectSample(double[] spectrumYDatas, int specRows, int specCols, int selectNumber)
{
try
{
if (spectrumYDatas == null || selectNumber < 1 || specRows < selectNumber || spectrumYDatas.Length != specRows * specCols)
{
throw new Exception("Invalid parameters");
}
IntPtr retptr = IntPtr.Zero;
if (CommonMethod.Is64BitVersion())
{
retptr = KSEuclideanSelectSample64(spectrumYDatas, specRows, specCols, selectNumber);
}
else
{
retptr = KSEuclideanSelectSample32(spectrumYDatas, specRows, specCols, selectNumber);
}
if (retptr == IntPtr.Zero)
{
ErrorString = GetErrorMessage();
return(null);
}
return(CommonMethod.CopyDataArrayFromIntptrAndFree <int>(ref retptr, selectNumber));
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
/// <summary>
/// AdvancedIdentify定性分析(光谱的数据点数量必须相同, X轴也必须相同)
/// </summary>
/// <param name="srcApiDatas">API原始光谱(未做基线或导数处理），一列X轴，一列Y轴</param>
/// <param name="apiDatas">API原始光谱插值后，一列X轴，一列Y轴</param>
/// <param name="inferDatas">干扰组分原始光谱插值后，一列X轴，多列Y轴</param>
/// <param name="inferRows">干扰组分数据行数（包括X轴）</param>
/// <param name="sampleDatas">待分析物原始光谱插值后，一列X轴，一列Y轴</param>
/// <param name="coefMethod">相关系数计算方法</param>
/// <returns></returns>
public static double Identify(double[] srcApiDatas, double[] apiDatas, double[] inferDatas, int inferRows, double[] sampleDatas, CoefficientMethod coefMethod)
{
if (apiDatas == null || apiDatas.Length == 0 || (apiDatas.Length % 2 != 0))
{
ErrorString = "Invalid parameters";
return(0);
}
//apiDatas包括一行X和一行Y
int specCols = apiDatas.Length / 2;
if (sampleDatas == null || apiDatas.Length != sampleDatas.Length ||
inferDatas == null || inferRows < 2 || inferDatas.Length != inferRows * specCols)
{
ErrorString = "Invalid parameters";
return(0);
}
try
{
if (CommonMethod.Is64BitVersion())
{
return(ADIdendify64(srcApiDatas, apiDatas, inferDatas, inferRows, sampleDatas, specCols, (int)coefMethod));
}
else
{
return(ADIdendify32(srcApiDatas, apiDatas, inferDatas, inferRows, sampleDatas, specCols, (int)coefMethod));
}
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(0);
}
}
/// <summary>
/// 光谱基线校正
/// </summary>
/// <param name="spectrumDatas">第一行为X数据，后面几行为Y数据</param>
/// <param name="specRows">数据的行数</param>
/// <param name="specCols">数据的列数</param>
/// <param name="method">基线校正方法</param>
/// <returns></returns>
public static bool BaselineCorrect(double[] spectrumDatas, int specRows, int specCols, BaseLineMethod method)
{
if (spectrumDatas == null || spectrumDatas.Length != specRows * specCols)
{
ErrorString = "Invalid parameters";
return(false);
}
if (method == BaseLineMethod.None)
{
return(true);
}
try
{
if (CommonMethod.Is64BitVersion())
{
return(ADBaselineCorrect64(spectrumDatas, specRows, specCols, (int)method));
}
else
{
return(ADBaselineCorrect32(spectrumDatas, specRows, specCols, (int)method));
}
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(false);
}
}
/// <summary>
/// 光谱相似系数
/// </summary>
/// <param name="srcYDatas">光谱的Y轴数据</param>
/// <param name="destYDatas">光谱的Y轴数据</param>
/// <param name="coefMethod">系数计算方法</param>
public static double Coefficient(double[] srcYDatas, double[] destYDatas, CoefficientMethod coefMethod)
{
if (srcYDatas == null || destYDatas == null || srcYDatas.Length == 0 || destYDatas.Length != srcYDatas.Length)
{
ErrorString = "Invalid parameters";
return(0);
}
try
{
if (CommonMethod.Is64BitVersion())
{
return(ADCoefficient64(srcYDatas, destYDatas, srcYDatas.Length, (int)coefMethod));
}
else
{
return(ADCoefficient32(srcYDatas, destYDatas, srcYDatas.Length, (int)coefMethod));
}
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(0);
}
}
/// <summary>
/// Savitzky–Golay平滑和求导数（处理后的数据在spectrumDatas返回）
/// </summary>
/// <param name="specDatas">第一行为X数据，后面几行为Y数据</param>
/// <param name="specRows">数据的行数</param>
/// <param name="specCols">数据的列数</param>
/// <param name="windowSize">平滑点数</param>
/// <param name="polyDegree">多项式阶数</param>
/// <param name="derDegree">导数阶数, 0=平滑</param>
/// <returns>正确或错误</returns>
public static bool SGSmoothAndDerivative(double[] specDatas, int specRows, int specCols, int windowSize, int polyDegree, int derDegree)
{
try
{
if (specDatas == null || specDatas.Length != specRows * specCols)
{
ErrorString = "Invalid parameters";
return(false);
}
bool retcode = false;
if (CommonMethod.Is64BitVersion())
{
retcode = PPSGSmoothAndDerivative64(specDatas, specRows, specCols, windowSize, polyDegree, derDegree);
}
else
{
retcode = PPSGSmoothAndDerivative32(specDatas, specRows, specCols, windowSize, polyDegree, derDegree);
}
if (!retcode)
{
ErrorString = CommonMethod.GetDLLErrorMessage();
}
return(retcode);
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(false);
}
}
/// <summary>
/// 预测时的MSC多元散射校正（处理后的数据在spectrumDatas返回）
/// </summary>
/// <param name="averageData">建模平均光谱（从PLS Coefficient获取）</param>
/// <param name="specDatas">第一行为X数据，后面几行为Y数据</param>
/// <param name="specRows">数据的行数</param>
/// <param name="specCols">数据的列数</param>
/// <returns>正确或错误</returns>
public static bool MutiScatterCorrectionOnPredict(double[] averageData, double[] specDatas, int specRows, int specCols)
{
try
{
if (specDatas == null || averageData == null || specDatas.Length != specRows * specCols)
{
ErrorString = "Invalid parameters";
return(false);
}
bool retcode = false;
if (CommonMethod.Is64BitVersion())
{
retcode = PPMutiScatterCorrectionOnPredict64(averageData, specDatas, specRows, specCols);
}
else
{
retcode = PPMutiScatterCorrectionOnPredict32(averageData, specDatas, specRows, specCols);
}
if (!retcode)
{
ErrorString = CommonMethod.GetDLLErrorMessage();
}
return(retcode);
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(false);
}
}
/// <summary>
/// SNV标准正态变换（处理后的数据在spectrumDatas返回）
/// </summary>
/// <param name="spectrumDatas">第一行为X数据，后面几行为Y数据</param>
/// <param name="specRows">数据的行数</param>
/// <param name="specCols">数据的列数</param>
/// <returns>正确或错误</returns>
public static bool SNVNormalDistribution(double[] spectrumDatas, int specRows, int specCols)
{
try
{
if (spectrumDatas == null || spectrumDatas.Length != specRows * specCols)
{
ErrorString = "Invalid parameters";
return(false);
}
bool retcode = false;
if (CommonMethod.Is64BitVersion())
{
retcode = PPSNVNormalDistribution64(spectrumDatas, specRows, specCols);
}
else
{
retcode = PPSNVNormalDistribution32(spectrumDatas, specRows, specCols);
}
if (!retcode)
{
ErrorString = CommonMethod.GetDLLErrorMessage();
}
return(retcode);
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(false);
}
}
/// <summary>
/// 获取C++ DLL返回的错误信息
/// </summary>
private static string GetErrorMessage()
{
if (CommonMethod.Is64BitVersion())
{
return(GetErrorMessage64());
}
else
{
return(GetErrorMessage32());
}
}
/// <summary>
/// 获取DLL错误消息
/// </summary>
/// <returns></returns>
public static string GetDLLErrorMessage()
{
IntPtr retptr = IntPtr.Zero;
if (CommonMethod.Is64BitVersion())
{
retptr = GetErrorMessage64();
}
else
{
retptr = GetErrorMessage32();
}
return(CommonMethod.CopyStringFromIntptrAndFree(ref retptr, Encoding.ASCII));
}
/// <summary>
/// 三次样条曲线插值（使用X轴步长）
/// </summary>
/// <param name="specDatas">第一行为X数据，后面几行为Y数据</param>
/// <param name="specRows">数据的行数</param>
/// <param name="specCols">数据的列数</param>
/// <param name="firstX">起始波数</param>
/// <param name="lastX">结束波数</param>
/// <param name="stepX">波数间隔</param>
/// <returns>返回处理后的数据, 第一行是X轴，其余行为Y轴</returns>
public static List <double[]> SplineCubicInterpolation(double[] specDatas, int specRows, int specCols, double firstX, double lastX, double stepX)
{
try
{
if (specDatas == null || specRows < 2 || specCols < 2 || stepX == 0 ||
(firstX < lastX && stepX < 0) || (firstX > lastX && stepX > 0))
{
throw new Exception("Invalid parameters");
}
IntPtr retptr = IntPtr.Zero;
int outColsSize = 0;
if (CommonMethod.Is64BitVersion())
{
retptr = PPSplineCubicInterpolation64(specDatas, specRows, specCols, firstX, lastX, stepX, ref outColsSize);
}
else
{
retptr = PPSplineCubicInterpolation32(specDatas, specRows, specCols, firstX, lastX, stepX, ref outColsSize);
}
if (retptr == IntPtr.Zero)
{
throw new Exception(CommonMethod.GetDLLErrorMessage());
}
List <double[]> retdatas = new List <double[]>();
//逐行拷贝返回数据，第一行是X轴，其余行为Y轴
for (int i = 0; i < specRows; i++)
{
double[] rowdata = new double[outColsSize];
Marshal.Copy(IntPtr.Add(retptr, i * outColsSize * sizeof(double)), rowdata, 0, outColsSize);
retdatas.Add(rowdata);
}
Marshal.FreeCoTaskMem(retptr);
return(retdatas);
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
/// <summary>
/// 是否有STANDARDIZING算法授权
/// </summary>
public static bool HasAuthority()
{
try
{
if (CommonMethod.Is64BitVersion())
{
return(SDHasAuthority64());
}
else
{
return(SDHasAuthority32());
}
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(false);
}
}
/// <summary>
/// 三次样条曲线插值（使用数据点数量,直接返回数组）
/// </summary>
/// <param name="specDatas">第一行为X数据，后面几行为Y数据</param>
/// <param name="specRows">数据的行数</param>
/// <param name="specCols">数据的列数</param>
/// <param name="firstX">起始波数</param>
/// <param name="lastX">结束波数</param>
/// <param name="dataCount">数据点数量</param>
/// <param name="returnArray">直接返回数组</param>
/// <returns>返回处理后的数据, 第一行是X轴，其余行为Y轴</returns>
public static double[] SplineCubicInterpolation(double[] specDatas, int specRows, int specCols, double firstX, double lastX, int dataCount, bool returnArray)
{
try
{
if (specDatas == null || specRows < 2 || specCols < 2 || dataCount < 1)
{
throw new Exception("Invalid parameters");
}
//如果数据格式相同，不需要处理
if (CommonMethod.IsSameXDatas(specDatas[0], specDatas[specCols - 1], firstX, lastX, dataCount) && dataCount == specCols)
{
return(specDatas);
}
IntPtr retptr = IntPtr.Zero;
if (CommonMethod.Is64BitVersion())
{
retptr = PPInterpolationUseDataCount64(specDatas, specRows, specCols, firstX, lastX, dataCount);
}
else
{
retptr = PPInterpolationUseDataCount32(specDatas, specRows, specCols, firstX, lastX, dataCount);
}
if (retptr == IntPtr.Zero)
{
throw new Exception(CommonMethod.GetDLLErrorMessage());
}
double[] retdatas = new double[dataCount * specRows];
Marshal.Copy(retptr, retdatas, 0, retdatas.Length);
Marshal.FreeCoTaskMem(retptr);
return(retdatas);
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
/// <summary>
/// 使用光谱校正系数，校正光谱
/// </summary>
/// <param name="coefData">光谱校正系数(BYTE)</param>
/// <param name="slaveData">光谱数据</param>
/// <param name="specRows">光谱的数量</param>
/// <param name="specCols">每条光谱数据数量</param>
/// <param name="withXDatas">是否包含X轴数据</param>
/// <returns>校正后的光谱,与slaveData大小相同</returns>
public static double[] ApplyCoefficient(byte[] coefData, double[] slaveData, int specRows, int specCols, bool withXDatas)
{
try
{
if (coefData == null || slaveData == null || specRows < 1)
{
throw new Exception("Invalid parameters");
}
if (!IsValidCoef(coefData, specCols))
{
throw new Exception("Invalid parameters");
}
IntPtr retptr = IntPtr.Zero;
if (CommonMethod.Is64BitVersion())
{
retptr = SDApplyCoefficient64(coefData, slaveData, specRows, specCols, withXDatas);
}
else
{
retptr = SDApplyCoefficient32(coefData, slaveData, specRows, specCols, withXDatas);
}
if (retptr == IntPtr.Zero)
{
ErrorString = GetErrorMessage();
return(null);
}
return(CommonMethod.CopyDataArrayFromIntptrAndFree <double>(ref retptr, specCols * specRows));
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
/// <summary>
/// 根据主机光谱创建辅机的校准系数
/// </summary>
/// <param name="algorithmType">校准算法</param>
/// <param name="masterData">主机数据（一条光谱一行Y轴数据）</param>
/// <param name="slaveData">辅机数据（一条光谱一行Y轴数据）</param>
/// <param name="specRows">光谱的行数</param>
/// <param name="specCols">每条光谱的数据点数量</param>
/// <param name="windowSize">校准窗口大小(PDS), RANK(SST)</param>
/// <param name="tolerance">校准偏差（PLS）</param>
/// <param name="firstX">起始波数</param>
/// <param name="lastX">结束波数</param>
/// <param name="withXDatas">是否包含X轴数据</param>
/// <returns>校准系数</returns>
public static byte[] GetCoefficient(enumAlgorithmType algorithmType, double[] masterData, double[] slaveData, int specRows, int specCols,
int windowSize, double tolerance, double firstX, double lastX, bool withXDatas)
{
if (masterData == null || slaveData == null || specRows < 2 || specCols < windowSize + 1 || windowSize < 1 ||
masterData.Length != specRows * specCols || masterData.Length != slaveData.Length)
{
ErrorString = "Invalid Parameters";
return(null);
}
try
{
IntPtr retptr = IntPtr.Zero;
int datasize = 0;
switch (algorithmType)
{
case enumAlgorithmType.PDS:
if (CommonMethod.Is64BitVersion())
{
retptr = PDSCoefficient64(masterData, slaveData, specRows, specCols, windowSize, firstX, lastX, withXDatas, ref datasize);
}
else
{
retptr = PDSCoefficient32(masterData, slaveData, specRows, specCols, windowSize, firstX, lastX, withXDatas, ref datasize);
}
break;
case enumAlgorithmType.PLS:
if (CommonMethod.Is64BitVersion())
{
retptr = PLSCoefficient64(masterData, slaveData, specRows, specCols, windowSize, tolerance, firstX, lastX, withXDatas, ref datasize);
}
else
{
retptr = PLSCoefficient32(masterData, slaveData, specRows, specCols, windowSize, tolerance, firstX, lastX, withXDatas, ref datasize);
}
break;
case enumAlgorithmType.SST:
if (CommonMethod.Is64BitVersion())
{
retptr = SSTCoefficient64(masterData, slaveData, specRows, specCols, windowSize, firstX, lastX, withXDatas, ref datasize);
}
else
{
retptr = SSTCoefficient32(masterData, slaveData, specRows, specCols, windowSize, firstX, lastX, withXDatas, ref datasize);
}
break;
default:
break;
}
if (retptr == IntPtr.Zero)
{
ErrorString = GetErrorMessage();
return(null);
}
return(CommonMethod.CopyDataArrayFromIntptrAndFree <byte>(ref retptr, datasize));
}
catch (Exception ex)
{
ErrorString = ex.Message;
return(null);
}
}
