surfduicommands.cpp

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

//
// ObjectARX defined commands

#include "StdAfx.h"
#include "StdArx.h"
#include "ChDbSurfD.h"
#include "AmiUtilities.h"
#include "BrUtilities.h"
#include "CmdUtilities.h"
#include "CreateDbObj.h"

#include "geassign.h"
#include "dbxutil.h"
#include "SurfDFun.h"

#include "GeUtilities.h"
#include "DbUtilities.h"
#include "GetUtilities.h"

// This is command 'SURFD' 曲面展开
void ChSURFD()
{
	// TODO: Implement the command
	// 得到原曲面
	AcDbHandle mhSurf;
	CSDData mCSDData;

/*
	AmiGeomKey *pSurfKey;
	AcDbObjectId oSurfId;
	AmiStatus amiEs; 
	amiEs = getGeomKeyFromPick("选择曲面:",Ami::surfKey,pSurfKey);
	if ( amiEs != Ami::eOk ) {
		acutPrintf("必须选择一个曲面!\n");
		return;
	}
	getDbIdFromGeomKey(pSurfKey,oSurfId);
	mhSurf = oSurfId.handle();
	pSurfKey->release();
*/
	int ret;

	AcDbEntity * pSurf;
	ret = selectEntity("\n选择曲面: ","ASSURFACE",pSurf);
	if (ret != RTNORM) {
		return;
	}
	getBaseSurfaceAndLoops(pSurf,mCSDData.oBaseSurf,mCSDData.oSurfLoops);
	pSurf->getAcDbHandle(mhSurf);
	pSurf->close();

	// 输入展开平面基点
	AcGePoint3d dSurfCenter;
	acedInitGet(RSG_NONULL,NULL);
	ret = acedGetPoint(NULL,"\n输入展开平面基点: ",asDblArray(dSurfCenter));
	if (ret==RTCAN) {
		return;
	}
	// 注意上步得到的是UCS下的坐标，要转换到世界坐标下
	acdbUcs2Wcs(asDblArray(dSurfCenter),asDblArray(dSurfCenter),false);

	ChDbSurfD *pDSurf;
	pDSurf = new ChDbSurfD();

	mCSDData.dCenter.set(dSurfCenter.x,dSurfCenter.y);
	mCSDData.dCenterZ = dSurfCenter.z;
	mCSDData.bAutoOCenter = true;
	mCSDData.bDevInner = true;
	mCSDData.bFullD = true;
	if (pDSurf->initialize(mhSurf,mCSDData) != Acad::eOk) {
		delete pDSurf;
		acutPrintf("\n创建展开对象失败!");
		return;
	}

	AcDbDictionary *pSurfDDict;
	Acad::ErrorStatus es;
	es = getNODCompanyDictionary(SURFD_DICT,pSurfDDict,AcDb::kForWrite,true);
	if (es == Acad::eCreateInvalidName ) {
		es = createSurfDDict(pSurfDDict);
		if (es != Acad::eOk) {
			delete pDSurf;
			acutPrintf("\n创建展开对象字典失败!");
			return;
		}
	} else if (es != Acad::eOk) {
		delete pDSurf;
		return;
	}

	es = addSurfDDictEntry(pDSurf,pSurfDDict);
	pSurfDDict->close();
	if (es != Acad::eOk) {
		delete pDSurf;
		acutPrintf("\n添加展开对象到字典失败!");
		return;
	}

	AcDbObjectIdArray ids,dSurfIds;
	CSDAreaISO csdObj;
	ChGeLoop3dArray loops;
	pDSurf->getCSDObj(csdObj);

	AcDbHandle  hCSDObj;
	pDSurf->getAcDbHandle(hCSDObj);
	pDSurf->close();

	csdObj.getDSurfLoops(loops);
	AcDbObjectId objId;
	AcDbSpline *spl;
	int i,len,j,jlen;
	len = loops.length();
	for (i=0; i<len; i++) {
		jlen = loops[i].length();
		for (j=0; j<jlen; j++) {
			createSpline((loops[i])[j],spl);
			postToDb(spl,objId);
			spl->close();
			ids.append(objId);
		}
	}

	dSurfIds = createPlane(ids);

	AcDbObject *pObj;
	len = ids.length();
	for (i=0; i<len; i++) {
		acdbOpenObject(pObj,ids[i],AcDb::kForWrite);
		pObj->erase();
		pObj->close();
	}

	char handleStr[132];
	hCSDObj.getIntoAsciiBuffer(handleStr);
	struct resbuf *pRb,*pTemp;
	acdbRegApp(appName);
	pRb = acutNewRb(AcDb::kDxfRegAppName);
	pTemp = pRb;
	pTemp->resval.rstring
		= (char*) malloc(strlen(appName) + 1);
	strcpy(pTemp->resval.rstring, appName);
	pTemp->rbnext = acutNewRb(AcDb::kDxfXdHandle);
	pTemp = pTemp->rbnext;
	pTemp->resval.rstring
		= (char*) malloc(strlen(handleStr) + 1);
	strcpy(pTemp->resval.rstring, handleStr);

	len = dSurfIds.length();
	for (i=0; i<len; i++) {
		acdbOpenObject(pObj,dSurfIds[i],AcDb::kForRead);
		pObj->upgradeOpen();
		pObj->setXData(pRb);
		pObj->close();
	}
	if (len) {
		acutPrintf("\n成功创建展开平面!");
	} else {
		acutPrintf("\n创建展开对象失败!");
	}

	acutRelRb(pRb);
}


// This is command 'P2D' 曲面点展开
void ChP2D()
{
	// TODO: Implement the command
	AcDbEntity *pObj;
	int ret;
	ret = selectEntity("\n选择展开平面: ","ASSURFACE",pObj);
	if (ret != RTNORM) {
		acutPrintf("\n未选中任何展开平面!");
		return;
	}

	ChDbSurfD *pSurfD;
	if (getSurfDObjFromMainObj(pObj,pSurfD) != Acad::eOk) {
		acutPrintf("\n该曲面不是一个展开平面, 或者展开平面对应的展开对象不存在!");
		pObj->close();
		return;
	}
	pObj->close();

	if (pSurfD->isInitialized() != Adesk::kTrue) {
		pSurfD->upgradeOpen();
		if (pSurfD->initialize() != Acad::eOk) {
			pSurfD->close();
			acutPrintf("\n展开平面的原曲面已经删除或修改，请重新生成展开曲面!");
			return;
		}
	}

	// 输入原曲面上的点
	AcGePoint3d op,dp;
	acedInitGet(RSG_NONULL,NULL);
	ret = acedGetPoint(NULL,"\n输入原曲面上需要展开的点: ",asDblArray(op));
	if (ret==RTCAN) {
		pSurfD->close();
		return;
	}
	// 注意上步得到的是UCS下的坐标，要转换到世界坐标下
	acdbUcs2Wcs(asDblArray(op),asDblArray(op),false);

	if (pSurfD->mapPointToD(op,dp) != Acad::eOk) {
		pSurfD->close();
		acutPrintf("\n失败，请确认输入的是展开平面的原曲面上的点再试!");
		return;
	} else {
		AcDbPoint *pPnt;
		pPnt = new AcDbPoint(dp);
		postToDb(pPnt);
		pPnt->close();
		acutPrintf("\n成功创建展开点!");
	}
	pSurfD->close();
}

// This is command 'P2O' 展开平面点回映
void ChP2O()
{
	// TODO: Implement the command

	AcDbEntity *pObj;
	int ret;
	ret = selectEntity("\n选择展开平面: ","ASSURFACE",pObj);
	if (ret != RTNORM) {
		acutPrintf("\n未选中任何展开平面!");
		return;
	}
	
	ChDbSurfD *pSurfD;
	if (getSurfDObjFromMainObj(pObj,pSurfD) != Acad::eOk) {
		acutPrintf("\n该曲面不是一个展开平面, 或者展开平面对应的展开对象不存在!");
		pObj->close();
		return;
	}
	pObj->close();
	
	if (pSurfD->isInitialized() != Adesk::kTrue) {
		pSurfD->upgradeOpen();
		if (pSurfD->initialize() != Acad::eOk) {
			pSurfD->close();
			acutPrintf("\n展开平面的原曲面已经删除或修改，请重新生成展开曲面!");
			return;
		}
	}
	
	// 输入展开平面上的点
	AcGePoint3d op,dp;
	acedInitGet(RSG_NONULL,NULL);
	ret = acedGetPoint(NULL,"\n输入展开平面上需要回映的点: ",asDblArray(dp));
	if (ret==RTCAN) {
		pSurfD->close();
		return;
	}
	// 注意上步得到的是UCS下的坐标，要转换到世界坐标下
	acdbUcs2Wcs(asDblArray(dp),asDblArray(dp),false);
	
	if (pSurfD->mapPointToO(dp,op) != Acad::eOk) {
		pSurfD->close();
		acutPrintf("\n失败，请确认输入的是展开平面上的点再试!");
		return;
	} else {
		AcDbPoint *pPnt;
		pPnt = new AcDbPoint(op);
		postToDb(pPnt);
		pPnt->close();
		acutPrintf("\n成功创建回映点!");
	}
	pSurfD->close();
}

// This is command 'C2D' 曲面曲线展开
void ChC2D()
{
	// TODO: Implement the command
	AcDbEntity *pObj;
	int ret;
	ret = selectEntity("\n选择展开平面: ","ASSURFACE",pObj);
	if (ret != RTNORM) {
		acutPrintf("\n未选中任何展开平面!");
		return;
	}
	
	ChDbSurfD *pSurfD;
	if (getSurfDObjFromMainObj(pObj,pSurfD) != Acad::eOk) {
		acutPrintf("\n该曲面不是一个展开平面, 或者展开平面对应的展开对象不存在!");
		pObj->close();
		return;
	}
	pObj->close();
	
	if (pSurfD->isInitialized() != Adesk::kTrue) {
		pSurfD->upgradeOpen();
		if (pSurfD->initialize() != Acad::eOk) {
			pSurfD->close();
			acutPrintf("\n展开平面的原曲面已经删除或修改，请重新生成展开曲面!");
			return;
		}
	}
	
	// 输入原曲面上的曲线
	AcGePoint3dArray curve;
	AcDbCurve *pCurveObj;
	ret = selectCurve("\n选择原曲面上的曲线(ESC或RETURN退出):",pCurveObj);
	if (ret == RTCAN || ret == RTERROR) {
		pSurfD->close();
		return;
	}
	getPntsFromCurve(pCurveObj,curve);
	if (curve.length()<3) {
		getPntsFromCurve(pCurveObj,curve,MIN_POINTNUM);
	}
	pCurveObj->close();

	AcGePoint3dArray dcurve;
	
	if (pSurfD->mapPointsToD(curve,dcurve,false) != Acad::eOk) {
		pSurfD->close();
		acutPrintf("\n失败，请确认输入的是展开平面的原曲面上的曲线再试!");
		return;
	} else {
		AcDbSpline *spl;
		createSpline(dcurve,spl);
		postToDb(spl);
		spl->close();
		acutPrintf("\n成功创建展开曲线!");
	}
	pSurfD->close();
}

// This is command 'C2O' 展开平面曲线回映
void ChC2O()
{
	// TODO: Implement the command
	AcDbEntity *pObj;
	int ret;
	ret = selectEntity("\n选择展开平面: ","ASSURFACE",pObj);
	if (ret != RTNORM) {
		acutPrintf("\n未选中任何展开平面!");
		return;
	}
	
	ChDbSurfD *pSurfD;
	if (getSurfDObjFromMainObj(pObj,pSurfD) != Acad::eOk) {
		acutPrintf("\n该曲面不是一个展开平面, 或者展开平面对应的展开对象不存在!");
		pObj->close();
		return;
	}
	pObj->close();
	
	if (pSurfD->isInitialized() != Adesk::kTrue) {
		pSurfD->upgradeOpen();
		if (pSurfD->initialize() != Acad::eOk) {
			pSurfD->close();
			acutPrintf("\n展开平面的原曲面已经删除或修改，请重新生成展开曲面!");
			return;
		}
	}
	
	// 输入展开平面上的曲线
	AcGePoint3dArray dcurve;
	AcDbCurve *pCurveObj;
	ret = selectCurve("\n选择展开平面上的曲线(ESC或RETURN退出):",pCurveObj);
	if (ret == RTCAN || ret == RTERROR) {
		pSurfD->close();
		return;
	}
	getPntsFromCurve(pCurveObj,dcurve);
	if (dcurve.length()<3) {
		getPntsFromCurve(pCurveObj,dcurve,MIN_POINTNUM);
	}
	pCurveObj->close();
	
	AcGePoint3dArray curve;
	
	if (pSurfD->mapPointsToO(dcurve,curve,false) != Acad::eOk) {
		pSurfD->close();
		acutPrintf("\n失败，请确认输入的是展开平面上的曲线再试!");
		return;
	} else {
		AcDbSpline *spl;
		createSpline(curve,spl);
		postToDb(spl);
		spl->close();
		acutPrintf("\n成功创建回映曲线!");
	}
	pSurfD->close();

}



// This is command 'SURFDA' 高级曲面展开
void ChSURFDA()
{
	// TODO: Implement the command

	// 得到原曲面
	AcDbHandle mhSurf;
	CSDData mCSDData;
	
	int ret;

	AcDbEntity * pSurf;
	ret = selectEntity("\n选择曲面: ","ASSURFACE",pSurf);	
	if (ret != RTNORM) {
		return;
	}
	getBaseSurfaceAndLoops(pSurf,mCSDData.oBaseSurf,mCSDData.oSurfLoops);
	pSurf->getAcDbHandle(mhSurf);
	pSurf->close();

	// 输入展开中心，默认为自动计算展开中心
	//
	AcGePoint3d oSurfCenter;
    acedInitGet(RSG_OTHER, "Auto _Auto");
	ret = acedGetPoint(NULL,"\n输入展开中心 <回车自动计算>: ",asDblArray(oSurfCenter));
	if (ret==RTCAN) {
		return;
	} else if (ret==RTNONE || ret==RTKWORD) {
		mCSDData.bAutoOCenter = true;
	} else if (ret==RTNORM) {
		// 注意上步得到的是UCS下的坐标，要转换到世界坐标下
		acdbUcs2Wcs(asDblArray(oSurfCenter),asDblArray(oSurfCenter),false);
		mCSDData.bAutoOCenter = false;
		mCSDData.oCenter = oSurfCenter;
	}

	if (!mCSDData.bAutoOCenter) {
		// 输入展开区域
		//
		ads_real res;
		acedInitGet(RSG_NONEG|RSG_NOZERO|RSG_OTHER, "Full _Full");
		ret = acedGetDist(NULL,"\n指定展开区域: "
			"输入或指定展开中心到展开区域边界的距离 <回车全部展开>: ",&res);
		
		if (ret==RTCAN) {
			return;
		} else if (ret==RTNONE || ret==RTKWORD) {
			mCSDData.bFullD = true;
		} else if (ret==RTNORM) {
			mCSDData.bFullD = false;
			AcGeDoubleArray dists;
			dists.setLogicalLength(4);
			dists.setAll(res);
			getEvalSection(mCSDData,dists);
		}
	} else {
		mCSDData.bFullD = true;
	}

	// 输入展开计算网格数
	//
	char key[20];
    acedInitGet(RSG_OTHER, "Auto User");
	ret = acedGetKword("\n指定展开计算网格数: 自动(A)/指定(U) <A>: ",key);
	if (ret==RTCAN) {
		return;
	} else if (ret==RTNORM) {
		if ( strcmp(key,"User") == 0 ) {
			int res;
			acedInitGet(RSG_NONULL|RSG_NONEG|RSG_NOZERO,NULL);
			acedGetInt("\nU向离散网格数:",&res);
			mCSDData.nU = res;
			acedInitGet(RSG_NONULL|RSG_NONEG|RSG_NOZERO,NULL);
			acedGetInt("\nV向离散网格数:",&res);
			mCSDData.nV = res;
		}
	}

	// 输入展开平面基点
	//
	AcGePoint3d dSurfCenter;
	acedInitGet(RSG_NONULL,NULL);
	ret = acedGetPoint(NULL,"\n输入展开平面基点: ",asDblArray(dSurfCenter));
	if (ret==RTCAN) {
		return;
	}
	// 注意上步得到的是UCS下的坐标，要转换到世界坐标下
	acdbUcs2Wcs(asDblArray(dSurfCenter),asDblArray(dSurfCenter),false);

	ChDbSurfD *pDSurf;
	pDSurf = new ChDbSurfD();

	mCSDData.dCenter.set(dSurfCenter.x,dSurfCenter.y);
	mCSDData.dCenterZ = dSurfCenter.z;
	mCSDData.bDevInner = true;
	if (pDSurf->initialize(mhSurf,mCSDData) != Acad::eOk) {
		delete pDSurf;
		acutPrintf("\n创建展开对象失败!");
		return;
	}

	AcDbDictionary *pSurfDDict;
	Acad::ErrorStatus es;
	es = getNODCompanyDictionary(SURFD_DICT,pSurfDDict,AcDb::kForWrite,true);
	if (es == Acad::eCreateInvalidName ) {
		es = createSurfDDict(pSurfDDict);
		if (es != Acad::eOk) {
			delete pDSurf;
			acutPrintf("\n创建展开对象字典失败!");
			pSurfDDict->close();
			return;
		}
	} else if (es != Acad::eOk) {
		delete pDSurf;
		acutPrintf("\n获取展开对象字典失败!");
		return;
	}


	AcDbObjectIdArray ids,dSurfIds;
	CSDAreaISO csdObj;
	ChGeLoop3dArray loops;
	pDSurf->getCSDObj(csdObj);
	csdObj.getDSurfLoops(loops);
	if (loops.length() == 0) {
		delete pDSurf;
		pSurfDDict->close();
		acutPrintf("\n展开对象轮廓不存在!");
		return;
	}

	es = addSurfDDictEntry(pDSurf,pSurfDDict);
	pSurfDDict->close();
	if (es != Acad::eOk) {
		delete pDSurf;
		acutPrintf("\n添加展开对象到字典失败!");
		return;
	}

	AcDbHandle  hCSDObj;
	pDSurf->getAcDbHandle(hCSDObj);
	pDSurf->close();

	AcDbSpline *spl;
	AcDbObjectId objId;
	int i,len,j,jlen;
	len = loops.length();
	for (i=0; i<len; i++) {
		jlen = loops[i].length();
		for (j=0; j<jlen; j++) {
			createSpline((loops[i])[j],spl);
			postToDb(spl,objId);
			spl->close();
			ids.append(objId);
		}
	}

	dSurfIds = createPlane(ids);

	AcDbObject *pObj;
	len = ids.length();
	for (i=0; i<len; i++) {
		acdbOpenObject(pObj,ids[i],AcDb::kForWrite);
		pObj->erase();
		pObj->close();
	}	

	char handleStr[132];
	hCSDObj.getIntoAsciiBuffer(handleStr);
	struct resbuf *pRb,*pTemp;
	acdbRegApp(appName);
	pRb = acutNewRb(AcDb::kDxfRegAppName);
	pTemp = pRb;
	pTemp->resval.rstring
		= (char*) malloc(strlen(appName) + 1);
	strcpy(pTemp->resval.rstring, appName);
	pTemp->rbnext = acutNewRb(AcDb::kDxfXdHandle);
	pTemp = pTemp->rbnext;
	pTemp->resval.rstring
		= (char*) malloc(strlen(handleStr) + 1);
	strcpy(pTemp->resval.rstring, handleStr);

	len = dSurfIds.length();
	for (i=0; i<len; i++) {
		acdbOpenObject(pObj,dSurfIds[i],AcDb::kForRead);
		pObj->upgradeOpen();
		pObj->setXData(pRb);
		pObj->close();
	}
	if (len) {
		acutPrintf("\n成功创建展开平面!");
	} else {
		acutPrintf("\n创建展开对象失败!");
	}

	acutRelRb(pRb);
}