queuearea.c

jiance jichang paidui de moxing.

		if(pModel->iArrLineCntPerRow[i] == 0)
		{
			break;
		}
		else
		{
			n++;
		}
	}
	n--;
	if (n<m)
	{
		return -1;
	}

	/* 慻崌娭悢傪巊偭偰丄慡偰慻崌傪庢摼偡傞丅*/
	cmComb(n, m, buff, &count);

	/* 奺慻崌偦傟偧傟偺嫍棧斾棪嵎偺憤寁傪寁嶼偡傞丅 */
	for(i = 0; i < 100; i++)
	{
		sumOfRatonSub[i] = -1.0;
	}

	for(i = 0; i < combCnt; i++)
	{
		preDistRatio = 0.0;
		sumOfRatonSub[i] = 0.0;

		for(j = 0; j < m; j++)
		{
			float ftemp = 0.0;
			if(j == 0)
			{
				dist1 = pModel->fArrDistOfRowiToRow0[combuf[i][j]];
			}
			else
			{
				dist1 = pModel->fArrDistOfRowiToRow0[combuf[i][j]] - pModel->fArrDistOfRowiToRow0[combuf[i][j-1]];
			}
			
			if(j == m -1)
			{
				dist2 = pModel->fArrDistOfRowiToRow0[n+1] - pModel->fArrDistOfRowiToRow0[combuf[i][j]];
			}
			else
			{
				dist2 = pModel->fArrDistOfRowiToRow0[combuf[i][j+1]] - pModel->fArrDistOfRowiToRow0[combuf[i][j]];
			}

			distRatio = dist2 / dist1;

			if(distRatio < 0.8 || distRatio > 1.8)
			{
				sumOfRatonSub[i] = -1.0;
				break;
			}

			ftemp = fabs(distRatio - preDistRatio);
			sumOfRatonSub[i] = sumOfRatonSub[i] + ftemp;
			preDistRatio = distRatio;
		}
	}

	/* 堦斣偄偄慻崌傪扵偟弌傞丅 */
	minIndex = 100;
	MinSumOfRatonSub = (float)m;
	for(i = 0; i < combCnt; i++)
	{
		if(sumOfRatonSub[i] < 0)
		{
			continue;
		}
		else if(sumOfRatonSub[i] < MinSumOfRatonSub)
		{
			minIndex = i;
		}
	}

	if (minIndex == 100)
	{
		return -2;
	}

	/*  */
	for(i = 1; i <= n; i++)
	{
		for(j = 0; j < m; j++)
		{
			if (i == combuf[minIndex][j])
			{
				break;
			}
		}
		if(j == m)
		{
			pModel->iArrLineCntPerRow[i] = 0;
		}
	}
	for(i=1; i < 100; i++)
	{
		if(pModel->iArrLineCntPerRow[i] == 0)
		{
			for(j=i; j<99; j++)
			{
				pModel->iArrLineCntPerRow[j] = pModel->iArrLineCntPerRow[j+1];
				pModel->fArrDistOfRowiToRow0[j] = pModel->fArrDistOfRowiToRow0[j+1];
				for(k=0;k<100;k++)
				{
					pModel->iArrLineDataPerRow[j][k] = pModel->iArrLineDataPerRow[j+1][k];
				}
			}
		}
	}

	return 1;
}

/**
 * @fn cmConstructQueueAreaModule
 * 
 * @brief
 * 揈梫丗Construct the Module of m_qAreaModel by analysing the picture of 
 *       air station waitting hall.
 * 
 * @param[in] pImgGray_Src
 * @param[in] fLeft
 * @param[in] fRight
 * @param[in] lLeft
 * @param[in] lRight
 * @param[in] lineCnt
 *
 * @return void
 */
int cmConstructQueueAreaModule(IplImage *pImgGray_Src, CvPoint fLeft, CvPoint fRight, 
							 CvPoint lLeft, CvPoint lRight, int lineCnt)
{
	float fSlopeErr, fDistErr = 10.0;
	int i, j, rowsCnt;
	int iCriticalGray = 140;
	CvMat *src = (CvMat*)pImgGray_Src;

	CvMemStorage *pStorage = NULL;
	CvSeq *pLines = NULL;
	CmLine *pCmLines = NULL, *pCmLine = NULL;
	
	IplImage *pImgLines1 = NULL, *pImgLines2 = NULL;

	CV_FUNCNAME("cmConstructQueueAreaModule");

	IplImage *pImgColor_dst = cvCreateImage(cvGetSize(pImgGray_Src), IPL_DEPTH_8U, 3 );
	pImgColor_dst->origin = pImgGray_Src->origin;
	cvCvtColor( pImgGray_Src, pImgColor_dst, CV_GRAY2BGR);

	__BEGIN__;

	if( pImgGray_Src->nChannels != 1 )
	{
		printf("cmConstructQueueAreaModule method can only be used with IPL_DEPTH_8U images");
		return -1;
	}

	if(m_qAreaModel != NULL)
	{
		cmReleaseQueueAreaModule(&m_qAreaModel);
	}

	m_qAreaModel = cmInitQueueAreaModule2(pImgGray_Src->origin, fLeft, fRight, lLeft, lRight, lineCnt);

	/* 僗僥僢僾堦乣嶰 HoughLine */
	pStorage = cvCreateMemStorage(0);

	pLines = cmHoughLine(pImgGray_Src, &pStorage);

#if 0
	pImgLines1 = cvCloneImage(pImgColor_dst);
	printf("LineData:\n");

	for(i = 0; i < pLines->total; i++)
    {
        CvPoint* line = (CvPoint*)cvGetSeqElem(pLines,i);
		cvLine(pImgLines1, line[0], line[1], CV_RGB(255,0,0),  1, 8, 0);
	}
	cmTestShowImage(pImgLines1);
#endif
	
	/* 僗僥僢僾巐 儘僕僢僋曽朄偵傛偭偰丄晄昁梫側慄傪饪偄偵偐偗傞丅*/
	pCmLines = cmFilterLines(m_qAreaModel, pLines, 0.0, 0.5, pImgGray_Src, iCriticalGray);
#if 0
	pImgLines1 = cvCloneImage(pImgColor_dst);
	printf("LineData:\n");
	pCmLine = pCmLines;
	while(pCmLine)
	{
		cmCvtFloatToStr(pCmLine->slope, 4, buff);
		cmPutText(pImgLines1, buff, cvPoint(pCmLine->pt1.x-2, pCmLine->pt1.y-8), CV_RGB(0,255,0));
		cvLine(pImgLines1, pCmLine->pt1, pCmLine->pt2, CV_RGB(255,0,0),  1, 8, 0);

		printf("startpoint(%d,%d)--endpoint(%d,%d)::slope=%f\n", pCmLine->pt1.x,pCmLine->pt1.y,pCmLine->pt2.x,
			pCmLine->pt2.y, pCmLine->slope);
		pCmLine = pCmLine->next;
	}

	cvNamedWindow("FilteredLines", 1);
	cvShowImage("FilteredLines", pImgLines1);
#endif
	/* 僗僥僢僾屲 摑崌捈慄*/

	fDistErr = (lLeft.y - fLeft.y)*(lLeft.y - fLeft.y) + (lLeft.x - fLeft.x)*(lLeft.x - fLeft.x);
	fDistErr = sqrt(fDistErr);
	
	fDistErr = fDistErr / (lineCnt+1);
	fDistErr = fDistErr / 4;
	pCmLines = cmUniteSameQueueLines(pCmLines, 0.10, fDistErr);

#if 0
	pImgLines2 = cvCloneImage(pImgColor_dst);
	printf("LineData:\n");
	pCmLine = pCmLines;
	while(pCmLine)
	{
		cmCvtFloatToStr(pCmLine->slope, 4, buff);
		cmPutText(pImgLines2, buff, cvPoint(pCmLine->pt1.x-2, pCmLine->pt1.y-8), CV_RGB(0,255,0));
		cvLine(pImgLines2, pCmLine->pt1, pCmLine->pt2, CV_RGB(255,0,0),  1, 8, 0);

		printf("startpoint(%d,%d)--endpoint(%d,%d)::slope=%f\n", pCmLine->pt1.x,pCmLine->pt1.y,pCmLine->pt2.x,
			pCmLine->pt2.y, pCmLine->slope);
		pCmLine = pCmLine->next;
	}

	cvNamedWindow("ClassifiedLines", 1);
	cvShowImage("ClassifiedLines", pImgLines2);
#endif

	/* 僗僥僢僾榋 楍偵婣懏*/
	cmClassifyLinesIntoRows(pCmLines, m_qAreaModel, 0.10, fDistErr);

	pCmLines = NULL;

	rowsCnt = cmDeletePhonyRows(m_qAreaModel, pImgGray_Src, iCriticalGray);

	cmCombinationQueqes(m_qAreaModel);
	//cmComb(4,3,buff, count);

	

#if 0
	/* Using for Making */
	for(i=0; i<100; i++)
	{
		if(m_qAreaModel->iArrLineDataPerRow[i][4] == 0 && i != 99)
		{
			continue;
		}

		printf("\n戞%d楍偺捈慄丗", i+1);
		for(j=4; j<=97; j=j+4)
		{
			if(m_qAreaModel->iArrLineDataPerRow[i][j] == 0)
			{
				break;
			}

			printf("start(%d,%d)--end(%d,%d) ", m_qAreaModel->iArrLineDataPerRow[i][j],m_qAreaModel->iArrLineDataPerRow[i][j+1],
				m_qAreaModel->iArrLineDataPerRow[i][j+2],m_qAreaModel->iArrLineDataPerRow[i][j+3]);

			cvLine(pImgColor_dst, cvPoint(m_qAreaModel->iArrLineDataPerRow[i][j],m_qAreaModel->iArrLineDataPerRow[i][j+1]), 
				cvPoint(m_qAreaModel->iArrLineDataPerRow[i][j+2],m_qAreaModel->iArrLineDataPerRow[i][j+3]), CV_RGB(255,0,0), 1, 8, 0);
		}
	}

	cvNamedWindow("KUKOU-DST", 1);
	cvShowImage("KUKOU-DST", pImgColor_dst);
	cvWaitKey(0);
#endif

	if (rowsCnt != m_qAreaModel->lineCount)
	{
		return -1;
	}
	 __END__;
}

CmQueueAreaModel * getCurrentVisibleQueueLines(IplImage *pImg_rgb, CvPoint fLeft, CvPoint fRight, CvPoint lLeft, CvPoint lRight)
{

	CvRect rect;
	CvPoint ptRD;

	CvSeq *pLines = NULL;
	CvMemStorage *pStorage = NULL;
	CmQueueAreaModel *pCurrQuLines = NULL;

	IplImage *pImg_gray = NULL;
	IplImage *pImgHough = NULL;
	IplImage *pImgFilter = NULL;
	IplImage *pImgUnited = NULL;

	CmLine *pCmLines = NULL;
	CmLine *pCmLine = NULL;
	
	int iCriticalGray = 140;
	int i,j,k;

	float fDistErr; 
	
	float fDistTemp, fDistSub;
	CvPoint pt1,pt2,ptIst;
	CmLine pLine1,pLine2;
	int iTemp;
	
	pImg_gray = cvCreateImage(cvGetSize(pImg_rgb), pImg_rgb->depth, 1);
	pImg_gray->origin = pImg_rgb->origin;
	cvCvtColor(pImg_rgb, pImg_gray, CV_BGR2GRAY);

	pCurrQuLines = cmInitQueueAreaModule2(pImg_gray->origin, fLeft, fRight, lLeft, lRight, 0);

	rect.x = fLeft.x <= lLeft.x ? fLeft.x : lLeft.x;
	rect.y = fLeft.y <= fRight.y ? fLeft.y : fRight.y;
	rect.width = fRight.x >= lRight.x ? fRight.x - rect.x : lRight.x - rect.x;
	rect.height = lLeft.y >= lRight.y ? lLeft.y - rect.y : lRight.y - rect.y;

	cvSetImageROI(pImg_gray, rect);

	pStorage = cvCreateMemStorage(0);
	pLines = cmHoughLine(pImg_gray, &pStorage);

	cvResetImageROI(pImg_gray);

	for(i = 0; i < pLines->total; i++)
    {
        CvPoint* line = (CvPoint*)cvGetSeqElem(pLines,i);
		line[0].x += rect.x;
		line[0].y += rect.y;
		line[1].x += rect.x;
		line[1].y += rect.y;
	}

#if 0
	pImgHough = cvCreateImage(cvGetSize(pImg_gray), pImg_gray->depth, 3);
	pImgHough->origin = pImg_gray->origin;
	cvCvtColor( pImg_gray, pImgHough, CV_GRAY2BGR);

	for(i = 0; i < pLines->total; i++)
    {
        CvPoint* line = (CvPoint*)cvGetSeqElem(pLines,i);
		cvLine(pImgHough, line[0], line[1], CV_RGB(255,0,0),  1, 8, 0);
	}
	cmTestShowImage(pImgHough, "Hough");
#endif
	
	pCmLines = cmFilterLines(pCurrQuLines, pLines, 0.0, 0.5, pImg_gray, iCriticalGray);
#if 0
	pImgFilter = cvCreateImage(cvGetSize(pImg_gray), pImg_gray->depth, 3);
	pImgFilter->origin = pImg_gray->origin;
	cvCvtColor( pImg_gray, pImgFilter, CV_GRAY2BGR);
	pCmLine = pCmLines;
	while(pCmLine)
	{
		cmCvtFloatToStr(pCmLine->slope, 4, buff);
		cmPutText(pImgFilter, buff, cvPoint(pCmLine->pt1.x-2, pCmLine->pt1.y-8), CV_RGB(0,255,0));
		cvLine(pImgFilter, pCmLine->pt1, pCmLine->pt2, CV_RGB(255,0,0),  1, 8, 0);
		pCmLine = pCmLine->next;
	}
	cmTestShowImage(pImgFilter, "Filtered");
#endif

	fDistErr = (m_qAreaModel->lastLineLeft.y - m_qAreaModel->firstLineLeft.y)*(m_qAreaModel->lastLineLeft.y - m_qAreaModel->firstLineLeft.y);
	fDistErr += (m_qAreaModel->lastLineLeft.x - m_qAreaModel->firstLineLeft.x)*(m_qAreaModel->lastLineLeft.x - m_qAreaModel->firstLineLeft.x);
	fDistErr = sqrt(fDistErr);
	
	fDistErr = fDistErr / (m_qAreaModel->lineCount+1);
	fDistErr = fDistErr / 4;
	pCmLines = cmUniteSameQueueLines(pCmLines, 0.10, fDistErr);
#if 0
	pImgUnited = cvCreateImage(cvGetSize(pImg_gray), pImg_gray->depth, 3);
	pImgUnited->origin = pImg_gray->origin;
	cvCvtColor( pImg_gray, pImgUnited, CV_GRAY2BGR);
	pCmLine = pCmLines;
	while(pCmLine)
	{
		cmCvtFloatToStr(pCmLine->slope, 4, buff);
		cmPutText(pImgUnited, buff, cvPoint(pCmLine->pt1.x-2, pCmLine->pt1.y-8), CV_RGB(0,255,0));
		cvLine(pImgUnited, pCmLine->pt1, pCmLine->pt2, CV_RGB(255,0,0),  1, 8, 0);
		pCmLine = pCmLine->next;
	}
	cmTestShowImage(pImgUnited, "United");
#endif

	cmClassifyLinesIntoRows(pCmLines, pCurrQuLines, 0.10, fDistErr);

#if 0
	/* Using for Making */
	for(i=0; i<100; i++)
	{
		if(pCurrQuLines->iArrLineDataPerRow[i][4] == 0 && i != 99)
		{
			continue;
		}

		printf("\n戞%d楍偺捈慄丗", i+1);
		for(j=4; j<=97; j=j+4)
		{
			if(pCurrQuLines->iArrLineDataPerRow[i][j] == 0)
			{
				break;
			}

			cvLine(pImg_rgb, cvPoint(pCurrQuLines->iArrLineDataPerRow[i][j],pCurrQuLines->iArrLineDataPerRow[i][j+1]), 
				cvPoint(pCurrQuLines->iArrLineDataPerRow[i][j+2],pCurrQuLines->iArrLineDataPerRow[i][j+3]), CV_RGB(255,0,0), 1, 8, 0);
		}
	}

	cmTestShowImage(pImg_rgb, "Classified");
#endif

	//奺楍偺捈慄傪惾偵偮偒傑偡
	for(i=0; i<100; i++)
	{
		pLine1 = cmLine(m_qAreaModel->firstLineLeft, m_qAreaModel->lastLineLeft);
		for(j=0; j<100; j++)
		{
			if(pCurrQuLines->iArrLineDataPerRow[j][4] != 0)
			{
				pt1.x = pCurrQuLines->iArrLineDataPerRow[j][4];
				pt1.y = pCurrQuLines->iArrLineDataPerRow[j][5];

				pt2.x = pCurrQuLines->iArrLineDataPerRow[j][6];
				pt2.y = pCurrQuLines->iArrLineDataPerRow[j][7];
				pLine2 = cmLine(pt1, pt2);
				ptIst = cmCalIntersectionOfTwoLines(&pLine1, &pLine2, 0);
				fDistTemp = cmCalDistanceOfPointToLine(ptIst, cmLine(m_qAreaModel->firstLineLeft,m_qAreaModel->firstLineRight));
				fDistSub = fabs(fDistTemp - m_qAreaModel->fArrDistOfRowiToRow0[i]);
				if(fDistSub < fDistErr)
				{
					if(i != j)
					{
						iTemp = pCurrQuLines->iArrLineCntPerRow[i];
						pCurrQuLines->iArrLineCntPerRow[i] = pCurrQuLines->iArrLineCntPerRow[j];
						pCurrQuLines->iArrLineCntPerRow[j] = iTemp;
						fDistTemp = pCurrQuLines->fArrDistOfRowiToRow0[i];
						pCurrQuLines->fArrDistOfRowiToRow0[i] = pCurrQuLines->fArrDistOfRowiToRow0[j];
						pCurrQuLines->fArrDistOfRowiToRow0[j] = fDistTemp;

						for(k=0; k<100; k++)
						{
							iTemp = pCurrQuLines->iArrLineDataPerRow[i][k];
							pCurrQuLines->iArrLineDataPerRow[i][k] = pCurrQuLines->iArrLineDataPerRow[j][k];
							pCurrQuLines->iArrLineDataPerRow[j][k]= iTemp;
						}
					}
					break;
				}
			}
		}
	}

	#if 1
	/* Using for Making */
	for(i=0; i<100; i++)
	{
		if(pCurrQuLines->iArrLineDataPerRow[i][4] == 0 && i != 99)
		{
			continue;
		}

		printf("\n戞%d楍偺捈慄丗", i+1);
		for(j=4; j<=97; j=j+4)
		{
			if(pCurrQuLines->iArrLineDataPerRow[i][j] == 0)
			{
				break;
			}

			cvLine(pImg_rgb, cvPoint(pCurrQuLines->iArrLineDataPerRow[i][j],pCurrQuLines->iArrLineDataPerRow[i][j+1]), 
				cvPoint(pCurrQuLines->iArrLineDataPerRow[i][j+2],pCurrQuLines->iArrLineDataPerRow[i][j+3]), CV_RGB(255,0,0), 1, 8, 0);
		}
	}

	cmTestShowImage(pImg_rgb, "sekinituki");
#endif 

	return pCurrQuLines;
}