OTS/OTSCPP/OTSClassifyEngine/ParticleClassifyEngine.cpp

#pragma  once
#include "stdafx.h"
#include "ParticleClassifyEngine.h"
#include "ParticleEngine/LogicExp.h"
#include "XMLSerialization.h"
#include <map>
#include <Element.h>
#include "OTSSTDLibFileMgr.h"
#include "COTSUtilityDllFunExport.h"

namespace OTSClassifyEngine
{
	using namespace expInterpreter;
bool ParticleClassifyEngine::Init()
{
	CSTDLibFileMgrPtr pLibFileMgr = CSTDLibFileMgrPtr(new CSTDLibFileMgr(m_StrName));
	//CSTDLibPtr lib;
	m_std = ParticleSTDPtr(new ParticleSTD());
	if (!pLibFileMgr->LoadPartSTD(m_std))
	{
		return FALSE;
	}
	 pLibFileMgr->LoadMaxEDSRulesData(m_std);
	 pLibFileMgr->LoadZeroElementRulesData(m_std);
	
	 string constantStr = pLibFileMgr->LoadConstantsData();
	 std::map<std::string, double> m_mapConstants;
	 m_mapConstants.clear();
	 std::vector<std::string> strs;
	 xmls::SplitString(constantStr, strs, ",");
	 for (std::string s : strs)
	 {
		 std::vector<std::string> oneExp;
		 xmls::SplitString(s, oneExp, "=");
		 m_mapConstants[oneExp[0]] = std::atof(oneExp[1].c_str());
	 }

	 m_std->setConstantsMap(m_mapConstants);
	return true;
}

bool ParticleClassifyEngine::Classify(COTSParticlePtr particle, CPosXrayPtr xray)
{

	if (particle == nullptr || xray == nullptr) return false;

	auto& originalPartEles = xray->GetElementQuantifyData();//find all the elements containing in the particle xray.
	//以下为调试用代码段(在log中打出颗粒元素），不要删除----------
	/*std::string allele="";
	for (auto che : originalPartEles)
	{
		allele += che->GetName().GetBuffer() ;
		allele += ":";
		allele += std::to_string(che->GetPercentage()).c_str();
		allele += "  ";
	}
	LogTrace(__FILE__, __LINE__, allele.c_str());*/
	//-----------------------------
	//zero element process,if satisfied the condition than erase the element from the list.

	auto partEles=ZeroElementProcess(particle, xray);//auto partEles = xray->GetElementQuantifyData();

	
	std::map<std::string, CElementChemistryPtr> mapChemistrys;
	for (auto ch : partEles)
	{
		mapChemistrys[ch->GetName().GetBuffer()] = ch;
	}


	PartSTDItemList stdItems = m_std->GetSTDItems();

	for (auto itm : stdItems)
	{
		std::string exp = itm->GetExpressionStr();

		//if the element quantity is not match the std item's keyelement num than  is unsatisfied.
			if (partEles.size() <itm->GetKeyElementList().size()) 
			{
				/*std::string s = std::to_string(partEles.size()) + ":" + std::to_string(itm->GetKeyElementList().size());
				LogTrace(__FILE__, __LINE__, s.c_str());*///调试用代码段
				particle->SetClassifyId(9);
				particle->TypeName("Not Identified");
				
				continue;
			}
			
		auto& mapStdEles = itm->GetMapElements();
		bool bMatch=true;
		// if the particle does not contain all the key elements of the item than is unsatisfied.
		for (auto che : mapStdEles)
		{
			
			auto chemical= mapChemistrys.find(che.second->GetName().GetBuffer());
			if (chemical == mapChemistrys.end())
			{
				particle->SetClassifyId(9);
				particle->TypeName("Not Identified");
				bMatch=false;
				break;
			}
		}
		
		if (!bMatch) continue;

	   // process the special property name such as "first_elem" and "Element#1" etc.
		for (std::string s : itm->GetUsingOtherpropertyList())
		{

			if (s.find("_elem")!=std::string::npos)
			{
				auto val = GetAtomicNoBySortingPercentage(s.c_str(), xray);				
				
				xmls::ReplaceAll(exp, s, std::to_string(val));
			}

			if (s.find("Element#")!=std::string::npos)
			{
				auto val = GetEleNameBySortingPercentage(s.c_str(), xray);//find the "Element#1" and  replace it with the real element name. 
				auto elelist = itm->GetKeyElementList();
				elelist.push_back(CElementPtr(new CElement(val)));// then replace it in the next step.
				itm->SetKeyElementList(elelist);				
				xmls::ReplaceAll(exp, s, val.GetBuffer());
			}
		}
		
		for (auto eleChemistry : itm->GetAllSortedEleList())
		{
			auto e = mapChemistrys.find(eleChemistry->GetName().GetBuffer());

			if (e != mapChemistrys.end())
			{
				std::string name = eleChemistry->GetName();

				xmls::ReplaceAll(exp, name, std::to_string(e->second->GetPercentage()));
			}
			else
			{
				std::string name = eleChemistry->GetName();

				xmls::ReplaceAll(exp, name, "0");
			}
		}
		//process the image property
		for (std::string s : itm->GetUsingImgPropertyNameList())
		{
			auto val=particle->GetImgPropertyValueByName(s.c_str());
			xmls::ReplaceAll(exp, s, std::to_string(val));
		}
		//process the "true" keyword.
		if (exp.find("true") != std::string::npos)
		{
			xmls::ReplaceAll(exp, "true", "(1=1)");
		}
		//process the "false" keyword.
		if (exp.find("false") != std::string::npos)
		{
			xmls::ReplaceAll(exp, "false", "(1=0)");
		}
		for (int i = 0; i < 10; i++)
		{
			std::string macStr = "MAC#" + std::to_string(i);
			if (exp.find(macStr) != std::string::npos)
			{
				auto val = GetMacValue(macStr.c_str());//find the "Mac#1" and  replace it with the real element name. 
				xmls::ReplaceAll(exp, macStr, std::to_string(val));
			}

		}
		//LogInfoTrace(__FILE__, __LINE__, exp.c_str());//调试用代码段

		//calculate the expression which has been processed.
		
		bool rst=CalcuExp(exp);
		if (rst)
		{
			//int id = itm->GetID();
			particle->SetType(OTS_PARTICLE_TYPE::IDENTIFIED);
			particle->SetClassifyId(itm->GetID());
			particle->TypeColor(itm->GetColor());
			particle->TypeName(itm->GetName());
			particle->SetHardness(itm->GetHardness());
			particle->SetDensity(itm->GetDensity());
			particle->SetConductivity(itm->GetElectrical_conductivity());
			return true;
		}
		else
		{
			continue;
		}
	}
	particle->SetType(OTS_PARTICLE_TYPE::NOT_IDENTIFIED);
	particle->TypeName("Not Identified");
	return true;
}



bool ParticleClassifyEngine::Classify(COTSParticlePtr particle, int SteelTech, CPosXrayPtr xray)
{
	throw std::logic_error("The method or operation is not implemented.");
}



bool ParticleClassifyEngine::IfNeedMaxEDS(COTSParticlePtr particle, CPosXrayPtr xray, double& MaxEDSTime)
{
	if (particle == nullptr || xray == nullptr) return false;
	MaxEDSRuleList Rules = m_std->GetMaxEDSRules();
	for (auto rule : Rules)
	{
		std::string exp = rule->m_expressionStr;
		auto& partEles = xray->GetElementQuantifyData();//find all the elements containing in the particle xray.
		if (partEles.size() < rule->m_elementList.size())
		{

			continue;// if the size not match then continue.
		}
		std::map<CString, CElementChemistryPtr> mapChe;
		for (auto ch : partEles)
		{
			mapChe[ch->GetName()] = ch;
		}
		auto& usingEles = rule->m_elementList;
		bool bMatch=true;
		for (auto che : usingEles)
		{
			auto chemical = mapChe.find(che->GetName());
			if (chemical == mapChe.end())
			{
				bMatch = false;
				break;
				
			}
		}
		if (!bMatch) continue;//if cann't find the element in the particle's element,then continue.

		// all the rule's using element are contained in the particle then we replace the element with the percentage value

		for (std::string s : rule->m_OtherpropertyList)
		{
			if (s.find("_elem")!=std::string::npos)
			{
				auto val = GetAtomicNoBySortingPercentage(s.c_str(), xray);
				
				xmls::ReplaceAll(exp, s, std::to_string(val));
			}
			if (s.find("Element#")!=std::string::npos)
			{
				auto val = GetEleNameBySortingPercentage(s.c_str(), xray);//find the "Element#1" and  replace it with the real element name. 
				auto& elelist = rule->m_elementList;
				elelist.push_back(CElementPtr(new CElement(val)));// then replace it in the next step.
				
			
				xmls::ReplaceAll(exp, s, val.GetBuffer());
			}

		}
		for (auto eleChemistry : rule->m_elementList)
		{
			auto e = mapChe[eleChemistry->GetName()];

			std::string name = eleChemistry->GetName();
			
			xmls::ReplaceAll(exp, name, std::to_string(e->GetPercentage()));
		}
		for (std::string s : rule->m_ImgPropertyList)
		{
			auto val = particle->GetImgPropertyValueByName(s.c_str());
			
			xmls::ReplaceAll(exp, s, std::to_string(val));
		}


		bool rst = CalcuExp(exp);
		if (rst)
		{
			MaxEDSTime = rule->m_MaxEDSTime;
			return true;

		}
		else
		{
			continue;
		}
	}
	MaxEDSTime = 0;
	return false;
}

CString ParticleClassifyEngine::GetEleNameBySortingPercentage(CString sortingNostr, CPosXrayInfoPtr xrayInfo)
{
	std::map<double, CElementChemistryPtr> mapPercent;
	std::map<int, CElementChemistryPtr> mapSorted;
	auto eles = xrayInfo->GetElementQuantifyData();
	for (auto e : eles)
	{
		mapPercent[e->GetPercentage()] = e;
	}
	auto itr = --mapPercent.end();
	for (int i=0;itr != mapPercent.begin();)
	{
		
		mapSorted.insert(std::pair<int, CElementChemistryPtr>(i, itr->second));
			itr--;
			i++;
	}
	std::string NoStr = sortingNostr;
	std::vector<string> strs;
	xmls::SplitString(NoStr, strs, "#");
	int No = std::stoi(strs[1]);
	if (mapSorted.size() > No)
	{
		return  mapSorted[No]->GetName();

	}
	else
	{
		return _T("");
	}
}
double ParticleClassifyEngine::GetMacValue(CString MacStr)
{
	auto mapconstant = m_std->GetMapConstants();
	
	if (mapconstant.find(MacStr.GetBuffer()) != mapconstant.end())
	{
		return mapconstant[MacStr.GetBuffer()];
	}
	else
	{
		return 0.0;
	}

}


int ParticleClassifyEngine::GetAtomicNoBySortingPercentage(CString sortingNostr, CPosXrayInfoPtr xrayInfo)
{
	std::map<double, CElementChemistryPtr> mapPercent;
	std::map<int, CElementChemistryPtr> mapSorted;
	auto eles = xrayInfo->GetElementQuantifyData();
	if (eles.size() == 0)
	{
		return 0;
	}
	for (auto e : eles)
	{
		mapPercent[e->GetPercentage()] = e;
	}
	
	auto itr = --mapPercent.end();
	for (int i = 0; itr != mapPercent.begin(); )
	{
		
			
			mapSorted.insert(std::pair<int, CElementChemistryPtr>(i, itr->second));
		
			itr--;
		i++;
	}
	std::string NoStr = sortingNostr;
	int No;
	if (sortingNostr == "first_elem") No = 0;
	if (sortingNostr == "second_elem") No = 1;
	if (sortingNostr == "third_elem") No = 2;
	if (sortingNostr == "fourth_elem") No = 3;
	if (sortingNostr == "fifth_elem") No = 4;
	if (sortingNostr == "sixth_elem") No = 5;
	if (sortingNostr == "seventh_elem") No =6;
	if (sortingNostr == "eighth_elem") No = 7;
	if (sortingNostr == "ninth_elem") No = 8;
	if (sortingNostr == "tenth_elem") No =9;
	if (mapSorted.size() > No)
	{
		std::string elename = mapSorted[No]->GetName();
		CElementPtr ele = CElementPtr(new CElement(elename.c_str()));
		return ele->GetAtomNum();
	}
	else
	{
		return 0;
	}
	
}

CElementChemistriesList ParticleClassifyEngine::ZeroElementProcess(COTSParticlePtr particle, CPosXrayPtr xray)
{

	auto& originalPartEles = xray->GetElementQuantifyData();//find all the elements containing in the particle xray.
	CElementChemistriesList partEles;
	for (auto che : originalPartEles)
	{
		auto newChe = CElementChemistryPtr(new CElementChemistry(che.get()));
		partEles.push_back(newChe);
	}

	std::map<CString, CElementChemistryPtr> mapChe;
	for (auto ch : partEles)
	{
		mapChe[ch->GetName()] = ch;
	}
	ZeroElementRuleList Rules = m_std->GetZeroRules();
	for (auto rule : Rules)
	{
		std::string exp = rule->GetExpressionStr();

		if (partEles.size() < rule->GetUsingElementList().size())
		{

			continue;// if the size not match then continue.
		}

		auto& usingEles = rule->GetUsingElementList();
		bool bMatch = true;
		for (auto che : usingEles)
		{
			auto chemical = mapChe.find(che->GetName());
			if (chemical == mapChe.end())
			{
				bMatch = false;
				break;//if cann't find the element in the particle's element,then continue.
			}
		}
		if (bMatch == false) continue;
		// all the rule's using element are contained in the particle then we replace the element with the percentage value

		for (std::string s : rule->GetOtherpropertyList())
		{
			if (s.find("_elem")!=std::string::npos)
			{
				auto val = GetAtomicNoBySortingPercentage(s.c_str(), xray);

				
				xmls::ReplaceAll(exp, s, std::to_string(val));
			}
			if (s.find("Element#")!=std::string::npos)
			{
				auto val = GetEleNameBySortingPercentage(s.c_str(), xray);//find the "Element#1" and  replace it with the real element name. 
				auto elelist = rule->GetUsingElementList();
				elelist.push_back(CElementPtr(new CElement(val)));// then replace it in the next step.
				rule->SetUsingElementList(elelist);
			
				xmls::ReplaceAll(exp, s, val.GetBuffer());
			}
			
			

		}

		for (auto eleChemistry : rule->GetUsingElementList())
		{
			auto e = mapChe.find(eleChemistry->GetName());
			if (e != mapChe.end())
			{
				std::string name = eleChemistry->GetName();
			
			xmls::ReplaceAll(exp, name, std::to_string((*e).second->GetPercentage()));
			}
			

		}

		for (std::string s : rule->GetImgPropertyList())
		{
			auto val = particle->GetImgPropertyValueByName(s.c_str());
			
			xmls::ReplaceAll(exp, s, std::to_string(val));
		}

		for (int i = 0; i < 10; i++)
		{
			std::string macStr = "MAC#" + std::to_string(i);
			if (exp.find(macStr) != std::string::npos)
			{
				auto val = GetMacValue(macStr.c_str());//find the "Mac#1" and  replace it with the real element name. 
				xmls::ReplaceAll(exp, macStr, std::to_string(val));
			}

		}
		bool rst = CalcuExp(exp);
		if (rst)
		{
			auto itr = std::find_if(partEles.begin(), partEles.end(), [rule](CElementChemistryPtr ele) {return ele->GetName() == CString(rule->GetZeroElementName().c_str()); });
				if (itr != partEles.end())
				{
					//partEles.erase(itr);//if satisfied the condition then erase the element(zero the element).
					(*itr)->SetPercentage(0);//if satisfied the condition then set element percenttage to 0(zero the element).
					double sumPercentage=0;
					for (auto ele : partEles)
					{
						sumPercentage += ele->GetPercentage();
					}
					for (auto ele : partEles)
					{
						ele->SetPercentage(ele->GetPercentage() / sumPercentage*100);
					}

				}
				
			
		}
		else
		{
			continue;
		}
	}

	return partEles;

}


OTSClassifyEngine::CLEEnginePtr GetParticleEngine(std::string libName)
{
	static CLEEnginePtr engine;
	if (engine == NULL)
	{
		engine = CLEEnginePtr(new ParticleClassifyEngine(libName));
		engine->Init();
	}
	return engine;
}
}