magicscissorsdoc.cpp

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

// MagicScissorsDoc.cpp : implementation of the CMagicScissorsDoc class
//

#include "stdafx.h"
#include "MagicScissors.h"
#include "MagicScissorsDoc.h"
#include "MainFrm.h"
#include "Old/IEDib.h"
#include "old/imagesegment.h"

#include "Image/Image.h"
#include "Image/ImageColor.h"
#include "Image/EdgeDetector.h"
#include "Image/ColorPixel.h"
#include "Image/Video.h"
#include "EdgeList.h"
#include "EdgePoint.h"
#include "FrameList.h"
#include "FrameInfo.h"
#include "ObjRgn.h"
#include "ObjList.h"
#include "Polygon.h"
#include "PolygonList.h"
#include "EdgeListStack.h"
#include "ObjListStack.h"
#include "BilateralPar.h"

#include "ObjectPropertyDlg.h"

#include "EdgeTracer.h"

#include "3DObject.h"
#include "Plane.h"
#include "Sphere.h"
#include "Cylinder.h"
#include "Ellipsoid.h"

#include "WriteObjDlg.h"
#include "OpenGLView.h"
#include "PathInputDlg.h"
#include "MultiFrameDlg.h"

#include "ActiveContour.h"

#include <math.h>


#define PI		3.14159265358979


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CMagicScissorsDoc

extern CMagicScissorsApp theApp;

IMPLEMENT_DYNCREATE(CMagicScissorsDoc, CDocument)

BEGIN_MESSAGE_MAP(CMagicScissorsDoc, CDocument)
	//{{AFX_MSG_MAP(CMagicScissorsDoc)
	ON_COMMAND(IDM_DATA_SAVE, OnDataSave)
	ON_COMMAND(IDM_DATA_OPEN, OnDataOpen)
	ON_COMMAND(IDM_OPEN_GL_VIEW, OnOpenGlView)
	ON_COMMAND(IDM_PROPERTY, OnProperty)
	ON_COMMAND(ID_EDIT_UNDO, OnEditUndo)
	ON_COMMAND(IDM_DATA_SAVEAS, OnDataSaveas)
	ON_COMMAND(IDM_WRITE_OBJECT, OnWriteObject)
	ON_COMMAND(IDM_SAVE_PATH, OnSavePath)
	ON_COMMAND(IDM_BILATERAL, OnBilateral)
	ON_COMMAND(IDM_Watershed, OnWatershed)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMagicScissorsDoc construction/destruction

CMagicScissorsDoc::CMagicScissorsDoc()
{
	// TODO: add one-time construction code here
	m_pImage = NULL;
	m_pVideo = NULL;
	m_pEdgeMap = NULL;
	m_pDepthmap = NULL;
	m_pEdgeList = NULL;
	m_pTempList = NULL;
	m_pFrameList = NULL;
	m_pModifyList = NULL;
	m_pEdgeUndoList = NULL;
	m_pObjUndoList = NULL;
	m_pPolygonList = NULL;
	m_pCurFrame = NULL;

	m_strDataFile = "";
	m_bEdge = FALSE;

	m_pMain = NULL;
	m_pSecond = NULL;

	m_pEdgeListStack = NULL;
	m_pObjUndoStack = NULL;

	m_strStereo = "";
	m_strLeft = "";
	m_strRight = "";
	m_strSeg = "";

	m_fEdge[0] = 0.4f;
	m_fEdge[1] = 0.7f;
	m_fEdge[2] = 1.0f;
	m_fEdge[3] = 1.3f;

	m_nMode = 0;
	m_nStartFrame = 0;
	m_nTotalFrame = 0;

	m_ImgSize = CSize(10,10);

	// Active contour 眠啊 何盒
	m_pActiveContour = NULL;

}

CMagicScissorsDoc::~CMagicScissorsDoc()
{	
	if( m_pVideo ) delete m_pVideo;
	if( m_pEdgeMap ) delete m_pEdgeMap;
	if( m_pDepthmap ) delete m_pDepthmap;
	if( m_pEdgeList ) delete m_pEdgeList;
	if( m_pTempList ) delete m_pTempList;
	if( m_pFrameList ) delete m_pFrameList;
	if( m_pModifyList ) delete m_pModifyList;
	if( m_pEdgeUndoList ) delete m_pEdgeUndoList;
	if( m_pObjUndoList ) delete m_pObjUndoList;
	if( m_pPolygonList ) delete m_pPolygonList;
	if( m_pEdgeListStack ) delete m_pEdgeListStack;
	if( m_pObjUndoStack ) delete m_pObjUndoStack;
	if( m_pImage ) delete m_pImage;

	// Active contour 眠啊 何盒
	if( m_pActiveContour ) delete m_pActiveContour;
}

BOOL CMagicScissorsDoc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;

	// TODO: add reinitialization code here
	// (SDI documents will reuse this document)
	m_nMode = 3;
/*
	CMultiFrameDlg dlg;
	if( dlg.DoModal() == IDOK )
	{
		m_strFileName = dlg.m_strPath + "\\" + dlg.m_strName;
		m_nStartFrame = dlg.m_nStart;
		m_nEndFrame = dlg.m_nEnd;
		m_nTotalFrame = m_nEndFrame-m_nStartFrame+1;
		m_nCurFrame = 0;	
		m_pFrameList = new CFrameList;	
		GetNextFrame();
		m_ImgSize = m_pImage->GetImageSize();		
		return TRUE;
	}*/	

	m_nStartFrame = 1;
	m_nEndFrame = 20;
	m_nTotalFrame = 20;
	m_nCurFrame = 0;
	m_pFrameList = new CFrameList;	

	if( theApp.m_pNewImage != NULL )
	{		
		if( m_pImage != NULL )
			delete [] m_pImage;
		
		//if( m_pCurFrame ) return TRUE;

		m_pImage = new CImage(theApp.m_pNewImage);
		theApp.m_pNewImage = NULL;
	}else
	{	
		GetNextFrame();
	}
	
	m_ImgSize = m_pImage->GetImageSize();

	return TRUE;

//	AfxGetMainWnd()->PostMessage(ID_FILE_CLOSE);

	return FALSE;

}



/////////////////////////////////////////////////////////////////////////////
// CMagicScissorsDoc serialization

void CMagicScissorsDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		// TODO: add storing code here
	}
	else
	{
		// TODO: add loading code here
	}
}

/////////////////////////////////////////////////////////////////////////////
// CMagicScissorsDoc diagnostics

#ifdef _DEBUG
void CMagicScissorsDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CMagicScissorsDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CMagicScissorsDoc commands

BOOL CMagicScissorsDoc::OnOpenDocument(LPCTSTR lpszPathName) 
{
	if (!CDocument::OnOpenDocument(lpszPathName))
		return FALSE;

	//OpenGLView();
	
	// TODO: Add your specialized creation code here
	m_pVideo = new CVideo(lpszPathName);
	if( !m_pVideo->IsValidate() )
	{
		delete m_pVideo;
		m_pVideo = NULL;
		AfxMessageBox("厚叼坷 颇老阑 秦刀且荐 绝嚼聪促.\r\n利寸茄 内郸捞 汲摹登绢 乐绰瘤 犬牢窍绞矫坷.");
		return FALSE;
	}
	m_nMode = 1;
	m_nTotalFrame = m_pVideo->GetTotalFrame();
	m_ImgSize = m_pVideo->GetVideoSize();
	m_nCurFrame = 0;	
	m_pFrameList = new CFrameList;
	GetNextFrame();
	m_strVideoFile = lpszPathName;	
	return TRUE;	
}

BOOL CMagicScissorsDoc::OpenGLView()
{
	CFrameWnd			*pWndSecondChild ;
	CMultiDocTemplate	*pDocTemplate ;
	pDocTemplate = theApp.GetDocTemplate(DOCTEMPLATE_SECONDVIEW);

	if (pDocTemplate != NULL)
	{
		// Note: First child frame does not exist at this point, so we cannot refer to it.
		pWndSecondChild = pDocTemplate->CreateNewFrame(this, NULL);	
		ASSERT(pWndSecondChild != NULL);
		// Third parameter (make window visible) defaults to TRUE.
		pDocTemplate->InitialUpdateFrame(pWndSecondChild, this);
		return TRUE;
	}
	else
		return FALSE;
	
}

BOOL CMagicScissorsDoc::GetNextFrame( BOOL bEdge )
{
	if( m_nMode == 1 )
	{
		if( !m_pVideo ) return FALSE;
	}

	if( m_nCurFrame == m_nTotalFrame )
		m_nCurFrame = 0;

	if( m_nMode == 1 )
	{
		if( !m_pImage )
			m_pImage = m_pVideo->GetFrame( m_nCurFrame );
		else
			m_pVideo->GetFrame( m_nCurFrame, m_pImage );

		/*CString file;
		file.Format("d:\\jsa\\jsa%06d.bmp", m_nCurFrame);
		m_pImage->SaveImage(file);*/
	}
	else if( m_nMode == 2 )
	{
		CString file;
		file.Format("%s%06d.bmp", m_strFileName, m_nStartFrame+m_nCurFrame);
		if( m_pImage ) delete m_pImage;
		m_pImage = new CImage(file);
		if( !m_pImage->IsValidate() )
		{
			file += "阑 凯荐 绝嚼聪促.";
			AfxMessageBox(file);
			return FALSE;
		}
		m_ImgSize = m_pImage->GetImageSize();
	}

	else if( m_nMode == 3 )
	{
		if(m_pImage)
		{
			int a = 0;

		}

		CFileDialog dlg(true);
		if(dlg.DoModal() == IDOK)
		{
			if( m_pImage ) delete m_pImage;
			m_pImage = new CImage(dlg.GetFileName());
			if( !m_pImage->IsValidate() )
			{
				return FALSE;
			}
			m_ImgSize = m_pImage->GetImageSize();
		}
		
	}

	if( m_pFrameList )
	{
		if( !m_pFrameList->GetFrame(m_nCurFrame) )
			m_pFrameList->AddFrame(m_nCurFrame, m_ImgSize);
		m_pCurFrame = m_pFrameList->GetFrame(m_nCurFrame);
	}

	if( bEdge )
	{
		DetectEdge();
		/*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]);
		//edge.Edge_Deriche_Filtering(1.0f);*/
	}			
	
	m_nCurFrame++;

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

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

	m_bEdge = bEdge;

	return TRUE;
}

BOOL CMagicScissorsDoc::GetPrevFrame()
{
	if( m_nMode == 1 )
	{
		if( !m_pVideo ) return FALSE;
	}
	
	if( m_nCurFrame == 1 ) return FALSE;
	
	m_nCurFrame -= 2;
	GetNextFrame(FALSE);

	return TRUE;
}

void CMagicScissorsDoc::AddEdge()
{
	if( !m_pEdgeList )
		m_pEdgeList = new CEdgeList;


	if( !m_pEdgeListStack )
		m_pEdgeListStack = new CEdgeListStack;

	m_pEdgeListStack->Push(m_pEdgeList);

	if( m_pTempList )
	{
		m_pEdgeList->AddSegment( m_pTempList );
		m_pTempList->Clear();
	}
}

void CMagicScissorsDoc::UndoEdge()
{
	if( m_pEdgeListStack )
	{
		CEdgeList* pList = m_pEdgeListStack->Pop();
		if( pList )
		{
			delete m_pEdgeList;
			m_pEdgeList = pList;
		}		
	}
}


void CMagicScissorsDoc::FindEdge(CPoint sp, CPoint ep)
{
	if( !m_pImage ) return;

	CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
	pFrame->m_wndOptionBar.UpdateData(TRUE);
	int w = pFrame->m_wndOptionBar.m_nSearchWidth;
	int e = pFrame->m_wndOptionBar.m_nEdge;
	
	if( !m_pEdgeMap || !m_bEdge )
	{
		DetectEdge();
		/*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();*/
	}

	if( !m_pTempList )
		m_pTempList = new CEdgeList;

	m_pTempList->Clear();

	CEdgePoint* last =  m_pEdgeList->GetLastPoint();

	if( last ) sp = *last;	

	FindConner(sp, ep, w);

	int dx,dy;	
	int step;

	float x1,y1,x2,y2;
	float ddx,ddy;

	dx = m_ptConner[2].x - m_ptConner[0].x;
	dy = m_ptConner[2].y - m_ptConner[0].y;

	if( dx == 0 )
	{
		step = abs(dy);
		ddx = (float)dx/step;
		ddy = (float)dy/step;
	}
	else if( fabs( (double)dy/dx ) <= 1.0 )
	{
		step = abs(dx);
		ddx = (float)dx/step;
		ddy = (float)dy/step;
	}
	else
	{
		step = abs(dy);
		ddx = (float)dx/step;
		ddy = (float)dy/step;
	}
	x1 = (float)m_ptConner[0].x;
	y1 = (float)m_ptConner[0].y;
	x2 = (float)m_ptConner[1].x;
	y2 = (float)m_ptConner[1].y;

	
	CPoint pnt;
	CEdgePoint* pt;
	CEdgeList* pList = m_pTempList;	

	pnt = FindEdgePoint( (int)x1, (int)y1, (int)x2, (int)y2, sp );
	
	if( pnt.x != -1 )
		pList->AddEdgePoint(pnt);
	else
		pList->AddEdgePoint(sp);
	
	for( int i = 0 ; i < step ; i++ )
	{
		x1 += ddx;
		x2 += ddx;
		y1 += ddy;
		y2 += ddy;
		
		pt = pList->GetLastPoint();
		if( pt )
		{
			pnt = FindEdgePoint( (int)x1, (int)y1, (int)x2, (int)y2, *pt );			
			if( pnt.x != -1 )
			{				
				pList->AddEdgePoint(pnt);			
			}
			else if( i == step-1 )
				pList->AddEdgePoint(ep);
				
		}
	}
}


void CMagicScissorsDoc::FindConner(CPoint sp, CPoint ep, int w)
{
	double theta;
	int dx,dy;
	CPoint cp1,cp2,cp3,cp4;

	dx = sp.x - ep.x;
	dy = sp.y - ep.y;

	theta = atan2( -dx, dy );

	dx = (int)(w*cos(theta)+0.5);
	dy = (int)(w*sin(theta)+0.5);

	cp1.x = sp.x - dx;
	cp1.y = sp.y - dy;

	cp2.x = sp.x + dx;
	cp2.y = sp.y + dy;

	cp3.x = ep.x - dx;
	cp3.y = ep.y - dy;