GeometryHelper.ArrangeAlgorithms 4.0.0

GeometryHelper.ArrangeAlgorithms

2D label placement for engineering drawings: given a set of labels, each associated with a guide segment and surrounding blocked regions, the library calculates translation vectors that keep labels from overlapping each other and from encroaching on the blocked regions.

It depends on AutoCAD and Tekla for nothing. The geometry it works in comes from GeometryHelper.PlaneGeometry, which comes with this package as a dependency.

Installation

dotnet add package GeometryHelper.ArrangeAlgorithms

GeometryHelper.PlaneGeometry and GeometryHelper.CommonGeometry come with it as dependencies.

Visual Examples

AutoCAD Integration

Here are some examples of labels arranged inside AutoCAD to avoid overlaps and blocked regions:

Greedy	Force Directed

Tekla Structures Integration

Here is an example of reinforcement marks before and after arrangement:

Before Arrangement	After Arrangement

Arranged Marks Avoiding Dimension Obstacles

Quick Start

var leader = new GeoLine2(0.0, 0.0, 2000.0, 0.0);

var arranges = new List<Arrange>
{
    new Arrange
    {
        // Label bounding box: center, width, height, rotation angle (radians, counter-clockwise)
        GeoRectangle2 = new GeoRectangle2(new GeoPoint2(1000.0, 0.0), 2000.0, 1000.0),
        // Guide segment: its midpoint is the origin for candidate positions expansion
        GeoLine2      = leader,
        // Minimum perpendicular offset between label edge and guide segment, specific to this label (default 50)
        MarkOffsetFromLine = 50.0,
        // Blocked regions the label must not overlap
        BlockPolygons = new List<GeoPolygon2>(),
        BlockLines    = new List<GeoLine2>()
    }
};

// Returns translation vector for each label, in the exact input order.
// Each Arrange object is also automatically updated: arranges[i].TranslationVector contains the same vector.
List<GeoVector2> moves = Arrange.Run(arranges);

for (int i = 0; i < arranges.Count; i++)
{
    // You can use the returned 'moves[i]' or read the property directly:
    GeoVector2 move = arranges[i].TranslationVector; 
    
    GeoPoint2 newPosition = arranges[i].GeoRectangle2.Center + move;
    bool isPlaced = arranges[i].Placed; // false = forced to fallback, still has overlap
}

To change the algorithm or fine-tune parameters, pass ArrangeOptions:

var options = new ArrangeOptions
{
    Algorithm           = ArrangeAlgorithmType.BoundedBacktracking,
    RowGap              = 20.0,
    PerpendicularLevels = 3
};

List<GeoVector2> moves = Arrange.Run(arranges, options);

ArrangeOptions is the shared configuration for the entire list. MarkOffsetFromLine is set per Arrange because each label may require a different offset:

var smallTextLabel = new Arrange
{
    GeoRectangle2 = new GeoRectangle2(new GeoPoint2(1000.0, 0.0), 2000.0, 1000.0),
    GeoLine2      = leader,
    MarkOffsetFromLine = 50.0   // small text, closely sticks to guide segment
};

var largeTextLabel = new Arrange
{
    GeoRectangle2 = new GeoRectangle2(new GeoPoint2(1000.0, 0.0), 4000.0, 2000.0),
    GeoLine2      = leader,
    MarkOffsetFromLine = 200.0  // large text, must move further away
};

List<GeoVector2> moves = Arrange.Run(new List<Arrange> { smallTextLabel, largeTextLabel }, options);

Candidate Positions Generation

All 5 algorithms share the same set of discrete candidate positions, expanding from the midpoint of the guide segment:

• Perpendicular Translation — each level in PerpendicularLevels creates a row of labels, symmetric on both sides of the guide segment. The first level is placed at half the label height plus the label's own MarkOffsetFromLine. Each subsequent level adds the label height plus RowGap.
• Longitudinal Sliding — in each row, the label slides parallel to the guide segment in both directions, up to a maximum of half the guide segment length plus LongitudinalOvershootRatio times the label width.

The algorithms only differ in how they select from this candidate set.

Five Algorithms

BoundedBacktracking and ConstraintSatisfaction automatically fallback to Greedy if no collision-free solution is found, ensuring every label always has a display position.

SimulatedAnnealing uses a fixed seed, so its results are reproducible between runs.

Parameters for each Arrange

Main Parameters of ArrangeOptions

Default values are in millimeters, matching conventional structural drawings.

Running inside AutoCAD

GeometryHelper.ArrangeAlgorithms.CadTest builds a DLL file to be loaded into AutoCAD:

dotnet build Samples/GeometryHelper.ArrangeAlgorithms.CadTest/GeometryHelper.ArrangeAlgorithms.CadTest.csproj

The output is located at Samples/GeometryHelper.ArrangeAlgorithms.CadTest/bin/Debug/net48/GeometryHelper.ArrangeAlgorithms.CadTest.dll. Load this file into AutoCAD using the NETLOAD command, then run one of the following commands: T1_Greedy, T1_BoundedBacktracking, T1_SimulatedAnnealing, T1_ForceDirected, T1_ConstraintSatisfaction. Select LINE or LWPOLYLINE objects, and the plugin will draw the label box before and after arrangement, along with statistics.

The project compiles against three AutoCAD assemblies — accoremgd, acdbmgd, acmgd — committed under Libraries/GeometryHelper.CadConvert/Lib and referenced from there by relative path, so no AutoCAD installation is needed to build. Loading the result still needs AutoCAD, which supplies those assemblies at run time.

Running inside Tekla Structures

GeometryHelper.ArrangeAlgorithms.TeklaTest is a console application that connects to the active Tekla Structures model and drawing to arrange reinforcement marks.

To build and run:

1. Open Tekla Structures and open a drawing with some reinforcement marks and dimensions selected.
2. Build the project:

   dotnet build Samples/GeometryHelper.ArrangeAlgorithms.TeklaTest/GeometryHelper.ArrangeAlgorithms.TeklaTest.csproj
   

3. Run the compiled executable:

   Samples/GeometryHelper.ArrangeAlgorithms.TeklaTest/bin/Debug/net48/GeometryHelper.ArrangeAlgorithms.TeklaTest.exe
   

Licence

MIT.