OTS/OTSCPP/OTSClassifyEngine/SpectrumCompareEngine/OTSClassifyOnSpectrumCompEng.cpp

#pragma once
#include "stdafx.h"
#include "OTSSTDLib.h"
#include "OTSClassifyOnSpectrumCompEng.h"
#include "OTSHelper.h"

using namespace std;
using namespace OTSTools;
namespace OTSClassifyEngine
{
	

	CClassifyOnSpectrumCompEng::CClassifyOnSpectrumCompEng(int iStartChannel, CSTDLibPtr stdLib )						// constructor
	{
		m_iStartChannel = iStartChannel;
		m_stdLib = stdLib;
	}

	CClassifyOnSpectrumCompEng::~CClassifyOnSpectrumCompEng()// detractor
	{
	}
	int CClassifyOnSpectrumCompEng::GetMatchingSTDId(  CPosXrayPtr posxray,  double& dValue)
	{
		if (m_stdLib->GetSTDItemCount() < 1)
		{
			return -1;
		}
		int id = 0;	// 存储最相似的那个mineralid
		double dcos = 0;
		dValue = -100000;	// 获取最大的相似值
		for (unsigned int i = 0; i < m_stdLib->GetSTDItemCount(); i++)
		{
			dcos = GetCosValue( posxray, m_stdLib->GetSTDItem(i)->GetXraySpectrum(), m_stdLib->GetSTDItem (i)->GetXraySpectrum()->GetChannelsNum());
			if (dcos > dValue)
			{
				dValue = dcos;
				id = m_stdLib->GetSTDItem (i)->GetID();
			}
		}

		return id;
	}
	CSTDSpectrumItemPtr CClassifyOnSpectrumCompEng::GetMatchingSTD(  CPosXrayPtr posxray, double& dValue)
	{
		CSTDSpectrumItemPtr itm;	// 存储最相似的那个mineral
		int stdItemCount = m_stdLib->GetSTDItemCount();
 		if (stdItemCount < 1)
		{
			return itm;
		}
		double dcos = 0;
		double dSimilarity = -1000;
			// 获取最大的相似值
		int idx = -1;
		for (unsigned int i = 0; i < stdItemCount; i++)
		{
			dcos = GetCosValue(posxray, m_stdLib->GetSTDItem(i)->GetXraySpectrum(), m_stdLib->GetSTDItem(i)->GetXraySpectrum()->GetChannelsNum());
			if (dcos > dSimilarity)
			{
				dSimilarity = dcos;
				idx = i;
				
			}
		}
		dValue = dSimilarity;
		itm = m_stdLib->GetSTDItem(idx);

		return itm;
	}

	CSTDSpectrumItemList CClassifyOnSpectrumCompEng::GetSTDOrderListBySpectrumMatching(CPosXrayPtr spectrum)
	{
		CSTDSpectrumItemList itms;
		std::map<double, CSTDSpectrumItemPtr> similaritymap;
		int stdItemCount = m_stdLib->GetSTDItemCount();
		if (stdItemCount < 1)
		{
			return itms;
		}
		double dcos = 0;
		double dSimilarity = -1000;
		// 获取最大的相似值
		int idx = -1;
		for (unsigned int i = 0; i < stdItemCount; i++)
		{
			dcos = GetCosValue(spectrum, m_stdLib->GetSTDItem(i)->GetXraySpectrum(), m_stdLib->GetSTDItem(i)->GetXraySpectrum()->GetChannelsNum());
	
			similaritymap[dcos] = m_stdLib->GetSTDItem(i);
		}
	
		auto itmIter = similaritymap.rbegin();
		while (itmIter!=similaritymap.rend())
		{
			itms.push_back(itmIter->second);
			itmIter++;
		}
		




		return itms;
	}

	// 20190903:增加参数iStartChannel哪个位置开始比较, vecIgnoreChannel里面的通道不处理,
	double CClassifyOnSpectrumCompEng::GetCosValue( CPosXrayPtr posXray,CPosXrayPtr posXray1, int iDataLen1)
	{
		if (posXray->GetChannelsNum() != iDataLen1)
		{
			return 0;
		}

		DWORD* pXrayData = posXray->GetXrayData();
		DWORD* pXrayData1 = posXray1->GetXrayData();


		// 公式: (x1y1+x2y2+x3y3+...x2000y2000) / (sqrt(x1^2 + x2^2 + ...x2000^2) * sqrt(y1^2 + y2^2 + ...y2000^2))
		double dotProduct = 0;
		double d1 = 0;
		double d2 = 0;
		for (int i = m_iStartChannel; i < iDataLen1; i++)
		{
			double r1 = pXrayData[i];
			double r2= pXrayData1[i];
			r1 *= r2;
			dotProduct = dotProduct + r1;
	
		}
		d1 = posXray->GetXrayDataVectorNorm();
		d2 = posXray1->GetXrayDataVectorNorm();
         return (0 == d1 || 0 == d2) ? 0 : dotProduct / (d1 * d2);
	
	}

	// 20190903:增加参数iStartChannel哪个位置开始比较, vecIgnoreChannel里面的通道不处理
	double CClassifyOnSpectrumCompEng::GetStdEvp( CPosXrayPtr posxray, DWORD* pXrayData1, int iDataLen1)
	{
		if (posxray->GetChannelsNum() != iDataLen1)
		{
			return 0;
		}
	
		DWORD* pXrayData = posxray->GetXrayData();
		//bool bignore = false;
		
		DWORD iSum1 = 0;
		DWORD iSum2 = 0;
		double dAva1 = 0;
		double dAva2 = 0;
		double dSquare1 = 0;
		double dSquare2 = 0;

		int num1= iDataLen1 - m_iStartChannel;

		// 求出能谱的平均值		
		for (int i = m_iStartChannel; i < iDataLen1; i++)
		{
			

			// 能谱差之和
			
				iSum1 = iSum1 + pXrayData1[i];


				iSum2 = iSum2 + pXrayData[i];

			
		}
		
		dAva1 = iSum1 /num1;
		dAva2 = iSum2 / num1;

		for (int i = m_iStartChannel; i < iDataLen1; i++)
		{
			dSquare1 = dSquare1 + (pXrayData1[i] - dAva1) * (pXrayData1[i] - dAva1);
			dSquare2 = dSquare2 + (pXrayData[i] - dAva1) * (pXrayData[i] - dAva1);
		}
		dSquare1 = dSquare1 / num1;
		dSquare2 = dSquare2 / num1;

		dSquare1 = sqrt(dSquare1);
		dSquare2 = sqrt(dSquare2);

		dSquare1 = dSquare1 * dAva2 / dAva1;    // 归一化

		return (dSquare1 < dSquare2) ? (dSquare1 / dSquare2) : (dSquare2 / dSquare1);
	}

	void CClassifyOnSpectrumCompEng::GetElementChannel(const vector<CString>& vecstrElementNames, vector<int>& veciChannel)
	{
		veciChannel.clear();
		for (unsigned int i = 0; i < (int)vecstrElementNames.size(); i++)
		{
			GetElementChannel(vecstrElementNames[i], veciChannel);
		}
	}

	void CClassifyOnSpectrumCompEng::GetElementChannel(CString strElementName, vector<int>& veciChannel)
	{
		CElement* pElement = NULL;
		pElement = new CElement(strElementName);
		if (pElement)
		{
			AddChannel(pElement->GetEnergyValueK(), veciChannel);
			AddChannel(pElement->GetEnergyValueL(), veciChannel);
			AddChannel(pElement->GetEnergyValueM(), veciChannel);

			delete pElement;
			pElement = NULL;
		}
	}

	void CClassifyOnSpectrumCompEng::AddChannel(double dEnergy, vector<int>& veciChannel)
	{
		int i = 0;
		int iChannel = 0;
		if (dEnergy >= 0 && dEnergy < 20)
		{
			dEnergy = dEnergy * 100;
			iChannel = (int)dEnergy;
			for (i = 0; i < (int)veciChannel.size(); i++)
			{
				if (veciChannel[i] == iChannel)
				{
					break;
				}
			}
			if (i >= (int)veciChannel.size())
			{
				veciChannel.push_back(iChannel);
			}
		}
	}
}