C3d Alignments

Civil 3D Alignments

Use this skill when creating, modifying, or querying alignments, working with stations, or configuring superelevation.

Alignment Collections

// All alignments (siteless + sited)
ObjectIdCollection allAlignments = doc.GetAlignmentIds();

// Only siteless alignments
ObjectIdCollection sitelessAlignments = doc.GetSitelessAlignmentIds();

Creating Alignments

Empty Alignment (no geometry)

// Overload 1: By name strings (pass "" for siteless)
ObjectId alignId = Alignment.Create(doc, "New Alignment",
    "",             // site name ("" = siteless)
    "0",            // layer name
    "Basic",        // alignment style name
    "AllLabels"     // label set style name
);

// Overload 2: By ObjectIds (pass ObjectId.Null for siteless)
ObjectId alignId = Alignment.Create(doc, "New Alignment",
    ObjectId.Null,  // siteId (Null = siteless)
    layerId,        // ObjectId of layer
    styleId,        // ObjectId of alignment style
    labelSetId      // ObjectId of label set style
);

// Overload 3: By ObjectIds with explicit AlignmentType
ObjectId alignId = Alignment.Create(doc, "New Alignment",
    ObjectId.Null, layerId, styleId, labelSetId,
    AlignmentType.Centerline
);

From Polyline

PromptEntityOptions opt = new PromptEntityOptions("\nSelect a polyline");
opt.SetRejectMessage("\nObject must be a polyline.");
opt.AddAllowedClass(typeof(Polyline), false);
PromptEntityResult res = ed.GetEntity(opt);

PolylineOptions plops = new PolylineOptions();
plops.AddCurvesBetweenTangents = true;
plops.EraseExistingEntities = true;
plops.PlineId = res.ObjectId;

// String overload
ObjectId alignId = Alignment.Create(doc, plops,
    "New Alignment", "MySite", "0", "Standard", "Standard");

// ObjectId overload
ObjectId alignId = Alignment.Create(doc, plops,
    "New Alignment", siteId, layerId, styleId, labelSetId);

From Corridor Feature Line

ObjectId alignId = Alignment.Create(corridorFeatureLine,
    "FL Alignment", siteId, layerId, styleId, labelSetId,
    AlignmentType.Centerline);

Offset Alignment (static methods)

The instance method CreateOffsetAlignment(double) is deprecated since Civil 3D 2010. Use the static overloads instead:

// By name strings (full station range)
ObjectId offsetId = Alignment.CreateOffsetAlignment(db,
    "Offset Align",       // new alignment name
    "Parent Alignment",   // parent alignment name
    10.0,                 // offset distance (positive = right)
    "Standard"            // style name
);

// By name strings (partial station range)
ObjectId offsetId = Alignment.CreateOffsetAlignment(db,
    "Offset Align", "Parent Alignment", 10.0, "Standard",
    100.0, 500.0          // startStation, endStation
);

// By ObjectIds (full station range)
ObjectId offsetId = Alignment.CreateOffsetAlignment(
    "Offset Align", parentAlignId, 10.0, styleId);

// By ObjectIds (partial station range)
ObjectId offsetId = Alignment.CreateOffsetAlignment(
    "Offset Align", parentAlignId, 10.0, styleId, 100.0, 500.0);

Connected Alignment

ObjectId connectedId = Alignment.CreateConnectedAlignment(
    "Connected Align", siteId, layerId, styleId, labelSetId,
    connectedAlignmentParams);

// Check if an alignment is connected
bool isConnected = align.IsConnectedAlignment;
ConnectedAlignmentInfo info = align.ConnectedAlignmentInfo;

Site Operations

// Copy to a named site
align.CopyToSite("MySite");

// Copy by site ObjectId
align.CopyToSite(siteId);

// Copy within the same site
align.CopyToSameSite();

Alignment Entities

Entities are lines, curves, and spirals that form the alignment path. The collection supports fixed, floating, and free constraint types.

Iterating Entities

AlignmentEntityCollection entities = align.Entities;

foreach (AlignmentEntity ae in align.Entities)
{
    switch (ae.EntityType)
    {
        case AlignmentEntityType.Arc:
            AlignmentArc myArc = ae as AlignmentArc;
            ed.WriteMessage("Arc R={0}, L={1}\n", myArc.Radius, myArc.Length);
            break;
        case AlignmentEntityType.Line:
            AlignmentLine myLine = ae as AlignmentLine;
            ed.WriteMessage("Line dir={0}\n", myLine.Direction);
            break;
        case AlignmentEntityType.Spiral:
            AlignmentSpiral mySpiral = ae as AlignmentSpiral;
            ed.WriteMessage("Spiral A={0}\n", mySpiral.A);
            break;
        // Also: SpiralCurve, SpiralSpiral, SpiralCurveSpiralCurveSpiral, etc.
    }
}

Accessing Entities

AlignmentEntity entity = entities.EntityAtId(entityId);     // by entity ID
AlignmentEntity entity = entities.GetEntityByOrder(index);   // by draw order
AlignmentEntity entity = entities.EntityAtStation(rawStation); // by station
int first = entities.FirstEntity;  // ID of first entity
int last  = entities.LastEntity;   // ID of last entity

Adding Fixed Entities (defined by coordinates)

// Fixed lines
AlignmentLine line = entities.AddFixedLine(startPoint, endPoint);
AlignmentLine line = entities.AddFixedLine(prevEntityId, startPoint, endPoint);
AlignmentLine line = entities.AddFixedLine(prevEntityId, distance);

// Fixed curves (many overloads)
AlignmentArc arc = entities.AddFixedCurve(prevEntityId, startPt, midPt, endPt);
AlignmentArc arc = entities.AddFixedCurve(pt1, pt2, radius, isClockwise);
AlignmentArc arc = entities.AddFixedCurve(centerPt, passThroughPt, isClockwise);
AlignmentArc arc = entities.AddFixedCurve(centerPt, radius, isClockwise);
AlignmentArc arc = entities.AddFixedCurve(pt1, dirAtPt1, radius, isClockwise);
AlignmentArc arc = entities.AddFixedCurve(pt1, dirAtPt1, pt2);
AlignmentArc arc = entities.AddFixedCurve(pt1, pt2, dirAtPt2);

// Fixed spirals
AlignmentSpiral sp = entities.AddFixedSpiral(prevId, startRadius, endRadius, length, spiralDef);
AlignmentSpiral sp = entities.AddFixedSpiral(prevId, radius, length, spiralCurveType, spiralDef);
AlignmentSpiral sp = entities.AddFixedSpiral(prevId, startPt, piPt, endPt, spiralDef);

Adding Floating Entities (attached to one neighbor)

// Floating lines
AlignmentLine line = entities.AddFloatingLine(prevEntityId, length);
AlignmentLine line = entities.AddFloatingLine(prevEntityId, passThroughPt);
AlignmentLine line = entities.AddFloatingLine(length, nextEntityId);

// Floating curves
AlignmentArc arc = entities.AddFloatingCurve(prevEntityId, passThroughPt);
AlignmentArc arc = entities.AddFloatingCurve(prevEntityId, radius, paramValue,
    paramType, isClockwise);

Adding Free Entities (constrained to two neighbors)

// Free line between two entities
AlignmentLine line = entities.AddFreeLine(prevEntityId, nextEntityId);

// Free curve between two entities
AlignmentArc arc = entities.AddFreeCurve(prevEntityId, nextEntityId,
    passThroughPt);
AlignmentArc arc = entities.AddFreeCurve(prevEntityId, nextEntityId,
    paramValue, paramType, isGreaterThan180, curveType);

// Free spiral-curve-spiral
AlignmentSCS scs = entities.AddFreeSCS(prevEntityId, nextEntityId,
    sp1Param, sp2Param, spType, radius, isGreaterThan180, spiralDef);

Removing Entities

entities.Remove(entity);
entities.RemoveAt(index);
entities.Clear();

Stations

Station Equations

StationEquation eq = align.StationEquations.Add(
    80,     // rawStationBack: raw station value at the equation point (distance from start)
    0,      // stationAhead: station value assigned going ahead past the equation
    StationEquationType.Increasing
);

Station Sets

StationTypes is a flags enum (note the plural). Common values: All, Major, Minor, GeometryPoint, Equation, SuperTransPoint.

// Get all stations with major=100, minor=20
Station[] stations = align.GetStationSet(StationTypes.All, 100, 20);
foreach (Station s in stations)
{
    ed.WriteMessage("Station {0}, Type: {1}, Location: ({2},{3})\n",
        s.RawStation, s.StationType, s.Location.X, s.Location.Y);
}

// Major stations only, single interval
Station[] majors = align.GetStationSet(StationTypes.Major, 100);

// Geometry points only (no interval needed)
Station[] geoPts = align.GetStationSet(StationTypes.GeometryPoint);

// Custom range with major=50, minor=10
Station[] ranged = align.GetStationSet(StationTypes.All, 50, 10, 100.0, 500.0);

Point Location from Station

// Simple version: station + offset -> easting + northing
double easting, northing;
align.PointLocation(station, offset, ref easting, ref northing);

// With tolerance and bearing
double bearing;
align.PointLocation(station, offset, tolerance,
    ref easting, ref northing, ref bearing);

Tolerance note: Determines which entity the point is on. A large tolerance may place the point on an earlier entity. Note parameter order is easting, northing (X, Y).

Station/Offset from Point (inverse of PointLocation)

// Simple version: easting + northing -> station + offset
double station, offset;
align.StationOffset(easting, northing, ref station, ref offset);

// With tolerance
align.StationOffset(easting, northing, tolerance, ref station, ref offset);

// Accept out-of-range points (beyond alignment start/end)
bool outOfRange;
align.StationOffsetAcceptOutOfRange(easting, northing,
    ref station, ref offset, ref outOfRange);

// With tolerance + out-of-range
align.StationOffsetAcceptOutOfRange(easting, northing, tolerance,
    ref station, ref offset, ref outOfRange);

Instantaneous Radius at Station

// Get the radius at a specific raw station value
// Returns double.PositiveInfinity for tangent segments
double radius = align.GetInstantaneousRadius(rawStation);

Reverse Alignment Direction

// Reverses the direction of the alignment geometry
align.Reverse();

Distance to Another Alignment

double distToOther, stationOnOther;
align.DistanceToAlignment(stationOnThis, otherAlignment,
    ref distToOther, ref stationOnOther);

// With explicit side
align.DistanceToAlignment(stationOnThis, otherAlignment,
    AlignmentSide.Left, ref distToOther, ref stationOnOther);

Design Speeds

DesignSpeed ds = align.DesignSpeeds.Add(0, 45);    // station 0+00, 45 mph
ds.Comment = "Straightaway";

ds = align.DesignSpeeds.Add(430, 30);               // station 4+30
ds.Comment = "Start of curve";

align.UseDesignSpeed = true; // Enable speed-based design

Note: GetDesignSpeed() requires a "raw" station value (without station equation modifications).

Superelevation

Superelevation is divided into curves, each containing transition regions with critical stations.

// Access superelevation curves
if (align.SuperelevationCurves.Count < 1)
{
    ed.WriteMessage("Must calculate superelevation data first.\n");
    return;
}

foreach (SuperelevationCurve sec in align.SuperelevationCurves)
{
    ed.WriteMessage("Curve: {0}, Start: {1}, End: {2}\n",
        sec.Name, sec.StartStation, sec.EndStation);

    foreach (SuperelevationCriticalStation sest in sec.CriticalStations)
    {
        ed.WriteMessage("  Station: {0}, Type: {1}, Region: {2}\n",
            sest.Station, sest.StationType, sest.TransitionRegionType);

        // Get slope for each cross segment type
        foreach (int i in Enum.GetValues(typeof(SuperelevationCrossSegmentType)))
        {
            try
            {
                double slope = sest.GetSlope(
                    (SuperelevationCrossSegmentType)i);
                ed.WriteMessage("    Slope: {0}, Segment: {1}\n", slope,
                    Enum.GetName(typeof(SuperelevationCrossSegmentType), i));
            }
            catch (InvalidOperationException) { } // Invalid segment type for this station
        }
    }
}

Key properties:

• Alignment.SuperelevationCurves - collection of SE curves
• Alignment.SuperelevationCriticalStations - all critical stations across all curves
• SuperelevationCriticalStationCollection.GetCriticalStationAt() - access individual stations

API Change Note (Civil 3D 2013+): SuperelevationData property and SuperElevationAtStation() method were removed. Use SuperelevationCurves and SuperelevationCriticalStations instead.

Alignment Styles

ObjectId styleId = doc.Styles.AlignmentStyles.Add("My Alignment Style");
AlignmentStyle style = ts.GetObject(styleId, OpenMode.ForWrite) as AlignmentStyle;

// Hide direction arrows
style.GetDisplayStylePlan(AlignmentDisplayStyleType.Arrow).Visible = false;

// Show curves in violet
style.GetDisplayStylePlan(AlignmentDisplayStyleType.Curve).Color =
    Color.FromColorIndex(ColorMethod.ByAci, 200);

// Show lines in blue
style.GetDisplayStylePlan(AlignmentDisplayStyleType.Line).Color =
    Color.FromColorIndex(ColorMethod.ByAci, 160);

// Assign to alignment
align.StyleId = style.Id;

Alignment Label Styles

Labels are set via LabelSet when creating an alignment, or through LabelSetStyles:

// Label set styles
var labelSetStyles = doc.Styles.LabelSetStyles.AlignmentLabelSetStyles;

// AlignmentLabelSetItem types:
// LabelStyleType.AlignmentMajorStation
// LabelStyleType.AlignmentMinorStation

// Minor stations must reference a parent major station AlignmentLabelSetItem

Alignment Label Property Fields

Major/minor stations:

<[Station Value(Uft|FS|P0|RN|AP|Sn|TP|B2|EN|W0|OF)]>
<[Northing(Uft|P4|RN|AP|Sn|OF)]>
<[Design Speed(P3|RN|AP|Sn|OF)]>
<[Alignment Name(CP)]>

Additional fields for specific label types:

• Minor stations: <[Offset From Major Station(...)]>
• Geometry points: <[Geometry Point Text(CP)]>, <[Geometry Point Entity Before/After Data(CP)]>
• Design speeds: <[Design Speed Before(...)]>
• Station equations: <[Station Ahead(...)]>, <[Station Back(...)]>, <[Increase/Decrease(CP)]>

Related Queries

// Get profile views for this alignment
ObjectIdCollection pvIds = align.GetProfileViewIds();

// Get sample line groups
ObjectIdCollection slgIds = align.GetSampleLineGroupIds();

// Get profiles
ObjectIdCollection profileIds = align.GetProfileIds();

// Get superelevation views
ObjectIdCollection seViewIds = align.GetSuperelevationViewIds();

// Get child offset alignments
ObjectIdCollection offsetIds = align.GetChildOffsetAlignmentIds();
ObjectIdCollection dynamicOnly = align.GetChildOffsetAlignmentIds(true); // only dynamic-update offsets

// Get label group IDs
ObjectIdCollection labelGroupIds = align.GetAlignmentLabelGroupIds();
ObjectIdCollection labelIds = align.GetAlignmentLabelIds();

// Export to polyline
ObjectId plineId = align.GetPolyline();

// Import a label set
align.ImportLabelSet("My Label Set");
align.ImportLabelSet(labelSetStyleId);

// Get station string with equations applied
string stationStr = align.GetStationStringWithEquations(rawStation);

// Get next unique alignment name
string uniqueName = Alignment.GetNextUniqueName("MyAlignment");

Useful Properties

// Alignment geometry range
double start  = align.StartingStation;
double end    = align.EndingStation;
double endEq  = align.EndingStationWithEquations;
double length = align.Length;

// Reference point (station origin)
Point2d refPt     = align.ReferencePoint;
double refStation  = align.ReferencePointStation;

// Site info
string siteName = align.SiteName;
bool isSiteless = align.IsSiteless;

// Offset alignment info
bool isOffset = align.IsOffsetAlignment;
OffsetAlignmentInfo oaInfo = align.OffsetAlignmentInfo;

// Type and creation mode
AlignmentType aType = align.AlignmentType;
AlignmentCreationType cMode = align.CreationMode;

// Cross slope at station (superelevation)
// Valid values: LeftOutShoulderCrossSlope, LeftOutLaneCrossSlope, LeftInShoulderCrossSlope,
//               LeftInLaneCrossSlope, RightOutShoulderCrossSlope, RightOutLaneCrossSlope,
//               RightInShoulderCrossSlope, RightInLaneCrossSlope
double slope = align.GetCrossSlopeAtStation(station,
    SuperelevationCrossSegmentType.LeftInLaneCrossSlope, true); // adjust side as needed

Gotchas

• Create() string overload fails if the named styles don't exist in the document
• Offset alignment does NOT inherit station labels, equations, or design speeds
• Station equations modify station values - some methods need "raw" stations (use GetStationStringWithEquations() for display)
• Superelevation curves must be calculated before accessing (manually or via wizard)
• GetSlope() throws InvalidOperationException for invalid segment types - catch silently
• PointLocation and StationOffset parameter order is easting, northing (X, Y), not northing, easting
• GetInstantaneousRadius() requires a raw station value
• The instance method CreateOffsetAlignment(double) is deprecated since Civil 3D 2010; use the static overloads
• StationTypes is a flags enum (plural) - use StationTypes.All, not StationType.All

Related Skills

• c3d-profiles - Profiles along alignments
• c3d-label-styles - General label style creation
• c3d-corridors - Corridors use alignments as baselines
• acad-editor-input - Selecting alignments with GetEntity and AddAllowedClass
• c3d-superelevation - Detailed superelevation data access, critical stations, and cross slopes
• c3d-intersections - Intersection objects at alignment crossings