Zou XiKun / left_over

// ConExtraction.cpp: implementation of the CConExtraction class.
#include "ConExtraction.h"
#include <string.h>
// Construction/Destruction
CConExtraction::CConExtraction():m_nbd(2),m_area(100),m_size(2)
{
   m_Contourvec.clear();
   vector<CContour>().swap(m_Contourvec);
   {
	   std::vector<CContour>tmp = m_Contourvec;
	   m_Contourvec.swap(tmp);
   }

   //m_ForeTargetvec.clear();
   //m_rect=NULL;//???
   m_rect.bottom = 0;
   m_rect.top = 0;
   m_rect.left = 0;
   m_rect.right = 0;
   //mark value:it is used to mark the contour point in order to repeatly scan 
}
/*
//copy construction function
CConExtraction::CConExtraction(const int &m_nbd, const int &m_area, const int &m_size)
{
	this->m_nbd=m_nbd;
	this->m_area=m_area;
	this->m_size=m_size;
}
*/

CConExtraction::~CConExtraction()
{
	m_Contourvec.clear();
	vector<CContour>().swap(m_Contourvec);
	{
		std::vector<CContour>tmp = m_Contourvec;
		m_Contourvec.swap(tmp);
	}
	//m_ForeTargetvec.clear();
}


/******************************************************************************
* Function:        ExtractContours
* Description:     
* Calls：          FetchContour
* Called By:       VibeModelGetTrace
* Input:           pSrcImage     当前图像前景背景（前景为255 背景为0）
                   width         图像宽度
				   height        图像高度
				   step          图像RGB step
* Output:          
* Return:          m_Contourvec
*******************************************************************************/
vector<CContour> CConExtraction::ExtractContours(
unsigned char *pSrcImage,// the point to the source imagedata
float *MaskImgCfd,
const int &width,        // the  pixel number of each coloum
const int &height,       // the pixel number of each row(列)
const int &step          // the byte number of each colum
)
{
	m_Contourvec.clear();
	//m_Contourvec.swap(vector<CContour>(0));
	vector<CContour>().swap(m_Contourvec);
	{
		std::vector<CContour>tmp = m_Contourvec;
		m_Contourvec.swap(tmp);
	}
	
	unsigned char *img = pSrcImage; // the point to the source imagedata
	//unsigned char *Diaimg = pSrcImage;
	//unsigned char *Removeimg = pSrcImage;

	int x = 0;
	int y = 0; // the parameter of the height and the width of the image

	//make zero borders
	// 将边界设为背景
	for (x = 0; x < width; x++)
	{
		pSrcImage[x] = 0;
		pSrcImage[step * (height - 1) + x] = 0;
	}
	for (y = 0; y < height; y++)
	{
		pSrcImage[step * y] = 0;
		pSrcImage[step * y + width - 1] = 0;
	}

	/*
	memset(pSrcImage, 0, width);
	memset(pSrcImage + step * (height - 1), 0, width);

	for (y = 1; y < height - 1; ++y)
	{
		pSrcImage += step;
		*pSrcImage = *(pSrcImage + width - 1) = 0;

	}
	*/
    //remove the unrelevant noise
    //RemoveNoise(Removeimg,width,height,step);

	//it is used to remove the hole of the contour 
	//Dilation(Diaimg,width,height,step);

    //find the  external contour point
	int prev=img[0+step];
	int pcur;

	iCPoint origin; // 外轮廓开始时的坐标

	CContour m_contour;
	
	for (y = 1; y < height - 1; ++y)
	{
		for (x = 1; x < width - 1; ++x)
		{
			pcur = img[step * y + x];
		
			if ((prev == 0) && (pcur == 255)) // external contour to extract
			{
				origin.x = x;
				origin.y = y;

				m_contour = FetchContour(img + step * y + x, MaskImgCfd, step, origin);

				// for debug use
				//m_contour.label=0;
			 	
				if (m_contour.label)
				{
					m_Contourvec.push_back(m_contour);
				}
			}
			else if ((prev == 255) && (pcur == 0)) // inner contour to fill
			{

			}
			else
			{
				prev=pcur;
			} 		
		} //for
	} //for

	return m_Contourvec;
}
/*
vector<CForegroundTarget> CConExtraction::DetectTarget(
unsigned char *pSrcImage,
const int &width,
const int &height,
const int &step
)
{
	m_Contourvec.clear();
	//m_Contourvec.swap(vector<CContour>(0));
	m_ForeTargetvec.clear();
	//m_ForeTargetvec.swap(vector<CForegroundTarget>(0));

	unsigned char *img = pSrcImage; //the point to the source imagedata
	unsigned char *Diaimg = pSrcImage;
	unsigned char *Removeimg = pSrcImage;

	int x = 0;
	int y = 0; // the parameter of the height and the width of the image

	//make zero borders
	memset(pSrcImage, 0, width);
	memset(pSrcImage + step * (height - 1), 0, width);

	for (y = 1; y < height - 1; ++y)
	{
		pSrcImage += step;
		*pSrcImage = *(pSrcImage + width - 1) = 0;
	}

     //remove the unrelevant noise
    RemoveNoise(Removeimg, width, height, step);

	//it is used to fill the hole of the contour 
	Dilation(Diaimg, width, height, step);

   //find the  external contour point
	int prev = img[0 + step];
	int pcur;

	iCPoint origin; //外轮廓开始时的坐标

	CContour m_contour;
	
    CForegroundTarget m_ForeTarget;

	for (y = 1; y < height - 1; ++y)
	{
		//img+=step;
		for (x = 1; x < width - 1; ++x)
		{
			pcur = img[step * y + x];
		
			if ((prev == 0) && (pcur == 255)) //external contour to extract
			{
				origin.x = x;
				origin.y = y;

				m_contour = FetchContour(img + step * y + x, step, origin);	
				if (m_contour.label)
				{
					//m_Contourvec.push_back(m_contour);
					m_ForeTarget.m_Contour = m_contour;
					m_ForeTarget.m_point.x = m_contour.xCenter;
					m_ForeTarget.m_point.y = m_contour.yCenter;
					m_ForeTargetvec.push_back(m_ForeTarget);
				}
			}
			else
			{
				prev=pcur;
			}
		} //for
	} //for

	return  m_ForeTargetvec;
}
*/

/******************************************************************************
* Function:        FetchContour
* Description:     
* Calls：          DELTAS
                   BoundingRect
* Called By:       ExtractContours
* Input:           pImage        指向当前点的指针
				   step          图像RGB step 每一行所占的字节数
				   pt            当前点坐标
* Output:       
* Return:          m_Contour
*******************************************************************************/
CContour CConExtraction::FetchContour(
unsigned char *pImage, // the pointer to the starting pixel position value of the external contour
float * cfg,
const int &step,       // the byte number of each colum
iCPoint &pt            // the starting point position of the external contour
)
{
	int deltas[16];
	// 相邻8个点距当前点的索引差
	DELTAS(deltas, step, 1);
	memcpy(deltas + 8, deltas, 8 * sizeof(deltas[0])); //initialize the deltas array

	// 对应的邻域内8个点的x，y偏移
	int CodeDeltas[8][2] = {{1, 0}, {1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}, {0, 1}, {1, 1}};

	unsigned char *i0 = pImage;
	unsigned char *i1, *i3, *i4 = NULL;

	int s, s_end;
	s_end = s = 4;

	vector<iCPoint> m_Pointvec;
	m_Pointvec.clear();
	vector<iCPoint>().swap(m_Pointvec);
	{
		std::vector<iCPoint>tmp = m_Pointvec;
		m_Pointvec.swap(tmp);
	}
	
	do
	{
		s = (s - 1) & 7;
		i1 = i0 + deltas[s];
		if (0 != (*i1))
		{
			break;
		}
	}while(s != s_end); //find the second contour point
	
	if (s != s_end)
	{
		i3 = i0;
		for(; ;) 
		{
			//s_end = s;

			// 通过循环取数 且当前点一定为前景 保证不会陷入无限循环中
			for(; ;)
			{
				i4 = i3 + deltas[++s];
				if (0 != (*i4))
				{
					break;
				}
			} //for(; ;)

			s &= 7;
			
			// 已经检索过的点不再进行分析 加速
			if (255 == *i3)
			{
				*i3 = this->m_nbd;
			}
			
			m_Pointvec.push_back(pt);
				
			pt.x += CodeDeltas[s][0];
			pt.y += CodeDeltas[s][1];

			if ((i4 == i0) && (i3 == i1)) //the condition of the connected component areas
			{
				break;
			}

			i3 = i4;
			s = (s + 4) & 7;
		} //for(; ;)
	} //if(s!=s_end)
	else
	{
		*i0 = this->m_nbd; //labeled by the signed char
	}

    CContour m_Contour;
        
	if (this->m_size <= m_Pointvec.size()) //the first step to remove the noise point
	{
        //get the rectangle of the contour
	    BoundingRect(m_Pointvec);

		int width = m_rect.right - m_rect.left;
	    int height = m_rect.bottom - m_rect.top;
	    int numpixel = width * height;

        if (this->m_area <= numpixel) //the second step to remove the noise point
		{
			m_Contour.left = m_rect.left;
	        m_Contour.top = m_rect.top;
		    m_Contour.right = m_rect.right;
		    m_Contour.bottom = m_rect.bottom;
			m_Contour.xCenter = (m_Contour.left + m_Contour.right) / 2;
			m_Contour.yCenter = (m_Contour.top + m_Contour.bottom) / 2;	
			int count = 0;
			double totalCfd = 0;
			for (auto item : m_Pointvec)
			{
				if (cfg[item.y * step + item.x] > 0.001)
				{
					totalCfd += cfg[item.y * step + item.x];
					++count;
				}
			}
			if (count)
			{
				m_Contour.cfd = totalCfd / count;
				m_Contour.label = true;
			}
			else
			{
				m_Contour.label = false;
			}
		}
		else
		{
			m_Contour.left = 0;
	    	m_Contour.top = 0;
			m_Contour.right = 0;
		    m_Contour.bottom = 0;
			m_Contour.xCenter = 0;
			m_Contour.yCenter = 0;
			m_Contour.cfd = 0;
		    m_Contour.label = false;
		}
	}
	else
	{
		m_Contour.left = 0;
	    m_Contour.top = 0;
		m_Contour.right = 0;
		m_Contour.bottom = 0;
		m_Contour.xCenter = 0;
		m_Contour.yCenter = 0;
		m_Contour.cfd = 0;
		m_Contour.label = false;
	}

	m_Pointvec.clear();
	vector<iCPoint>().swap(m_Pointvec);
	{
		std::vector<iCPoint>tmp = m_Pointvec;
		m_Pointvec.swap(tmp);
	}

	return m_Contour;
}

//this function is used to get the external rectangle
void CConExtraction::BoundingRect(vector<iCPoint> Pointvec)
{
	int xmin, xmax;
	int ymin, ymax;
	
	vector<iCPoint>::iterator iter_begin = Pointvec.begin();
	vector<iCPoint>::iterator iter_end = Pointvec.end();

	xmin = xmax = (*iter_begin).x;
	ymin = ymax = (*iter_begin).y; //intialize the value

	iter_begin += 1;
	for(; iter_begin != iter_end; ++iter_begin)
	{
		int xPoint = (*iter_begin).x;
		int yPoint = (*iter_begin).y;
		if (xmin > xPoint)
		{
			xmin = xPoint;
		}
		if (xmax < xPoint)
		{
			xmax = xPoint;
		}
		if (ymin > yPoint)
		{
			ymin = yPoint;
		}
		if (ymax < yPoint)
		{
			ymax = yPoint;
		}
	}
     
	m_rect.top = ymin;
	m_rect.left = xmin;
	m_rect.right = xmax;
	m_rect.bottom = ymax;
}

/*
//this function is used to fill the hole of the contour
void CConExtraction::Dilation(
unsigned char *pSrcImage,
const int &width,
const int &height,
const int &step)
{

	int deltas[8];
	DELTAS(deltas, step, 1);

	int i, j;
	i = j = 0;

    int num;
	num = 0;

	unsigned char *lpSrc = NULL;
	unsigned char *lpDst = NULL;
	unsigned char *pixel = NULL;

	int label = 0;

	unsigned char *pDstImage = new unsigned char[height * width];

	for (i = 0; i < height; ++i)
	{
		for (j = 0; j < width; ++j)
		{
			pDstImage[i * width + j] = 0;
		}
	}
	
	for (i = 1; i < height - 1; ++i)
	{
		for (j = 1; j < width - 1; ++j)
		{
			label = i * step + j;

			lpSrc = pSrcImage + label;
		
			for (num = 0; num < 8; ++num)
			{
				pixel = lpSrc + deltas[num];

				if (1 == (*pixel))
				{
					pDstImage[label] = 1;
					break;
				}
			}
		}
	}

	for (i = 0; i < height; ++i)
	{
		for (j = 0; j < width; ++j)
		{
			label = i * width + j;
			pSrcImage[label] = pDstImage[label];
		}
	}

	delete  []pDstImage;
	pDstImage = NULL;
}
*/
/*
//this function is used to remove the noise of background before Fetching contour
void CConExtraction::RemoveNoise(
unsigned char *pSrcImage,
const int &width,
const int &height,
const int &step)
{
	int deltas[8];
	DELTAS(deltas, step, 1);

	unsigned char *pSrc = pSrcImage;

	int i, j;
	i = j = 0;

	int label = 0;
   
	unsigned char *pDstImage = new unsigned char[height * width];

	for (i = 0; i < height; ++i)
	{
		for (j = 0; j < width; ++j)
		{
			label = i * width + j;
			pDstImage[label] = pSrcImage[label];
		}
	}

	int label0, label1, label2, label3;
	label0 = label1 = label2 = label3 = 0;

	for (i = 2; i < height - 2; ++i)
	{
		for (j = 2; j < width - 2; ++j)
		{
			label0 = i * step + j;
			label1 = (i - 1) * step + j;
			label2 = (i + 1) * step + j;
			label3 = (i + 2) * step + j;
			if (1 == pSrc[label0])
			{
				if (0 == pSrc[label0 + 1] && 0 == pSrc[label0 - 1]
				   && 0 == pSrc[label1] && 0 == pSrc[label1 + 1] && 0 == pSrc[label1 - 1]
				   && 0 == pSrc[label2] && 0 == pSrc[label2 + 1] && 0 == pSrc[label2 - 1])
				{
					pDstImage[label0] = 0;
				}

				if (1 == pSrc[label0 + 1] && 0 == pSrc[label0 - 1] && 0 == pSrc[label0 + 2]
				   && 0 == pSrc[label1] && 0 == pSrc[label1 + 1] && 0 == pSrc[label1 - 1] && 0 == pSrc[label1 + 2]
				   && 0 == pSrc[label2] && 0 == pSrc[label2 + 1] && 0 == pSrc[label2 - 1] && 0 == pSrc[label2 + 2])
				{
					pDstImage[label0] = 0;
					pDstImage[label0 + 1] = 0;
				}
				if (1 == pSrc[label2] && 0 == pSrc[label2 + 1] && 0 == pSrc[label2 - 1]
			       && 0 == pSrc[label0 + 1] && 0 == pSrc[label0 - 1]
				   && 0 == pSrc[label1] && 0 == pSrc[label1 + 1] && 0 == pSrc[label1 - 1]
				   && 0 == pSrc[label3] && 0 == pSrc[label3 + 1] && 0 == pSrc[label3 - 1])
				{
					pDstImage[label0] = 0;
					pDstImage[label2] = 0;
				}
				if (1 == pSrc[label0 + 1] && 0 == pSrc[label0 - 1] && 0 == pSrc[label0 + 2]
				&& 1 == pSrc[label2] && 1 == pSrc[label2 + 1] && 0 == pSrc[label2 - 1] && 0 == pSrc[label2 + 2]
				&& 0 == pSrc[label1] && 0 == pSrc[label1 + 1] && 0 == pSrc[label1 - 1] && 0 == pSrc[label1 + 2]
				&& 0 == pSrc[label3] && 0 == pSrc[label1 + 1] && 0 == pSrc[label3 - 1] && 0 == pSrc[label3 + 2])
				{
					pDstImage[label0] = 0;
					pDstImage[label0 + 1] = 0;
					pDstImage[label2] = 0;
					pDstImage[label2 + 1] = 0;
				}
			}
		}
	}

	for (i = 0; i < height; ++i)
	{
		for (j = 0; j < width; ++j)
		{
			label = i * width + j;
			pSrcImage[label] = pDstImage[label];
		}
	}

	delete  []pDstImage;
	pDstImage = NULL;
}
*/