magicscissorsdoc.cpp

刚上传内容的相关CODEC不能单独上传。于是

			
			m_pDepthmap->SaveImage("d:\\depth0.bmp");

			
			for( i = 0 ; i < objnum ; i++ )
			{
				pRgn = pObjList->GetObject(i);
				pPtList = pRgn->GetEdgeList();
				rect = pRgn->GetBound();
				sx = rect.left;
				sy = rect.top;
				w = rect.Width()+1;
				h = rect.Height()+1;
				for( y = sy ; y < sy+h ; y++ )
				{
					for( x = sx ; x < sx+w ; x++ )
					{
						/*if( pRgn->PtInRgn( CPoint(x,y) ) )
						{
							desr[y][x].r = desr[y][x].g = desr[y][x].b = 0;
							desl[y][x].r = desl[y][x].g = desl[y][x].b = 0;							
						}*/
						if( pRgn->PtInRgn( CPoint(x,y) ) )
							depth[y][x] = sdepth[y][x];
					}
				}
			}
			pDepthmap->SaveImage("d:\\depth1.bmp");

			for( j = 0 ; j < size.cy ; j++ )
			{
				posl = posr = -1;
				for( i = 0 ; i < size.cx ; i++ )
				{
					rx = (rc*depth[j][i]-i*vpos)/(depth[j][i]-vpos);
					lx = (lc*depth[j][i]-i*vpos)/(depth[j][i]-vpos);
					
					if( posr == -1 )
						posr = rx;
					
					if( rx >= 0 && rx < size.cx )
						desr[j][rx] = src[j][i];
					if( rx - posr > 1 )
					{
						while(1)
						{
							if( posr == rx ) break;
							desr[j][posr].r = (src[j][i-1].r+src[j][i].r)/2;
							desr[j][posr].g = (src[j][i-1].g+src[j][i].g)/2;
							desr[j][posr].b = (src[j][i-1].b+src[j][i].b)/2;
							posr++;
						}
					}
					else 
						posr = rx;

					if( posl == -1 )
						posl = lx;
					
					if( lx >= 0 && lx < size.cx )
						desl[j][lx] = src[j][i];
					if( lx - posl > 1 )
					{
						while(1)
						{
							if( posl == lx ) break;
							desl[j][posl].r = (src[j][i-1].r+src[j][i].r)/2;
							desl[j][posl].g = (src[j][i-1].g+src[j][i].g)/2;
							desl[j][posl].b = (src[j][i-1].b+src[j][i].b)/2;
							posl++;
						}
					}
					else 
						posl = lx;
				}
			}
			/*
			for( i = 0 ; i < objnum ; i++ )
			{
				pRgn = pObjList->GetObject(i);
				pPtList = pRgn->GetEdgeList();
				rect = pRgn->GetBound();
				sx = rect.left;
				sy = rect.top;
				w = rect.Width()+1;
				h = rect.Height()+1;
				for( y = sy ; y < sy+h ; y++ )
				{
					posl = posr = -1;
					for( x = sx ; x < sx+w ; x++ )
					{
						if( pRgn->PtInRgn( CPoint(x,y) ) )
						{
							rx = (rc*(depth[y][x]-128)-x*vpos)/((depth[y][x]-128)-vpos);
							//lx = (lc*(depth[y][x]-128)-x*vpos)/((depth[y][x]-128)-vpos);
							if( posr == -1 )
								posr = rx;
							
							if( rx >= 0 && rx < size.cx )
								desr[y][rx] = src[y][x];
							if( rx - posr > 1 )
							{
								while(1)
								{
									if( posr == rx ) break;
									desr[y][posr].r = (src[y][x-1].r+src[y][x].r)/2;
									desr[y][posr].g = (src[y][x-1].g+src[y][x].g)/2;
									desr[y][posr].b = (src[y][x-1].b+src[y][x].b)/2;
									posr++;
								}
							}
							else 
								posr = rx;						

						}
					}
				}
			}*/


			for( j = 0 ; j < size.cy ; j++ )
			{
				for( i = 1 ; i < size.cx ; i++ )
				{
					if( desr[j][i].r == 0 && desr[j][i].g == 0 && desr[j][i].b == 0 )
						desr[j][i] = desr[j][i-1];
					if( desl[j][i].r == 0 && desl[j][i].g == 0 && desl[j][i].b == 0 )
						desl[j][i] = desl[j][i-1];
				}

				if( j % 2 )
					memcpy( desi[j], desr[j], sizeof(CColorPixel)*size.cx );
				else
					memcpy( desi[j], desl[j], sizeof(CColorPixel)*size.cx );
			}		
			delete pDepthmap;

		}

		extname.Format("%06d.bmp", sframe+f );
		//pImageL->SaveImage((LPSTR)(LPCTSTR)(m_strLeft+extname) );
		m_pImage->SaveImage((LPSTR)(LPCTSTR)(m_strLeft+extname) );
		extname.Format("%06d.bmp", sframe+f );
		pImageR->SaveImage((LPSTR)(LPCTSTR)(m_strRight+extname) );
		extname.Format("%06d.bmp", sframe+f );
		pImageI->SaveImage((LPSTR)(LPCTSTR)(m_strStereo+extname) );

		((CProgressCtrl*)pDlg->GetDlgItem(IDC_PROGRESS1))->SetPos(f);
		pDlg->UpdateWindow();
		count++;
		output.Format("%d / %d frames", count, fnum);
		pDlg->GetDlgItem(IDC_OUT)->SetWindowText(output);

	}


	pDlg->ShowWindow(SW_HIDE);
	pDlg->DestroyWindow();
	delete pDlg;

	delete pImageR;
	delete pImageL;
	delete pImageI;

}

void CMagicScissorsDoc::DataSave()
{
	OnDataSave();
}


void CMagicScissorsDoc::OnSavePath() 
{
	// TODO: Add your command handler code here
	CPathInputDlg dlg;
	
	if( m_strStereo == "" )
	{		
		CString basename;
		if( m_nMode == 1 )
			basename = m_strVideoFile;			
		else 		
			basename = m_strFileName + ".bmp";

		int l = basename.ReverseFind('\\');
		basename = basename.Left(l);
		CString extname;		
		dlg.m_strBase = basename;

		if( m_nMode == 1 )
			basename = m_strVideoFile;			
		else 		
			basename = m_strFileName + ".bmp";
		
		l = basename.ReverseFind('.');
		basename = basename.Left(l);
		l = basename.ReverseFind('\\');
		basename = basename.Right(basename.GetLength()-l);
		dlg.m_strStereo = dlg.m_strBase + "\\intl" + basename;
		dlg.m_strLeft = dlg.m_strBase + "\\left" + basename;
		dlg.m_strRight = dlg.m_strBase + "\\right" + basename;
		dlg.m_strSeg = dlg.m_strBase + "\\seg" + basename;
		if( m_nMode == 2 )
			dlg.m_nFrame = m_nStartFrame;
		else
			dlg.m_nFrame = 0;
	}	
	else
	{
		dlg.m_strStereo = m_strStereo;
		dlg.m_strLeft = m_strLeft;
		dlg.m_strRight = m_strRight; 
		dlg.m_strSeg = m_strSeg;
		dlg.m_nFrame = m_nStartFrame;
	}
	if( dlg.DoModal() == IDOK )
	{
		m_strStereo = dlg.m_strStereo;
		m_strLeft = dlg.m_strLeft;
		m_strRight = dlg.m_strRight;
		m_strSeg = dlg.m_strSeg;
		m_nStartFrame = dlg.m_nFrame;
	}

}


void CMagicScissorsDoc::DetectEdge()
{
	CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
	pFrame->m_wndOptionBar.UpdateData(TRUE);	
	int e = pFrame->m_wndOptionBar.m_nEdge;

	CWaitCursor wait;
	CImageColor color(m_pImage);
	if( m_pEdgeMap )
		color.ConvertGray(m_pEdgeMap );
	else
		m_pEdgeMap = color.ConvertGray(TRUE);
	
	CEdgeDetector edge(m_pEdgeMap);
	edge.Edge_Deriche(m_fEdge[e-1]);
	m_bEdge = TRUE;
	wait.Restore();	
}


void CMagicScissorsDoc::DeleteFrameInfo(int start, int end)
{
	if( m_pFrameList )
	{
		for( int i = start ; i <= end ; i++ )
		{
			CFrameInfo* info = m_pFrameList->GetFrame(i);
			if( info ) info->ClearObject();				
		}
	}	
}

//////////////////////////////////////////////////////////////

void CMagicScissorsDoc::CreateActiveContour( CRect rect )
{
	CWaitCursor wait;

	if( m_pActiveContour )
	{
		delete m_pActiveContour;
		m_pActiveContour = NULL;
	}

	m_pActiveContour = new CActiveContour;
	if( !m_pActiveContour )
		return;
	ASSERT( m_pActiveContour != NULL );

	int left = rect.left;
	int right = rect.right;
	int top = rect.top;
	int bottom = rect.bottom;

	if( m_pEdgeList )
		delete m_pEdgeList;
	m_pEdgeList = NULL;

	m_pEdgeList = new CEdgeList;
	ASSERT( m_pEdgeList != NULL );

	int i, j;

	m_pEdgeList->AddEdgePoint( left, top );
	m_pEdgeList->AddEdgePoint( right, top );
	m_pEdgeList->AddEdgePoint( right, bottom );
	m_pEdgeList->AddEdgePoint( left, bottom );
	m_pEdgeList->AddEdgePoint( left, top+1 );

	BOOL	flag;
	
	flag = m_pActiveContour->Create( m_pEdgeList );
	flag = m_pActiveContour->FeedEdgeImage( m_pEdgeMap );
	flag = m_pActiveContour->SetParameter(1, 0.005, 0.01);
	flag = m_pActiveContour->Evolve(10);
	flag = m_pActiveContour->GetActiveContour( m_pEdgeList );

	wait.Restore();
}

void CMagicScissorsDoc::EvolveActiveContour()
{
	if( !m_pActiveContour )
		return;

	BOOL	flag;
	flag = m_pActiveContour->Evolve(5);
	flag = m_pActiveContour->GetActiveContour( m_pEdgeList );
}

void CMagicScissorsDoc::OnBilateral() 
{
	BilateralPar InputMesseage;

	if(InputMesseage.DoModal() == IDOK)
	{	
		CImage Origindib(m_pImage), Resultdib;

		CSize size;
		int Height = size.cy = Origindib.GetYSize();
		int Width  = size.cx = Origindib.GetXSize();
						
		// 函荐 急攫 //
		int Masksize   = InputMesseage.m_TotalMasksize;
		int GeoSigma   = InputMesseage.m_GeoParameter;
		int PhotoSigma = InputMesseage.m_PhotoParameter;
		
		register int i, j, p, q;
		
		int PhotoMasksize = Masksize , GeoMasksize = Masksize , Bilatersize = Masksize;
		int PhotoMaskHalf = PhotoMasksize/2 , GeoMaskHalf = GeoMasksize/2 , BilaterHalf = Bilatersize / 2;
		
		double** Geometric = new double*[GeoMasksize];
		double*  m_pGeoMask  = new double[GeoMasksize*GeoMasksize];
		for(i = 0 ; i < GeoMasksize ; i++)
			Geometric[i] = &m_pGeoMask[GeoMasksize*i];
		
		// To Compute GeoMetric Closeness							//
		// 楷魂 加档 俺急阑 困秦 固府 Array 救俊 拌魂等 蔼阑 历厘窃 //
		for(i = 0 ; i < GeoMasksize ; i++)
		{
			for(j = 0; j < GeoMasksize ; j++)
			{
				double a = sqrt((GeoMaskHalf - i) * (GeoMaskHalf - i) + (GeoMaskHalf - j) * (GeoMaskHalf - j));
				Geometric[i][j] =  exp(-0.5 * (a / GeoSigma) * (a / GeoSigma));
			}
		}
		
		// To compute Photometric similarity	  //
		// Exp 楷魂狼 加档甫 临捞扁 困秦 固府沥狼 //
		double pExp[256];
		for(i = 0 ; i < 255 ; i++)
			pExp[i] = exp((-1.0/2.0)*((i/PhotoSigma)*(i/PhotoSigma)));
				
		if(m_pImage->GetColorMode() == 8 )
		{
			CSize size;
			size.cx = m_pImage->GetXSize();
			size.cy = m_pImage->GetYSize();
			Resultdib.CreateImage(size,m_pImage->GetColorMode(),255);

			BYTE** Inputptr = Origindib.GetPtr();
			BYTE** Resultptr= Resultdib.GetPtr();

			for( i = 0 ; i < Height ; i++)
			{
				for( j = 0 ; j < Width ; j++)
				{
					double Normalize = 0.0f , OutAcc = 0.0f;
					int Photometric = 0;

					for( p = 0 ; p < Bilatersize ; p++)
					{
						for( q = 0 ; q < Bilatersize ; q++)
						{
							int Xx = i-BilaterHalf+p;
							int Yy = j-BilaterHalf+q;

							// 抗寇贸府 
							if(Xx < 0 || Xx >= Height || Yy < 0 || Yy >= Width)continue;

							Photometric  = abs(Inputptr[Xx][Yy] - Inputptr[i][j]);
							OutAcc      += Inputptr[Xx][Yy] * pExp[Photometric] * Geometric[p][q];
							Normalize   += pExp[Photometric] * Geometric[p][q];
						}
					}
					Resultptr[i][j] = (BYTE)(OutAcc/Normalize);
				}
			}
			AfxNewImage(Resultdib);
		}

		else if(m_pImage->GetColorMode() == 24)
		{				
			CSize size;
			size.cx = m_pImage->GetXSize();
			size.cy = m_pImage->GetYSize();
			Resultdib.CreateImage(size,m_pImage->GetColorMode(),255);
			
			int PhotoRed, PhotoGreen, PhotoBlue;
			double GeoRedAcc=0.0f, GeoBlueAcc=0.0f, GeoGreenAcc=0.0f , GeoNormalize=0.0f , GeoTemp = 0.0f;
			
			CColorPixel** RGBInputptr = Origindib.GetColorPtr();
			CColorPixel** RGBOutptr	  = Resultdib.GetColorPtr();
			
			//Bilater Filter //
			for( i = 0 ; i < Height ; i++)
			{
				for( j = 0 ; j < Width ; j++)
				{					
					double	PhotoGreenAcc = 0.0f , PhotoRedAcc = 0.0f , PhotoBlueAcc = 0.0f , GemNormalize = 0.0f,
						OutRedAcc = 0.0f, OutGreenAcc = 0.0f , OutBlueAcc = 0.0f ,NormalizeRed = 0.0f , 
						NormalizeGreen = 0.0f , NormalizeBlue = 0.0f;
					
					for( p = 0 ; p < Bilatersize ; p++)
					{
						for( q = 0 ; q < Bilatersize ; q++)
						{
							int Xx = i-PhotoMaskHalf+p;
							int Yy = j-PhotoMaskHalf+q;

							if(Xx < 0 || Xx >= Height || Yy < 0 || Yy >= Width)continue;

							//To compute Photometric Similarity //
							PhotoRed   = abs(RGBInputptr[Xx][Yy].r - RGBInputptr[i][j].r);//函荐历厘 
							PhotoGreen = abs(RGBInputptr[Xx][Yy].g - RGBInputptr[i][j].g);//函荐历厘
							PhotoBlue  = abs(RGBInputptr[Xx][Yy].b - RGBInputptr[i][j].b);//函荐历厘 
														
							// Paper 俊辑 肋给利篮 何盒 Original Pixel 捞 酒囱 Mask 郴何狼 Pixel 蔼阑 措涝 秦具窃 
							OutRedAcc   += RGBInputptr[Xx][Yy].r * pExp[PhotoRed]   * Geometric[p][q];
							OutGreenAcc += RGBInputptr[Xx][Yy].g * pExp[PhotoGreen] * Geometric[p][q];
							OutBlueAcc  += RGBInputptr[Xx][Yy].b * pExp[PhotoBlue]  * Geometric[p][q];
							
							// Normalize //
							NormalizeRed   += pExp[PhotoRed]  *Geometric[p][q];
							NormalizeGreen += pExp[PhotoGreen]*Geometric[p][q];
							NormalizeBlue  += pExp[PhotoBlue] *Geometric[p][q];
						}
					}
					// Normalize //
					RGBOutptr[i][j].r = int(OutRedAcc/NormalizeRed);
					RGBOutptr[i][j].g = int(OutGreenAcc/NormalizeGreen);
					RGBOutptr[i][j].b = int(OutBlueAcc/NormalizeBlue);
					if((OutRedAcc/NormalizeRed) > 255)
						RGBOutptr[i][j].r = 255;
					if((OutRedAcc/NormalizeRed) < 0)
						RGBOutptr[i][j].r = 0;
					if((OutGreenAcc/NormalizeGreen) > 255)
						RGBOutptr[i][j].g = 255;
					if((OutGreenAcc/NormalizeGreen) < 0)
						RGBOutptr[i][j].g = 0;
					if((OutBlueAcc/NormalizeBlue) > 255)
						RGBOutptr[i][j].b = 255;
					if((OutBlueAcc/NormalizeBlue) < 0)
						RGBOutptr[i][j].b = 0;
				}
			}

			AfxNewImage(Resultdib);
		}
		else
		{
			AfxMessageBox("瘤盔窍瘤 臼绰 祸惑荐狼 捞固瘤涝聪促");
		}
			delete [] Geometric;
			delete [] m_pGeoMask;
	}	
}

void CMagicScissorsDoc::OnWatershed() 
{
	IEDib input, output;
	CImageSegment m_segment;
	CImage ProcessedImage(m_pImage);

	CSize size;
	size.cy = m_pImage->GetYSize();
	size.cx = m_pImage->GetXSize();

	input.CreateRGBImage(m_pImage->GetXSize(), m_pImage->GetYSize());
	output.CreateRGBImage(m_pImage->GetXSize(), m_pImage->GetYSize());

	ConvertIMAGEtoDIB(m_pImage, &input);

	m_segment.Segment(&input);
	m_segment.GetOutputImage(&output);
	
	ConvertDIBtoIMAGE(&output, &ProcessedImage);

	AfxNewImage(ProcessedImage);
	
}

void CMagicScissorsDoc::ConvertIMAGEtoDIB(CImage *input, IEDib *output)
{
	// Old Ver. 困茄 converting //
	// CImage -> IEDib		    //
	int width = input->GetXSize();
	int height = input->GetYSize();

	CColorPixel** ptrInput = input->GetColorPtr();
	RGBBYTE** ptrOutput = output->GetRGBPtr();

	int x, y;
	for(y = 0; y < height; y++)
	{
		for(x = 0; x < width; x++)
		{
			ptrOutput[y][x].r = ptrInput[y][x].r;
			ptrOutput[y][x].g = ptrInput[y][x].g;
			ptrOutput[y][x].b = ptrInput[y][x].b;
		}
	}
	output->FreePtr(ptrOutput);
}

void CMagicScissorsDoc::ConvertDIBtoIMAGE(IEDib *input, CImage *ouput)
{
	// Old Ver. 困茄 converting //
	// IEDib -> CImage		    //
	int width = input->GetWidth();
	int height = input->GetHeight();

	CColorPixel** ptrOutput = ouput->GetColorPtr();
	RGBBYTE** ptrInput = input->GetRGBPtr();

	int x, y;
	for(y = 0; y < height; y++)
	{
		for(x = 0; x < width; x++)
		{
			ptrOutput[y][x].r = ptrInput[y][x].r;
			ptrOutput[y][x].g = ptrInput[y][x].g;
			ptrOutput[y][x].b = ptrInput[y][x].b;
		}
	}
	input->FreePtr(ptrInput);
}