objrgn.cpp

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

// ObjRgn.cpp: implementation of the CObjRgn class.
//
//////////////////////////////////////////////////////////////////////

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

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

#include "ObjectPropertyDlg.h"

#include "Image/Image.h"

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

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

CObjRgn::CObjRgn()
{
	m_pEdgeList = NULL;
	m_pNext = m_pPrev = NULL;
	m_pObject = NULL;
}

CObjRgn::CObjRgn(CObjRgn& obj)
{
	m_pEdgeList = NULL;
	m_pNext = m_pPrev = NULL;
	m_pObject = NULL;

	m_pEdgeList = new CEdgeList( *obj.GetEdgeList() );
	UpdateRgn();
	if( obj.m_pObject ) Create( obj.m_pObject );
}

CObjRgn::~CObjRgn()
{
	if( m_pEdgeList ) delete m_pEdgeList;
	if( m_pObject ) delete m_pObject;
}

BOOL CObjRgn::Create(CEdgeList* pList)
{
	if( m_pEdgeList ) return FALSE;
	m_pEdgeList = pList;
	UpdateRgn();
	return TRUE;
}

BOOL CObjRgn::Smoothing(int n)
{
	int l = m_pEdgeList->GetLength();

	CEdgeList* pList = new CEdgeList;
	for( int i = 0 ; i < l ; i+= n )
		pList->AddEdgePoint( *m_pEdgeList->GetPoint(i) );
	
	delete m_pEdgeList;
	m_pEdgeList = pList;

	UpdateRgn();

	return TRUE;
}

void CObjRgn::Paint( CDC* pDC, COLORREF col )
{
	if( m_ObjRgn.m_hObject )
	{
		CBrush brush;
		brush.CreateSolidBrush(col);
		pDC->FrameRgn(&m_ObjRgn, &brush, 1, 1 );
	}
	else if( m_pEdgeList )
		m_pEdgeList->Paint( pDC, col, TRUE );
	
}

BOOL CObjRgn::UpdateRgn()
{
	if( !m_pEdgeList ) return FALSE;

	int n = m_pEdgeList->GetLength();
	if( n == 0 ) return FALSE;

	CPoint* point = new CPoint[n];

	int l,r,t,b;
	l = 99999;
	r = -1;
	t = 99999;
	b = -1;
	
	for( int i = 0 ; i < n ; i++ )
	{
		point[i] = *(m_pEdgeList->GetPoint(i));
		if( point[i].x < l )
			l = point[i].x;
		else if( point[i].x >r )
			r = point[i].x;
		if( point[i].y < t )
			t = point[i].y;
		else if( point[i].y > b )
			b = point[i].y;
	}

	if( m_ObjRgn.m_hObject )
		m_ObjRgn.DeleteObject();
	
	m_ObjRgn.CreatePolygonRgn( point, n, WINDING );
	delete [] point;

	m_Bound = CRect(l,t,r,b);

	return TRUE;
}

BOOL CObjRgn::PtInRgn(CPoint point)
{
	if( !m_ObjRgn.m_hObject ) return FALSE;
	else
		return m_ObjRgn.PtInRegion(point);
}

BOOL CObjRgn::Modify(CEdgeList* pList)
{
	
	int n0 = m_pEdgeList->GetLength();
	int n1 = pList->GetLength();

	int i,j;
	int is0,is1,ie0,ie1;
	is0 = ie0 = is1 = ie1 = -1;
	CPoint pt1,pt2;

	BOOL bFind = FALSE;
	for( i = 0 ; i < n1 ; i++ )
	{
		pt1 = *pList->GetPoint(i);
		for( j = 0 ; j < n0 ; j++ )
		{
			pt2 = *m_pEdgeList->GetPoint(j);
			if( abs(pt1.x-pt2.x)<=1 && abs(pt1.y-pt2.y)<=1 )
			{
				if( is0 == -1 )
				{
					is0 = j;
					is1 = i;
					bFind = TRUE;
					break;
				}
			}
		}
		if( bFind ) break;
	}

	if( is0 == -1 ) return FALSE;

	bFind = FALSE;
	for( i = n1-1 ; i > is1 ; i-- )
	{
		pt1 = *pList->GetPoint(i);
		for( j = 0 ; j < n0 ; j++ )
		{
			pt2 = *m_pEdgeList->GetPoint(j);
			if( abs(pt1.x-pt2.x)<=1 && abs(pt1.y-pt2.y)<=1 )
			{
				if( ie0 == -1 )
				{
					ie0 = j;
					ie1 = i;
					bFind = TRUE;
					break;	
				}
			}
		}
		if( bFind ) break;
	}

	if( ie0 == -1 ) return FALSE;

	CEdgeList* pEdgeList = new CEdgeList;

	if( abs(is0-ie0) > n0/2 )
	{
		if( is0 > ie0 )
		{
			for( i = is0 ; i >= ie0 ; i-- )
				pEdgeList->AddPoint( *m_pEdgeList->GetPoint(i) );
			for( i = ie1-1 ; i > is1 ; i-- )
				pEdgeList->AddPoint( *pList->GetPoint(i) );
		}
		else
		{
			for( i = is0 ; i <= ie0 ; i++ )
				pEdgeList->AddPoint( *m_pEdgeList->GetPoint(i) );
			for( i = ie1-1 ; i > is1 ; i-- )
				pEdgeList->AddPoint( *pList->GetPoint(i) );
		}
	}
	else
	{
		if( is0 > ie0 )
		{
			for( i = 0 ; i <= ie0 ; i++ )
				pEdgeList->AddPoint( *m_pEdgeList->GetPoint(i) );
			for( i = ie1-1 ; i > is1 ; i-- )
				pEdgeList->AddPoint( *pList->GetPoint(i) );
			for( i = is0 ; i < n0 ; i++ )
				pEdgeList->AddPoint( *m_pEdgeList->GetPoint(i) );
		}
		else
		{
			for( i = 0 ; i <= is0 ; i++ )
				pEdgeList->AddPoint( *m_pEdgeList->GetPoint(i) );
			for( i = is1+1 ; i < ie1 ; i++ )
				pEdgeList->AddPoint( *pList->GetPoint(i) );
			for( i = ie0 ; i < n0 ; i++ )
				pEdgeList->AddPoint( *m_pEdgeList->GetPoint(i) );
		}
	}

	delete m_pEdgeList;
	m_pEdgeList = pEdgeList;
	UpdateRgn();

	return TRUE;
}

BOOL CObjRgn::Write(CFile* pFile)
{
	int type = 0;
	if( m_pEdgeList )
	{
		m_pEdgeList->Write(pFile);
		if( m_pObject )
			m_pObject->Write(pFile);
		else
			pFile->Write( &type, sizeof(int) );
		return TRUE;
	}
	else
		return FALSE;
}

BOOL CObjRgn::Read(CFile* pFile)
{
	m_pEdgeList = new CEdgeList;
	int type;
	if( m_pEdgeList )
	{
		if( m_pEdgeList->Read(pFile) )
		{
			UpdateRgn();
			pFile->Read( &type, sizeof(int) );
			if( type != 0 )
				ReadObject( type, pFile );
			return TRUE;
		}
		else 
			return FALSE;
	}
	else
		return FALSE;
}

void CObjRgn::Render(GLUquadricObj* pQuad, CImage* pImage, BOOL bGlobal)
{
	if( m_pObject )
		m_pObject->Render(pQuad, pImage, bGlobal);
}

BOOL CObjRgn::Create(C3DObject* pObject)
{
	if( m_pObject ) delete m_pObject;

	switch( pObject->GetType() )
	{
	case PLANE:
		m_pObject = new CPlane((CPlane*)pObject);
		m_pObject->m_nY = m_Size.cy;
		m_pObject->m_Rect = m_Bound;
		break;
	case CYLINDER:
		m_pObject = new CCylinder((CCylinder*)pObject);
		m_pObject->m_nY = m_Size.cy;
		m_pObject->m_Rect = m_Bound;
		break;
	case SPHERE:
		m_pObject = new CSphere((CSphere*)pObject);
		m_pObject->m_nY = m_Size.cy;
		m_pObject->m_Rect = m_Bound;
		break;
	case ELLIPSOID:
		m_pObject = new CEllipsoid((CEllipsoid*)pObject);
		m_pObject->m_nY = m_Size.cy;
		m_pObject->m_Rect = m_Bound;
		break;
	}
	return TRUE;
}

BOOL CObjRgn::CopyPrev(C3DObject* pObject)
{
	if( m_pObject ) delete m_pObject;

	switch( pObject->GetType() )
	{
	case PLANE:
		m_pObject = new CPlane;
		break;
	case CYLINDER:
		m_pObject = new CCylinder;
		break;
	case SPHERE:
		m_pObject = new CSphere;
		break;
	case ELLIPSOID:
		m_pObject = new CEllipsoid;
		break;
	}
	m_pObject->Create(m_pEdgeList, m_Bound, m_Size.cy );
	m_pObject->CopyParam(pObject);		

	return TRUE;
}

BOOL CObjRgn::ReadObject(int type, CFile* pFile)
{
	if( m_pObject ) delete m_pObject;

	switch( type )
	{
	case PLANE:
		m_pObject = new CPlane;
		break;
	case CYLINDER:
		m_pObject = new CCylinder;
		break;
	case SPHERE:
		m_pObject = new CSphere;
		break;
	case ELLIPSOID:
		m_pObject = new CEllipsoid;		
		break;
	}
	m_pObject->m_nY = m_Size.cy;
	m_pObject->m_Rect = m_Bound;		
	m_pObject->SetList(m_pEdgeList);
	return m_pObject->Read(pFile);
}

BOOL CObjRgn::Property()
{
	CObjectPropertyDlg dlg;
	dlg.m_Rect = m_Bound;
	dlg.m_pList = m_pEdgeList;

	if( m_pObject )
	{
		switch( m_pObject->GetType() )
		{
		case PLANE:
			dlg.m_pObject = new CPlane((CPlane*)m_pObject);
			break;
		case CYLINDER:
			dlg.m_pObject = new CCylinder((CCylinder*)m_pObject);
			break;
		case SPHERE:
			dlg.m_pObject = new CSphere((CSphere*)m_pObject);
			break;
		case ELLIPSOID:
			dlg.m_pObject = new CEllipsoid((CEllipsoid*)m_pObject);
			break;
		}
	}
	
	dlg.DoModal();

	if( dlg.m_pObject )
		return Create( dlg.m_pObject );
	else 
		return FALSE;
}

CPoint CObjRgn::GetCentroid()
{
	int n = m_pEdgeList->GetLength();
	CPoint pt;
	int x, y;
	int i;

	x = y = 0;
	for( i = 0 ; i < n ; i++ )
	{
		pt = *(m_pEdgeList->GetPoint(i));
		x += pt.x;
		y += pt.y;
	}

	x = (int)((float)x/n+0.5);
	y = (int)((float)y/n+0.5);

	return CPoint(x,y);
}

void CObjRgn::SetSize(CSize size)
{
	m_Size = size;
}