add missing files

OTSCPP/OTSClassifyEngine/ExpressionParseEngine/PartSTDRuleItem.cpp

@@ -0,0 +1,228 @@
+#pragma once
+#include "stdafx.h"
+#include "PartSTDRuleItem.h"
+#include "XMLSerialization.h"
+#include "OTSFileSys.h"
+#include "Element.h"
+using namespace OTSTools;
+using namespace OTSDATA;
+using namespace xmls;
+std::map<std::string, OTSDATA::CElementPtr>& PartSTDRuleItem::GetMapElements()
+{
+	if (m_mapEleItems.size() == 0)
+	{
+		for (auto ele : m_KeyelementList)
+		{
+			m_mapEleItems[ele->GetName().GetBuffer()] = ele;
+		}
+	}
+
+	return m_mapEleItems;
+}
+
+void PartSTDRuleItem::Serialize(bool isStoring, tinyxml2::XMLDocument* classDoc, tinyxml2::XMLElement* rootNode)
+{
+	// name
+	xmls::xString xstrName;
+	// color
+	xmls::xString xsColor;//COLORREF, C# can't access
+
+	xmls::xInt xnSTDId;
+	xmls::xString xKeyElementListStr;
+	xmls::xString xSubElementListStr;
+
+	xmls::xString xUsingConstants;
+	xmls::xString xImgPropertyListStr;
+	xmls::xString xOtherPropertyListStr;
+	xmls::xString xExpstr;
+	//xmls::Collection< CElementRange> xElementRanges;
+	xmls::xString xHardness;
+	xmls::xString xDensity;
+	xmls::xString xElectrical_conductivity;
+
+	xmls::Slo slo;
+	slo.Register("StrName", &xstrName);
+	slo.Register("Color", &xsColor);
+
+	slo.Register("STDId", &xnSTDId);
+
+	slo.Register("KeyElementList", &xKeyElementListStr);
+	slo.Register("SubElementList", &xSubElementListStr);
+	slo.Register("UsingConstants", &xUsingConstants);
+	slo.Register("UsingImgPropertyList", &xImgPropertyListStr);
+	slo.Register("UsingOtherPropertyList", &xOtherPropertyListStr);
+	slo.Register("Expression", &xExpstr);
+	slo.Register("Hardness", &xHardness);
+	slo.Register("Density", &xDensity);
+	slo.Register("Electrical_conductivity", &xElectrical_conductivity);
+	if (isStoring)
+	{
+		xstrName = GetName();
+		xsColor = GetColor();
+		xHardness = m_Hardness;
+		xDensity = m_Density;
+		xElectrical_conductivity = m_Electrical_conductivity;
+		xnSTDId = GetID();
+
+		CString s = "";
+		for (auto poElement : m_KeyelementList)
+		{
+			s += poElement->GetName() + ",";
+		}
+		s = s.TrimRight(",");
+		xKeyElementListStr = s;
+
+		s = "";
+		for (auto poElement : m_SubelementList)
+		{
+			s += poElement->GetName() + ",";
+		}
+		s = s.TrimRight(",");
+		xSubElementListStr = s;
+
+		for (auto pName : m_ImgPropertyList)
+		{
+			s += pName.c_str();
+			s += ",";
+		}
+		s = s.TrimRight(",");
+		xImgPropertyListStr = s;
+
+		for (auto pName : m_OtherpropertyList)
+		{
+			s += pName.c_str();
+			s += ",";
+		}
+		s = s.TrimRight(",");
+		xOtherPropertyListStr = s;
+
+		slo.Serialize(true, classDoc, rootNode);
+	}
+	else
+	{
+		slo.Serialize(false, classDoc, rootNode);
+
+		SetName(xstrName.value().c_str());
+		SetColor(xsColor.value().c_str());
+		SetExpressionStr(xExpstr.value());
+		m_Hardness = xHardness.value();
+		m_Density = xDensity.value();
+		m_Electrical_conductivity = xElectrical_conductivity.value();
+		SetID(xnSTDId.value());
+		std::vector<string> eles;
+
+		std::string elements = xKeyElementListStr.c_str();
+		xmls::SplitString(elements, eles, ",");
+		for (int i = 0; i < eles.size(); ++i)
+		{
+			CString ss = eles[i].c_str();
+			m_KeyelementList.push_back(CElementPtr(new CElement(ss)));
+		}
+
+		elements = xSubElementListStr.c_str();
+		eles.clear();
+		xmls::SplitString(elements, eles, ",");
+		for (int i = 0; i < eles.size(); ++i)
+		{
+			CString ss = eles[i].c_str();
+			m_SubelementList.push_back(CElementPtr(new CElement(ss)));
+		}
+
+
+		std::vector<string> pNames;
+		std::string propertynames = xImgPropertyListStr.c_str();
+		xmls::SplitString(propertynames, pNames, ",");
+		for (int i = 0; i < pNames.size(); ++i)
+		{
+			std::string ss = pNames[i];
+			m_ImgPropertyList.push_back(ss);
+		}
+		std::vector<string> pOthers;
+		std::string otherPropertynames = xOtherPropertyListStr.c_str();
+		xmls::SplitString(otherPropertynames, pOthers, ",");
+		for (int i = 0; i < pOthers.size(); ++i)
+		{
+			std::string ss = pOthers[i];
+			m_OtherpropertyList.push_back(ss);
+		}
+		for (auto ele : m_KeyelementList)
+		{
+			m_mapEleItems[ele->GetName().GetBuffer()] = ele;
+		}
+		xmls::SplitString(xUsingConstants.value(), m_usingConstants, ",");
+
+	}
+
+}
+CElementsList PartSTDRuleItem::GetAllSortedEleList()
+{
+	std::multimap<int, CElementPtr> mapEles;// sorted all the using elements by the name's length,so that we can always handle the longer name element first.
+	//because if we handle short name element first ,we may treat "Cu" as "C" or other have the same character in name element.
+	for (auto ele : m_KeyelementList)
+	{
+		mapEles.insert(std::pair<int, CElementPtr>(ele->GetName().GetLength(), ele));
+	}
+	for (auto ele : m_SubelementList)
+	{
+		mapEles.insert(std::pair<int, CElementPtr>(ele->GetName().GetLength(), ele));
+
+	}
+	CElementsList eleList;
+
+	for (auto itr = mapEles.rbegin(); itr != mapEles.rend(); itr++)
+	{
+		eleList.push_back(itr->second);
+
+	}
+	return eleList;
+
+}
+void PartSTDRuleItem::AddXraySpectrum(CPosXrayPtr xray)
+{
+	if (m_spectrums.size() < 50)//only memory 50 spectrum for one item.
+	{
+		m_spectrums.push_back(xray);
+	}
+	
+}
+double PartSTDRuleItem::CalculateSimilarity(CPosXrayPtr xray)
+{
+	double maxSimilarity=0;
+	for (auto mySpectrum : m_spectrums)
+	{
+		double sim=GetCosValue(mySpectrum, xray, GENERALXRAYCHANNELS);
+		if (sim > maxSimilarity)
+		{
+			maxSimilarity = sim;
+		}
+	}
+	return maxSimilarity;
+}
+double PartSTDRuleItem::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 = 0; 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);
+
+}

OTSCPP/OTSClassifyEngine/ExpressionParseEngine/PartSTDRuleItem.h

@@ -0,0 +1,91 @@
+#pragma once
+#include <string>
+#include <vector>
+#include "element.h"
+#include <map>
+#include "Posxray.h"
+using namespace std;
+using namespace OTSDATA;
+class PartSTDRuleItem :public xmls::ISlo
+{
+public:
+
+	std::map<std::string, CElementPtr>& GetMapElements();
+
+	virtual void Serialize(bool isStoring, tinyxml2::XMLDocument* classDoc, tinyxml2::XMLElement* rootNode) override;
+	
+	std::string  GetHardness() const { return m_Hardness; }
+	void SetHardness(std::string val) { m_Hardness = val; }
+	std::string  GetDensity() const { return m_Density; }
+	void SetDensity(std::string val) { m_Density = val; }
+	std::string GetElectrical_conductivity() const { return m_Electrical_conductivity; }
+	void SetElectrical_conductivity(std::string val) { m_Electrical_conductivity = val; }
+	int GetID() const { return ID; }
+	void SetID(int val) { ID = val; }
+	std::string GetName() const { return m_name; }
+	void SetName(std::string val) { m_name = val; }
+	std::string GetColor() const { return m_color; }
+	void SetColor(std::string val) { m_color = val; }
+
+	int GetGrpID() const { return m_grpId; }
+	void SetGrpID(int val) { m_grpId = val; }
+	std::string GetGrpName() const { return m_grpName; }
+	void SetGrpName(std::string val) { m_grpName = val; }
+	std::string GetGrpColor() const { return m_grpColor; }
+	void SetGrpColor(std::string val) { m_grpColor = val; }
+
+	std::vector<std::string> GetUsingImgPropertyNameList() { return m_ImgPropertyList; }
+	void SetUsingImgPropertyNameList(std::vector<std::string> val) { m_ImgPropertyList = val; }
+
+	std::vector<std::string> GetUsingOtherpropertyList() { return m_OtherpropertyList; }
+	void SetUsingOtherpropertyList(std::vector<std::string> val) { m_OtherpropertyList = val; }
+
+	std::vector<std::string> GetUsingConstants() const { return m_usingConstants; }
+
+	std::string GetExpressionStr() const { return m_expressionStr; }
+	void SetExpressionStr(std::string val) { m_expressionStr = val; }
+	CElementsList GetKeyElementList() const { return m_KeyelementList; }
+	void SetKeyElementList(CElementsList val) { m_KeyelementList = val; }
+
+	CElementsList GetSubElementList() const { return m_SubelementList; }
+	void SetSubElementList(CElementsList val) { m_SubelementList = val; }
+	CElementsList GetAllSortedEleList();
+	
+	
+	std::string GetFormula() const { return m_Formula; }
+	void SetFormula(std::string val) { m_Formula = val; }
+	std::string GetElement() const { return m_Element; }
+	void SetElement(std::string val) { m_Element = val; }
+	double GetBSE() const { return m_BSE; }
+	void SetBSE(double val) { m_BSE = val; }
+	void AddXraySpectrum(CPosXrayPtr xray);
+	void SetIsElementAnalysis(bool isanalysis) { m_elementAnalysis = isanalysis; };
+	bool GetIsElementAnalysis() { return m_elementAnalysis; };
+	double CalculateSimilarity(CPosXrayPtr xray);
+private:
+	double GetCosValue(CPosXrayPtr posXray, CPosXrayPtr posXray1, int iDataLen1);
+	int ID;
+	std::string m_name;
+	std::string m_color;
+	int m_grpId;
+	std::string m_grpName;
+	std::string m_grpColor;
+	CElementsList m_KeyelementList;
+	CElementsList m_SubelementList;
+	std::vector<std::string> m_ImgPropertyList;
+	std::vector<std::string> m_OtherpropertyList;
+	std::vector<std::string> m_usingConstants;
+	std::string m_expressionStr;
+	std::map <std::string, CElementPtr> m_mapEleItems;
+	std::string m_Hardness;
+	std::string m_Density;
+	std::string  m_Electrical_conductivity;
+	double m_BSE;
+	std::string m_Formula;
+	std::string m_Element;
+	bool m_elementAnalysis;
+	CPosXrayList m_spectrums;
+
+};
+typedef std::shared_ptr<PartSTDRuleItem>  PartSTDRuleItemPtr;
+typedef std::vector<PartSTDRuleItemPtr> PartSTDRuleItemList;