[求助]]：[ARX程序]：求助!!!急急急急!!!!!!!!!!!

mx1979

我现在在用ARX做程序!!现在遇到了这样的问题!!在brep例程中给出了如何遍历3dSolid实体的所有面,也给出了如何把一个面划分网格的程序!!可现在我把循环访问实体的所有面,然后在小网格上显示颜色,于是就想把上面两段程序连起来,这就时循环调用面的划分网格程序!!执行中,程序划分了第一个面,在划分第2个面的时候,就不能在划分网格了!!请问怎么解决!!!非常急急急急!!!!!!!!!!!

下面是我给的程序代码:
static void test()
{
AcBr::ErrorStatus returnValue=AcBr::eOk;
Acad::ErrorStatus acadReturnValue = Acad::eOk;

AcDb3dSolid *pEnt;
AcGePoint3d pickPnt;
ads_name ent;
AcDbObjectId objId;
AcBrBrep brepEntity;
AcBrBrepFaceTraverser brepFaceTrav;
int faceCount;
AcBrFace brepFace;

acedEntSel("\n Pick a solid\n", ent, asDblArray(pickPnt));

acadReturnValue=acdbGetObjectId(objId,ent);
if(acadReturnValue!= Acad::eOk)
{
acutPrintf("\n Error in getting AcDbObjecyId:");
return ;
}

acadReturnValue=acdbOpenObject(pEnt,objId,AcDb::kForRead);
if(acadReturnValue!= Acad::eOk)
{
acutPrintf("\n Error in opening AcDbEntity:");
return ;
}

returnValue=brepEntity.set((const AcDbEntity&)*pEnt);
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in AcBrBrep::set:");
return ;
}

returnValue=brepFaceTrav.setBrep(brepEntity);
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in AcBrBrepFaceTraverser::setBrep:");
return ;
}

faceCount=0;
while (!brepFaceTrav.done() && (returnValue == AcBr::eOk))
{
returnValue=brepFaceTrav.getFace(brepFace);
if(returnValue!=AcBr::eOk)
{
acutPrintf("\n Error in AcBrBrepFaceTraverser::getFace:");
return ;
}

returnValue = faceMesh(brepFace);
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in faceMesh:");
return ;
}

faceCount++;
returnValue = brepFaceTrav.next();
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in AcBrBrepFaceTraverser::next:");
return ;
}

}

pEnt->close();
acutPrintf("\n ***brep has %d faces.\n",faceCount);

}

static AcBr::ErrorStatus
faceMesh(const AcBrFace& faceEntity)
{
AcBr::ErrorStatus returnValue = AcBr::eOk;

// Verify that AcBr was explicitly and not implicitly loaded,
// by testing ObjectARX functions (which are unavailable unless
// explicitly loaded)
if (faceEntity.isA() == NULL)
{
acutPrintf("\n faceMesh: AcBrEntity::isA() failed\n");
return returnValue;
}
if (!faceEntity.isKindOf(AcBrFace::desc()))
{
acutPrintf("\n faceMesh: AcBrEntity::isKindOf() failed\n");
return returnValue;
}
AcBrEntity* entClass = (AcBrEntity*)&faceEntity;
AcBrEdge* pEdge = AcBrEdge::cast(entClass);
if (pEdge != NULL)
{
acutPrintf("\n faceMesh: AcBrEntity::cast() failed\n");
return (AcBr::ErrorStatus)eNotThatKindOfClass;
}

AcGe::EntityId entId;
returnValue = faceEntity.getSurfaceType(entId);
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in AcBrFace::getSurfaceType:");
return returnValue;
}

AcGeSurface* surfaceGeometry = NULL;
AcGeSurface* nativeGeometry = NULL;

// NOTE: ignore unsupported geometry types for now, since we already know
// that elliptic cylinders and elliptic cones are rejected by AcGe, but we
// can still perform useful evaluations on the external bounded surface.
returnValue = getNativeSurface(faceEntity, surfaceGeometry, nativeGeometry);
if ((returnValue != AcBr::eOk) && (returnValue != (AcBr::ErrorStatus)Acad::eInvalidInput))
{
acutPrintf("\n Error in getNativeSurface:");
delete surfaceGeometry;
delete nativeGeometry;
return returnValue;
}

// conditionally set the mesh controls based on surface type
AcBrMesh2dControl meshCtrl;
switch (entId)
{
case(kPlane):
acutPrintf("\nSurface Type: Plane\n");
if ((returnValue = meshCtrl.setMinSubdivisionsInU()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMinSubdivisionsInV()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxSubdivisions()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxNodeSpacing(kMaxNodeSpacing)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setAngTol(90.0 * kDeg2Rad)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setDistTol(kDistTol)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxAspectRatio(kMaxAspectRatio)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setElementShape(AcBr::kAllQuadrilaterals)) != eOk)
return returnValue;
break;
case(kSphere):
acutPrintf("\nSurface Type: Sphere\n");
if ((returnValue = meshCtrl.setMinSubdivisionsInU(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMinSubdivisionsInV(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxSubdivisions()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxNodeSpacing(kMaxNodeSpacing)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setAngTol()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setDistTol(kDistTol)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxAspectRatio(kMaxAspectRatio)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setElementShape(AcBr::kAllQuadrilaterals)) != eOk)
return returnValue;
break;
case(kTorus):
acutPrintf("\nSurface Type: Torus\n");
if ((returnValue = meshCtrl.setMinSubdivisionsInU(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMinSubdivisionsInV(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxSubdivisions()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxNodeSpacing(kMaxNodeSpacing)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setAngTol()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setDistTol(kDistTol)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxAspectRatio(kMaxAspectRatio)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setElementShape(AcBr::kAllQuadrilaterals)) != eOk)
return returnValue;
break;
case(kCylinder):
acutPrintf("\nSurface Type: Circular Cylinder\n");
if ((returnValue = meshCtrl.setMinSubdivisionsInU(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMinSubdivisionsInV(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxSubdivisions()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxNodeSpacing(kMaxNodeSpacing)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setAngTol()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setDistTol(kDistTol)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxAspectRatio(kMaxAspectRatio)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setElementShape(AcBr::kAllQuadrilaterals)) != eOk)
return returnValue;
break;
case(kCone):
acutPrintf("\nSurface Type: Circular Cone\n");
if ((returnValue = meshCtrl.setMinSubdivisionsInU(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMinSubdivisionsInV(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxSubdivisions()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxNodeSpacing(kMaxNodeSpacing)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setAngTol()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setDistTol(kDistTol)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxAspectRatio(kMaxAspectRatio)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setElementShape(AcBr::kAllQuadrilaterals)) != eOk)
return returnValue;
break;
case(kNurbSurface):
acutPrintf("\nSurface Type: NURB Surface\n");
if ((returnValue = meshCtrl.setMinSubdivisionsInU(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMinSubdivisionsInV(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxSubdivisions()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxNodeSpacing(kMaxNodeSpacing)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setAngTol(30.0 * kDeg2Rad)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setDistTol(kDistTol)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxAspectRatio(kMaxAspectRatio)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setElementShape(AcBr::kAllQuadrilaterals)) != eOk)
return returnValue;
break;
// NOTE: This surface is not yet supported in AcGe, so we infer the definition
// data by analysing evaluated data on the external bounded surface.
case(kEllipCylinder):
acutPrintf("\nSurface Type: Elliptic Cylinder\n");
if ((returnValue = meshCtrl.setMinSubdivisionsInU(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMinSubdivisionsInV(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxSubdivisions()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxNodeSpacing(kMaxNodeSpacing)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setAngTol()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setDistTol(kDistTol)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxAspectRatio(kMaxAspectRatio)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setElementShape(AcBr::kAllQuadrilaterals)) != eOk)
return returnValue;
break;
// NOTE: This surface is not yet supported in AcGe, so we infer the definition
// data by analysing evaluated data on the external bounded surface.
case(kEllipCone):
acutPrintf("\nSurface Type: Elliptic Cone\n");
if ((returnValue = meshCtrl.setMinSubdivisionsInU(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMinSubdivisionsInV(2L)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxSubdivisions()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxNodeSpacing(kMaxNodeSpacing)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setAngTol()) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setDistTol(kDistTol)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setMaxAspectRatio(kMaxAspectRatio)) != eOk)
return returnValue;
if ((returnValue = meshCtrl.setElementShape(AcBr::kAllQuadrilaterals)) != eOk)
return returnValue;
break;
default:
acutPrintf("\nSurface Type: Unexpected Non Surface\n");
return (AcBr::ErrorStatus)Acad::eInvalidInput;
} // end switch(entId)
delete nativeGeometry;

// make the mesh filter from the topology entity and the mesh controls
AcBrEntity* meshEnt = (AcBrEntity*)&faceEntity;
AcBrMesh2dFilter meshFilter;
meshFilter.insert(make_pair(meshEnt, (const AcBrMesh2dControl)meshCtrl));

// generate the mesh, display any errors and attempt to dump all
// generated elements (most errors are not fatal so we want to do
// the best we can with whatever subset of the face was meshed).
AcBrMesh2d faceMesh;
if ((returnValue = faceMesh.generate(meshFilter)) != eOk)
{
acutPrintf("\n Error in AcBrMesh2d::generate:");
return returnValue;
}

// check to see if the mesh owner is the face we used in the filter
AcBrEntity* meshOwner = NULL;
if ((returnValue = faceMesh.getEntityAssociated(meshOwner)) != eOk)
{
acutPrintf("\n Error in AcBrMesh2d::getEntityAssociate:");
return returnValue;
}
if (!meshEnt->isEqualTo(meshOwner))
{
acutPrintf("\nMesh owner is not the face we asked to mesh!");
}

// dump or display the elements (regardless of incomplete mesh)
returnValue = meshDisplay(faceMesh);

return returnValue;
}

static AcBr::ErrorStatus
meshDisplay(const AcBrMesh2d& mesh)
{
AcBr::ErrorStatus returnValue = AcBr::eOk;

// make a global element traverser
AcBrMesh2dElement2dTraverser meshElemTrav;
returnValue = meshElemTrav.setMesh(mesh);
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in AcBrMesh2dElement2dTraverser::setMesh:");
return returnValue;
}

// display the elements
while (!meshElemTrav.done() && (returnValue == AcBr::eOk) && !acedUsrBrk())
{
// convert the nodes into a 3d point array for AcDbPolyline
AcGePoint3dArray pts;

AcBrElement2dNodeTraverser elemNodeTrav;
returnValue = elemNodeTrav.setElement(meshElemTrav);
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in AcBrElement2dNodeTraverser::setElement:");
return returnValue;
}

while (!elemNodeTrav.done() && (returnValue == AcBr::eOk))
{
AcBrNode node;
returnValue = elemNodeTrav.getNode(node);
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in AcBrElement2dNodeTraverser::getNode:");
return returnValue;
}

// add the node geometry data to the lightweight polyline point array
returnValue = nodeDisplay(node, pts);
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in nodeDisplay:");
return returnValue;
}

returnValue = elemNodeTrav.next();
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in AcBrElement2dNodeTraverser::next:");
return returnValue;
}
} // end element while

// create a simple, closed polygon from the element node list
AcDbFace* pFace;
if(pts.logicalLength()==4)
{
pFace = new AcDbFace(pts[0], pts[1], pts[2], pts[3], Adesk::kTrue,
Adesk::kTrue, Adesk::kTrue, Adesk::kTrue);
if (pFace == NULL)
{
returnValue = (AcBr::ErrorStatus)Acad::eOutOfMemory;
acutPrintf("\n Unable to allocate memory for face");
return returnValue;
}
}
else if(pts.logicalLength()==3)
{
pFace = new AcDbFace(pts[0], pts[1], pts[2], Adesk::kTrue,
Adesk::kTrue, Adesk::kTrue, Adesk::kTrue);
if (pFace == NULL)
{
returnValue = (AcBr::ErrorStatus)Acad::eOutOfMemory;
acutPrintf("\n Unable to allocate memory for face");
return returnValue;
}
}
else
{
delete pFace;
return (AcBr::ErrorStatus)Acad::eOutOfMemory;
}

pFace->setColorIndex(2);

// post the polyline to the database (this should display the element)
AcDbObjectId objId;
if (addToDatabase(pFace, objId) != AcBr::eOk)
{
acutPrintf("\n addToDatabase failed");
return returnValue;
}

// close the database object
if (pFace->close() != AcBr::eOk)
{
acutPrintf("\n AcDb3dPolyline::close() failed");
return returnValue;
}

returnValue = meshElemTrav.next();
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in AcBrMesh2dElement2dTraverser::next:");
return returnValue;
}

} // end mesh while

return returnValue;
}

static AcBr::ErrorStatus
getNativeSurface(const AcBrFace& faceEntity,
AcGeSurface*& surfaceGeometry,
AcGeSurface*& nativeGeometry)
{
AcBr::ErrorStatus returnValue = faceEntity.getSurface(surfaceGeometry);
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in AcBrFace::getSurface:");
return returnValue;
}
if (surfaceGeometry == NULL)
{
acutPrintf("\n getNativeSurface: external bounded surface is undefined\n");
returnValue = AcBr::eMissingGeometry;
return returnValue;
}
if (surfaceGeometry->type() != kExternalBoundedSurface)
{
acutPrintf("\n getNativeSurface: surface is not an external bounded surface\n");
returnValue = AcBr::eMissingGeometry;
return returnValue;
}
AcGeExternalSurface baseGeometry;
((AcGeExternalBoundedSurface*)surfaceGeometry)->getBaseSurface(baseGeometry);
if (!baseGeometry.isDefined())
{
acutPrintf("\n getNativeSurface: external surface is undefined\n");
returnValue = AcBr::eMissingGeometry;
return returnValue;
}
if (!baseGeometry.isNativeSurface(nativeGeometry) || (nativeGeometry == NULL))
{
acutPrintf("\n getNativeSurface: native surface is undefined\n");
returnValue = AcBr::eMissingGeometry;
return returnValue;
}
return returnValue;
}

static AcBr::ErrorStatus
nodeDisplay(const AcBrNode& node, AcGePoint3dArray& pts)
{
AcBr::ErrorStatus returnValue = AcBr::eOk;

AcGePoint3d nodePoint;
returnValue = node.getPoint(nodePoint);
if (returnValue != AcBr::eOk)
{
acutPrintf("\n Error in AcBrNode::getPoint:");
return returnValue;
}
pts.append((const AcGePoint3d&)nodePoint);

return returnValue;
}

static Acad::ErrorStatus
addToDatabase(AcDbEntity* pEnt, AcDbObjectId& objId)
{
Acad::ErrorStatus acadReturnValue = Acad::eOk;
AcDbBlockTable* pBlockTable;
AcDbBlockTableRecord* pSpaceRecord;

AcDbDatabase *pCurDwg = acdbHostApplicationServices()->workingDatabase();
if (pCurDwg==NULL)
return Acad::eNoDatabase;

if ((acadReturnValue = pCurDwg->getBlockTable(pBlockTable,
AcDb::kForRead)) != Acad::eOk)
{
acutPrintf("\n acdbCurDwg()->getBlockTable() failed");
return acadReturnValue;
}

if ((acadReturnValue = pBlockTable->getAt(ACDB_MODEL_SPACE,
pSpaceRecord, AcDb::kForWrite)) != Acad::eOk)
{
acutPrintf("\n AcDbBlockTable::getAt() failed");
return acadReturnValue;
}

// close the block table object
if ((acadReturnValue = pBlockTable->close()) != Acad::eOk)
{
acutPrintf("\n AcDbBlockTable::close() failed");
return acadReturnValue;
}

// append the entity to the display list
if ((acadReturnValue = pSpaceRecord->appendAcDbEntity(objId, pEnt)) != Acad::eOk)
{
acutPrintf("\n AcDbBlockTableRecord::appendAcDbEntity() failed");
return acadReturnValue;
}

// close the block table record object
if ((acadReturnValue = pSpaceRecord->close()) != Acad::eOk)
{
acutPrintf("\n AcDbBlockTableRecord::close() failed");
return acadReturnValue;
}

return acadReturnValue;
}