edgelist.cpp

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

// EdgeList.cpp: implementation of the CEdgeList class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MagicScissors.h"
#include "EdgeList.h"
#include "EdgePoint.h"

#include <math.h>

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CEdgeList::CEdgeList()
{
	m_pRoot = NULL;
	m_pLast = NULL;

	m_pPrev = m_pNext = NULL;
}

CEdgeList::CEdgeList(CEdgeList& list)
{
	m_pRoot = NULL;
	m_pLast = NULL;
	CopyList(&list);
}

CEdgeList::~CEdgeList()
{
	if( m_pRoot ) DeleteAll();
}

BOOL CEdgeList::AddEdgePoint(int x, int y)
{
	if( !m_pLast )
	{
		return AddPoint(x,y);		
	}

	CPoint pt1 = *m_pLast;;
	CPoint pt2 = CPoint(x,y);

	int dx,dy;	
	int step;

	float fx,fy;
	float ddx,ddy;

	dx = pt2.x - pt1.x;
	dy = pt2.y - pt1.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;
	}
	fx = (float)pt1.x;
	fy = (float)pt1.y;
		
	for( int i = 0 ; i < step ; i++ )
	{
		fx += ddx;
		fy += ddy;
		AddPoint((int)(fx+.5),(int)(fy+.5));
	}
	return TRUE;
}

BOOL CEdgeList::AddEdgePoint(CPoint point)
{
	return AddEdgePoint( point.x, point.y );
}

BOOL CEdgeList::AddEdgePoint(CEdgePoint point)
{
	return AddEdgePoint( point.x, point.y );
}

BOOL CEdgeList::AddPoint(int x, int y)
{
	CEdgePoint* pPoint = new CEdgePoint(x,y);
	if( !pPoint ) return FALSE;

	if( m_pLast )
	{
		m_pLast->m_pNext = pPoint;
		pPoint->m_pPrev = m_pLast;
		m_pLast = pPoint;
	}
	else
	{
		m_pRoot = pPoint;
		m_pLast = m_pRoot;
	}	
	return TRUE;
}

BOOL CEdgeList::AddPoint(CPoint point)
{
	CEdgePoint* pPoint = new CEdgePoint;
	if( !pPoint ) return FALSE;

	*pPoint = point;	

	if( m_pLast )
	{
		m_pLast->m_pNext = pPoint;
		pPoint->m_pPrev = m_pLast;
		m_pLast = pPoint;
	}
	else
	{
		m_pRoot = pPoint;
		m_pLast = m_pRoot;
	}	
	return TRUE;
}

BOOL CEdgeList::DeletePoint(int n)
{
	CEdgePoint* pPoint;
	pPoint = m_pRoot;

	for( int i = 0 ; i < n ; i++ )
	{
		if( !pPoint ) return FALSE;
		pPoint = pPoint->m_pNext;
	}

	CEdgePoint* pPrev;
	CEdgePoint* pNext;

	if( pPoint == m_pRoot )
	{
		m_pRoot = pPoint->m_pNext;
		if( m_pRoot )
			m_pRoot->m_pPrev = NULL;
		else
			m_pLast = NULL;
	}
	else if( pPoint == m_pLast )
	{
		m_pLast = pPoint->m_pPrev;
		m_pLast->m_pNext = NULL;
	}
	else
	{
		pPrev = pPoint->m_pPrev;
		pNext = pPoint->m_pNext;
		pPrev->m_pNext = pNext;
		pNext->m_pPrev = pPrev;
	}
	
	delete pPoint;

	return TRUE;
}

CEdgePoint* CEdgeList::GetPoint(int n)
{
	CEdgePoint* pPoint;
	pPoint = m_pRoot;

	for( int i = 0 ; i < n ; i++ )
	{
		if( !pPoint ) return NULL;
		pPoint = pPoint->m_pNext;
	}
	return pPoint;
}

CEdgePoint* CEdgeList::GetLastPoint()
{
	return m_pLast;
}

int CEdgeList::GetLength()
{
	int n = 0;
	
	CEdgePoint* pPoint;
	pPoint = m_pRoot;
	while( pPoint )
	{
		n++;
		pPoint = pPoint->m_pNext;
	}
	return n;
}

void CEdgeList::Clear()
{
	DeleteAll();
}

void CEdgeList::DeleteAll()
{	
	CEdgePoint* pPoint;
	CEdgePoint* pNext;
	pPoint = m_pRoot;

	while( pPoint )
	{
		pNext = pPoint->m_pNext;
		delete pPoint;
		pPoint = pNext;
	}
	m_pRoot = NULL;
	m_pLast = NULL;
}

BOOL CEdgeList::AddSegment(CEdgeList* pList)
{
	if( !pList || !pList->m_pRoot ) return FALSE;
	
	int n = pList->GetLength();

	for( int i = 0 ; i < n ; i++ )
		AddPoint( *(pList->GetPoint(i)) );

	return TRUE;
}

BOOL CEdgeList::CopyList(CEdgeList* pList)
{
	if( !pList || !pList->m_pRoot ) return FALSE;

	DeleteAll();

	int n = pList->GetLength();

	for( int i = 0 ; i < n ; i++ )
	{
		//CEdgePoint* pPoint = new CEdgePoint(*(pList->GetPoint(i)));
		AddPoint(*(pList->GetPoint(i)));
	}
	return TRUE;
}

void CEdgeList::operator = (CEdgeList& list)
{
	CopyList(&list);
}

void CEdgeList::Paint(CDC* pDC, COLORREF col, BOOL bLoop)
{
	int n,i;

	n = GetLength();

	if( n == 0 ) return;

	CPen pen;
	pen.CreatePen(PS_SOLID, 1, col);
	CPen* pPen = pDC->SelectObject( &pen );

	CEdgePoint* pnt;
	pnt = GetPoint(0);
	pDC->MoveTo( pnt->x, pnt->y );
	pDC->SetPixel( pnt->x, pnt->y, col );
	for( i = 1 ; i < n ; i++ )
	{
		pnt = GetPoint(i);
		//pDC->LineTo( pnt->x, pnt->y );
		pDC->SetPixel( pnt->x, pnt->y, col );
	}
	if( bLoop )
	{
		//pnt = GetPoint(0);
		//pDC->LineTo( pnt->x, pnt->y );
	}	
	pDC->SelectObject( pPen );
}

void CEdgeList::MakeClosedPath()
{
	while(1)
	{
		if( MakeClosed() ) break;
	}
}

BOOL CEdgeList::MakeClosed()
{
	static int s = 0;
	int n = GetLength();
	int i,j;
	CEdgePoint* pSrc;
	CEdgePoint* pDes;
	CEdgePoint* pTmp;
	
	pSrc = GetPoint(s);
	for( i = s ; i < n ; i++ )
	{		
		pDes = pSrc->m_pNext;
		for( j = i+1 ; j < i+100 ; j++ )
		{
			// ring 备炼肺 八荤
			if( pDes == NULL ) pDes = m_pRoot;
			
			if( *pSrc == *pDes )
			{
				if( j < n )
				{
					pTmp = pSrc->m_pNext;
					pDes = pDes->m_pNext;
					pSrc->m_pNext = pDes;
					if( pDes )
						pDes->m_pPrev = pSrc;
					
					pSrc = pTmp;
					while( pSrc != pDes )
					{
						pTmp = pSrc->m_pNext;
						delete pSrc;
						pSrc = pTmp;
					}					
				}
				else
				{
					m_pRoot = pDes;
					pDes = pDes->m_pPrev;
					while( pDes )
					{
						pTmp = pDes->m_pPrev;
						delete pDes;
						pDes = pTmp;
					}

					m_pLast = pSrc->m_pPrev;
					while( pSrc )
					{
						pTmp = pSrc->m_pNext;
						delete pSrc;
						pSrc = pTmp;
					}
					m_pRoot->m_pPrev = NULL;
					m_pLast->m_pNext = NULL;
				}
				return FALSE;
			}
			pDes = pDes->m_pNext;
		}
		pSrc = pSrc->m_pNext;
	}
	s = 0;
	return TRUE;
}


BOOL CEdgeList::Write(CFile* pFile)
{
	CEdgePoint* pPoint;	
	pPoint = m_pRoot;
	
	int n;
	int x,y;
	n = GetLength();
	pFile->Write( &n, sizeof(int) );
	while( pPoint )
	{
		x = pPoint->x;
		y = pPoint->y;
		pFile->Write(&x, sizeof(int));
		pFile->Write(&y, sizeof(int));
		pPoint = pPoint->m_pNext;
	}
	return TRUE;
}

BOOL CEdgeList::Read(CFile* pFile)
{
	int n;
	int x,y;
	
	pFile->Read( &n, sizeof(int) );

	for( int i = 0 ; i < n ; i++ )
	{
		pFile->Read(&x, sizeof(int));
		pFile->Read(&y, sizeof(int));
		AddPoint(x,y);
	}
	return TRUE;
}