(C#)算HATCH的周长的代码

CSharpBoy · 发表于 2016-7-15 13:29:19

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

×

游客，如果您要查看本帖隐藏内容请回复

void HatchPerimeter(ObjectId entId)
{
Document activeDoc = Application.DocumentManager.MdiActiveDocument;
Database db = activeDoc.Database;
Editor ed = activeDoc.Editor;
using (Transaction tr = db.TransactionManager.StartTransaction())
{
Hatch hatch = tr.GetObject(entId, OpenMode.ForRead) as Hatch;
int nLoops = hatch.NumberOfLoops;
double totalExternalPerimeter =0.0;
double totalInternalPerimeter =0.0;
for(int i=0; i < nLoops; i++)
{
double loopLength = 0.0;
HatchLoopTypes hlt = hatch.LoopTypeAt(i);
HatchLoop hatchLoop = hatch.GetLoopAt(i);
if ((hatch.LoopTypeAt(i) & HatchLoopTypes.Polyline)
== HatchLoopTypes.Polyline)
{
BulgeVertexCollection bulges
= hatchLoop.Polyline;
int nVertices = bulges.Count;
Polyline testPoly = new Polyline(nVertices);
for(int vx = 0; vx < bulges.Count; vx++)
{
BulgeVertex bv = bulges[vx];
testPoly.AddVertexAt(
vx,
bv.Vertex,
bv.Bulge,
1.0,
1.0
);
}
LineSegment3d ls = new LineSegment3d();
CircularArc3d cs = new CircularArc3d();
double d = 0.0, p1 = 0.0, p2 = 1.0;
for(int ver = 0; ver < nVertices-1; ver++)
{
d = testPoly.GetBulgeAt(ver);
if( d <= 1e-5 )
{
ls = testPoly.GetLineSegmentAt(ver);
loopLength += ls.Length;
}
else
{
Point2d v1
= new Point2d(
bulges[ver].Vertex.X,
bulges[ver].Vertex.Y
);
Point2d v2
= new Point2d(
bulges[ver + 1].Vertex.X,
bulges[ver + 1].Vertex.Y
);
if (v1.IsEqualTo(v2) == false)
{
cs = testPoly.GetArcSegmentAt(ver);
p1 = cs.GetParameterOf(cs.StartPoint);
p2 = cs.GetParameterOf(cs.EndPoint);
loopLength +=
cs.GetLength
(
p1,
p2,
Tolerance.Global.EqualPoint
);
}
}
}
}
else
{
Curve2dCollection curves = hatchLoop.Curves;
if (curves != null)
{
foreach (Curve2d curve in curves)
{
if (hatchLoop.LoopType
== HatchLoopTypes.External)
{
totalExternalPerimeter +=
curve.GetLength(0.0, 1.0);
}
else
{
totalInternalPerimeter +=
curve.GetLength(0.0, 1.0);
}
}
}
}
if ( nLoops > 1 &&
((hlt & HatchLoopTypes.External) != HatchLoopTypes.External))
{
totalInternalPerimeter += loopLength;
}
else
{
totalExternalPerimeter += loopLength;
}
}
ed.WriteMessage(
string.Format
(
"\nExternal Perimeter : {0}",
totalExternalPerimeter
)
);
ed.WriteMessage(
string.Format
(
"\nInternal Perimeter : {0}",
totalInternalPerimeter
)
);
tr.Commit();
}
}

void HatchPerimeter(ObjectId entId) 
{ 
    Document activeDoc = Application.DocumentManager.MdiActiveDocument; 
    Database db = activeDoc.Database; 
    Editor ed = activeDoc.Editor; 
 
    using (Transaction tr = db.TransactionManager.StartTransaction()) 
    { 
        Hatch hatch = tr.GetObject(entId, OpenMode.ForRead) as Hatch; 
        int nLoops = hatch.NumberOfLoops; 
 
        double totalExternalPerimeter =0.0; 
        double totalInternalPerimeter =0.0; 
 
        for(int i=0; i < nLoops; i++) 
        { 
            double loopLength = 0.0; 
            HatchLoopTypes hlt = hatch.LoopTypeAt(i); 
            HatchLoop hatchLoop = hatch.GetLoopAt(i); 
 
            if ((hatch.LoopTypeAt(i) & HatchLoopTypes.Polyline) 
                                    == HatchLoopTypes.Polyline) 
            { 
                BulgeVertexCollection bulges 
                                            = hatchLoop.Polyline; 
 
                int nVertices = bulges.Count; 
                Polyline testPoly = new Polyline(nVertices); 
 
                for(int vx = 0; vx < bulges.Count; vx++) 
                { 
                    BulgeVertex bv = bulges[vx]; 
                    testPoly.AddVertexAt( 
                                            vx, 
                                            bv.Vertex, 
                                            bv.Bulge, 
                                            1.0, 
                                            1.0 
                                        ); 
                } 
 
                LineSegment3d ls = new LineSegment3d(); 
                CircularArc3d cs = new CircularArc3d(); 
                double d = 0.0, p1 = 0.0, p2 = 1.0; 
 
                for(int ver = 0; ver < nVertices-1; ver++) 
                { 
                    d = testPoly.GetBulgeAt(ver); 
                    if( d <= 1e-5 ) 
                    { 
                        ls = testPoly.GetLineSegmentAt(ver); 
                        loopLength += ls.Length; 
                    } 
                    else 
                    { 
                        Point2d v1 
                            = new Point2d( 
                                            bulges[ver].Vertex.X, 
                                            bulges[ver].Vertex.Y 
                                         ); 
                        Point2d v2 
                            = new Point2d( 
                                            bulges[ver + 1].Vertex.X, 
                                            bulges[ver + 1].Vertex.Y 
                                         ); 
                        if (v1.IsEqualTo(v2) == false) 
                        { 
                            cs = testPoly.GetArcSegmentAt(ver); 
                            p1 = cs.GetParameterOf(cs.StartPoint); 
                            p2 = cs.GetParameterOf(cs.EndPoint); 
 
                            loopLength += 
                                cs.GetLength 
                                ( 
                                    p1, 
                                    p2, 
                                    Tolerance.Global.EqualPoint 
                                ); 
                        } 
                    } 
                } 
            } 
            else 
            { 
                Curve2dCollection curves = hatchLoop.Curves; 
                if (curves != null) 
                { 
                    foreach (Curve2d curve in curves) 
                    { 
                        if (hatchLoop.LoopType 
                            == HatchLoopTypes.External) 
                        { 
                            totalExternalPerimeter += 
                                    curve.GetLength(0.0, 1.0); 
                        } 
                        else 
                        { 
                            totalInternalPerimeter += 
                                    curve.GetLength(0.0, 1.0); 
                        } 
                    } 
                } 
            } 
 
            if (    nLoops > 1 && 
                    ((hlt & HatchLoopTypes.External) != HatchLoopTypes.External)) 
            { 
                totalInternalPerimeter += loopLength; 
            } 
            else 
            { 
                totalExternalPerimeter += loopLength; 
            } 
        } 
 
        ed.WriteMessage( 
                            string.Format 
                            ( 
                                "\nExternal Perimeter : {0}", 
                                totalExternalPerimeter 
                            ) 
                       ); 
 
        ed.WriteMessage( 
                            string.Format 
                            ( 
                                "\nInternal Perimeter : {0}", 
                                totalInternalPerimeter 
                            ) 
                       ); 
        tr.Commit(); 
    } 
}

CSharpBoy · 发表于 2016-7-15 13:30:27

算HATCH周长的ARX代码

// Perimeter calculation of a hatch using ObjectARX
static void ADS_HatchTest(void)
{
ads_name en;
ads_point pt;
if( acedEntSel(
ACRX_T("\nSelect a hatch :"),
en,
pt
) != RTNORM )
{
return;
}
AcDbObjectId entId = AcDbObjectId::kNull;
Acad::ErrorStatus es;
es = acdbGetObjectId(entId, en);
if(es != Acad::eOk)
return;
HatchPerimeter(entId);
}
static void HatchPerimeter(AcDbObjectId entId)
{
Acad::ErrorStatus es;
AcDbEntity *pEnt;
es = acdbOpenAcDbEntity(
pEnt,
entId,
AcDb::kForRead
);
if( es != Acad::eOk )
return;
if( pEnt->isA() != AcDbHatch::desc() )
{
acutPrintf(ACRX_T("\n Please select a hatch."));
pEnt->close();
return;
}
AcDbHatch* pHatch = AcDbHatch::cast(pEnt);
int nLoops = pHatch->numLoops();
double totalExternalPerimeter =0.0;
double totalInternalPerimeter =0.0;
for(int i=0; i < nLoops; i++)
{
double loopLength = 0.0;
long loopType;
if( pHatch->loopTypeAt( i )
& AcDbHatch::kPolyline )
{
AcGePoint2dArray vertices;
AcGeDoubleArray bulges;
pHatch->getLoopAt(
i,
loopType,
vertices,
bulges
);
int nVertices = vertices.length();
AcDbPolyline testPoly(nVertices);
for( int vx=0; vx < nVertices; vx++)
{
double bulge = 0.0;
if(bulges.length() < nVertices)
bulge = 0.0;
else
bulge = bulges[vx];
testPoly.addVertexAt(
vx,
vertices[vx],
bulge
);
}
AcGeLineSeg3d ls;
AcGeCircArc3d as;
double d = 0.0, p1 = 0.0, p2 = 1.0;
for(int ver = 0; ver < nVertices; ver++)
{
es = testPoly.getBulgeAt( i, d );
if( es != Acad::eOk )
break;
if( d <= 1e-5 )
{
es = testPoly.getLineSegAt(ver, ls);
if( es != Acad::eOk )
break;
loopLength += ls.length();
}
else
{
AcGePoint2d v1;
AcGePoint2d v2;
v1.set(
vertices[ver].x,
vertices[ver].y
);
if (ver == (nVertices - 1))
{
v2.set(
vertices[0].x,
vertices[0].y
);
}
else
{
v2.set(
vertices[ver+1].x,
vertices[ver+1].y
);
}
if (v1.isEqualTo(v2, AcGeContext::gTol)
== Adesk::kFalse)
{
es = testPoly.getArcSegAt( i, as );
if( es != Acad::eOk )
break;
p1 = as.paramOf(as.startPoint());
p2 = as.paramOf(as.endPoint());
loopLength += as.length( p1, p2 );
}
}
}
}
else
{
AcGePoint2dArray vertices;
AcGeDoubleArray bulges;
AcGeVoidPointerArray edgePtrs;
AcGeIntArray edgeTypes;
pHatch->getLoopAt(i, loopType,edgePtrs, edgeTypes );
AcGeCompositeCurve2d compCurve( edgePtrs );
AcGeInterval interval;
compCurve.getInterval( interval );
loopLength
= compCurve.length(
interval.lowerBound(),
interval.upperBound()
);
}
if( nLoops > 1 && !(loopType & AcDbHatch::kExternal ))
totalInternalPerimeter += loopLength;
else
totalExternalPerimeter += loopLength;
}
acutPrintf(
ACRX_T("\nExternal Perimeter : %lf"),
totalExternalPerimeter
);
acutPrintf(
ACRX_T("\nInternal Perimeter : %lf"),
totalInternalPerimeter
);
pEnt->close();
}

// Perimeter calculation of a hatch using ObjectARX 
static void ADS_HatchTest(void) 
{ 
    ads_name en; 
    ads_point pt; 
    if( acedEntSel( 
                    ACRX_T("\nSelect a hatch :"), 
                    en, 
                    pt 
                   ) != RTNORM ) 
    { 
        return; 
    } 
 
    AcDbObjectId entId = AcDbObjectId::kNull; 
    Acad::ErrorStatus es; 
    es = acdbGetObjectId(entId, en); 
    if(es != Acad::eOk) 
          return; 
 
    HatchPerimeter(entId); 
} 
 
static void HatchPerimeter(AcDbObjectId entId) 
{ 
    Acad::ErrorStatus es; 
    AcDbEntity *pEnt; 
    es = acdbOpenAcDbEntity( 
                            pEnt, 
                            entId, 
                            AcDb::kForRead 
                           ); 
    if( es != Acad::eOk ) 
        return; 
 
    if( pEnt->isA() != AcDbHatch::desc() ) 
    { 
        acutPrintf(ACRX_T("\n Please select a hatch.")); 
        pEnt->close(); 
        return; 
    } 
 
    AcDbHatch* pHatch = AcDbHatch::cast(pEnt); 
 
    int nLoops = pHatch->numLoops(); 
    double totalExternalPerimeter =0.0; 
    double totalInternalPerimeter =0.0; 
 
    for(int i=0; i < nLoops; i++) 
    { 
        double loopLength = 0.0; 
        long loopType; 
 
        if( pHatch->loopTypeAt( i ) 
          & AcDbHatch::kPolyline ) 
        {    
            AcGePoint2dArray vertices;    
            AcGeDoubleArray bulges;    
            pHatch->getLoopAt( 
                                i, 
                                loopType, 
                                vertices, 
                                bulges 
                             );   
            int nVertices = vertices.length(); 
 
            AcDbPolyline testPoly(nVertices); 
 
            for( int vx=0; vx < nVertices; vx++) 
            { 
                double bulge = 0.0; 
                if(bulges.length() < nVertices) 
                  bulge = 0.0; 
                else 
                  bulge = bulges[vx]; 
                testPoly.addVertexAt( 
                                        vx, 
                                        vertices[vx], 
                                        bulge 
                                    ); 
            } 
 
            AcGeLineSeg3d ls; 
            AcGeCircArc3d as; 
            double d = 0.0, p1 = 0.0, p2 = 1.0; 
 
            for(int ver = 0; ver < nVertices; ver++) 
            { 
                es = testPoly.getBulgeAt( i, d ); 
                if( es != Acad::eOk ) 
                    break; 
 
                if( d <= 1e-5 ) 
                { 
                    es = testPoly.getLineSegAt(ver, ls); 
                    if( es != Acad::eOk ) 
                          break; 
                    loopLength += ls.length(); 
                } 
                else 
                { 
                    AcGePoint2d v1; 
                    AcGePoint2d v2; 
                    v1.set( 
                            vertices[ver].x, 
                            vertices[ver].y 
                          ); 
 
                    if (ver == (nVertices - 1)) 
                    { 
                        v2.set( 
                                vertices[0].x, 
                                vertices[0].y 
                              ); 
                    } 
                    else 
                    { 
                        v2.set( 
                                 vertices[ver+1].x, 
                                 vertices[ver+1].y 
                              ); 
                    } 
 
                    if (v1.isEqualTo(v2, AcGeContext::gTol) 
                                        == Adesk::kFalse) 
                    { 
                        es = testPoly.getArcSegAt( i, as ); 
                        if( es != Acad::eOk ) 
                            break; 
 
                        p1 = as.paramOf(as.startPoint()); 
                        p2 = as.paramOf(as.endPoint()); 
 
                        loopLength += as.length( p1, p2 ); 
                    } 
                } 
            } 
        }   
        else 
        {    
            AcGePoint2dArray vertices;    
            AcGeDoubleArray bulges; 
            AcGeVoidPointerArray edgePtrs; 
            AcGeIntArray edgeTypes; 
 
            pHatch->getLoopAt(i, loopType,edgePtrs, edgeTypes ); 
            AcGeCompositeCurve2d compCurve( edgePtrs ); 
 
            AcGeInterval interval;   
            compCurve.getInterval( interval ); 
 
            loopLength 
                = compCurve.length( 
                                    interval.lowerBound(), 
                                    interval.upperBound() 
                                  ); 
        } 
 
        if( nLoops > 1 && !(loopType & AcDbHatch::kExternal ))    
            totalInternalPerimeter += loopLength; 
        else 
            totalExternalPerimeter += loopLength; 
    } 
 
    acutPrintf( 
                ACRX_T("\nExternal Perimeter : %lf"), 
                totalExternalPerimeter 
              ); 
 
    acutPrintf( 
                ACRX_T("\nInternal Perimeter : %lf"), 
                totalInternalPerimeter 
              ); 
 
    pEnt->close(); 
}

zjy2999 · 发表于 2016-7-20 09:19:11

学习！！！！！！！！！

dnbcgrass · 发表于 2016-7-20 09:59:28

回复学习学习！

lucas3 · 发表于 2016-7-20 11:00:15

dnbcgrass 发表于 2016-7-20 09:59
回复学习学习！

大师也学Ｃ#呢？

junming.zhou · 发表于 2017-11-18 15:11:41

学习！！学习

GANXIZHI2 · 发表于 2018-1-8 17:58:46

学习！！！！！！！！！

wfch20000 · 发表于 2018-1-9 08:47:28

haoba,woxiangkankan

yoksa · 发表于 2018-5-11 09:00:49

13110033110 · 发表于 2018-6-26 11:28:19

学习！！！！！！！！！

那年86 · 发表于 2018-7-4 08:32:49

现在都不更新了么

那年86 · 发表于 2018-7-4 08:34:14

顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶

44934394 · 发表于 2019-6-11 08:21:36

正在学习中，非常感谢

44934394 · 发表于 2019-6-11 08:25:32

非常感谢，正在学习中

819534890 · 发表于 2019-6-11 14:29:03

回复学习，谢谢分享

账号		自动登录	找回密码
密码			立即注册

[每日一码] (C#)算HATCH的周长的代码

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

点评