Polylijnen aanmaken en analyseren met C# in AutoCAD

Polylijnen zijn de meest gebruikte geometrie in AutoCAD-tekeningen: contouren, tracés, muuropeningen, parkeerplaatsen. In dit artikel leer je hoe je via C# lichte polylijnen (Polyline) aanmaakt, bogen toevoegt met de bulge-waarde, oppervlaktes en omtrekken berekent, en bestaande polylijnen analyseert en aanpast.

Lightweight Polyline vs 2D Polyline

AutoCAD heeft twee polylijnklassen: Polyline (lichtgewicht, aanbevolen) en Polyline2d (oud formaat). Gebruik altijd Polyline voor nieuwe code — hij is compacter, sneller en ondersteunt alle moderne functies. Polyline3d is voor 3D-puntenreeksen zonder bogen.

Een eenvoudige polylijn aanmaken

[CommandMethod("MAAKPOLYLIJN")]
public void MaakPolylijn()
{
    var doc = Application.DocumentManager.MdiActiveDocument;
    var db  = doc.Database;

    using (var tr = db.TransactionManager.StartTransaction())
    {
        var ms = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite);

        var pl = new Polyline();
        pl.AddVertexAt(0, new Point2d(0,   0),   0, 0, 0);   // punt 0
        pl.AddVertexAt(1, new Point2d(100, 0),   0, 0, 0);   // punt 1
        pl.AddVertexAt(2, new Point2d(100, 50),  0, 0, 0);   // punt 2
        pl.AddVertexAt(3, new Point2d(0,   50),  0, 0, 0);   // punt 3
        pl.Closed = true;    // sluit de rechthoek
        pl.ConstantWidth = 0.5;

        ms.AppendEntity(pl);
        tr.AddNewlyCreatedDBObject(pl, true);
        tr.Commit();
    }
}

Bogen toevoegen met de bulge-waarde

Een boog in een polylijn wordt bepaald door de bulge-waarde van een segment. Bulge = tan(hoek/4), waarbij hoek de insluithook van de boog is. Een halfcirkel heeft bulge ±1.0. Positief = boog links van de richting, negatief = rechts.

// Maak een D-vorm: rechte lijn + halve cirkel
var pl = new Polyline();
pl.AddVertexAt(0, new Point2d(0,  0),  0.0, 0, 0);  // segment 0→1 is recht
pl.AddVertexAt(1, new Point2d(0, 50),  1.0, 0, 0);  // segment 1→2 is halve cirkel (bulge=1)
pl.AddVertexAt(2, new Point2d(0,  0),  0.0, 0, 0);
pl.Closed = false;
// Bulge wijzigen na aanmaken:
// pl.SetBulgeAt(1, 1.0);

Punten uitlezen en analyseren

public void AnalyseerPolylijn(Transaction tr, ObjectId plId)
{
    var pl = (Polyline)tr.GetObject(plId, OpenMode.ForRead);
    var ed = Application.DocumentManager.MdiActiveDocument.Editor;

    ed.WriteMessage($"\nAantal segmenten : {pl.NumberOfVertices - (pl.Closed ? 0 : 1)}");
    ed.WriteMessage($"\nGesloten         : {pl.Closed}");
    ed.WriteMessage($"\nOppervlakte      : {pl.Area:F2} mm²");
    ed.WriteMessage($"\nLengte           : {pl.Length:F2} mm");

    for (int i = 0; i < pl.NumberOfVertices; i++)
    {
        var pt     = pl.GetPoint2dAt(i);
        var bulge  = pl.GetBulgeAt(i);
        var segType = Math.Abs(bulge) < 1e-6 ? "lijn" : "boog";
        ed.WriteMessage($"\n  Punt {i}: ({pt.X:F1}, {pt.Y:F1})  bulge={bulge:F3}  [{segType}]");
    }
}

Een punt toevoegen aan een bestaande polylijn

public void VoegPuntToe(Transaction tr, ObjectId plId, Point2d punt, double bulge = 0.0)
{
    var pl = (Polyline)tr.GetObject(plId, OpenMode.ForWrite);
    int idx = pl.NumberOfVertices;
    pl.AddVertexAt(idx, punt, bulge, 0, 0);
}

Polylijn inkorten of splitsen op een punt

public void SplitsPolylijn(Database db, Transaction tr, ObjectId plId, double parameter)
{
    var pl = (Polyline)tr.GetObject(plId, OpenMode.ForRead);

    // SplitBy geeft een reeks nieuwe curves terug
    var curves = new DBObjectCollection();
    pl.Explode(curves); // alternatief: pl.GetSubEntities()

    var ms = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite);
    foreach (Entity ent in curves)
    {
        ms.AppendEntity(ent);
        tr.AddNewlyCreatedDBObject(ent, true);
    }

    pl.UpgradeOpen();
    pl.Erase();
}

Polylijn offsetten

Offset geeft een nieuwe curve terug op de opgegeven afstand. Handig voor het aanmaken van bufferstroken of wanddikte.

public void OffsetPolylijn(Database db, Transaction tr, ObjectId plId, double afstand)
{
    var pl = (Polyline)tr.GetObject(plId, OpenMode.ForRead);
    var ms = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite);

    // Offset geeft een CurveCollection terug
    foreach (Entity ent in pl.GetOffsetCurves(afstand))
    {
        ms.AppendEntity(ent);
        tr.AddNewlyCreatedDBObject(ent, true);
    }
}

Polylijn naar lijn/boog-segmenten exploderen

Gebruik Explode() om een polylijn om te zetten naar losse Line- en Arc-objecten. Nuttig als je individuele segmenten wil verwerken of exporteren.

public void ExplodeerNaarSegmenten(Database db, Transaction tr, ObjectId plId)
{
    var pl = (Polyline)tr.GetObject(plId, OpenMode.ForRead);
    var ms = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite);

    var segmenten = new DBObjectCollection();
    pl.Explode(segmenten);

    foreach (Entity seg in segmenten)
    {
        if (seg is Line l)
            Application.DocumentManager.MdiActiveDocument.Editor
                .WriteMessage($"\nLijn: {l.Length:F2} mm");
        else if (seg is Arc a)
            Application.DocumentManager.MdiActiveDocument.Editor
                .WriteMessage($"\nBoog: R={a.Radius:F2} hoek={a.TotalAngle * 180 / Math.PI:F1}°");

        ms.AppendEntity(seg);
        tr.AddNewlyCreatedDBObject(seg, true);
    }
    pl.UpgradeOpen();
    pl.Erase();
}

Oppervlakteberekening in bulk

Voor een stuklijst of hoeveelhedenraming kun je alle gesloten polylijnen doorlopen en hun oppervlaktes optellen.

public double BerekenTotaalOppervlak(Database db, Transaction tr)
{
    double totaal = 0;
    var ms = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId, OpenMode.ForRead);

    foreach (ObjectId id in ms)
    {
        if (tr.GetObject(id, OpenMode.ForRead) is Polyline pl && pl.Closed)
            totaal += pl.Area;
    }
    return totaal;
}

Veelgemaakte fouten

Bulge bij het laatste punt van een open polylijn — de bulge van het laatste vertex heeft geen effect bij een open polylijn (er is geen volgend punt). Stel hem in op 0.

ConstantWidth vs StartWidth/EndWidth — ConstantWidth stelt alle segmenten gelijk in. Voor variabele breedte gebruik je SetStartWidthAt en SetEndWidthAt per vertex.

Area van een open polylijn — AutoCAD berekent de oppervlakte door de polylijn virtueel te sluiten. Controleer altijd of de polylijn echt gesloten is (pl.Closed == true) als je oppervlakteberekeningen uitvoert.

Samenvatting

Polylijnen zijn de ruggengraat van de meeste AutoCAD-tekeningen. Met de .NET API kun je ze aanmaken, analyseren, splitsen, offsetten en exploderen. Bijzonder krachtig is de bulge-waarde voor bogen en de Area-property voor directe oppervlakteberekening — dit zijn functies die handmatig uren werk kosten maar geautomatiseerd in milliseconden draaien.

Polylines are the most commonly used geometry in AutoCAD drawings: outlines, routes, wall openings, parking spaces. This article shows how to create lightweight polylines (Polyline), add arcs via the bulge value, calculate areas and perimeters, and analyse and modify existing polylines in C#.

Lightweight Polyline vs 2D Polyline

AutoCAD has two polyline classes: Polyline (lightweight, recommended) and Polyline2d (legacy format). Always use Polyline for new code — it's more compact, faster and supports all modern features.

Creating a Simple Polyline

var pl = new Polyline();
pl.AddVertexAt(0, new Point2d(0,   0),  0, 0, 0);
pl.AddVertexAt(1, new Point2d(100, 0),  0, 0, 0);
pl.AddVertexAt(2, new Point2d(100, 50), 0, 0, 0);
pl.AddVertexAt(3, new Point2d(0,   50), 0, 0, 0);
pl.Closed = true;
pl.ConstantWidth = 0.5;
ms.AppendEntity(pl);
tr.AddNewlyCreatedDBObject(pl, true);

Adding Arcs with the Bulge Value

An arc in a polyline is defined by the bulge of a segment. Bulge = tan(angle/4), where angle is the included angle. A semicircle has bulge ±1.0. Positive = arc to the left of the direction, negative = right.

// D-shape: straight line + semicircle
var pl = new Polyline();
pl.AddVertexAt(0, new Point2d(0,  0), 0.0, 0, 0);
pl.AddVertexAt(1, new Point2d(0, 50), 1.0, 0, 0); // bulge=1 → semicircle
pl.AddVertexAt(2, new Point2d(0,  0), 0.0, 0, 0);

Reading and Analysing Points

for (int i = 0; i < pl.NumberOfVertices; i++)
{
    var pt    = pl.GetPoint2dAt(i);
    var bulge = pl.GetBulgeAt(i);
    var type  = Math.Abs(bulge) < 1e-6 ? "line" : "arc";
    Console.WriteLine($"Vertex {i}: ({pt.X:F1}, {pt.Y:F1})  bulge={bulge:F3}  [{type}]");
}
Console.WriteLine($"Area: {pl.Area:F2}  Length: {pl.Length:F2}");

Offsetting a Polyline

foreach (Entity ent in pl.GetOffsetCurves(offset))
{
    ms.AppendEntity(ent);
    tr.AddNewlyCreatedDBObject(ent, true);
}

Bulk Area Calculation

double total = 0;
foreach (ObjectId id in ms)
    if (tr.GetObject(id, OpenMode.ForRead) is Polyline p && p.Closed)
        total += p.Area;

Common Pitfalls

Bulge on the last vertex of an open polyline — bulge on the last vertex has no effect for open polylines. Set it to 0.

ConstantWidth vs per-vertex widths — ConstantWidth sets all segments equally. For variable widths use SetStartWidthAt / SetEndWidthAt per vertex.

Area on an open polyline — AutoCAD calculates area by virtually closing the polyline. Always verify pl.Closed == true before relying on area calculations.

Summary

Polylines are the backbone of most AutoCAD drawings. With the .NET API you can create, analyse, split, offset and explode them. The bulge value for arcs and the Area property for instant surface calculation are particularly powerful — tasks that take hours manually but run in milliseconds when automated.