Skip to main content

Advanced Entities

About 4 min

Advanced Entities

Dimensions, hatches, block inserts, and other advanced entity types.

HatchEnt - Hatch

const { HatchEnt, PolylineEnt, Edge, Edges, EdgeType, Engine } = vjcad;

// 1. Create boundary (closed polyline)
const boundary = new PolylineEnt();
boundary.setPoints([
    [0, 0],
    [100, 0],
    [100, 60],
    [0, 60]
]);
boundary.isClosed = true;
boundary.setDefaults();

// 2. Create hatch
const hatch = new HatchEnt();
hatch.patternName = "ANSI31";  // Pattern name
hatch.patternScale = 1.0;      // Pattern scale
hatch.patternAngle = 0;        // Pattern angle

// 3. Set boundary
const edge = new Edge();
edge.edgeType = EdgeType.Polyline;
edge.bulgePoints = boundary.bulgePoints.clone();

const edges = new Edges();
edges.add(edge);
hatch.setLoops(edges);

hatch.setDefaults();
hatch.color = 4;
Engine.addEntities([boundary, hatch]);

Common hatch patterns:

PatternDescription
SOLIDSolid fill
ANSI31Diagonal lines
ANSI32Cross lines
ANSI33Diagonal lines (denser)
ANSI34Diagonal lines (sparser)

Properties:

  • patternName - Pattern name
  • patternScale - Pattern scale
  • patternAngle - Pattern angle
  • color - Fill color

Dimension Entities

LinearDimensionEnt - Linear Dimension

const { LinearDimensionEnt, Point2D, Engine } = vjcad;

const dim = new LinearDimensionEnt(
    new Point2D(0, 0),     // startPoint: dimension start point
    new Point2D(100, 0),   // endPoint: dimension end point
    new Point2D(50, 20),   // thirdPoint: dimension line position
    0                      // dimAngle: 0=horizontal, PI/2=vertical
);
dim.setDefaults();
dim.textHeight = 5;
dim.arrowSize = 3;
dim.textOverride = "L=<>";  // <> will be replaced with measured value
dim.color = 3;
Engine.addEntities(dim);

AlignedDimensionEnt - Aligned Dimension

const { AlignedDimensionEnt, Point2D, Engine } = vjcad;

const dim = new AlignedDimensionEnt(
    new Point2D(0, 0),     // startPoint
    new Point2D(100, 50),  // endPoint
    new Point2D(50, 40)    // thirdPoint
);
dim.setDefaults();
Engine.addEntities(dim);

RadialDimensionEnt - Radius Dimension

const { RadialDimensionEnt, Point2D, CircleEnt, Engine } = vjcad;

// Create circle first
const circle = new CircleEnt([50, 50], 30);
circle.setDefaults();
Engine.addEntities(circle);

// Create radius dimension
const dim = new RadialDimensionEnt(
    new Point2D(50, 50),   // center: circle center
    new Point2D(80, 50),   // chordPoint: point on circumference
    10                     // leaderLength: leader extension length
);
dim.setDefaults();
Engine.addEntities(dim);

DiametricDimensionEnt - Diameter Dimension

const { DiametricDimensionEnt, Point2D, Engine } = vjcad;

const dim = new DiametricDimensionEnt(
    new Point2D(20, 50),   // chordPoint1: diameter endpoint 1
    new Point2D(80, 50),   // chordPoint2: diameter endpoint 2
    10                     // leaderLength
);
dim.setDefaults();
Engine.addEntities(dim);

AngleDimensionEnt - Angle Dimension

const { AngleDimensionEnt, Point2D, Engine } = vjcad;

const dim = new AngleDimensionEnt(
    new Point2D(0, 0),     // center: angle vertex
    new Point2D(100, 0),   // xLine1Point: point on first side
    new Point2D(50, 80),   // xLine2Point: point on second side
    new Point2D(60, 40)    // arcPoint: dimension arc position
);
dim.setDefaults();
Engine.addEntities(dim);

ArcDimensionEnt - Arc Length Dimension

const { ArcDimensionEnt, Point2D, Engine } = vjcad;

const dim = new ArcDimensionEnt(
    new Point2D(50, 50),   // center
    new Point2D(80, 50),   // xLine1Point: arc start point
    new Point2D(50, 80),   // xLine2Point: arc end point
    new Point2D(70, 70)    // arcPoint: dimension position
);
dim.setDefaults();
Engine.addEntities(dim);

OrdinateDimensionEnt - Ordinate Dimension

const { OrdinateDimensionEnt, Point2D, Engine } = vjcad;

const dim = new OrdinateDimensionEnt(
    new Point2D(100, 50),  // definingPoint: point being dimensioned
    new Point2D(120, 70),  // leaderEndPoint: leader end point
    true                   // useXAxis: true=X coordinate, false=Y coordinate
);
dim.setDefaults();
Engine.addEntities(dim);

Common dimension properties:

PropertyDescription
textHeightText height
arrowSizeArrow size
textOverrideText override (<> is replaced with measured value)
scaleFactorScale factor
decimalPlacesDecimal places

Dimension methods:

  • getMeasurement() - Get measured value
  • getFormattedMeasurement() - Get formatted text

Associative Dimensions

Dimensions can be associated with source entities so they update automatically when the source entity moves.

const { LinearDimensionEnt, LineEnt, Point2D, Engine } = vjcad;

// Create a line
const line = new LineEnt([0, 0], [100, 0]);
line.setDefaults();
Engine.addEntities(line);

// Create a dimension
const dim = new LinearDimensionEnt(
    new Point2D(0, 0),
    new Point2D(100, 0),
    new Point2D(50, 20),
    0
);
dim.setDefaults();
Engine.addEntities(dim);

// Establish association (must be after addEntities)
dim.setSourceEntities(
    line.id, -1,    // Start point associated entity and segment index (-1=whole line)
    line.id, -1,    // End point associated entity
    'start',        // Start point type
    'end'           // End point type
);

// Check association status
console.log("isAssociative:", dim.isAssociative);

Point types:

  • 'start' - Start point
  • 'end' - End point
  • 'center' - Center point
  • 'midpoint' - Mid point

Precise positioning:

// Use parameterT (0~1 represents proportional position on segment)
dim.setSourceEntities(
    line.id, -1,
    line.id, -1,
    undefined,       // Don't use pointType
    undefined,
    0.25,            // startParameterT: at 1/4 position
    0.75             // endParameterT: at 3/4 position
);

InsertEnt - Block Insert

Create Block Definition

const { LineEnt, CircleEnt, Engine } = vjcad;

const doc = Engine.currentDoc;
const blockName = "MySymbol";

// Check if it already exists
let blockDef = doc.blocks.itemByName(blockName);
if (!blockDef) {
    // Create block definition
    blockDef = doc.blocks.add(blockName);
    blockDef.basePoint = [0, 0];  // Base point
    
    // Add entities to block
    const line1 = new LineEnt([-10, 0], [10, 0]);
    const line2 = new LineEnt([0, -10], [0, 10]);
    const circle = new CircleEnt([0, 0], 5);
    
    line1.setDefaults();
    line2.setDefaults();
    circle.setDefaults();
    
    blockDef.addEntity(line1);
    blockDef.addEntity(line2);
    blockDef.addEntity(circle);
}

Insert Block Reference

const { InsertEnt, Engine } = vjcad;

const insert = new InsertEnt();
insert.blockId = blockDef.blockId;     // Block ID (required)
insert.insertionPoint = [50, 50];      // Insertion point
insert.scaleFactor = 1.5;              // Scale factor
insert.rotation = Math.PI / 4;         // Rotation angle (radians)
insert.setDefaults();
insert.color = 5;
Engine.addEntities(insert);

Explode Block

// Get entities within block (explode)
const explodedEnts = insert.getNestEnts(true);
explodedEnts.forEach(ent => {
    Engine.addEntities(ent);
});
Engine.eraseEntities(insert);

Properties:

  • blockId - Block ID (required, obtained from blockDef.blockId)
  • insertionPoint - Insertion point
  • scaleFactor - Scale factor
  • rotation - Rotation angle (radians)

Methods:

  • getNestEnts(explode?) - Get nested entities (when true, returns independent entities for exploding)

Symbol Management

Load Symbols from Local Storage

const { 
    getLocalStorageService, 
    parseSymbolVcadData, 
    mergeSymbolToDocument,
    Point2D, Engine 
} = vjcad;

const localService = getLocalStorageService();

// Get categories and symbol list
const categories = await localService.getLocalSymbolCategories();
const symbols = await localService.getLocalSymbolList(categories[0].id);
const symbol = await localService.getLocalSymbol(symbols[0].id);

// Parse symbol data
const symbolDoc = await parseSymbolVcadData(symbol.vcadData);

// Merge into document
const addedEntities = mergeSymbolToDocument(
    symbolDoc,
    new Point2D(100, 100),   // insertPoint
    symbol.basePoint,         // basePoint
    1.5,                      // scale
    45,                       // rotation (degrees)
    false                     // clearSourceInfo
);

Engine.zoomExtents();

Interactive Symbol Insertion

const { insertSymbolInteractive } = vjcad;

const entities = await insertSymbolInteractive(
    symbolData,
    basePoint,
    {
        allowScale: true,      // Allow specifying scale
        allowRotation: true,   // Allow specifying rotation
        clearSourceInfo: false
    }
);

Create Local Symbol

const { 
    getLocalStorageService,
    buildSymbolVcadData,
    generateThumbnailFromEntities
} = vjcad;

const localService = getLocalStorageService();

// Create category
const category = await localService.createLocalSymbolCategory("My Symbols");

// Create symbol content
const entities = [line1, circle1];

// Generate symbol data
const vcadData = await buildSymbolVcadData(entities, false);
const thumbnail = await generateThumbnailFromEntities(entities, 128, 128);

// Save symbol
const symbol = await localService.saveLocalSymbol({
    categoryId: category.id,
    name: "Cross Symbol",
    basePoint: [0, 0],
    thumbnail: thumbnail,
    vcadData: vcadData
});

MLeaderEnt - Multi-Leader

const { MLeaderEnt, Point2D, Engine } = vjcad;

const mleader = new MLeaderEnt();
mleader.leaderPoints = [
    new Point2D(0, 0),      // Arrow position
    new Point2D(50, 50),    // Vertex point
    new Point2D(100, 50)    // Text position
];
mleader.text = "Annotation content";
mleader.textHeight = 5;
mleader.arrowSize = 3;
mleader.setDefaults();
Engine.addEntities(mleader);

GroupEnt - Group

const { GroupEnt, LineEnt, CircleEnt, Engine } = vjcad;

// Create entities
const line = new LineEnt([0, 0], [100, 0]);
const circle = new CircleEnt([50, 50], 20);
line.setDefaults();
circle.setDefaults();

// Create group
const group = new GroupEnt("MyGroup", [line, circle]);
group.setDefaults();
Engine.addEntities(group);

// Access entities within group
group.items.forEach((item, index) => {
    console.log(`${index}: ${item.type}`);
});

// Explode group
const explodedEntities = group.explode();
explodedEntities.forEach(ent => {
    Engine.addEntities(ent);
});
Engine.eraseEntities(group);