void
ArxDbgUtils::collectVertices(const AcDb3dPolyline* pline, AcGePoint3dArray& pts)
{
ASSERT(pline != NULL);
ASSERT(pts.isEmpty());
AcDbObjectIterator* vertexIter = pline->vertexIterator();
ASSERT(vertexIter != NULL);
if (vertexIter == NULL)
return;
AcDb3dPolylineVertex* vertex;
for (; !vertexIter->done(); vertexIter->step()) {
if (acdbOpenObject(vertex, vertexIter->objectId(), AcDb::kForRead) == Acad::eOk) {
if (vertex->vertexType() != AcDb::k3dControlVertex)
pts.append(vertex->position());
vertex->close();
}
}
delete vertexIter;
ASSERT(pts.isEmpty() == false);
if (pline->isClosed()) {
AcGePoint3d tmpPt = pts[0]; // used to be a bug in dynamic arrays (not sure if its still there??)
pts.append(tmpPt);
}
}
static void ExplodeGoafPolygon( const AcGePoint3dArray& polygon,
const AcGePoint3dArray& inner_polygon,
const AcGePoint3dArray& outer_polygon,
AcGePoint3dArray& spts, AcGePoint3dArray& epts )
{
int n = polygon.length();
for( int i = 0; i < n; i++ )
{
AcGePoint3d spt = polygon[i], ept = polygon[( i + 1 ) % n];
// 如果向外扩展的坐标没有发生变化
// 则使向内扩展坐标
if( spt == outer_polygon[2 * i] || ept == outer_polygon[2 * i + 1] )
{
spt = inner_polygon[i];
ept = inner_polygon[( i + 1 ) % n];
}
else
{
spt = outer_polygon[2 * i];
ept = outer_polygon[2 * i + 1];
}
spts.append( spt );
epts.append( ept );
}
}
static void AppendNewGoafPolygon( const AcGePoint3dArray& polygons,
const AcDbIntArray& polygon_counts,
const AcDbIntArray& colinearEdges,
const AcDbIntArray& parTypes,
const AcGePoint3dArray& ex_spts,
const AcGePoint3dArray& ex_epts,
const AcGeDoubleArray& ex_dirs,
const AcDbIntArray& linePos,
int k,
AcGePoint3dArray& spts,
AcGePoint3dArray& epts,
AcGeDoubleArray& dirs,
AcDbIntArray& gas_types,
AcDbIntArray& gas_linePos )
{
int s = 0;
for( int i = 0; i < k; i++ )
{
s += polygon_counts[i];
}
int t = s + polygon_counts[k];
for( int i = s; i < t; i++ )
{
if( colinearEdges[i] == 0 )
{
spts.append( ex_spts[i] );
epts.append( ex_epts[i] );
dirs.append( ex_dirs );
gas_types.append( parTypes[i] );
gas_linePos.append( linePos[i] );
}
}
}
void
ArxDbgUtils::collectVertices(const AcDb2dPolyline* pline, AcGePoint3dArray& pts,
AcGeDoubleArray& bulges, bool asWcsPts)
{
ASSERT(pline != NULL);
ASSERT(pts.isEmpty() && bulges.isEmpty());
AcDbObjectIterator* vertexIter = pline->vertexIterator();
ASSERT(vertexIter != NULL);
if (vertexIter == NULL)
return;
AcDb2dVertex* vertex;
for (; !vertexIter->done(); vertexIter->step()) {
if (acdbOpenObject(vertex, vertexIter->objectId(), AcDb::kForRead) == Acad::eOk) {
if (vertex->vertexType() != AcDb::k2dSplineCtlVertex) {
if (asWcsPts)
pts.append(pline->vertexPosition(*vertex)); // returns WCS
else
pts.append(vertex->position()); // returns ECS
bulges.append(vertex->bulge());
}
vertex->close();
}
}
delete vertexIter;
ASSERT(pts.isEmpty() == Adesk::kFalse);
if (pline->isClosed()) {
AcGePoint3d tmpPt = pts[0]; // used to be a bug in dynamic arrays (not sure if its still there??)
pts.append(tmpPt);
bulges.append(0.0);
}
}
//- Osnap points protocol
Acad::ErrorStatus SingleTunnelDraw::subGetOsnapPoints (
AcDb::OsnapMode osnapMode,
int gsSelectionMark,
const AcGePoint3d& pickPoint,
const AcGePoint3d& lastPoint,
const AcGeMatrix3d& viewXform,
AcGePoint3dArray& snapPoints,
AcDbIntArray& geomIds ) const
{
assertReadEnabled () ;
// 只捕捉1种类型的点：端点
if( osnapMode != AcDb::kOsModeEnd )
return Acad::eOk;
Acad::ErrorStatus es = Acad::eOk;
if ( osnapMode == AcDb::kOsModeEnd )
{
snapPoints.append( m_startPt );
snapPoints.append( m_endPt );
}
return es;
}
void DrawRect( AcGiWorldDraw* mode, const AcGePoint3d& insertPt, double angle, double width, double height, bool fill )
{
AcGiSubEntityTraits& traits = mode->subEntityTraits();
AcGeVector3d v1( AcGeVector3d::kXAxis ), v2( AcGeVector3d::kXAxis );
v1.rotateBy( angle, AcGeVector3d::kZAxis );
v2.rotateBy( angle + PI / 2, AcGeVector3d::kZAxis );
AcGePoint3dArray pts;
pts.append( CaclPt( insertPt, v1, width, v2, height ) );
v1.rotateBy( PI, AcGeVector3d::kZAxis );
pts.append( CaclPt( insertPt, v1, width, v2, height ) );
v2.rotateBy( PI, AcGeVector3d::kZAxis );
pts.append( CaclPt( insertPt, v1, width, v2, height ) );
v1.rotateBy( PI, AcGeVector3d::kZAxis );
pts.append( CaclPt( insertPt, v1, width, v2, height ) );
// 是否填充
AcGiFillType ft = traits.fillType();
traits.setFillType( fill ? kAcGiFillAlways : kAcGiFillNever );
mode->geometry().polygon( pts.length(), pts.asArrayPtr() );
traits.setFillType( ft );
}
static void DividArc( const AcGePoint3d& spt, const AcGePoint3d& ept, const AcGePoint3d& thirdPt,
int count, AcGePoint3dArray& pts )
{
pts.append( spt );
AcGeCircArc3d arc( spt, thirdPt, ept );
AcGePoint3d cnt = arc.center();
// double radius = arc.radius();
AcGeVector3d v1 = spt - cnt;
AcGeVector3d v2 = ept - cnt;
int c = ( arc.normal().z > 0 ? 1 : -1 ); // 弧线方向
double a1 = v1.angleTo( AcGeVector3d::kXAxis, -AcGeVector3d::kZAxis );
double a2 = v2.angleTo( AcGeVector3d::kXAxis, -AcGeVector3d::kZAxis );
double dq = abs( a2 - a1 ) / count;
//acutPrintf(_T("\na1:%.3f, a2:%.3f dq:%.3f c:%d"), a1, a2, dq, c);
for( int i = 1; i < count; i++ )
{
v1.rotateBy( c * dq, AcGeVector3d::kZAxis );
pts.append( cnt + v1 );
//acutPrintf(_T("\n点%d:(%d,%d)"),i,pts[i].x,pts[i].y);
}
pts.append( ept );
}
void DetermineHoleGEDraw::caclBackGroundMinPolygon( AcGePoint3dArray& pts )
{
pts.append(m_spt1);
pts.append(m_spt2);
pts.append(m_spt3);
pts.append(m_spt4);
}
Acad::ErrorStatus
AsdkSmiley::osnapQuad(
const AcGePoint3d& pickPoint,
AcGePoint3dArray& snapPoints) const
{
AcGeVector3d xoff(0,0,0);
AcGeVector3d yoff(0,0,0);
// Osnap quad to the face's quad points
//
xoff.x = yoff.y = radius();
AcGePoint3d center( center() );
snapPoints.append( center + xoff );
snapPoints.append( center + yoff );
snapPoints.append( center - xoff );
snapPoints.append( center - yoff );
// Osnap quad to the eyes' quad points
//
AcGePoint3dArray eyearray;
AcGePoint3d eyecen;
eyes( eyearray );
for( int i = 0; i < eyearray.length(); i++ ){
eyecen = eyearray.at( i );
xoff.x = meyesize;
yoff.y = meyesize;
snapPoints.append( eyecen + xoff );
snapPoints.append( eyecen + yoff );
snapPoints.append( eyecen - xoff );
snapPoints.append( eyecen - yoff );
}
return Acad::eOk;
}
bool
ArxDbgUtils::collectVertices(const AcDbPolygonMesh* pmesh, AcGePoint3dArray& pts,
int& mSize, int& nSize)
{
AcDbObjectIterator* vertexIter = pmesh->vertexIterator();
if (vertexIter == NULL)
return false;
Acad::ErrorStatus es;
AcDbPolygonMeshVertex* pVertex;
AcGePoint3d tmpPt;
if (pmesh->polyMeshType() == AcDb::kSimpleMesh) {
mSize = pmesh->mSize();
nSize = pmesh->nSize();
}
else {
mSize = pmesh->mSurfaceDensity();
nSize = pmesh->nSurfaceDensity();
}
int nCount = 0;
int totalCount = 0;
for (; !vertexIter->done(); vertexIter->step()) {
es = acdbOpenObject(pVertex, vertexIter->objectId(), AcDb::kForRead);
if (es != Acad::eOk) {
ArxDbgUtils::rxErrorMsg(es);
delete vertexIter;
return false;
}
pts.append(pVertex->position());
nCount++;
totalCount++;
if (nCount == nSize) {
if (pmesh->isNClosed()) {
tmpPt = pts[totalCount - nSize]; // work around bug by making temp copy (not sure if still a bug??)
pts.append(tmpPt);
totalCount++;
}
nCount = 0;
}
}
delete vertexIter;
if (pmesh->isNClosed())
nSize++;
if (pmesh->isMClosed()) {
mSize++;
for (int i=0; i<nSize; i++) {
tmpPt = pts[i]; // see note above
pts.append(tmpPt);
}
}
return true;
}
Acad::ErrorStatus DoubleArcTunnelDraw::subGetGripPoints( AcGePoint3dArray& gripPoints, AcDbIntArray& osnapModes, AcDbIntArray& geomIds ) const
{
assertReadEnabled () ;
gripPoints.append( m_startPt );
gripPoints.append( m_endPt );
gripPoints.append( m_thirdPt );
return Acad::eOk;
}
static void DrawLinePoints( AcGiWorldDraw* mode, const AcGePoint3dArray& pts )
{
int len = pts.length();
for( int i = 0; i < len - 1; i++ )
{
AcGePoint3dArray tpts;
tpts.append( pts[i] );
tpts.append( pts[i + 1] );
mode->geometry().worldLine( tpts.asArrayPtr() );
}
}
//- Grip points protocol
Acad::ErrorStatus SingleTunnelDraw::subGetGripPoints (
AcGePoint3dArray& gripPoints, AcDbIntArray& osnapModes, AcDbIntArray& geomIds ) const
{
assertReadEnabled () ;
//----- This method is never called unless you return eNotImplemented
//----- from the new getGripPoints() method below (which is the default implementation)
gripPoints.append( m_startPt );
gripPoints.append( m_endPt );
return Acad::eOk;
}
Adesk::Boolean SingleTunnelDraw::subWorldDraw( AcGiWorldDraw* mode )
{
assertReadEnabled () ;
AcGePoint3dArray pts;
pts.append( m_startPt );
pts.append( m_endPt );
mode->geometry().worldLine( pts.asArrayPtr() );
return Adesk::kTrue;
}
void
ArxDbgUtils::collectVertices(const AcDb2dPolyline* pline, AcGePoint3dArray& pts,
AcDbIntArray& types, AcGeDoubleArray& bulges,
AcGeDoubleArray& startWidths,
AcGeDoubleArray& endWidths, bool& hasWidth)
{
ASSERT(pline != NULL);
ASSERT(pts.isEmpty() && bulges.isEmpty());
hasWidth = false;
AcDbObjectIterator* vertexIter = pline->vertexIterator();
ASSERT(vertexIter != NULL);
if (vertexIter == NULL)
return;
AcDb2dVertex* vertex;
for (; !vertexIter->done(); vertexIter->step()) {
if (acdbOpenObject(vertex, vertexIter->objectId(), AcDb::kForRead) == Acad::eOk) {
if (vertex->vertexType() != AcDb::k2dSplineCtlVertex) {
pts.append(pline->vertexPosition(*vertex)); // returns WCS
bulges.append(vertex->bulge());
startWidths.append(vertex->startWidth());
endWidths.append(vertex->endWidth());
if (vertex->startWidth() || vertex->endWidth())
hasWidth = true;
types.append(vertex->vertexType());
}
vertex->close();
}
}
delete vertexIter;
ASSERT(pts.isEmpty() == false);
if (pline->isClosed()) {
AcGePoint3d tmpPt = pts[0]; // used to be a bug in dynamic arrays (not sure if its still there??)
pts.append(tmpPt);
bulges.append(0.0);
int tmpType = types[0];
types.append(tmpType);
double tmpWidth = startWidths[0];
startWidths.append(tmpWidth);
tmpWidth = endWidths[0];
endWidths.append(tmpWidth);
}
}
void
AsdkSmiley::eyes(AcGePoint3dArray& array) const
{
assertReadEnabled();
// left eye
AcGePoint3d eye = center();
eye[X] -= meyesapart / 2;
eye[Y] += meyesheight;
array.append(eye);
// right eye
eye[X] += meyesapart;
array.append(eye);
} // smiley eyes
void TailraceGEDraw::caclBackGroundMinPolygon( AcGePoint3dArray& pts )
{
//AcGeCircArc3d arc( m_pt2, m_pt0, m_pt3 );
//AcGePoint3d cnt = arc.center();
//double radius = arc.radius();
//AcGeVector3d v = pt - cnt;
//v.normalize();
DividArc( m_pt2, m_pt3, m_pt0, 90, pts );
pts.append(m_pt8);
pts.append(m_pt5);
pts.append(m_pt4);
}
void Additional_Class::Get_PolyLine_Point( AcDbObjectId PolyLineId,AcGePoint3dArray &PointArray )
{
AcDbEntity *pEnt_Temp = NULL;
Acad::ErrorStatus es = acdbOpenAcDbEntity(pEnt_Temp, PolyLineId, AcDb::kForRead);
if (es != Acad::eOk)
{
acutPrintf(_T("\nOPEN POLYLINE ERROR"));
return;
}
if (!pEnt_Temp->isKindOf(AcDbPolyline::desc()))
{
acutPrintf(_T("\nENTITY IS NOT POLYLINE"));
return;
}
AcDbPolyline *pPolyLine = AcDbPolyline::cast(pEnt_Temp);
int num = pPolyLine->numVerts();
AcGePoint3d Start_temp_PT,End_temp_PT;
for (int index=0; index<num; index++)
{
if (pPolyLine->segType(index) == AcDbPolyline::kLine)
{
AcGeLineSeg3d tempLine;
pPolyLine->getLineSegAt(index,tempLine);
Start_temp_PT = tempLine.startPoint();
End_temp_PT = tempLine.endPoint();
PointArray.append(Start_temp_PT);
PointArray.append(End_temp_PT);
}
else if (pPolyLine->segType(index) == AcDbPolyline::kArc)
{
AcGeCircArc2d tempArc;
pPolyLine->getArcSegAt(index,tempArc);
Start_temp_PT.set(tempArc.startPoint().x,tempArc.startPoint().y,0);
End_temp_PT.set(tempArc.endPoint().x,tempArc.endPoint().y,0);
PointArray.append(Start_temp_PT);
PointArray.append(End_temp_PT);
}
}
pEnt_Temp->close();
AcGeIntArray IndexArray;
for (int i=1; i<PointArray.length();i++)
{
if (PointArray[i] == PointArray[i-1])
{
IndexArray.append(i);
PointArray.remove(PointArray[i]);
}
}
}
void DrawCross( AcGiWorldDraw* mode, const AcGePoint3d& pt, double radius )
{
AcGeVector3d v( AcGeVector3d::kXAxis );
v *= radius;
for( int i = 0; i < 4; i++ )
{
AcGePoint3dArray pts;
pts.append( pt );
pts.append( pt + v );
mode->geometry().worldLine( pts.asArrayPtr() );
v.rotateBy( PI / 2, AcGeVector3d::kZAxis );
}
}
Acad::ErrorStatus PDSphere::getgrippoints(AcGePoint3dArray& gripArray) const
{
assertReadEnabled();
gripArray.append(m_ptCenter);
gripArray.append(m_ptCenter + AcGeVector3d(1,0,0)*m_dRadius);
gripArray.append(m_ptCenter + AcGeVector3d(0,1,0)*m_dRadius);
gripArray.append(m_ptCenter + AcGeVector3d(0,0,1)*m_dRadius);
gripArray.append(m_ptCenter + AcGeVector3d(-1,0,0)*m_dRadius);
gripArray.append(m_ptCenter + AcGeVector3d(0,-1,0)*m_dRadius);
gripArray.append(m_ptCenter + AcGeVector3d(0,0,-1)*m_dRadius);
return Acad::eOk;
}
static void FindPolygonLinePos( const AcDbVoidPtrArray& lines,
const AcGePoint3dArray& polygons,
const AcDbIntArray& polygon_counts,
int k,
AcDbIntArray& linePos )
{
int s = 0;
for( int i = 0; i < k; i++ )
{
s += polygon_counts[i];
}
int t = s + polygon_counts[k];
AcGePoint3dArray polygon;
for( int i = s; i < t; i++ )
{
polygon.append( polygons[i] );
}
int n = polygon.length();
for( int i = 0; i < n; i++ )
{
linePos.append( FindLineByPoints( lines, polygon[i], polygon[( i + 1 ) % n] ) );
}
}
Acad::ErrorStatus
rx_scanPline(AcDb2dPolyline* pline,
AcGePoint3dArray& points,
AcGeDoubleArray& bulges)
{
Acad::ErrorStatus es = Acad::eOk;
AcDb2dVertex* vert = NULL;
AcDbObjectId vId;
AcDbObjectIterator *vIter;
vIter = pline->vertexIterator();
for (; !vIter->done(); vIter->step()) {
vId = vIter->objectId();
if ( (es =pline->openVertex(vert, vId, AcDb::kForRead)) != Acad::eOk )
return es;
points.append(vert->position());
bulges.append(vert->bulge());
}
delete vIter;
return es;
}
//----- Implement Osnaps
Acad::ErrorStatus OarxEmployee::getOsnapPoints (
AcDb::OsnapMode osnapMode, int gsSelectionMark, const AcGePoint3d &pickPoint,
const AcGePoint3d &lastPoint, const AcGeMatrix3d &viewXform, AcGePoint3dArray &snapPoints,
AcDbIntArray &geomIds
) const {
//----- Make sure the object is open is read mode
assertReadEnabled () ;
switch ( osnapMode ) {
case AcDb::kOsModeNear:
case AcDb::kOsModeCen:
case AcDb::kOsModeIns:
snapPoints.append (center ()) ;
return (Acad::eOk) ;
case AcDb::kOsModeQuad:
case AcDb::kOsModeMid:
case AcDb::kOsModeEnd:
case AcDb::kOsModeNode:
case AcDb::kOsModePerp:
case AcDb::kOsModeTan:
default:
break;
}
return (Acad::eInvalidInput) ;
}
void
ArxDbgUtils::collectVertices(const AcDbPolyFaceMesh* pface, AcDbObjectIdArray& vfaces, AcGePoint3dArray& pts)
{
AcDbObjectIterator* vertexIter = pface->vertexIterator();
if (vertexIter == NULL)
return;
AcDbFaceRecord* vface;
AcDbPolyFaceMeshVertex* pfaceVertex;
AcDbObject* obj;
// walk through and seperate vfaces and vertices into two
// seperate arrays
Acad::ErrorStatus es;
for (; !vertexIter->done(); vertexIter->step()) {
es = acdbOpenObject(obj, vertexIter->objectId(), AcDb::kForRead);
if (es == Acad::eOk) {
if ((vface = AcDbFaceRecord::cast(obj)) != NULL)
vfaces.append(obj->objectId());
else if ((pfaceVertex = AcDbPolyFaceMeshVertex::cast(obj)) != NULL)
pts.append(pfaceVertex->position());
else {
ASSERT(0);
}
obj->close();
}
else
ArxDbgUtils::rxErrorMsg(es);
}
delete vertexIter;
}
static void YCROYCRO_CG_AddPolyline()
{
AcGePoint2d ptStart(0,0), ptEnd(100, 100);
CCreateEnt::CreatePolyline(ptStart, ptEnd, 1);
AcGePoint3d pt1(0, 0, 0), pt2(100, 0, 0), pt3(100, 100, 0);
AcGePoint3dArray points;
points.append(pt1);
points.append(pt2);
points.append(pt3);
CCreateEnt::Create3dPolyline(points);
CCreateEnt::CreatePolygon(AcGePoint2d::kOrigin, 6, 30, 0, 1);
AcGePoint2d pt(60, 70);
CCreateEnt::CreateRectangle(pt, ptEnd, 1);
pt.set(50, 50);
CCreateEnt::CreatePolyCircle(pt, 30, 1);
CCreateEnt::CreatePolyArc(pt, 50, CCalculation::GtoR(45), CCalculation::GtoR(225), 1);
}
Acad::ErrorStatus
AsdkSmiley::getGripPoints(
AcGePoint3dArray& gripPoints,
AcDbIntArray& osnapMasks,
AcDbIntArray& geomIds) const
{
assertReadEnabled();
// Grip points to face
//
AcGePoint3d center( center() );
gripPoints.append( center );
AcGeVector3d xoff( radius(), 0, 0 ),
yoff( 0, radius(), 0 );
gripPoints.append( center + xoff );
gripPoints.append( center + yoff );
gripPoints.append( center - xoff );
gripPoints.append( center - yoff );
// Grip points to mouth
//
AcGeLineSeg3d chord( mouthLeft(), mouthRight() );
gripPoints.append( mouthLeft() );
gripPoints.append( mouthRight() );
gripPoints.append( chord.midPoint() );
gripPoints.append( mouthBottom() );
// Grip points to eyes
//
AcGePoint3dArray eyearray;
AcGePoint3d eyecen;
eyes( eyearray );
for( int i = 0; i < eyearray.length(); i++ ){
eyecen = eyearray.at( i );
gripPoints.append( eyecen );
AcGeVector3d xoff( meyesize, 0, 0 ),
yoff( 0, meyesize, 0 );
gripPoints.append( eyecen + xoff );
gripPoints.append( eyecen + yoff );
gripPoints.append( eyecen - xoff );
gripPoints.append( eyecen - yoff );
}
return Acad::eOk;
}
Acad::ErrorStatus SphereNitrogenPipeDraw::subGetGripPoints( AcGePoint3dArray& gripPoints, AcDbIntArray& osnapModes, AcDbIntArray& geomIds ) const
{
assertReadEnabled () ;
gripPoints.append( m_pt );
return Acad::eOk;
}
Acad::ErrorStatus GasPumpGEDraw::subGetGripPoints( AcGePoint3dArray& gripPoints, AcDbIntArray& osnapModes, AcDbIntArray& geomIds ) const
{
assertReadEnabled () ;
gripPoints.append( m_startPt );
return Acad::eOk;
}
Acad::ErrorStatus PolyLineDirectionDraw::subGetGripPoints( AcGePoint3dArray& gripPoints, AcDbIntArray& osnapModes, AcDbIntArray& geomIds ) const
{
assertReadEnabled () ;
gripPoints.append( m_insertPt );
return Acad::eOk;
}
Acad::ErrorStatus asdkBolt::getGripPoints(AcGePoint3dArray& gripPoints,
AcDbIntArray& osnapModes,
AcDbIntArray& geomIds) const
{
assertReadEnabled();
gripPoints.append(position);
return Acad::eOk;
}
