 |
| Doslib - một sản phẩm miễn phí của McNeel |
void
transactCommand()
{
Adesk::Boolean interrupted;
Acad::ErrorStatus es = Acad::eOk;
AcDbObjectId savedCylinderId,savedExtrusionId;
// Create a poly and post it to the database.
//
acutPrintf("\nCreating a poly...Please supply the"
" required input.");
if ((es = createAndPostPoly()) != Acad::eOk)
return;
// Start a transaction.
//
AcTransaction *pTrans
= actrTransactionManager->startTransaction();
assert(pTrans != NULL);
acutPrintf("\n\n###### Started transaction one."
" ######\n");
// Select the poly and extrude it.
//
AcDbObject *pObj = NULL;
AsdkPoly *pPoly = NULL;
AcDb3dSolid *pSolid = NULL;
AcDbObjectId objId;
ads_name ename;
ads_point pickpt;
for (;;) {
switch (acedEntSel("\nSelect a polygon: ",
ename, pickpt))
{
case RTNORM:
acdbGetObjectId(objId, ename);
if ((es = pTrans->getObject(pObj, objId,
AcDb::kForRead)) != Acad::eOk)
{
acutPrintf("\nFailed to obtain an object"
" through transaction.");
actrTransactionManager->abortTransaction();
return;
}
assert(pObj != NULL);
pPoly = AsdkPoly::cast(pObj);
if (pPoly == NULL) {
acutPrintf("\nNot a polygon. Try again");
continue;
}
break;
case RTNONE:
case RTCAN:
actrTransactionManager->abortTransaction();
return;
default:
continue;
}
break;
}
// Now that a poly is created, convert it to a region
// and extrude it.
//
acutPrintf("\nWe will be extruding the poly.");
AcGePoint2d c2d = pPoly->center();
ads_point pt;
pt[0] = c2d[0]; pt[1] = c2d[1]; pt[2] = pPoly->elevation();
acdbEcs2Ucs(pt,pt,asDblArray(pPoly->normal()),Adesk::kFalse);
double height;
if (acedGetDist(pt, "\nEnter Extrusion height: ",
&height) != RTNORM)
{
actrTransactionManager->abortTransaction();
return;
}
if ((es = extrudePoly(pPoly, height,savedExtrusionId)) !=
Acad::eOk) {
actrTransactionManager->abortTransaction();
return;
}
// Create a cylinder at the center of the polygon of
// the same height as the extruded poly.
//
double radius = (pPoly->startPoint()
- pPoly->center()).length() * 0.5;
pSolid = new AcDb3dSolid;
assert(pSolid != NULL);
pSolid->createFrustum(height, radius, radius, radius);
AcGeMatrix3d mat(AcGeMatrix3d::translation(
pPoly->elevation()*pPoly->normal())*
AcGeMatrix3d::planeToWorld(pPoly->normal()));
pSolid->transformBy(mat);
// Move it up again by half the height along
// the normal.
//
AcGeVector3d x(1, 0, 0), y(0, 1, 0), z(0, 0, 1);
AcGePoint3d moveBy(pPoly->normal()[0] * height * 0.5,
pPoly->normal()[1] * height * 0.5,
pPoly->normal()[2] * height * 0.5);
mat.setCoordSystem(moveBy, x, y, z);
pSolid->transformBy(mat);
addToDb(pSolid, savedCylinderId);
actrTransactionManager
->addNewlyCreatedDBRObject(pSolid);
pSolid->draw();
acutPrintf("\nCreated a cylinder at the center of"
" the poly.");
// Start another transaction. Ask the user to select
// the extruded solid followed by selecting the
// cylinder. Make a hole in the extruded solid by
// subtracting the cylinder from it.
//
pTrans = actrTransactionManager->startTransaction();
assert(pTrans != NULL);
acutPrintf("\n\n###### Started transaction two."
" ######\n");
AcDb3dSolid *pExtrusion, *pCylinder;
if ((es = getASolid("\nSelect the extrusion: ", pTrans,
AcDb::kForWrite, savedExtrusionId, pExtrusion))
!= Acad::eOk)
{
actrTransactionManager->abortTransaction();
actrTransactionManager->abortTransaction();
return;
}
assert(pExtrusion != NULL);
if ((es = getASolid("\nSelect the cylinder: ", pTrans,
AcDb::kForWrite, savedCylinderId, pCylinder))
!= Acad::eOk)
{
actrTransactionManager->abortTransaction();
actrTransactionManager->abortTransaction();
return;
}
assert(pCylinder != NULL);
pExtrusion->booleanOper(AcDb::kBoolSubtract, pCylinder);
pExtrusion->draw();
acutPrintf("\nSubtracted the cylinder from the"
" extrusion.");
// At this point, the cylinder is a NULL solid. Erase it.
//
assert(pCylinder->isNull());
pCylinder->erase();
// Start another transaction and slice the resulting
// solid into two halves.
//
pTrans = actrTransactionManager->startTransaction();
assert(pTrans != NULL);
acutPrintf("\n\n##### Started transaction three."
" ######\n");
AcGeVector3d vec, normal;
AcGePoint3d sp,center;
pPoly->getStartPoint(sp);
pPoly->getCenter(center);
vec = sp - center;
normal = pPoly->normal().crossProduct(vec);
normal.normalize();
AcGePlane sectionPlane(center, normal);
AcDb3dSolid *pOtherHalf = NULL;
pExtrusion->getSlice(sectionPlane, Adesk::kTrue,
pOtherHalf);
assert(pOtherHalf != NULL);
// Move the other half three times the vector length
// along the vector.
//
moveBy.set(vec[0] * 3.0, vec[1] * 3.0, vec[2] * 3.0);
mat.setCoordSystem(moveBy, x, y, z);
pOtherHalf->transformBy(mat);
AcDbObjectId otherHalfId;
addToDb(pOtherHalf, otherHalfId);
actrTransactionManager
->addNewlyCreatedDBRObject(pOtherHalf);
pOtherHalf->draw();
pExtrusion->draw();
acutPrintf("\nSliced the resulting solid into half"
" and moved one piece.");
// Now abort transaction three, to return to the hole in
// the extrusion.
//
Adesk::Boolean yes = Adesk::kTrue;
if (getYOrN("\nLet's abort transaction three, yes?"
" [Y] : ", Adesk::kTrue, yes,interrupted) == Acad::eOk
&& yes == Adesk::kTrue)
{
acutPrintf("\n\n$$$$$$ Aborting transaction"
" three. $$$$$$\n");
actrTransactionManager->abortTransaction();
acutPrintf("\nBack to the un-sliced solid.");
pExtrusion->draw();
char option[256];
acedGetKword("\nHit any key to continue.", option);
} else {
acutPrintf("\n\n>>>>>> Ending transaction three."
" <<<<<<\n");
actrTransactionManager->endTransaction();
}
// Start another transaction (three again). This time,
// slice the solid along a plane that is perpendicular
// to the plane we used last time: that is the slice
// we really wanted.
//
pTrans = actrTransactionManager->startTransaction();
assert(pTrans != NULL);
acutPrintf("\n\n##### Started transaction three."
" ######\n");
moveBy.set(normal[0] * 3.0, normal[1] * 3.0,
normal[2] * 3.0);
normal = vec;
normal.normalize();
sectionPlane.set(center, normal);
pOtherHalf = NULL;
pExtrusion->getSlice(sectionPlane, Adesk::kTrue,
pOtherHalf);
assert(pOtherHalf != NULL);
mat.setCoordSystem(moveBy, x, y, z);
pOtherHalf->transformBy(mat);
addToDb(pOtherHalf, otherHalfId);
actrTransactionManager
->addNewlyCreatedDBRObject(pOtherHalf);
pOtherHalf->draw();
pExtrusion->draw();
acutPrintf("\nSliced the resulting solid into half"
" along a plane");
acutPrintf("\nperpendicular to the old one and moved"
" one piece.");
// Now, give the user the option to end all the transactions.
//
yes = Adesk::kFalse;
if (getYOrN("\nAbort transaction three?: ",
Adesk::kFalse, yes,interrupted) == Acad::eOk
&& yes == Adesk::kTrue)
{
acutPrintf("\n\n$$$$$$ Aborting transaction"
" three. $$$$$$\n");
actrTransactionManager->abortTransaction();
acutPrintf("\nBack to the un-sliced solid.");
} else {
acutPrintf("\n\n>>>>>> Ending transaction three."
" <<<<<<\n");
actrTransactionManager->endTransaction();
}
yes = Adesk::kFalse;
if (getYOrN("\nAbort transaction two?: ",
Adesk::kFalse, yes,interrupted) == Acad::eOk
&& yes == Adesk::kTrue)
{
acutPrintf("\n\n$$$$$$ Aborting transaction two."
" $$$$$$\n");
actrTransactionManager->abortTransaction();
acutPrintf("\nBack to separate extrusion and"
" cylinder.");
} else {
acutPrintf("\n\n>>>>>> Ending transaction two."
" <<<<<<\n");
actrTransactionManager->endTransaction();
}
yes = Adesk::kFalse;
if (getYOrN("\nAbort transaction one?: ",
Adesk::kFalse, yes,interrupted) == Acad::eOk
&& yes == Adesk::kTrue)
{
acutPrintf("\n\n$$$$$$ Aborting transaction one."
" $$$$$$\n");
actrTransactionManager->abortTransaction();
acutPrintf("\nBack to just the Poly.");
} else {
actrTransactionManager->endTransaction();
acutPrintf("\n\n>>>>>> Ending transaction one."
" <<<<<<\n");
}
}
static Acad::ErrorStatus
createAndPostPoly()
{
int nSides = 0;
while (nSides < 3) {
acedInitGet(INP_NNEG, "");
switch (acedGetInt("\nEnter number of sides: ",
&nSides))
{
case RTNORM:
if (nSides < 3)
acutPrintf("\nNeed at least 3 sides.");
break;
default:
return Acad::eInvalidInput;
}
}
ads_point center, startPt, normal;
if (acedGetPoint(NULL, "\nLocate center of polygon: ",
center) != RTNORM)
{
return Acad::eInvalidInput;
}
startPt[0] = center[0];
startPt[1] = center[1];
startPt[2] = center[2];
while (asPnt3d(startPt) == asPnt3d(center)) {
switch (acedGetPoint(center,
"\nLocate start point of polygon: ", startPt)) {
case RTNORM:
if (asPnt3d(center) == asPnt3d(startPt))
acutPrintf("\nPick a point different"
" from the center.");
break;
default:
return Acad::eInvalidInput;
}
}
// Set the normal to the plane of the polygon to be
// the same as the Z direction of the current UCS,
// (0, 0, 1) since we also got the center and
// start point in the current UCS. (acedGetPoint()
// returns in the current UCS.)
normal[X] = 0.0;
normal[Y] = 0.0;
normal[Z] = 1.0;
acdbUcs2Wcs(normal, normal, Adesk::kTrue);
acdbUcs2Ecs(center, center, normal, Adesk::kFalse);
acdbUcs2Ecs(startPt, startPt, normal, Adesk::kFalse);
double elev = center[2];
AcGePoint2d cen = asPnt2d(center),
start = asPnt2d(startPt);
AcGeVector3d norm = asVec3d(normal);
AsdkPoly *pPoly = new AsdkPoly;
if (pPoly==NULL)
return Acad::eOutOfMemory;
Acad::ErrorStatus es;
if ((es=pPoly->set(cen, start, nSides, norm,
"transactPoly",elev))!=Acad::eOk)
return es;
pPoly->setDatabaseDefaults(
acdbHostApplicationServices()->workingDatabase());
postToDb(pPoly);
return Acad::eOk;
}
// Extrudes the poly to a given height.
//
static Acad::ErrorStatus
extrudePoly(AsdkPoly* pPoly, double height, AcDbObjectId& savedExtrusionId)
{
Acad::ErrorStatus es = Acad::eOk;
// Explode to a set of lines.
//
AcDbVoidPtrArray lines;
pPoly->explode(lines);
// Create a region from the set of lines.
//
AcDbVoidPtrArray regions;
AcDbRegion::createFromCurves(lines, regions);
assert(regions.length() == 1);
AcDbRegion *pRegion
= AcDbRegion::cast((AcRxObject*)regions[0]);
assert(pRegion != NULL);
// Extrude the region to create a solid.
//
AcDb3dSolid *pSolid = new AcDb3dSolid;
assert(pSolid != NULL);
pSolid->extrude(pRegion, height, 0.0);
for (int i = 0; i < lines.length(); i++) {
delete (AcRxObject*)lines[i];
}
for (i = 0; i < regions.length(); i++) {
delete (AcRxObject*)regions[i];
}
// Now we have a solid. Add it to database, then
// associate the solid with a transaction. After
// this, transaction management is in charge of
// maintaining it.
//
pSolid->setPropertiesFrom(pPoly);
addToDb(pSolid, savedExtrusionId);
actrTransactionManager
->addNewlyCreatedDBRObject(pSolid);
pSolid->draw();
return Acad::eOk;
}
static Acad::ErrorStatus
getASolid(char* prompt,
AcTransaction* pTransaction,
AcDb::OpenMode mode,
AcDbObjectId checkWithThisId,
AcDb3dSolid*& pSolid)
{
AcDbObject *pObj = NULL;
AcDbObjectId objId;
ads_name ename;
ads_point pickpt;
for (;;) {
switch (acedEntSel(prompt, ename, pickpt)) {
case RTNORM:
AOK(acdbGetObjectId(objId, ename));
if (objId != checkWithThisId) {
acutPrintf("\n Select the proper"
" solid.");
continue;
}
AOK(pTransaction->getObject(pObj, objId, mode));
assert(pObj != NULL);
pSolid = AcDb3dSolid::cast(pObj);
if (pSolid == NULL) {
acutPrintf("\nNot a solid. Try again");
AOK(pObj->close());
continue;
}
break;
case RTNONE:
case RTCAN:
return Acad::eInvalidInput;
default:
continue;
}
break;
}
return Acad::eOk;
}
#define actrTransactionManager \
AcTransactionManager::cast(
acrxSysRegistry()->at(AC_TRANSACTION_MANAGER_OBJ))
// - asdkucsarx._test command (do not rename)
static void asdkucsarx_test(void)
{
Acad::ErrorStatus es;
AcDbUCSTableRecord *myUCS = new AcDbUCSTableRecord;
//define your own ucs
AcGePoint3d origin_point(0,0,0);
AcGeVector3d UCSXaxis(0,1,0);
AcGeVector3d UCSYaxis(1,0,0);
myUCS->setOrigin(origin_point);
myUCS->setXAxis(UCSXaxis);
myUCS->setYAxis(UCSYaxis);
es=myUCS->setName( _T("MyUCS"));
if (es != Acad::eOk)
{
acutPrintf(_T("\nFailed to set name"));
return;
}
AcDbObjectId UCSId;
AcDbSymbolTable *pUCSTable;
if (acdbHostApplicationServices()->workingDatabase()->
getUCSTable(pUCSTable,AcDb::kForWrite)==Acad::eOk)
{
es=pUCSTable->add(UCSId,myUCS);
es=pUCSTable->close();
es= myUCS->close();
}
else
{
acutPrintf(_T("\nFailed to get UCS table"));
return;
}
//To set the current UCS, I accessed
// the active AcDbViewportTableRecord
// and used setUCS to set the UCS I created as current.
AcDbViewportTable *pVT;
es = acedVports2VportTableRecords();
if (es != Acad::eOk)
{
acutPrintf(
_T("\nFailed to load vport info into vport table records"));
return;
}
es=acdbHostApplicationServices()->
workingDatabase()->getViewportTable(pVT,AcDb::kForRead);
if (es != Acad::eOk)
{
acutPrintf(_T("\nFailed to get vport table"));
pVT->close();
return;
}
AcDbViewportTableIterator* pIter = NULL;
es=pVT->newIterator(pIter);
if (es != Acad::eOk)
{
acutPrintf(_T("\nFailed to get vport table"));
pVT->close();
delete pIter;
return;
}
for (pIter->start();!pIter->done();pIter->step())
{
AcDbViewportTableRecord* pRec;
//it should be open for write mode
es=pIter->getRecord(pRec,AcDb::kForWrite);
if (es != Acad::eOk)
{
acutPrintf(
_T("\nFailed to get vport table record"));
pVT->close();
pRec->close();
delete pIter;
return;
}
TCHAR* name=NULL;
es=pRec->getName(name);
if (es != Acad::eOk)
{
acutPrintf(
_T("\nFailed to get name from vport table"));
pVT->close();
pRec->close();
delete pIter;
return;
}
if (_tcsicmp(name,_T("*ACTIVE"))==0)
{
es=pRec->setUcs(UCSId);
}
es=pRec->close();
}
es=acedVportTableRecords2Vports(); //force update
es=pVT->close();
delete pIter;
return ;
}
// Only works in paperspace
AcDbObjectId mCurViewportId = acedGetCurViewportObjectId();
if (mCurViewportId == AcDbObjectId::kNull)
{
acutPrintf(_T("\nCommand only works in paperspace."));
return;
}
AcDbViewport *pCurViewport;
if (Acad::eOk != acdbOpenObject(pCurViewport,mCurViewportId,
AcDb::kForRead))
{
acutPrintf(_T("\nCannot get active viewport."));
return;
}
if (pCurViewport->number() != 1)
{
acutPrintf(_T("\nCommand only works in paperspace."));
pCurViewport->close();
return;
}
pCurViewport->close();
// Ask for the position
ads_point pt1,pt2;
if (RTNORM != acedGetPoint(NULL,
_T("\nSelect first corner: "), pt1))
return;
if (RTNORM != acedGetCorner(pt1,
_T("\nSelect second corner: "), pt2))
return;
// Ask for the view to use
ACHAR mViewName[133];
if (RTNORM != acedGetString(0,
_T("\nEnter name of view to use: "), mViewName))
return;
// Create new viewport
AcDbViewport *pViewport = new AcDbViewport;
pViewport->setWidth(fabs(pt2[X] - pt1[X]));
pViewport->setHeight(fabs(pt2[Y] - pt1[Y]));
pViewport->setCenterPoint(AcGePoint3d(
pt1[X] + (pt2[X] - pt1[X]) / 2,
pt1[Y] + (pt2[Y] - pt1[Y]) / 2,
pt1[Z]));
// Append new viewport to paper space
AcDbBlockTable *pTable;
AcDbBlockTableRecord *pPsBTR;
if (Acad::eOk != acdbHostApplicationServices()->
workingDatabase()->getBlockTable(pTable, AcDb::kForRead))
{
acutPrintf(_T("\nCannot get block table."));
delete pViewport;
return;
}
if (Acad::eOk != pTable->getAt(ACDB_PAPER_SPACE, pPsBTR,
AcDb::kForWrite))
{
acutPrintf(_T("\nCannot access paper space."));
pTable->close();
delete pViewport;
return;
}
pTable->close();
AcDbObjectId mViewPortId;
if (Acad::eOk != pPsBTR->appendAcDbEntity(mViewPortId, pViewport))
{
acutPrintf(_T("\nCannot append viewport to paper space."));
pPsBTR->close();
delete pViewport;
return;
}
pPsBTR->close();
pViewport->setOn();
// Set the view
AcDbViewTable *pViewTable;
AcDbViewTableRecord *pViewTR;
if (Acad::eOk != acdbHostApplicationServices()->
workingDatabase()->getViewTable(pViewTable, AcDb::kForRead))
{
acutPrintf(_T("\nCannot get view table."));
pViewport->close();
return;
}
if (Acad::eOk != pViewTable->getAt(mViewName,
pViewTR, AcDb::kForRead))
{
acutPrintf(_T("\nCannot access view '%s'."), mViewName);
pViewport->close();
pViewTable->close();
return;
}
pViewTable->close();
if (acedSetCurrentView(pViewTR, pViewport)!=Acad::eOk)
acutPrintf(_T("\nFailed to set view"));
// Close the objects
pViewTR->close();
pViewport->close();
AcDbHatch::HatchStyle style() const;
Acad::ErrorStatus setStyle(AcDbHatch::HatchStyle hstyle);
Acad::ErrorStatus acqHatch1()
{
AcDbHatch* pHatch = new AcDbHatch();
// Set hatch plane
//
AcGeVector3d normal(0.0, 0.0, 1.0);
pHatch->setNormal(normal);
pHatch->setElevation(0.0);
// Set non associative hatch
//
pHatch->setAssociative(Adesk::kFalse);
// Set hatch pattern to SolidFill type
//
pHatch->setPattern(AcDbHatch::kPreDefined, "SOLID");
// Set hatch style to kNormal
//
pHatch->setHatchStyle(AcDbHatch::kNormal);
// Construct hatch external boundary
//
AcGePoint2dArray vertexPts;
AcGeDoubleArray vertexBulges;
vertexPts.setPhysicalLength(0).setLogicalLength(5);
vertexPts[0].set(2.0, 2.0);
vertexPts[1].set(8.0, 2.0);
vertexPts[2].set(8.0, 8.0);
vertexPts[3].set(2.0, 8.0);
vertexPts[4].set(2.0, 2.0);
vertexBulges.setPhysicalLength(0).setLogicalLength(5);
for (int i = 0; i < 5; i++)
vertexBulges[i] = 0.0;
// Append an external loop (rectangle) to hatch boundary
pHatch->appendLoop(AcDbHatch::kExternal, vertexPts, vertexBulges);
// Construct a circle
//
AcGePoint2d cenPt(5.0, 5.0);
double TWOPI = 2.0 * 3.1415926535897932;
AcGeCircArc2d *cirArc = new AcGeCircArc2d();
cirArc->setCenter(cenPt);
cirArc->setRadius(1.0);
cirArc->setAngles(0.0, TWOPI);
// Append an internal circular loop to hatch boundary
//
AcGeIntArray edgeTypes;
AcGeVoidPointerArray edgePtrs;
edgeTypes.append(AcDbHatch::kCirArc);
edgePtrs.append((void*)cirArc);
pHatch->appendLoop(AcDbHatch::kDefault, edgePtrs, edgeTypes);
// Elaborate solid fill
//
pHatch->evaluateHatch();
// Post hatch entity to database
//
AcDbObjectId newId;
postToModelSpace(pHatch, newId);
return eOk;
}
Acad::ErrorStatus acqHatch2()
{
AcDbHatch* pHatch = new AcDbHatch();
// Set hatch plane
//
AcGeVector3d normal(0.0, 0.0, 1.0);
pHatch->setNormal(normal);
pHatch->setElevation(0.0);
// Set hatch pattern to ANSI31 predefined type
//
pHatch->setHatchPattern(AcDbHatch::kPreDefined, "ANSI31");
// Set Associativity
//
pHatch->setAssociative(Adesk::kTrue);
// Construct database AcDbLines
//
AcGePoint2d vertexPts[4];
AcDbObjectId lineId, cirId, hatchId;
AcDbObjectIdArray dbObjIds;
AcDbLine *line;
vertexPts[0].set(2.0, 2.0, 0.0);
vertexPts[1].set(8.0, 2.0, 0.0);
vertexPts[2].set(8.0, 8.0, 0.0);
vertexPts[3].set(2.0, 8.0, 0.0);
for (int i = 0; i < 4; i++) {
line = new AcDbLine();
line->setStartPoint(vertexPts[i])
line->setEndPoint(vertexPts[(i == 3) ? 0 : i+1])
line->postToDb(line, lineId);
dbObjIds.append(lineId);
}
// Append an external rectangular loop to hatch boundary
//
pHatch->appendLoop(AcDbHatch::kExternal, dbObjIds);
// Create a AcDbCircle and post it to database
//
AcGePoint2d cenPt(5.0, 5.0, 0.0);
AcGeVector3d normal(0.0, 0.0, 1.0);
AcDbCircle *circle = new AcDbCircle();
circle->setNormal(normal);
circle->setCenter(cenPt);
circle->setRadius(1.0);
circle->postToDb(circle, cirId);
dbObjIds.setLogicalLength(0);
dbObjIds.append(cirId);
// Append an internal loop (circle) to hatch boundary
//
pHatch->appendLoop(AcDbHatch::kDefault, dbObjIds);
// Elaborate hatch lines
//
pHatch->evaluateHatch();
// Get all associative source boundary object Ids for later use.
//
dbObjIds.setLogicalLength(0);
pHatch->getAssocObjIds(dbObjIds);
// Post hatch entity to database
//
pHatch->postToDb(pHatch, hatchId);
// Attach hatchId to all source boundary objects for notification.
//
AcDbEntity *pEnt;
int numObjs = dbObjIds.length();
Acad::ErrorStatus es;
for (i = 0; i < numObjs; i++) {
es = acdbOpenAcDbEntity(pEnt, dbObjIds[i], AcDb::kForWrite);
if (es == Acad::eOk) {
pEnt->addPersistentReactor(hatchId);
pEnt->close();
}
}
return eOk;
}
Acad::ErrorStatus GetLength(AcDbObjectId id, double& length)
{
Acad::ErrorStatus es;
AcDbCurve* pEnt;
es = acdbOpenObject(pEnt, id, AcDb::kForRead);
if( es == Acad::eOk && pEnt)
{
double startParam, endParam, startDist, endDist;
es = pEnt->getStartParam(startParam);
if( es!=Acad::eOk ) { pEnt->close(); return es; }
es = pEnt->getEndParam(endParam);
if( es!=Acad::eOk ) { pEnt->close(); return es; }
es = pEnt->getDistAtParam(startParam, startDist);
if( es!=Acad::eOk ) { pEnt->close(); return es; }
es = pEnt->getDistAtParam(endParam, endDist);
if( es!=Acad::eOk ) { pEnt->close(); return es; }
es = pEnt->close();
length = endDist - startDist;
}
return es;
}
| Π(pi, wi, pj, wj) = pipj 2 - wi - wj . |
| | |
| | |
File: examples/Triangulation_2/regular.cpp
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Regular_triangulation_euclidean_traits_2.h>
#include <CGAL/Regular_triangulation_filtered_traits_2.h>
#include <CGAL/Regular_triangulation_2.h>
#include <fstream>
typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
typedef CGAL::Regular_triangulation_filtered_traits_2<K> Traits;
typedef CGAL::Regular_triangulation_2<Traits> Regular_triangulation;
int main()
{
std::ifstream in("data/regular.cin");
Regular_triangulation::Weighted_point wp;
int count = 0;
std::vector<Regular_triangulation::Weighted_point> wpoints;
while(in >> wp){
count++;
wpoints.push_back(wp);
}
Regular_triangulation rt(wpoints.begin(), wpoints.end());
rt.is_valid();
std::cout << "number of inserted points : " << count << std::endl;
std::cout << "number of vertices : " ;
std::cout << rt.number_of_vertices() << std::endl;
std::cout << "number of hidden vertices : " ;
std::cout << rt.number_of_hidden_vertices() << std::endl;
return 0;
}
