chdbsurfd.cpp

能在MDT5/6环境下对已经存在地曲面进行全部和局部区域展开

/////////////////////////////////////////////
// ChDbSurfD custom object.

#include "StdAfx.h"
#include "StdArx.h"
#include "dbproxy.h"
#include "geassign.h"
#include "acgi.h"

#include "AmiUtilities.h"
#include "BrUtilities.h"
#include "acutmigr.h"
#include "GeUtilities.h"

#define VERSION_CHDBSURFD 1


//{{AFX_ARX_MACRO
ACRX_DXF_DEFINE_MEMBERS(ChDbSurfD, AcDbObject,
						 AcDb::kDHL_CURRENT, AcDb::kMReleaseCurrent,
                        AcDbProxyObject::kNoOperation,
						 CHDBSURFD, ChSurfDObj);
//}}AFX_ARX_MACRO


// Constructor / Destructor

ChDbSurfD::ChDbSurfD()
{
	//{{AFX_ARX_DATA_INIT(ChDbSurfD)
	//}}AFX_ARX_DATA_INIT

	// TODO: do your initialization.
	mName = "";
}

ChDbSurfD::~ChDbSurfD()
{
	// TODO: clean up.

}


Acad::ErrorStatus ChDbSurfD::dwgInFields(AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es;

	// Call dwgInFields from AcDbObject
	if ((es = AcDbObject::dwgInFields(pFiler)) != Acad::eOk) {
		return es;
	}

	// Read version number.
	Adesk::UInt16 version;
	pFiler->readItem(&version);
	if (version > VERSION_CHDBSURFD)
		return Acad::eMakeMeProxy;

	// Read the data members.
	switch (version)
	{
	case (1):
		// TODO: here you can file data members not
		//       created by the ObjectARX Add-In.

		// 曲面句柄
		pFiler->readAcDbHandle(&mhSurf);
		
		// 曲面展开参数
		pFiler->readPoint3d(&(mData.oCenter));
		pFiler->readPoint2d(&(mData.dCenter));
		pFiler->readDouble(&(mData.dCenterZ));
		Adesk::Int32 iTmp;
		pFiler->readInt32(&iTmp);	mData.nU = iTmp;
		pFiler->readInt32(&iTmp);	mData.nV = iTmp;
		double		 dTmp;
		pFiler->readDouble(&dTmp);	mData.oEvalU.setLower(dTmp);
		pFiler->readDouble(&dTmp);	mData.oEvalU.setUpper(dTmp);
		pFiler->readDouble(&dTmp);	mData.oEvalV.setLower(dTmp);
		pFiler->readDouble(&dTmp);	mData.oEvalV.setUpper(dTmp);
		pFiler->readBool(&(mData.bFullD));
		pFiler->readBool(&(mData.bAutoOCenter));
		pFiler->readBool(&(mData.bDevInner));
		pFiler->readInt32(&iTmp);	mData.nTol = iTmp;

		char *name;
		pFiler->readString(&name);	mName = name;
		delString(name);

		break;
	}


	return pFiler->filerStatus();
}

Acad::ErrorStatus ChDbSurfD::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es;

	// Call dwgOutFields from AcDbObject
	if ((es = AcDbObject::dwgOutFields(pFiler)) != Acad::eOk) {
		return es;
	}

	// Write version number.
	pFiler->writeItem((Adesk::UInt16) VERSION_CHDBSURFD);

	// Write the data members.
	// TODO: here you can file datamembers not
	//       created by the ObjectARX Add-In.

	// 曲面句柄
	pFiler->writeAcDbHandle(mhSurf);
	
	// 曲面展开参数
	pFiler->writePoint3d(mData.oCenter);
	pFiler->writePoint2d(mData.dCenter);
	pFiler->writeDouble(mData.dCenterZ);
	pFiler->writeInt32(mData.nU);
	pFiler->writeInt32(mData.nV);
	pFiler->writeDouble(mData.oEvalU.lowerBound());
	pFiler->writeDouble(mData.oEvalU.upperBound());
	pFiler->writeDouble(mData.oEvalV.lowerBound());
	pFiler->writeDouble(mData.oEvalV.upperBound());
	pFiler->writeBool(mData.bFullD);
	pFiler->writeBool(mData.bAutoOCenter);
	pFiler->writeBool(mData.bDevInner);
	pFiler->writeInt32(mData.nTol);

	pFiler->writeString(mName);

	return pFiler->filerStatus();
}

// 展开对象初始化, 使用自身的展开数据初始化
Acad::ErrorStatus 
ChDbSurfD::initialize()
{
	if (mhSurf.isNull()) {
		return Acad::eInvalidInput;
	}
	AcDbObjectId eId;
	AcDbDatabase *pDb;
	Acad::ErrorStatus es;
	pDb = acdbHostApplicationServices()->workingDatabase();
	es = pDb->getAcDbObjectId(eId,false,mhSurf);
	if (es != Acad::eOk) {
		return es;
	}
	AcDbEntity *pObj;
	es = acdbOpenObject(pObj,eId,AcDb::kForRead,false);
	if (es != Acad::eOk) {
		return es;
	}

	if (getBaseSurfaceAndLoops(pObj,mData.oBaseSurf,mData.oSurfLoops) != Acad::eOk) {
		pObj->close();
		return Acad::eInvalidInput;
	}
	pObj->close();

	if (mCSDObj.set(mData)) {
		return Acad::eOk;
	} else {
		return Acad::eInvalidInput;
	}
}

// 展开对象初始化, 使用给定的数据初始化
Acad::ErrorStatus 
ChDbSurfD::initialize(const AcDbHandle& hSurf,const CSDData& data)
{
	if (hSurf.isNull()) {
		return Acad::eInvalidInput;
	}

	AcDbObjectId eId;
	AcDbDatabase *pDb;
	Acad::ErrorStatus es;
	pDb = acdbHostApplicationServices()->workingDatabase();
	es = pDb->getAcDbObjectId(eId,false,hSurf);
	if (es != Acad::eOk) {
		return es;
	}
	AcDbEntity *pObj;
	es = acdbOpenObject(pObj,eId,AcDb::kForRead,false);
	if (es != Acad::eOk) {
		return es;
	}
	
	CSDData dataCopy=data;
	if (dataCopy.oSurfLoops.length() == 0) {
		if ( getBaseSurfaceAndLoops(pObj,dataCopy.oBaseSurf,dataCopy.oSurfLoops) != Acad::eOk) {
//		if (!getBaseSurfaceAndLoops(hSurf,dataCopy.oBaseSurf,dataCopy.oSurfLoops)) {
			pObj->close();
			return Acad::eInvalidInput;
		}
	}
	pObj->close();
	
	if (mCSDObj.set(dataCopy)) {
		mData = dataCopy;
		mhSurf = hSurf;
		return Acad::eOk;
	} else {
		return Acad::eInvalidInput;
	}
}


// 映射曲面上一点到展开平面上,注意op必须是曲面上的点，否则可能错误
Acad::ErrorStatus 
ChDbSurfD::mapPointToD(const AcGePoint3d& op,AcGePoint2d& dp)
{
	bool bRet;
	bRet = mCSDObj.mapPointToD(op,dp);
	
	if (bRet) {
		return Acad::eOk;
	} else {
		return Acad::eInvalidInput;
	}
}

Acad::ErrorStatus 
ChDbSurfD::mapPointToD(const AcGePoint3d& op,AcGePoint3d& dp)
{
	bool bRet;
	bRet = mCSDObj.mapPointToD(op,dp);
	
	if (bRet) {
		return Acad::eOk;
	} else {
		return Acad::eInvalidInput;
	}
}

// 如果bIfForcedMap＝true,则当某个点不能映射时，继续映射下一个点，否则返回错误，dc置空
Acad::ErrorStatus 
ChDbSurfD::mapPointsToD(const AcGePoint3dArray& oc,AcGePoint2dArray& dc,bool bIfForcedMap)
{
	bool bRet;
	bRet = mCSDObj.mapPointsToD(oc,dc,bIfForcedMap);
	
	if (bRet) {
		return Acad::eOk;
	} else {
		return Acad::eInvalidInput;
	}
}

Acad::ErrorStatus 
ChDbSurfD::mapPointsToD(const AcGePoint3dArray& oc,AcGePoint3dArray& dc,bool bIfForcedMap)
{
	bool bRet;
	bRet = mCSDObj.mapPointsToD(oc,dc,bIfForcedMap);
	
	if (bRet) {
		return Acad::eOk;
	} else {
		return Acad::eInvalidInput;
	}
}

// 映射展开平面上一点到曲面上,成功返回true
Acad::ErrorStatus 
ChDbSurfD::mapPointToO(const AcGePoint2d& dp,AcGePoint3d& op)
{
	bool bRet;
	bRet = mCSDObj.mapPointToO(dp,op);
	
	if (bRet) {
		return Acad::eOk;
	} else {
		return Acad::eInvalidInput;
	}
}

Acad::ErrorStatus 
ChDbSurfD::mapPointToO(const AcGePoint3d& dp,AcGePoint3d& op)
{
	bool bRet;
	bRet = mCSDObj.mapPointToO(dp,op);
	
	if (bRet) {
		return Acad::eOk;
	} else {
		return Acad::eInvalidInput;
	}
}

Acad::ErrorStatus 
ChDbSurfD::mapPointsToO(const AcGePoint2dArray& dc,AcGePoint3dArray& oc,bool bIfForcedMap)
{
	bool bRet;
	bRet = mCSDObj.mapPointsToO(dc,oc,bIfForcedMap);
	
	if (bRet) {
		return Acad::eOk;
	} else {
		return Acad::eInvalidInput;
	}
}

Acad::ErrorStatus 
ChDbSurfD::mapPointsToO(const AcGePoint3dArray& dc,AcGePoint3dArray& oc,bool bIfForcedMap)
{
	bool bRet;
	bRet = mCSDObj.mapPointsToO(dc,oc,bIfForcedMap);
	
	if (bRet) {
		return Acad::eOk;
	} else {
		return Acad::eInvalidInput;
	}
}


// 对象是否已经初始化
Adesk::Boolean 
ChDbSurfD::isInitialized(void) const
{
	if (mCSDObj.isDefined()) {
		return Adesk::kTrue;
	} else {
		return Adesk::kFalse;
	}
}

void ChDbSurfD::getCSDData(CSDData& data)
{
	data = mData;
}

void ChDbSurfD::getOSurf(AcDbHandle& hSurf)
{
	hSurf = mhSurf;
}

Adesk::Boolean ChDbSurfD::getCSDObj(CSDAreaISO& obj)
{
	if (mCSDObj.isDefined()) {
		obj = mCSDObj;
		return Adesk::kTrue;
	} else {
		return Adesk::kFalse;
	}
}