ÇúÏß×ª»»Àà - AutoCAD.net/VB.net/C# ±à³Ì¼¼Êõ - AutoCADÂÛÌ³ - Ã÷¾CADÉçÇø - µÚ2Ò³

highflybird ·¢±íÓÚ 2010-7-29 10:26:00

ÎÒÒ²À´·¢Ò»¸öarx°æ±¾µÄ£¬¹ØÓÚsplineºÍ3dpolyline,ÒÔ¼°2dpolylineµÄ´¦Àí±È½Ï¸´ÔÓ¡£
ÁíÍâ¸Ð¾õÂ¥Ö÷µÄÁ½¸öµØ·½¿¼ÂÇÇ·Í×¡£
1¡¢ÊÇ¶ÔÓÚpolyline ÔÚ3d¿Õ¼ä×´Ì¬ÏÂµÄ×ª»»Èç¹ûnormal²»ÊÇ(0,0,1)£¬»á³öÎÊÌâ¡£
2¡¢¶ÔÓÚsplineµÄ´¦Àí£¬ÓÃNurbµÃµ½µÄÈç¹û×ª³ÉAcDbSpline,ÔÚ·â±ÕÇé¿öÏÂ£¬»á¸úÔÀ´µÄ²»Ò»ÖÂ¡£

ÌØ±ð¸ÐÐ»Â¥Ö÷µÄ´úÂë£¬ÎÒ×ª»¯ÎªarxµÄÊ±ºò´ÓÖÐÊÜÒæÆÄ¶à¡£

#include "Conversion.h"
// LINE
Acad::ErrorStatus AcDbCurveToAcGeCurve(AcGeCurve3d * &pGe,const AcDbLine * pLine)
{
pGe = new AcGeLineSeg3d(pLine->startPoint(), pLine->endPoint());
return Acad::eOk;
}
Acad::ErrorStatus AcGeCurveToAcDbCurve(AcDbCurve * &pDb,const AcGeLineSeg3d * pGe)
{
pDb= new AcDbLine(pGe->startPoint(),pGe->endPoint());
return Acad::eOk;
}
// ARC
Acad::ErrorStatusAcDbCurveToAcGeCurve(AcGeCurve3d * &pGe,const AcDbArc * pDbArc)
{
pGe =new AcGeCircArc3d(
pDbArc->center(),
pDbArc->normal(),
pDbArc->normal().perpVector(),
pDbArc->radius(),
pDbArc->startAngle(),
pDbArc->endAngle());
return Acad::eOk;
}
Acad::ErrorStatus AcGeCurveToAcDbCurve(AcDbCurve * &pDb,const AcGeCircArc3d * pGe)
{
if (pGe->isClosed())
{
pDb = new AcDbCircle(pGe->center(),pGe->normal(),pGe->radius());
}
else
{
pDb = new AcDbArc(pGe->center(),pGe->normal(),pGe->radius(),pGe->startAng(),pGe->endAng());
}
return Acad::eOk;
}

// CIRCLE
Acad::ErrorStatusAcDbCurveToAcGeCurve(AcGeCurve3d * &pGe,const AcDbCircle * pDbCircle)
{
pGe =new AcGeCircArc3d(pDbCircle->center(),pDbCircle->normal(),pDbCircle->radius());
return Acad::eOk;
}

// ELLIPSE
Acad::ErrorStatusAcDbCurveToAcGeCurve(AcGeCurve3d * &pGe,const AcDbEllipse * pDb)
{
pGe =new AcGeEllipArc3d(
pDb->center(),
pDb->majorAxis(),
pDb->minorAxis(),
pDb->majorAxis().length(),
pDb->minorAxis().length(),
pDb->startAngle(),
pDb->endAngle());
return Acad::eOk;
}
Acad::ErrorStatusAcGeCurveToAcDbCurve(AcDbCurve * &pDb,const AcGeEllipArc3d * pGe)
{
pDb = new AcDbEllipse(
pGe->center(),
pGe->normal(),
pGe->majorAxis()*pGe->majorRadius(),
pGe->minorRadius()/pGe->majorRadius(),
pGe->startAng(),
pGe->endAng());
return Acad::eOk;
}
// SPLINE
Acad::ErrorStatus AcDbCurveToAcGeCurve(AcGeCurve3d * &pGe,const AcDbSpline * pSpline,bool isFit)
{
Acad::ErrorStatus es;
int degree;
double fitTolerance,controlPtTol,knotTol;
Adesk::Boolean tangentsExist,tangentStartDef,tangentEndDef,bIsRational,bIsPeriodic,bIsClosed;
AcGeVector3d startTangent,endTangent;
AcGePoint3dArray controlPoints,fitPoints;
AcGeDoubleArray knots,weights;
bIsClosed = pSpline->isClosed();
AcGeNurbCurve3d *pNurb = NULL;
if (pSpline->hasFitData() && isFit)
{
AcGeTol tol;
es = pSpline->getFitData(fitPoints,degree,fitTolerance,tangentsExist,startTangent,endTangent);
if (es == Acad::eOk)
{
tangentStartDef = tangentsExist;
tangentEndDef = tangentsExist;
AcGeTol fitTol;
pSpline->fitTolerance();
fitTol.setEqualPoint(fitTolerance);
if (tangentsExist)
{
pNurb = new AcGeNurbCurve3d(fitPoints,startTangent,endTangent,tangentStartDef,tangentEndDef,fitTol);
}
else
{
pNurb = new AcGeNurbCurve3d(fitPoints,fitTol);
}
}
else
{
return Acad::eNotImplementedYet;
}
}
else
{
es = pSpline->getNurbsData(degree,bIsRational,bIsClosed,bIsPeriodic,controlPoints,knots,weights,controlPtTol,knotTol);
if (es == Acad::eOk)
{
if (bIsRational)
{
pNurb = new AcGeNurbCurve3d(degree,knots,controlPoints,weights,bIsPeriodic);
}
else
{
pNurb = new AcGeNurbCurve3d(degree,knots,controlPoints,bIsPeriodic);
}
}
else
{
return Acad::eNotImplementedYet;
}
}
bIsClosed?pNurb->makeClosed():pNurb->makeOpen();
pGe = pNurb;
return es;
}
Acad::ErrorStatus AcGeCurveToAcDbCurve(AcDbCurve * &pDb,const AcGeNurbCurve3d * pGe)
{
if (pGe->hasFitData())
{
AcGePoint3dArray fitPoints;
AcGeTol fitTolerance;
Adesk::Boolean tangentsExist;
AcGeVector3d startTangent;
AcGeVector3d endTangent;
double tol;
pGe->getFitData(fitPoints,fitTolerance,tangentsExist,startTangent,endTangent);
pDb = new AcDbSpline(fitPoints,startTangent,endTangent,pGe->order(),fitTolerance.equalPoint());
}
else
{
int degree;
Adesk::Boolean bIsRational,periodic;
AcGePoint3dArray controlPoints;
AcGeKnotVector knots1;
AcGeDoubleArray weights;
pGe->getDefinitionData(degree,bIsRational,periodic,knots1,controlPoints,weights);
AcGeDoubleArray knots;
for (int i = 0;i<knots1.length();i++)
{
knots.append(knots1);
}
pDb =new AcDbSpline(degree,bIsRational,pGe->isClosed(),periodic,controlPoints,knots,weights,0.0,pGe->knots().tolerance());
}
return Acad::eOk;
}
// POLYLINE
Acad::ErrorStatusAcDbCurveToAcGeCurve(AcGeCurve3d * &pGe,const AcDbPolyline * pPoly)
{
AcGeLineSeg3d *pLine = NULL;
AcGeCircArc3d *pArc = NULL;
AcGeVoidPointerArray GeCurves;
for( int i = 0; i < pPoly->numVerts(); i++ )
{
if( pPoly->segType(i) == AcDbPolyline::kLine )
{
pLine = new AcGeLineSeg3d;
pPoly->getLineSegAt(i, *pLine);
GeCurves.append(pLine);
}
else if( pPoly->segType(i) == AcDbPolyline::kArc )
{
pArc = new AcGeCircArc3d;
pPoly->getArcSegAt(i, *pArc);
GeCurves.append(pArc);
}
}
pGe =new AcGeCompositeCurve3d(GeCurves);
return Acad::eOk;
}
Acad::ErrorStatus AcGeCurveToAcDbCurve(AcDbCurve * &pDb,const AcGeCompositeCurve3d * pGe)
{
AcGePoint3d startPnt,endPnt;
if( pGe->hasEndPoint(endPnt) == Adesk ::kFalse ||
pGe->hasStartPoint(startPnt) == Adesk::kFalse)
{
return Acad::eNotImplementedYet;
}
//get the plane of Curve3d
AcGePlane plane;
AcGeLine3d line;
AcGePoint3d p1,p2,p3;
if(pGe->isPlanar(plane))
{
if(pGe->isLinear(line)) //Oh,it's a little tricky!
{
line.getPerpPlane(startPnt,plane);
plane.get(p1,p2,p3);
plane.set(p2,p3-p2);
}
plane.get(p1,p2,p3);
}
else
{
return Acad::eNotImplementedYet;
}
//Creat a polyline
AcDbPolyline *pPoly = new AcDbPolyline();
AcGeVoidPointerArray curveList;
pGe->getCurveList(curveList);//get all the segments
AcGeCurve3d *pCurve = NULL;
AcGeCircArc3d *pArc = NULL;
int i;
double b;
AcGePoint2d pt;
for(i = 0;i < curveList.length();i++)
{
pCurve=(AcGeCurve3d *) (curveList);
pCurve->hasStartPoint(startPnt);
pt = startPnt.convert2d(plane);
if (pCurve->isKindOf(AcGe::kCircArc3d))
{
pArc = (AcGeCircArc3d *)(pCurve);
b = tan(0.25 * pArc->endAng());
if (pArc->normal()!=plane.normal())
{
pPoly->addVertexAt(i,pt,-b);
}
else
{
pPoly->addVertexAt(i,pt,b);
}
}
else
{
pPoly->addVertexAt(i,pt);
}
}
if(!pGe->isClosed())
{
pt = endPnt.convert2d(plane);
pPoly->addVertexAt(i,pt);
}
else
{
pPoly->setClosed(Adesk::kTrue);
}
//the most important step;
AcGeMatrix3d xform;
AcGeVector3d XAxis = p1-p2;
AcGeVector3d YAxis = p3-p2;
AcGeVector3d ZAxis = XAxis.crossProduct(YAxis);
xform.setCoordSystem(p2,XAxis,YAxis,ZAxis);
pPoly->transformBy(xform);
pDb = pPoly;
return Acad::eOk;
}
// POLYLINE3D
Acad::ErrorStatus AcDbCurveToAcGeCurve(AcGeCurve3d * &pGe,const AcDb3dPolyline * pPoly3d,bool isFit)
{
AcGeVoidPointerArray GeCurves;
AcGePoint3d pt1;
AcGePoint3d pt2;
double Param;
pPoly3d->getEndParam(Param);
GeCurves.setLogicalLength((int)Param);
for (int i= 0; i < (int)Param;i++)
{
pPoly3d->getPointAtParam(i,pt1);
pPoly3d->getPointAtParam(i+1,pt2);
GeCurves = new AcGeLineSeg3d(pt1,pt2);
}
if (!isFit)
{
pGe= new AcGeCompositeCurve3d(GeCurves);
return Acad::eOk;
}
AcDbSpline *pSpline= NULL;
pPoly3d->getSpline(pSpline);
Acad::ErrorStatus es = AcDbCurveToAcGeCurve(pGe,pSpline);
delete pSpline;
pSpline = NULL;
return es;
}
Acad::ErrorStatus AcGeCurveToAcDbCurve(AcDbCurve * &pDb,const AcGePolyline3d *pGe)
{
AcGePoint3dArray pts;
for (int i = 0;i < pGe->numControlPoints();i++)
{
pts.append(pGe->controlPointAt(i));
}
pDb = new AcDb3dPolyline((AcDb::Poly3dType)pGe->type(),pts,pGe->isClosed());
return Acad::eOk;
}
// POLYLINE2D
Acad::ErrorStatus AcDbCurveToAcGeCurve(AcGeCurve3d * &pGe,const AcDb2dPolyline *pPoly2d,bool isFit)
{
AcDb::Poly2dType type;
type=pPoly2d->polyType();
AcDbPolyline * pLwpoly = NULL;
Acad::ErrorStatus es;
if ((type==AcDb::k2dSimplePoly)||(type==AcDb::k2dFitCurvePoly))
{
pLwpoly=new AcDbPolyline;
es = pLwpoly->convertFrom((AcDbEntity *&)pPoly2d,Adesk::kFalse);
if (es!=Acad::eOk)
{
delete pLwpoly;
pLwpoly=NULL;
return es;
}
es = AcDbCurveToAcGeCurve(pGe,pLwpoly);
pLwpoly->close();
return es;
}
else
{
AcGeVoidPointerArray GeCurves;
AcGePoint3d pt1;
AcGePoint3d pt2;
double Param;
pPoly2d->getEndParam(Param);
AcGeLineSeg3d *pLine = NULL;
for (int i= 0; i < (int)Param;i++)
{
pPoly2d->getPointAtParam(i,pt1);
pPoly2d->getPointAtParam(i+1,pt2);
pLine = new AcGeLineSeg3d(pt1,pt2);
GeCurves.append(pLine);
}
pGe = new AcGeCompositeCurve3d(GeCurves);
return Acad::eOk;
}
}
// catch all for all other entity types.
Acad::ErrorStatus AcDbCurveToAcGeCurve(AcGeCurve3d * &pGe,const AcDbCurve *pDbCurve)
{
if (pDbCurve->isKindOf(AcDbLine::desc()))
{
return AcDbCurveToAcGeCurve(pGe,(AcDbLine *)pDbCurve);
}
if (pDbCurve->isKindOf(AcDbArc::desc()))
{
return AcDbCurveToAcGeCurve(pGe,(AcDbArc *)pDbCurve);
}
if (pDbCurve->isKindOf(AcDbCircle::desc()))
{
return AcDbCurveToAcGeCurve(pGe,(AcDbCircle *)pDbCurve);
}
if (pDbCurve->isKindOf(AcDbEllipse::desc()))
{
return AcDbCurveToAcGeCurve(pGe,(AcDbEllipse *)pDbCurve);
}
if (pDbCurve->isKindOf(AcDbSpline::desc()))
{
return AcDbCurveToAcGeCurve(pGe,(AcDbSpline *)pDbCurve);
}
if (pDbCurve->isKindOf(AcDbPolyline::desc()))
{
return AcDbCurveToAcGeCurve(pGe,(AcDbPolyline *)pDbCurve);
}
if (pDbCurve->isKindOf(AcDb3dPolyline::desc()))
{
return AcDbCurveToAcGeCurve(pGe,(AcDb3dPolyline *)pDbCurve);
}
if (pDbCurve->isKindOf(AcDb2dPolyline::desc()))
{
return AcDbCurveToAcGeCurve(pGe,(AcDb2dPolyline *)pDbCurve);
}
return Acad::eNotImplementedYet;
}
Acad::ErrorStatus AcDbCurveToAcGeCurve(AcGeCurve3d * &pGe,const AcDbEntity *pEnt)
{
if (pEnt->isKindOf(AcDbCurve::desc()))
{
return AcDbCurveToAcGeCurve(pGe,(AcDbCurve *)pEnt);
}
return Acad::eNotImplementedYet;
}
Acad::ErrorStatus AcGeCurveToAcDbCurve(AcDbCurve * &pDb,const AcGeCurve3d * pGe)
{
AcGe::EntityId type = pGe->type();
switch (type)
{
case AcGe::kLineSeg3d:
return AcGeCurveToAcDbCurve(pDb,(AcGeLineSeg3d *) pGe);
case AcGe::kCircArc3d:
return AcGeCurveToAcDbCurve(pDb,(AcGeCircArc3d *) pGe);
case AcGe::kEllipArc3d:
return AcGeCurveToAcDbCurve(pDb,(AcGeEllipArc3d *) pGe);
case AcGe::kNurbCurve3d:
return AcGeCurveToAcDbCurve(pDb,(AcGeNurbCurve3d *) pGe);
case AcGe::kCompositeCrv3d:
return AcGeCurveToAcDbCurve(pDb,(AcGeCompositeCurve3d*) pGe);
case AcGe::kPolyline3d:
return AcGeCurveToAcDbCurve(pDb,(AcGePolyline3d *) pGe);
default:
return Acad::eNotImplementedYet;
}
}

Ñ©É½·Éºü_lzh ·¢±íÓÚ 2010-7-29 10:38:00

polylineÈ·ÊµÃ»¿¼ÂÇ£¬Ð»Ð»highflybirdµÄÌáÐÑ
splineµÄ´¦ÀíÒª×ÐÏ¸¿´ÏÂÁË£¬ÒÔÇ°µÄ´¦ÀíÈ·ÊµÓÐÎÊÌâ

highflybird ·¢±íÓÚ 2010-7-29 10:46:00

Êµ¼ÊÉÏÎÒ×ÐÏ¸ÑÐ¾¿ÁËÒ»ÏÂAcDb3dPolylineºÍAcGePolyline3dµÄ×ª»»ÎÊÌâ£¬¾õµÃÈçÏÂÎÊÌâÓ¦¸Ã¿¼ÂÇ£º
AcGePolyline3dÃ»ÓÐÄâºÏÀàÐÍ£¬ÕâÑùÈç¹ûAcDb×ª³ÉAcGeµÄÊ±ºò£¬ÔÚÓÐÄâºÏµÄÇé¿öÏÂ£¬¾ÍÎÞ´Ó´¦Àí£¬Òò´ËÖ»ÄÜ¾ßÌåÇé¿ö¾ßÌå´¦ÀíÁË¡£
2dpolylineÒ²ÀàËÆ¡£
ÓÐµãÐèÒªËµÃ÷µÄÊÇ£ºArx¸úC#µÄ´¦ÀíÓÐµã²»Ò»ÑùµÄÊÇ£¬arxÔÚ×ª»»ºó£¬ Èç¹ûÄã²»ÐèÒªÄÇ¸öÀàÁË£¬ÄãÓ¦¸Ãdelete»òÕßfreeÄã´´½¨µÄ¡£
 
Áí²Î¼ûÎÒµÄ: 
http://www.objectarx.net/forum.php?mod=viewthread&tid=4935&extra=page%3D1

ºÓ²® ·¢±íÓÚ 2010-10-28 10:31:00

±¾Ìû×îºóÓÉ ×÷Õß ÓÚ 2010-10-28 14:22:34 ±à¼

Â¥Ö÷µÄÇúÏß×ª»»Àà°üÀ¨ÁËÒÔÏÂÈý²¿·Ö£º
1.×ª»»Ge2dÇúÏßÎªDbÇúÏß
2.×ª»»Ge3dÇúÏßÎªDbÇúÏß
3.×ª»»DbÇúÏßÎªGe3dÇúÏß

ºÃÏñÈ±ÉÙÁËÏÂÃæÒ»Ð©ÄÚÈÝ£¬²»ÖªÄÜ·ñÌí¼ÓÉÏ£¿
1.Ã»ÓÐ×ª»»DbÇúÏßÎªGe2dÇúÏßµÄ·½·¨
2.×ª»»Ge2dÇúÏßÎªDbÇúÏßÖÐ£¬Ã»ÓÐCompositeCurve2dToPolyline

ÁíÍâ£¬¶ÔÓÚ×ª»»LineSegment2dÎªLineÇúÏß£¬ËÆºõÖ´ÐÐÏÂÃæº¯Êý¾Í¿ÉÒÔÁË£º

public static Line ToLine(LineSegment2d ls2d)
   {
         Plane plane = ();
         return
            new Line(
               new Point3d(plane, ls2d.StartPoint),
               new Point3d(plane, ls2d.EndPoint));
   }
ÎªºÎ»¹ÒªÖ´ÐÐÕâÒ»²½£¬TransformByÔÚÕâÀïÆðÊ²Ã´×÷ÓÃ£¿

public static Line ToLine(LineSegment2d ls2d, Matrix3d mat)
   {
         Line l = ToLine(ls2d);
         l.TransformBy(mat);
         return l;
   }

Ñ©É½·Éºü_lzh ·¢±íÓÚ 2010-10-28 19:34:00

DbÇúÏßÎªGe2dÇúÏßµÄ·½·¨Ã»ÓÐ×ö£¬µ±Ê±¸Ð¾õÃ»ÓÐÕâÖÖÐèÇó
TransformByÖ÷Òª¿¼ÂÇÈýÎ¬µÄ²Ù×÷

ºÓ²® ·¢±íÓÚ 2010-10-28 19:51:00

ÄÜ·ñ°ÑÕâ¸öÏÈ¼ÓÉÏ£ºCompositeCurve2dToPolyline

Ñ©É½·Éºü_lzh ·¢±íÓÚ 2010-10-29 10:00:00

Õâ¸ö¿ÉÒÔÖ±½Ó²Î¿¼
public static Polyline ToPolyline(this CompositeCurve3d cc3d)
CompositeCurveµÄ´¦ÀíÓÐµãÓôÃÆ£¬ÔÚDB¿âÃ»ÓÐÑÏ¸ñ¶ÔÓ¦µÄ¶ÔÏó

ÁíÍâ£¬TlsBasal»ù±¾Àà¿âÒÑ¸üÐÂ
<a href="http://bbs.mjtd.com/forum.php?mod=viewthread&tid=75701&extra=&page=1">http://bbs.mjtd.com/forum.php?mod=viewthread&tid=75701&extra=&page=1</a>

ºÓ²® ·¢±íÓÚ 2010-10-29 10:25:00

¸Õ¿ªÊ¼ÓÃVB.NET£¬Ö»ÊÇ³õ²½£¬Í¨¹ý×ª»»C#µ½VB.NETÀ´Ñ§Ï°AutoCAD .NET API¡£
Ä¿Ç°DLL»¹ÓÃ²»ÉÏ¡£CompositeCurve3dToPolylineºÍCompositeCurve2dToPolylineÓ¦¸ÃÓÐÐ©²î±ð£¬·Åµ½ÒÔºóÔÙ×ö°É¡£

chpmould ·¢±íÓÚ 2010-10-31 18:04:00

Ñ§Ï°ÁË£¬Ò»¶¨Òª¶¥

Ò³: 1 [2] 3

Ã÷¾­CADÉçÇø's Archiver

Ã÷¾CADÉçÇø's Archiver