OTS/OTS_GB/OTSData/OTSParticle.cpp

#include "stdafx.h"
#include "OTSParticle.h"
#include "Element.h"


namespace OTSDATA {

	// COTSParticle

	// constructor
	COTSParticle::COTSParticle()													// constructor
	{
		Init();
		
	}

	COTSParticle::COTSParticle(const COTSParticle& a_oSource)								// copy constructor
	{
		// can't copy itself
		if (&a_oSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(a_oSource);
	}

	COTSParticle::COTSParticle(COTSParticle* a_poSource)								// copy constructor
	{
		// can't copy itself
		if (a_poSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(*a_poSource);
	}

	COTSParticle& COTSParticle::operator=(const COTSParticle& a_oSource)					// =operator
	{
		// cleanup
		Cleanup();

		// copy the class data over
		Duplicate(a_oSource);

		// return class
		return *this;
	}

	BOOL COTSParticle::operator==(const COTSParticle& a_oSource)							// ==operator
	{
		// return FASLE, if the two segments list are in different size		
		return ( m_nTagId == a_oSource.m_nTagId &&
			m_nSearchId == a_oSource.m_nSearchId &&
			m_nAnalysisId == a_oSource.m_nAnalysisId &&
			m_nFieldId == a_oSource.m_nFieldId &&
			m_dArea == a_oSource.m_dArea &&
			m_cAveGray == a_oSource.m_cAveGray &&
			m_nTypeId == a_oSource.m_nTypeId &&
			m_poiXRayPos == a_oSource.m_poiXRayPos &&
			*(m_pFeature.get()) == *(a_oSource.m_pFeature.get()));
		
	}

	COTSParticle::~COTSParticle()										// destructor
	{
		Cleanup();
	}



	void COTSParticle::Serialize(bool isStoring, tinyxml2::XMLDocument * classDoc, tinyxml2::XMLElement * rootNode)
	{
		xmls::xInt xTagId;
		xmls::xInt xnSearchId;
		xmls::xInt xnAnalysisId;
		xmls::xInt xnFieldId;
		xmls::xDouble xdArea;
		xmls::xRect xrectParticle;
		xmls::xInt xcAveGray;
		xmls::xInt xType;
		xmls::xPoint xpoiXRayPos;
		xmls::Slo slo;
		slo.Register("TagId", &xTagId);
		slo.Register("SearchId", &xnSearchId);
		slo.Register("AnalysisId", &xnAnalysisId);
		slo.Register("FieldId", &xnFieldId);
		slo.Register("Area", &xdArea);
		slo.Register("rectParticle", &xrectParticle);
		slo.Register("AveGray", &xcAveGray);
		slo.Register("Type", &xType);
		slo.Register("poiXRayPos", &xpoiXRayPos);
		slo.Register("Feature", m_pFeature.get());
		if (isStoring)
		{
			xTagId = m_nTagId;
			xnSearchId = m_nSearchId;
			xnAnalysisId = m_nAnalysisId;
			xnFieldId = m_nFieldId;
			xdArea = m_dArea;
			xrectParticle = m_rectParticle;
			xcAveGray = m_cAveGray;
			xType = m_nTypeId;
			xpoiXRayPos = m_poiXRayPos;

			slo.Serialize(true, classDoc, rootNode);
		}
		else
		{
			slo.Serialize(false, classDoc, rootNode);
			m_nTagId = xTagId.value();
			m_nSearchId = xnSearchId.value();
			m_nAnalysisId = xnAnalysisId.value();
			m_nFieldId = xnFieldId.value();
			m_dArea = xdArea.value();
			m_rectParticle = xrectParticle.value();
			m_cAveGray = xcAveGray.value();
			m_nTypeId = xType.value();
			m_poiXRayPos = xpoiXRayPos.value();
			
		}
	}


	double COTSParticle::GetImgPropertyValueByName(CString propertyName)
	{
		//double pvalue;
		if (propertyName == "Dmax") return   this->GetDMax();
		if (propertyName == "Dmin") return   this->GetDMin();
		if (propertyName == "Area") return   this->GetArea();
		if (propertyName == "Dferet") return   this->GetFeretDiameter();
		if (propertyName == "With") return   this->GetWidth();
		if (propertyName == "Height") return   this->GetHeight();
		if (propertyName == "Perimeter") return   this->GetPerimeter();
		if (propertyName == "Dperp") return   this->GetDPerp();
		if (propertyName == "Dinscr") return   this->GetDInscr();
		if (propertyName == "Dmean") return   this->GetDMean();
		if (propertyName == "Orientation") return   this->GetOrientation();
		if (propertyName == "Delong") return   this->GetDElong();
		if (propertyName == "AspectElong") return   this->GetAspectElong();
		if (propertyName == "Dequalcircle") return   this->GetEqualCircleDiameter();
		if (propertyName == "Aspect") return   this->GetAspectRatio();
		if (propertyName == "Vedio") return   this->GetVideo();
		if (propertyName == "X") return   this->GetXRayPos().x;
		if (propertyName == "Y") return   this->GetXRayPos().y;
		//return pvalue;
	}



	BOOL COTSParticle::CalCoverRect()
	{
		ASSERT(m_pFeature);
		if (!m_pFeature)
		{
			return FALSE;
		}

		COTSSegmentsList a_listSegment = m_pFeature->GetSegmentsList();

		// height is most height - lowest + 1
		// width is the widest - thinnest + 1
		int nSize = (int)a_listSegment.size();

		// no segment, no need to compute
		if (nSize <= 0)
		{
			return FALSE;
		}

		// get the most highest, lowest, widest, thinness
		int nHmin = a_listSegment[0]->GetHeight();
		int nHmax = a_listSegment[0]->GetHeight();
		int	nWmin = a_listSegment[0]->GetStart();
		int	nWmax = a_listSegment[0]->GetStart() + a_listSegment[0]->GetLength() - 1;

		// loop segment list
		for (auto pSegement : a_listSegment)
		{
			int nHt = pSegement->GetHeight();
			if (nHt < nHmin)
			{
				nHmin = nHt;
			}
			if (nHt > nHmax)
			{
				nHmax = nHt;
			}
			int nSt = pSegement->GetStart();
			int nEd = pSegement->GetStart() + pSegement->GetLength() - 1;
			if (nSt < nWmin)
			{
				nWmin = nSt;
			}
			if (nEd > nWmax)
			{
				nWmax = nEd;
			}
		}

		if (nHmin > nHmax || nWmin > nWmax)
		{
			return FALSE;
		}

		// get the rect
		m_rectParticle.top = nHmin;
		m_rectParticle.left = nWmin;
		m_rectParticle.bottom = nHmax;
		m_rectParticle.right = nWmax;

		return TRUE;
	}


	
	BOOL COTSParticle::CalArea()
	{
		ASSERT(m_pFeature);
		if (!m_pFeature)
		{
			return FALSE;
		}

		COTSSegmentsList a_listSegment = m_pFeature->GetSegmentsList();

		// Area is all the segment's length add.
		int nSize = (int)a_listSegment.size();

		m_dArea = 0;

		// no segment, no need to compute
		if (nSize <= 0)
		{
			return FALSE;
		}

		// loop segment list
		for (auto pSegement : a_listSegment)
		{
			m_dArea += (double)pSegement->GetLength();
		}

		return TRUE;
	}

	BOOL COTSParticle::CalXRayPos()
	{
		ASSERT(m_pFeature);
		if (!m_pFeature)
		{
			return FALSE;
		}

		COTSSegmentsList a_listSegment = m_pFeature->GetSegmentsList();

		// all the pixels add
		int nSize = (int)a_listSegment.size();

		// no segment, no need to compute
		if (nSize <= 0)
		{
			return FALSE;
		}

		// get the 1/3 high part, the longest
		if(m_rectParticle.IsRectNull())
		{
			if (!CalCoverRect())
			return FALSE;
		}
		
		COTSSegmentsList listSegmentLength;
		listSegmentLength.clear();

		int nHMax = a_listSegment[0]->GetHeight();
		int nHMin = a_listSegment[0]->GetHeight();

		for (auto pSegment : a_listSegment)
		{
			int nH = pSegment->GetHeight();
			if (nH < nHMin)
			{
				nHMin = nH;
			}
			if (nH > nHMax)
			{
				nHMax = nH;
			}
		}


		int nHeight = m_rectParticle.Height();
		int nHStart = (int)(nHeight / 3 + nHMin + 0.5);
		int nHEnd = (int)(2 * nHeight / 3 + nHMax + 0.5);

		for (auto pSegment : a_listSegment)
		{
			int nH = pSegment->GetHeight();
			if (nH >= nHStart && nH <= nHEnd)
			{
				COTSSegmentPtr pSegmentNew = COTSSegmentPtr(new COTSSegment(*pSegment.get()));
				listSegmentLength.push_back(pSegmentNew);
			}
		}

		// get the longest length in the middle 1/3 part
		if ((int)listSegmentLength.size() < 0)
		{
			return FALSE;
		}
		
		int nLMax = listSegmentLength[0]->GetLength();
		for (auto pSegment : listSegmentLength)
		{
			int nL = pSegment->GetLength();
			if (nL > nLMax)
			{
				nLMax = nL;
			}
		}


		COTSSegmentsList listSegmentMaxLength;
		listSegmentMaxLength.clear();
		// find the segment has the longest length
		for (auto pSegment : listSegmentLength)
		{
			if (pSegment->GetLength() == nLMax)
			{
				COTSSegmentPtr pSegmentNew = COTSSegmentPtr(new COTSSegment(*pSegment.get()));
				listSegmentMaxLength.push_back(pSegmentNew);
			}
		}

		// get the middle longest length 
		if ((int)listSegmentMaxLength.size() < 0)
		{
			return FALSE;
		}
		
		COTSSegmentPtr pSegCur = listSegmentMaxLength[0];
		int nSegStart = pSegCur->GetStart();
		int nSegHeight = pSegCur->GetHeight();
		int nSegLength = pSegCur->GetLength();

		CPoint ptSegCenter;
		ptSegCenter.x = (int)(nSegStart + nSegLength / 2 + 0.5);
		ptSegCenter.y = nSegHeight;

		CPoint ptPartCenter = m_rectParticle.CenterPoint();
		
		double nHToMMin = sqrt((ptSegCenter.x - ptPartCenter.x)*(ptSegCenter.x - ptPartCenter.x) + (ptSegCenter.y - ptPartCenter.y)*(ptSegCenter.y - ptPartCenter.y));
		
		for (auto pSegment : listSegmentMaxLength)
		{
			nSegStart = pSegment->GetStart();
			nSegHeight = pSegment->GetHeight();
			nSegLength = pSegment->GetLength();

			ptSegCenter.x = (int)(nSegStart + nSegLength / 2 + 0.5);
			ptSegCenter.y = nSegHeight;

			double nHToM = sqrt((ptSegCenter.x - ptPartCenter.x)*(ptSegCenter.x - ptPartCenter.x) + (ptSegCenter.y - ptPartCenter.y)*(ptSegCenter.y - ptPartCenter.y));

			if (nHToM < nHToMMin)
			{
				nHToMMin = nHToM;
			}

		}


		// get the middle longest segment
		for (auto pSegment : listSegmentMaxLength)
		{
			nSegStart = pSegment->GetStart();
			nSegHeight = pSegment->GetHeight();
			nSegLength = pSegment->GetLength();

			ptSegCenter.x = (int)(nSegStart + nSegLength / 2 + 0.5);
			ptSegCenter.y = nSegHeight;

			double nHToM = sqrt((ptSegCenter.x - ptPartCenter.x)*(ptSegCenter.x - ptPartCenter.x) + (ptSegCenter.y - ptPartCenter.y)*(ptSegCenter.y - ptPartCenter.y));
			
			if (nHToM == nHToMMin)
			{
				m_poiXRayPos = ptPartCenter;
				break;
			}
		}		
				
		return TRUE;
	}

	void COTSParticle::SetFeature(COTSFeaturePtr a_pFeature)
	{
		ASSERT(a_pFeature);
		if (!a_pFeature)
		{
			return;
		}
		//m_pFeature = COTSFeaturePtr(new COTSFeature(*a_pFeature.get()));
		m_pFeature = a_pFeature;
	}

	// cleanup
	void COTSParticle::Cleanup()
	{		
	}

	// initialization
	void COTSParticle::Init()
	{
		// initialization

		// id and tag id
		m_nTagId = -1;
		m_nSearchId = -1;
		m_nAnalysisId = -1;
		m_nFieldId = -1;
		// type
		m_nTypeId = (int)OTS_PARTCLE_TYPE::INVALID;
		// area
		m_dArea = 0;
		// gray
		m_cAveGray = 0;
		// feature
		m_pFeature = COTSFeaturePtr(new COTSFeature());
		 m_dFeretDiameter=0;
		//最小外接矩形的宽度
		 m_Width=0;
		//最小外接矩形的长度
		 m_Height=0;
		// STD chemical type

		 m_Perimeter=0;
		 m_DMax=0;
		 m_DMin=0;
		 m_Dp=0;
		 m_Di=0;
		 m_Dm=0;
		 m_De=0;
		 m_Orientation=0;
		GB_CHEMICAL_TYPE m_nChemical= GB_CHEMICAL_TYPE::INVALID;
	}

	// duplication 
	void COTSParticle::Duplicate(const COTSParticle& a_oSource)
	{
		// initialization
		Init();

		// copy data over

		// id and tag id
		m_nTagId = a_oSource.m_nTagId;
		m_nSearchId = a_oSource.m_nSearchId;
		m_nAnalysisId = a_oSource.m_nAnalysisId;
		m_nFieldId = a_oSource.m_nFieldId;
		// type
		m_nTypeId = a_oSource.m_nTypeId;
		
		// area
		m_dArea = a_oSource.m_dArea;

		// rectangle
		m_rectParticle = a_oSource.m_rectParticle;

		// gray
		m_cAveGray = a_oSource.m_cAveGray;	

		// x-ray position
		m_poiXRayPos = a_oSource.m_poiXRayPos;

		m_Width = a_oSource.m_Width;
		m_Height = a_oSource.m_Height;
		m_TypeName = a_oSource.m_TypeName;
		m_TypeColor = a_oSource.m_TypeColor;
		// feature
		m_pFeature = COTSFeaturePtr(new COTSFeature(*a_oSource.m_pFeature.get()));
	}
}