Class AcDbSpline

Represents a spline entity in AutoCAD.

A spline is a 3D geometric object defined by control points or fit points. Splines are smooth curves that can be used to create complex curved shapes in drawings. They can be either open or closed curves.

Example

// Create a spline from control points
const controlPoints = [
  new AcGePoint3d(0, 0, 0),
  new AcGePoint3d(5, 5, 0),
  new AcGePoint3d(10, 0, 0)
];
const knots = [0, 0, 0, 1, 1, 1];
const spline = new AcDbSpline(controlPoints, knots);

// Create a spline from fit points
const fitPoints = [
  new AcGePoint3d(0, 0, 0),
  new AcGePoint3d(5, 5, 0),
  new AcGePoint3d(10, 0, 0)
];
const spline2 = new AcDbSpline(fitPoints, AcGeKnotParameterizationType.Uniform);

Hierarchy (View Summary)

Constructors

constructor

Properties

typeName

Accessors

area attrs closed color database dxfTypeName extensionDictionary geometricExtents isTemp layer lineStyle lineType linetypeScale lineWeight objectId ownerId properties resolvedColor transparency type visibility

Methods

assignDatabase clone close createExtensionDictionary dxfOut dxfOutFields erase getAttr getAttrWithoutException getEntityColor getGeneralProperties getLayerColor getOffsetCurves getOffsetSideAtPoint getXData hasExplicitColor hasExplicitLayer hasExplicitTransparency rebuild removeXData resolveEffectiveProperties resolveStandardColor setAttr setEntityColor setXData shouldResolveColorFromCecolor subGetGripPoints subGetOsnapPoints subWorldDraw transformBy triggerModifiedEvent worldDraw fromControlPoints fromDwgSpline fromFitPoints

Constructors

constructor

  • new AcDbSpline(
        controlPoints: AcGeVector3dLike[],
        knots: number[],
        weights?: number[],
        degree?: number,
        closed?: boolean,
    ): AcDbSpline

  • Creates a new spline entity from control points.

    This constructor creates a spline using the specified control points, knots, and optional weights. The control points must be in World Coordinate System (WCS) coordinates.

    Parameters

    • controlPoints: AcGeVector3dLike[]

      Array of control points in WCS coordinates

    • knots: number[]

      Array of knot values that define the spline's parameterization

    • Optionalweights: number[]

      Optional array of weights for each control point (default: 1 for all)

    • Optionaldegree: number

      Optional degree of the spline (default: 3)

    • Optionalclosed: boolean

      Whether the spline should be closed (default: false)

    Returns AcDbSpline

    Example

    const controlPoints = [
      new AcGePoint3d(0, 0, 0),
      new AcGePoint3d(5, 5, 0),
      new AcGePoint3d(10, 0, 0)
    ];
    const knots = [0, 0, 0, 1, 1, 1];
    const spline = new AcDbSpline(controlPoints, knots);
  • new AcDbSpline(
        fitPoints: AcGeVector3dLike[],
        knotParam: AcGeKnotParameterizationType,
        degree?: number,
        closed?: boolean,
    ): AcDbSpline

  • Creates a new spline entity from fit points.

    This constructor creates a spline that passes through the specified fit points. The fit points must be in World Coordinate System (WCS) coordinates.

    Parameters

    • fitPoints: AcGeVector3dLike[]

      Array of fit points in WCS coordinates

    • knotParam: AcGeKnotParameterizationType

      Knot parameterization type that defines how knots are generated

    • Optionaldegree: number

      Optional degree of the spline (default: 3)

    • Optionalclosed: boolean

      Whether the spline should be closed (default: false)

    Returns AcDbSpline

    Example

    const fitPoints = [
      new AcGePoint3d(0, 0, 0),
      new AcGePoint3d(5, 5, 0),
      new AcGePoint3d(10, 0, 0)
    ];
    const spline = new AcDbSpline(fitPoints, AcGeKnotParameterizationType.Uniform);

Properties

StatictypeName

typeName: string = 'Spline'

The entity type name

Accessors

area

attrs

closed

  • get closed(): boolean

  • Gets whether this spline is closed.

    A closed spline forms a complete loop where the end point connects to the start point.

    Returns boolean

    True if the spline is closed, false otherwise

    Example

    const isClosed = spline.closed;
    console.log(`Spline is closed: ${isClosed}`);
  • set closed(value: boolean): void

  • Sets whether this spline is closed.

    Parameters

    • value: boolean

      True to close the spline, false to open it

    Returns void

    Example

    spline.closed = true; // Close the spline

color

database

  • get database(): AcDbDatabase

  • Gets the database in which this object is resident.

    When an object isn't added to a database, this property returns the current working database. After it is added to a database, it will be set automatically. You should never set this value manually.

    Returns AcDbDatabase

    The database this object belongs to

    Example

    const db = obj.database;
  • set database(db: AcDbDatabase): void

  • Sets the database for this object.

    This is typically set automatically when the object is added to a database. Manual setting should be avoided unless you know what you're doing.

    Parameters

    Returns void

    Example

    obj.database = myDatabase;

dxfTypeName

  • get dxfTypeName(): string

  • Gets the DXF entity type name written to the file.

    This value is the literal DXF record type emitted for the entity during DXF export, such as LINE, INSERT, or DIMENSION.

    Every concrete entity class must explicitly define this property so the DXF export contract stays local to the entity implementation rather than being inferred by the base class.

    Returns string

    The DXF entity type name used during export

extensionDictionary

  • get extensionDictionary(): undefined | string

  • Gets the objectId of the extension dictionary owned by this object.

    If the object does not have an extension dictionary, this returns undefined.

    In ObjectARX terms, this is equivalent to AcDbObject::extensionDictionary().

    Returns undefined | string

    The extension dictionary objectId, or undefined

    Example

    const dictId = obj.extensionDictionary
    if (dictId) {
      console.log('Has extension dictionary:', dictId)
    }
  • set extensionDictionary(value: undefined | string): void

  • Sets the objectId of the extension dictionary owned by this object.

    This does not create or delete the dictionary object itself — it only establishes or clears the ownership relationship.

    Passing undefined removes the association.

    Parameters

    • value: undefined | string

      The extension dictionary objectId, or undefined

    Returns void

    Example

    obj.extensionDictionary = dict.objectId

geometricExtents

  • get geometricExtents(): AcGeBox3d

  • Gets the geometric extents (bounding box) of this spline.

    Returns AcGeBox3d

    The bounding box that encompasses the entire spline

    Example

    const extents = spline.geometricExtents;
    console.log(`Spline bounds: ${extents.minPoint} to ${extents.maxPoint}`);

isTemp

  • get isTemp(): any

  • Returns true if this object is temporary and not yet committed to the database.

    A temporary object is identified by its objectId starting with the TEMP prefix.

    Returns any

layer

  • get layer(): string

  • Gets the name of the layer referenced by this entity.

    Returns string

    The layer name

    Example

    const layerName = entity.layer;
  • set layer(value: string): void

  • Sets the name of the layer for this entity.

    Parameters

    • value: string

      The new layer name

    Returns void

    Example

    entity.layer = 'MyLayer';

lineStyle

lineType

  • get lineType(): string

  • Gets the name of the line type referenced by this entity.

    Returns string

    The linetype name

    Example

    const lineType = entity.lineType;
  • set lineType(value: string): void

  • Sets the name of the line type for this entity.

    Parameters

    • value: string

      The new linetype name

    Returns void

    Example

    entity.lineType = 'DASHED';

linetypeScale

  • get linetypeScale(): number

  • Gets the line type scale factor of this entity.

    When an entity is first instantiated, its line type scale is initialized to an invalid value. When the entity is added to the database, if a linetype scale has not been specified for the entity, it is set to the database's current line type scale value.

    Returns number

    The linetype scale factor

    Example

    const scale = entity.linetypeScale;
  • set linetypeScale(value: number): void

  • Sets the line type scale factor for this entity.

    Parameters

    • value: number

      The new linetype scale factor

    Returns void

    Example

    entity.linetypeScale = 2.0;

lineWeight

objectId

  • get objectId(): string

  • Gets the object ID.

    AutoCAD uses 64-bit integers to represent handles, which exceed the maximum integer value of JavaScript. Therefore, strings are used to represent object handles.

    Returns string

    The object ID as a string

    Example

    const id = obj.objectId;
    console.log(`Object ID: ${id}`);
  • set objectId(value: string): void

  • Sets the object ID.

    Parameters

    • value: string

      The new object ID

    Returns void

    Example

    obj.objectId = 'new-object-id';

ownerId

  • get ownerId(): string

  • Gets the object ID of the owner of this object.

    Returns string

    The owner object ID

    Example

    const ownerId = obj.ownerId;
  • set ownerId(value: string): void

  • Sets the object ID of the owner of this object.

    Parameters

    • value: string

      The new owner object ID

    Returns void

    Example

    obj.ownerId = 'parent-object-id';

properties

  • get properties(): AcDbEntityProperties

  • Returns the full property definition for this entity, including all property groups and runtime accessors.

    This getter is used by the property inspector UI to:

    • determine the layout and grouping of properties,
    • look up editable flags and metadata,
    • read/write live values on this entity using accessors.

    The returned structure contains:

    • static metadata (label, type, group structure),
    • dynamic accessor bindings that expose the actual values stored in the entity.

    Note: The groups array contains AcDbEntityPropertyGroup objects whose properties entries are runtime-resolved property descriptors that include AcDbPropertyAccessor objects. Each property object therefore conforms to AcDbEntityRuntimeProperty.

    Returns AcDbEntityProperties

resolvedColor

transparency

type

  • get type(): string

  • Gets the type name of this entity.

    This method returns the entity type by removing the "AcDb" prefix from the constructor name.

    Returns string

    The entity type name

    Example

    const entity = new AcDbLine();
    console.log(entity.type); // "Line"

visibility

  • get visibility(): boolean

  • Gets whether this entity is visible.

    Returns boolean

    True if the entity is visible, false otherwise

    Example

    const isVisible = entity.visibility;
  • set visibility(value: boolean): void

  • Sets whether this entity is visible.

    Parameters

    • value: boolean

      True to make the entity visible, false to hide it

    Returns void

    Example

    entity.visibility = false; // Hide the entity

Methods

ProtectedassignDatabase

clone

close

  • close(): void

  • Closes the object.

    All changes made to the object since it was opened are committed to the database, and a "closed" notification is sent. This method can be overridden by subclasses to provide specific cleanup behavior.

    Returns void

    Example

    obj.close();

createExtensionDictionary

  • createExtensionDictionary(): undefined | string

  • Creates the extension dictionary for this object if it does not already exist.

    This method closely mirrors the behavior of AcDbObject::createExtensionDictionary() in ObjectARX.

    • If the object already owns an extension dictionary, no new dictionary is created and the existing dictionary's objectId is returned.
    • Otherwise, a new AcDbDictionary is created, added to the same database, owned by this object, and its objectId is stored on this object.

    Returns undefined | string

    The objectId of the extension dictionary

    Example

    const dictId = obj.createExtensionDictionary()

dxfOut

dxfOutFields

erase

getAttr

  • getAttr(attrName: string): any

  • Gets the value of the specified attribute.

    This method will throw an exception if the specified attribute doesn't exist. Use getAttrWithoutException() if you want to handle missing attributes gracefully.

    Parameters

    • attrName: string

      The name of the attribute to retrieve

    Returns any

    The value of the specified attribute

    Throws

    When the specified attribute doesn't exist

    Example

    try {
      const value = obj.getAttr('objectId');
    } catch (error) {
      console.error('Attribute not found');
    }

getAttrWithoutException

  • getAttrWithoutException(attrName: string): any

  • Gets the value of the specified attribute without throwing an exception.

    This method returns undefined if the specified attribute doesn't exist, making it safer for optional attributes.

    Parameters

    • attrName: string

      The name of the attribute to retrieve

    Returns any

    The value of the specified attribute, or undefined if it doesn't exist

    Example

    const value = obj.getAttrWithoutException('optionalAttribute');
    if (value !== undefined) {
      // Use the value
    }

ProtectedgetEntityColor

ProtectedgetGeneralProperties

ProtectedgetLayerColor

getOffsetCurves

  • getOffsetCurves(offsetDist: number): AcDbCurve[]

  • Creates offset curves at the given signed distance, similar to ObjectARX AcDbCurve::getOffsetCurves.

    The sign of offsetDist determines the offset side relative to the curve direction in the curve plane. Returns an empty array when offsetting fails.

    Parameters

    • offsetDist: number

      Signed offset distance in drawing units

    Returns AcDbCurve[]

    Offset curve entities (equivalent to AcDbVoidPtrArray)

getOffsetSideAtPoint

getXData

  • getXData(appId: string): undefined | AcDbResultBuffer

  • Retrieves the XData associated with this object for a given application ID.

    Extended Entity Data (XData) allows applications to attach arbitrary, application-specific data to an AcDbObject. Each XData entry is identified by a registered application name (AppId) and stored as an AcDbResultBuffer.

    This method is conceptually equivalent to AcDbObject::xData() in ObjectARX, but simplified to return the entire result buffer for the specified AppId.

    Parameters

    • appId: string

      The application ID (registered AppId name) that owns the XData

    Returns undefined | AcDbResultBuffer

    The AcDbResultBuffer associated with the AppId, or undefined if no XData exists for that AppId

    Example

    const xdata = obj.getXData('MY_APP')
    if (xdata) {
      // Read values from the result buffer
    }

ProtectedhasExplicitColor

ProtectedhasExplicitLayer

ProtectedhasExplicitTransparency

rebuild

  • rebuild(
        controlPoints: AcGeVector3dLike[],
        knots: number[],
        weights?: number[],
        degree?: number,
        closed?: boolean,
    ): void

  • Rebuilds the spline geometry with new parameters.

    This method recreates the underlying geometric spline object with the specified parameters. It supports the same parameter combinations as the constructor.

    Parameters

    • controlPoints: AcGeVector3dLike[]

      Array of control points in WCS coordinates

    • knots: number[]

      Array of knot values that define the spline's parameterization

    • Optionalweights: number[]

      Optional array of weights for each control point (default: 1 for all)

    • Optionaldegree: number

      Optional degree of the spline (default: 3)

    • Optionalclosed: boolean

      Whether the spline should be closed (default: false)

    Returns void

    Example

    const controlPoints = [
      new AcGePoint3d(0, 0, 0),
      new AcGePoint3d(5, 5, 0),
      new AcGePoint3d(10, 0, 0)
    ];
    const knots = [0, 0, 0, 1, 1, 1];
    spline.rebuild(controlPoints, knots);
  • rebuild(
        fitPoints: AcGeVector3dLike[],
        knotParam: AcGeKnotParameterizationType,
        degree?: number,
        closed?: boolean,
    ): void

  • Rebuilds the spline geometry with new parameters.

    This method recreates the underlying geometric spline object with the specified parameters. It supports the same parameter combinations as the constructor.

    Parameters

    • fitPoints: AcGeVector3dLike[]

      Array of fit points in WCS coordinates

    • knotParam: AcGeKnotParameterizationType

      Knot parameterization type that defines how knots are generated

    • Optionaldegree: number

      Optional degree of the spline (default: 3)

    • Optionalclosed: boolean

      Whether the spline should be closed (default: false)

    Returns void

    Example

    const fitPoints = [
      new AcGePoint3d(0, 0, 0),
      new AcGePoint3d(5, 5, 0),
      new AcGePoint3d(10, 0, 0)
    ];
    spline.rebuild(fitPoints, AcGeKnotParameterizationType.Uniform);

removeXData

  • removeXData(appId: string): void

  • Removes the XData associated with the specified application ID.

    After removal, calls to getXData() for the same AppId will return undefined. If no XData exists for the given AppId, this method has no effect.

    This mirrors the behavior of clearing XData for a specific application in ObjectARX rather than removing all XData from the object.

    Parameters

    • appId: string

      The application ID whose XData should be removed

    Returns void

    Example

    obj.removeXData('MY_APP')

resolveEffectiveProperties

  • resolveEffectiveProperties(): void

  • Resolves the effective properties of this entity.

    This method determines the final, usable values for entity properties such as layer, linetype, lineweight, color, and other display-related attributes. If a property is not explicitly set on the entity (for example, it is undefined or specified as ByLayer / ByBlock), the value is resolved according to the current AutoCAD system variables and drawing context.

    Typical system variables involved in the resolution process include, but are not limited to:

    • CLAYER – Current layer
    • CELTYPE – Current linetype
    • CELWEIGHT – Current lineweight
    • CECOLOR – Current color

    The resolution follows AutoCAD semantics:

    • Explicitly assigned entity properties take precedence
    • ByLayer properties are inherited from the entity’s layer
    • ByBlock properties are inherited from the owning block reference
    • If no explicit value can be determined, the corresponding system variable or default drawing value is used

    This method does not change user-defined property settings; it only computes and applies the final effective values used for display, selection, and downstream processing.

    Returns void

ProtectedresolveStandardColor

setAttr

ProtectedsetEntityColor

setXData

  • setXData(resbuf: AcDbResultBuffer): void

  • Attaches or replaces XData for this object.

    If XData already exists for the given AppId, it is replaced by the provided AcDbResultBuffer. The caller is responsible for ensuring that:

    • The AppId is registered in the database's AppId table
    • The result buffer follows valid DXF/XData conventions (e.g. starts with a 1001 group code for the AppId)

    This method is conceptually similar to AcDbObject::setXData() in ObjectARX.

    Parameters

    Returns void

    Example

    const rb = new AcDbResultBuffer([
      { code: AcDbDxfCode.ExtendedDataRegAppName, value: 'MY_APP' },
      { code: AcDbDxfCode.ExtendedDataAsciiString, value: 'custom value' }
    ])

    obj.setXData('MY_APP', rb)

ProtectedshouldResolveColorFromCecolor

subGetGripPoints

subGetOsnapPoints

subWorldDraw

transformBy

triggerModifiedEvent

worldDraw

  • worldDraw(
        renderer: AcGiRenderer<AcGiEntity>,
        delay?: boolean,
    ): undefined | AcGiEntity

  • Called by cad application when it wants the entity to draw itself in WCS (World Coordinate System) and acts as a wrapper / dispatcher around subWorldDraw(). The children class should never overidde this method.

    It executes the following logic:

    • Skips drawing when the entity's layer is not drawable under the database AcDbDatabase.drawNoPlotLayers policy
    • Handles traits (color, linetype, lineweight, transparency, etc.)
    • Sets AcGiRenderer.context database for draw-time database lookups
    • Calls subWorldDraw() to do the actual geometry output

    Parameters

    • renderer: AcGiRenderer<AcGiEntity>

      The renderer to use for drawing

    • Optionaldelay: boolean

      The flag to delay creating one rendered entity and just create one dummy entity. Renderer can delay heavy calculation operation to avoid blocking UI when this flag is true. For now, text and mtext entity supports this flag only. Other types of entities just ignore this flag.

    Returns undefined | AcGiEntity

    The rendered entity, or undefined if drawing failed

StaticfromControlPoints

  • fromControlPoints(
        controlPoints: AcGeVector3dLike[],
        knots: number[],
        weights: undefined | number[],
        declaredDegree: undefined | number,
        closed: boolean,
    ): null | AcDbSpline

  • Creates a spline entity from control points, knots, and optional weights.

    Unlike the constructor, this factory tolerates imperfect DWG/DXF data: it derives a valid degree when declaredDegree is missing or zero, clamps degree to the available control points, and returns null instead of throwing when the input cannot produce a valid NURBS curve.

    Parameters

    • controlPoints: AcGeVector3dLike[]

      Control vertices in World Coordinate System (WCS) coordinates

    • knots: number[]

      Full knot vector for the spline

    • weights: undefined | number[]

      Optional per-control-point weights; ignored when the array length does not match controlPoints.length

    • declaredDegree: undefined | number

      Degree from the source file; when less than 1, derived from knots.length - controlPoints.length - 1, then clamped to [1, controlPoints.length - 1]

    • closed: boolean

      Whether the spline forms a closed loop

    Returns null | AcDbSpline

    A new spline entity, or null if construction fails

    Example

    const spline = AcDbSpline.fromControlPoints(
      [
        { x: 0, y: 0, z: 0 },
        { x: 1, y: 1, z: 0 },
        { x: 2, y: 0, z: 0 },
        { x: 3, y: 1, z: 0 }
      ],
      [0, 0, 0, 0, 1, 1, 1, 1],
      undefined,
      0,
      false
    );

StaticfromDwgSpline

  • fromDwgSpline(
        spline: {
            controlPoints: AcGeVector3dLike[];
            degree?: number;
            endTangent?: null | AcGeVector3dLike;
            fitPoints: AcGeVector3dLike[];
            flag: number;
            knots: number[];
            numberOfControlPoints: number;
            numberOfFitPoints: number;
            numberOfKnots: number;
            startTangent?: null | AcGeVector3dLike;
            weights?: number[];
        },
    ): null
    | AcDbSpline

  • Creates a spline entity from parsed DWG/DXF SPLINE fields.

    This is the preferred entry point for file converters. Control-point data is tried first; when that fails (for example, too few control points for the knot vector), fit-point data is used as a fallback.

    The flag field encodes spline properties from group code 70:

    • bit 0 (0x01): closed spline
    • bit 1 (0x02): periodic
    • bit 2 (0x04): rational (weights are passed separately via weights)
    • bit 10 (1024): Chord knot parameterization for fit splines
    • bit 11 (2048): SqrtChord knot parameterization for fit splines
    • when neither Chord nor SqrtChord is set: Uniform knot parameterization

    Parameters

    • spline: {
          controlPoints: AcGeVector3dLike[];
          degree?: number;
          endTangent?: null | AcGeVector3dLike;
          fitPoints: AcGeVector3dLike[];
          flag: number;
          knots: number[];
          numberOfControlPoints: number;
          numberOfFitPoints: number;
          numberOfKnots: number;
          startTangent?: null | AcGeVector3dLike;
          weights?: number[];
      }

      Parsed SPLINE entity payload from a DWG/DXF reader

      • controlPoints: AcGeVector3dLike[]

        Control vertices (group codes 10/20/30)

      • Optionaldegree?: number

        Declared degree (group code 71)

      • OptionalendTangent?: null | AcGeVector3dLike

        Optional end tangent (group codes 13/23/33)

      • fitPoints: AcGeVector3dLike[]

        Fit points (group codes 11/21/31)

      • flag: number

        SPLINE flags (group code 70)

      • knots: number[]

        Knot values (group code 40)

      • numberOfControlPoints: number

        Count of control points (group code 73)

      • numberOfFitPoints: number

        Count of fit points (group code 74)

      • numberOfKnots: number

        Count of knots (group code 72)

      • OptionalstartTangent?: null | AcGeVector3dLike

        Optional start tangent (group codes 12/22/32)

      • Optionalweights?: number[]

        Optional weights (group code 41)

    Returns null | AcDbSpline

    A new spline entity, or null when neither control nor fit data can be used

StaticfromFitPoints

  • fromFitPoints(
        fitPoints: AcGeVector3dLike[],
        knotParam: AcGeKnotParameterizationType,
        declaredDegree: undefined | number,
        closed: boolean,
        startTangent?: null | AcGeVector3dLike,
        endTangent?: null | AcGeVector3dLike,
    ): null | AcDbSpline

  • Creates a spline entity that interpolates fit points.

    Knots and control points are computed internally from the fit data. Start and end tangents are applied only when they are non-zero direction vectors. Degree is clamped so that fitPoints.length + tangentCount >= degree + 1.

    Parameters

    • fitPoints: AcGeVector3dLike[]

      Points the spline should pass through, in WCS coordinates

    • knotParam: AcGeKnotParameterizationType

      Knot parameterization ('Uniform', 'Chord', or 'SqrtChord')

    • declaredDegree: undefined | number

      Requested degree from the source file; defaults to 3 when missing or less than 1, then clamped to fit the available fit/tangent data

    • closed: boolean

      Whether the spline forms a closed loop

    • OptionalstartTangent: null | AcGeVector3dLike

      Optional start tangent direction; ignored when zero-length

    • OptionalendTangent: null | AcGeVector3dLike

      Optional end tangent direction; ignored when zero-length

    Returns null | AcDbSpline

    A new spline entity, or null if construction fails

    Example

    const spline = AcDbSpline.fromFitPoints(
      [{ x: 0, y: 0, z: 0 }, { x: 10, y: 0, z: 0 }],
      'Uniform',
      3,
      false,
      { x: 1, y: 0, z: 0 },
      { x: 1, y: 0, z: 0 }
    );

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods