ofs-dxf-ts 1.0.0

package/dist/core/dxf-builder.js

@@ -0,0 +1,549 @@
+/**
+ * DxfBuilder — Backward-compatible wrapper around DxfDocument.
+ *
+ * ✅ Works in both Node.js AND Browser/Angular environments.
+ *
+ * Usage (existing — unchanged):
+ *   const builder = new DxfBuilder();
+ *   builder.addPolyline(points, 'MyLayer', 3);
+ *   builder.addText('Hello', 100, 200, 5, 0, 'TEXT', 7);
+ *   const dxfString = builder.saveString();
+ *
+ * NEW: Template-based (Node.js):
+ *   const builder = new DxfBuilder('./template/template2018.dxf');
+ *
+ * NEW: Template-based (Browser/Angular):
+ *   const builder = DxfBuilder.fromString(templateDxfString);
+ *
+ * NEW: Convenience API:
+ *   builder.addLayer('MyLayer', 3, 'DASHED');
+ *   builder.addLine([0,0], [100,100], 'MyLayer', 1);
+ *   builder.addArc(50, 50, 25, 0, 180, 'MyLayer', 4);
+ *   builder.addHatch('SOLID', [[[0,0],[100,0],[100,100],[0,100]]], 'MyLayer', 3);
+ *
+ * NEW: Sheet composition:
+ *   builder.defineBlock('BM', b => { b.addCircle(0, 0, 1.5, '0'); b.addLine([-2, 0], [2, 0], '0'); });
+ *   builder.addBlock('BM', 519395.8, 1034018.6, 10, 0, 'SYMBOL');
+ *   builder.addCallout([519300, 1034000], ['ก่อสร้างอาคารทางน้ำเข้า', 'ขนาด 2-1.75x1.75 ม.'], [519350, 1034150]);
+ *   builder.addLayout('A1', 841, 594, [0, 0, 0, 0], [{ center: [420, 297], width: 800, height: 560,
+ *       viewCenter: [519500, 1033500], scale: 12500 }]);
+ *   builder.onLayout('A1', b => b.addText('แผนที่แสดงตำแหน่งหมุดหลักฐาน', 420, 20, 8));
+ */
+import { DxfDocument } from './dxf-document.js';
+import { Modelspace } from './modelspace.js';
+import { TextEntityAlignment } from './dxf-entities.js';
+import { BLOCK_REGISTRY } from '../template/block-registry.js';
+import { rotatePoint } from '../geometry/math.utils.js';
+import { estimateTextWidth } from '../geometry/text.utils.js';
+export class DxfBuilder {
+    _document;
+    /** Current drawing target: model space, a layout, or a block being defined. */
+    _msp;
+    /**
+     * Create a new DxfBuilder.
+     * @param template Optional path to a DXF template file (Node.js only), or a loaded DxfDocument.
+     */
+    constructor(template) {
+        if (template instanceof DxfDocument) {
+            this._document = template;
+        }
+        else if (template) {
+            this._document = DxfDocument.readFile(template);
+        }
+        else {
+            this._document = DxfDocument.create();
+        }
+        this._msp = this._document.modelspace();
+        if (!template) {
+            this._initializeLayers();
+        }
+    }
+    /**
+     * Create a DxfBuilder from a DXF template string.
+     * ✅ Works in Browser/Angular.
+     */
+    static fromString(content) {
+        return new DxfBuilder(DxfDocument.fromString(content));
+    }
+    // ─── Property Access ───
+    /** Access the underlying DxfDocument. */
+    get doc() { return this._document; }
+    /** Access the current drawing target directly for ezdxf-style operations. */
+    get msp() { return this._msp; }
+    // ─── Layer Management ───
+    /**
+     * Add or update a layer.
+     * @param name  Layer name
+     * @param color ACI color index (0-256)
+     * @param linetype Linetype name (e.g. 'CONTINUOUS', 'DASHED', 'CENTER')
+     */
+    addLayer(name, color = 7, linetype = 'CONTINUOUS') {
+        this._document.addLayer(name, color, linetype);
+    }
+    /**
+     * Add a linetype. Pattern values are in drawing units: positive = dash,
+     * negative = gap, 0 = dot. Existing names in the template are kept.
+     * @example builder.addLineType('BOUNDARY', '____ . ____', [20, -5, 0, -5]);
+     */
+    addLineType(name, description, pattern) {
+        this._document.addLineType(name, description, pattern);
+    }
+    /**
+     * Add a text style. Existing names in the template are kept.
+     * @example builder.addTextStyle('THAI', 'THSarabunNew.ttf');
+     */
+    addTextStyle(name, font, height) {
+        this._document.addTextStyle(name, font, height);
+    }
+    // ─── Geometry Entities ───
+    /**
+     * Add a single LINE entity (two-point segment).
+     */
+    addLine(start, end, layer = '0', color, linetype) {
+        this._ensureLayer(layer);
+        this._msp.add_line(start, end, { layer, color, linetype });
+    }
+    /**
+     * Add a LWPOLYLINE entity (multi-vertex polyline).
+     */
+    addPolyline(points, layer = '0', color, linetype, closed = false) {
+        this._ensureLayer(layer);
+        const pts = points.map(p => [p[0], p[1]]);
+        this._msp.add_lwpolyline(pts, { layer, color, linetype }, closed);
+    }
+    /**
+     * Add a CIRCLE entity.
+     */
+    addCircle(cx, cy, radius, layer = '0', color) {
+        this._ensureLayer(layer);
+        this._msp.add_circle([cx, cy], radius, { layer, color });
+    }
+    /**
+     * Add an ARC entity.
+     * @param cx Center X
+     * @param cy Center Y
+     * @param radius Radius
+     * @param startAngle Start angle in degrees
+     * @param endAngle End angle in degrees
+     */
+    addArc(cx, cy, radius, startAngle, endAngle, layer = '0', color) {
+        this._ensureLayer(layer);
+        this._msp.add_arc([cx, cy], radius, startAngle, endAngle, { layer, color });
+    }
+    /**
+     * Add an ELLIPSE entity.
+     * @param cx Center X
+     * @param cy Center Y
+     * @param majorAxisX Major axis endpoint X (relative to center)
+     * @param majorAxisY Major axis endpoint Y (relative to center)
+     * @param ratio Ratio of minor to major axis (0..1)
+     */
+    addEllipse(cx, cy, majorAxisX, majorAxisY, ratio, layer = '0', color) {
+        this._ensureLayer(layer);
+        this._msp.add_ellipse([cx, cy], [majorAxisX, majorAxisY], ratio, 0, Math.PI * 2, { layer, color });
+    }
+    /**
+     * Add a POINT entity.
+     */
+    addPoint(x, y, layer = '0', color) {
+        this._ensureLayer(layer);
+        this._msp.add_point([x, y], { layer, color });
+    }
+    // ─── Text Entities ───
+    /**
+     * Add a TEXT entity.
+     */
+    addText(text, x, y, height = 2, rotation = 0, layer = 'TEXT', color = 7) {
+        this._ensureLayer(layer);
+        this._msp.add_text(text, { height, rotation, layer, color }).set_placement([x, y]);
+    }
+    /**
+     * Add an MTEXT entity (multi-line text with word wrap).
+     */
+    addMText(text, x, y, width = 100, height = 2.5, layer = 'TEXT', color) {
+        this._ensureLayer(layer);
+        const e = this._msp.add_mtext(text, { height, layer, color, width });
+        e.position = [x, y];
+    }
+    // ─── Complex Entities ───
+    /**
+     * Add a HATCH entity (solid fill or pattern fill).
+     *
+     * @param patternName  'SOLID', a built-in pattern (see HATCH_PATTERNS, ISO/mm based),
+     *                     or any name together with `opts.patternLines`.
+     * @param boundaries   Array of boundary polygons, each as an array of [x,y] points.
+     *                     Polygons inside another polygon become holes.
+     * @param layer        Layer name
+     * @param color        ACI color
+     * @param opts         scale (pattern units × scale = drawing units), angle (degrees), patternLines
+     *
+     * @example
+     *   // Solid fill
+     *   builder.addHatch('SOLID', [[[0,0],[100,0],[100,100],[0,100]]], 'MyLayer', 3);
+     *
+     *   // Pattern fill
+     *   builder.addHatch('ANSI31', [[[0,0],[50,0],[50,50],[0,50]]], 'MyLayer', 7, { scale: 2, angle: 45 });
+     */
+    addHatch(patternName, boundaries, layer = '0', color, opts = {}) {
+        this._ensureLayer(layer);
+        const hatchBoundaries = boundaries.map(pts => ({
+            type: 'polyline',
+            points: pts,
+            closed: true,
+        }));
+        this._msp.add_hatch(patternName, hatchBoundaries, { layer, color }, {
+            solid: patternName.toUpperCase() === 'SOLID',
+            scale: opts.scale,
+            angle: opts.angle,
+            patternLines: opts.patternLines,
+        });
+    }
+    /**
+     * Add a raster IMAGE, e.g. a scanned topographic map as a background.
+     *
+     * DXF only references the image file: keep the file next to the .dxf and
+     * pass its file name, or pass an absolute path.
+     *
+     * @param imagePath  file name/path as the CAD application should resolve it
+     * @param pixelSize  image size in pixels [width, height] (DXF cannot read the file)
+     * @param insertion  lower-left corner in drawing units
+     * @param worldSize  image size in drawing units [width, height]
+     *
+     * @example
+     *   // 1:50,000 sheet scanned at 7087×7087 px covering 15 km
+     *   builder.addImage('topo_4927II.jpg', [7087, 7087], [513000, 1027000], [15000, 15000], 'RASTER');
+     */
+    addImage(imagePath, pixelSize, insertion, worldSize, layer = '0', opts = {}) {
+        this._ensureLayer(layer);
+        const perPixel = [worldSize[0] / pixelSize[0], worldSize[1] / pixelSize[1]];
+        this._msp.add_image(insertion, imagePath, pixelSize, perPixel, { layer }, opts);
+    }
+    /**
+     * Add a DIMENSION entity (linear dimension between two points).
+     */
+    addDimension(point1, point2, dimLinePosition, layer = 'DIM', color, text) {
+        this._ensureLayer(layer);
+        this._msp.add_dimension(point1, point2, dimLinePosition, { layer, color, text });
+    }
+    /**
+     * Add a LEADER entity (arrow with annotation line).
+     */
+    addLeader(vertices, layer = '0', color, hasArrowhead = true) {
+        this._ensureLayer(layer);
+        this._msp.add_leader(vertices, { layer, color, has_arrowhead: hasArrowhead });
+    }
+    /**
+     * Add a SPLINE entity (smooth curve through control points).
+     */
+    addSpline(controlPoints, degree = 3, layer = '0', color) {
+        this._ensureLayer(layer);
+        this._msp.add_spline(controlPoints, degree, { layer, color });
+    }
+    // ─── Structure / OnfarmLine ───
+    /** Add a line from an OnfarmLine structure object. */
+    addLineFromObject(onfarmLine, layer = 'structure') {
+        this._ensureLayer(layer);
+        const pts = onfarmLine.coordinate.map(p => [p[0], p[1]]);
+        this._msp.add_lwpolyline(pts, { layer, color: onfarmLine.color, linetype: onfarmLine.type });
+    }
+    // ─── Blocks ───
+    /**
+     * Define a reusable block (symbol). Draw it with the normal builder API in
+     * block-local coordinates around `basePoint`, then place it with addBlock().
+     *
+     * @example
+     *   builder.defineBlock('SCHOOL', b => {
+     *       b.addPolyline([[-2, -1.5], [2, -1.5], [2, 1.5], [-2, 1.5]], '0', 5, undefined, true);
+     *       b.addHatch('SOLID', [[[-2, -1.5], [2, -1.5], [2, 1.5], [-2, 1.5]]], '0', 5);
+     *   });
+     *   builder.addBlock('SCHOOL', 518807, 1033917, 20, 0, 'POI');
+     */
+    defineBlock(name, draw, basePoint = [0, 0]) {
+        const collector = new Modelspace();
+        this._withTarget(collector, () => draw(this));
+        this._document.addBlockDefinition(name, collector.entities, basePoint);
+    }
+    /**
+     * Add a block reference (INSERT).
+     * Template or defined block → INSERT entity. Registry block → manual drawing. Neither → placeholder.
+     */
+    addBlock(name, x, y, scale, rotation, layer = '0', attributes = {}) {
+        this._ensureLayer(layer);
+        if (this._document.hasBlock(name)) {
+            this._msp.add_blockref(name, [x, y], { layer, xscale: scale, yscale: scale, zscale: scale, rotation });
+        }
+        else if (BLOCK_REGISTRY[name]) {
+            this._drawFromRegistry(name, x, y, scale, rotation, layer);
+        }
+        else {
+            this._msp.add_text(`[Block:${name}]`, { height: scale * 2, rotation, layer }).set_placement([x, y]);
+        }
+        let offset = 0;
+        for (const [key, value] of Object.entries(attributes)) {
+            this._msp.add_text(`${key}: ${value}`, { height: scale * 2, rotation, layer }).set_placement([x + 5, y + offset]);
+            offset += scale * 5;
+        }
+    }
+    // ─── View / Zoom Management ───
+    /**
+     * Auto-zoom to fit all entities with optional padding.
+     * Sets $EXTMIN, $EXTMAX, $VIEWCTR, $VIEWSIZE in HEADER.
+     * @example builder.zoomExtents(100);  // 100 unit padding
+     */
+    zoomExtents(padding = 0) {
+        this._document.zoomExtents(padding);
+    }
+    /**
+     * Zoom to a specific window (rectangle).
+     * @example builder.zoomWindow(1000, 2000, 5000, 6000);
+     */
+    zoomWindow(minX, minY, maxX, maxY) {
+        this._document.zoomWindow(minX, minY, maxX, maxY);
+    }
+    /**
+     * Set the drawing extents manually.
+     */
+    setExtents(minX, minY, maxX, maxY) {
+        this._document.setExtents(minX, minY, maxX, maxY);
+    }
+    /**
+     * Set initial view center and zoom level.
+     */
+    setViewCenter(x, y, viewHeight) {
+        this._document.setViewCenter(x, y, viewHeight);
+    }
+    // ─── Layer Management (extended) ───
+    /** Freeze a layer (hidden, not plotted, not selectable). */
+    freezeLayer(name) { this._document.freezeLayer(name); }
+    /** Thaw a layer (undo freeze). */
+    thawLayer(name) { this._document.thawLayer(name); }
+    /** Lock a layer (visible but not editable). */
+    lockLayer(name) { this._document.lockLayer(name); }
+    /** Unlock a layer. */
+    unlockLayer(name) { this._document.unlockLayer(name); }
+    /** Turn a layer off (hidden but still selectable). */
+    setLayerOff(name) { this._document.setLayerOff(name); }
+    /** Turn a layer on. */
+    setLayerOn(name) { this._document.setLayerOn(name); }
+    /** Change layer color. */
+    setLayerColor(name, color) { this._document.setLayerColor(name, color); }
+    /** Change layer linetype. */
+    setLayerLinetype(name, linetype) { this._document.setLayerLinetype(name, linetype); }
+    // ─── Annotations ───
+    /**
+     * Add a callout: a leader from `anchor` to a boxed, multi-line label.
+     * The leader attaches to the box edge midpoint nearest the anchor.
+     *
+     *   anchor ●──────────┤ ก่อสร้างอาคารทางน้ำเข้า │
+     *                     │ ขนาด 2-1.75x1.75 ม.   │
+     *
+     * @param anchor  the point being annotated
+     * @param text    lines of text (array, or a string with "\n")
+     * @param boxAt   top-left corner of the box
+     * @returns the box extent [minX, minY, maxX, maxY]
+     */
+    addCallout(anchor, text, boxAt, opts = {}) {
+        const layer = opts.layer ?? 'TEXT';
+        this._ensureLayer(layer);
+        const lines = Array.isArray(text) ? text : text.split('\n');
+        const h = opts.textHeight ?? 2.5;
+        const step = h * (opts.lineSpacing ?? 1.6);
+        const pad = opts.padding ?? h * 0.8;
+        const widest = Math.max(0, ...lines.map(t => estimateTextWidth(t, h, opts.widthFactor)));
+        const width = opts.boxWidth ?? widest + 2 * pad;
+        const height = 2 * pad + h * 1.3 + step * (lines.length - 1); // 0.3h leaves room for descenders
+        const [left, top] = boxAt;
+        const right = left + width, bottom = top - height;
+        this._msp.add_lwpolyline([[left, top], [right, top], [right, bottom], [left, bottom]], { layer, color: opts.boxColor ?? opts.color }, true);
+        lines.forEach((line, i) => {
+            if (!line)
+                return;
+            const y = top - pad - h - i * step;
+            const t = this._msp.add_text(line, { height: h, layer, color: opts.textColor ?? opts.color, style: opts.style });
+            if (opts.align === 'center')
+                t.set_placement([(left + right) / 2, y], TextEntityAlignment.CENTER);
+            else
+                t.set_placement([left + pad, y]);
+        });
+        const inside = anchor[0] >= left && anchor[0] <= right && anchor[1] >= bottom && anchor[1] <= top;
+        if (!inside) {
+            const midX = (left + right) / 2, midY = (top + bottom) / 2;
+            const dist = (p) => Math.hypot(p[0] - anchor[0], p[1] - anchor[1]);
+            const attach = [[left, midY], [right, midY], [midX, top], [midX, bottom]]
+                .reduce((best, p) => (dist(p) < dist(best) ? p : best));
+            const attr = { layer, color: opts.color };
+            this._msp.add_lwpolyline([anchor, attach], attr);
+            const size = opts.arrowSize ?? h * 0.8;
+            if (opts.arrow === 'dot') {
+                const ring = Array.from({ length: 16 }, (_, k) => {
+                    const a = (k * Math.PI) / 8;
+                    return [anchor[0] + (size / 2) * Math.cos(a), anchor[1] + (size / 2) * Math.sin(a)];
+                });
+                this._msp.add_hatch('SOLID', [{ type: 'polyline', points: ring, closed: true }], attr);
+            }
+            else if (opts.arrow === 'arrow') {
+                const len = dist(attach) || 1;
+                const dx = (attach[0] - anchor[0]) / len, dy = (attach[1] - anchor[1]) / len;
+                const bx = anchor[0] + dx * size, by = anchor[1] + dy * size, w = size / 3;
+                const p2 = [bx - dy * w, by + dx * w];
+                const p3 = [bx + dy * w, by - dx * w];
+                this._msp.add_solid([anchor, p2, p3, p3], attr);
+            }
+        }
+        return [left, bottom, right, top];
+    }
+    /**
+     * Add an annotation with a leader.
+     *
+     * @deprecated MULTILEADER entities written by this library were not
+     * AutoCAD-compatible. This now draws `addCallout(vertices[0], text, textPosition)`
+     * with an arrowhead; use addCallout directly.
+     */
+    addMLeader(vertices, text, textPosition, layer = '0', color, opts = {}) {
+        this.addCallout(vertices[0] ?? textPosition, text, textPosition, {
+            layer, color,
+            textHeight: opts.textHeight,
+            boxWidth: opts.textWidth,
+            arrow: 'arrow',
+            arrowSize: opts.arrowSize,
+        });
+    }
+    /**
+     * Add a TABLE (drawn as grid of LINE + TEXT entities).
+     * Cells may span columns/rows with `colSpan` / `rowSpan` (HTML table rules).
+     *
+     * @example
+     *   builder.addTable([100, 500], [20, 40, 50, 50], 8, [
+     *       [{ text: 'ลำดับ', rowSpan: 2 }, { text: 'หมุด', rowSpan: 2 }, { text: 'พิกัด', colSpan: 2 }],
+     *       [{ text: 'North' }, { text: 'East' }],
+     *       [{ text: '1' }, { text: 'BM.07' }, { text: '1,034,018.584' }, { text: '519,395.838' }],
+     *   ], 'TABLE', 2.5);
+     */
+    addTable(position, columnWidths, rowHeight, rows, layer = '0', textHeight = 2.5, opts = {}) {
+        this._ensureLayer(layer);
+        this._msp.add_table({
+            position, columnWidths, rowHeight, rows, layer, textHeight,
+            rowHeights: opts.rowHeights,
+            headerColor: opts.headerColor,
+            gridColor: opts.gridColor,
+            textColor: opts.textColor,
+        });
+    }
+    // ─── Layout (Paper Space) ───
+    /**
+     * Add a Paper Space layout for plotting. Paper units are mm; the origin
+     * is the lower-left corner of the printable area (inside the margins).
+     * A viewport's model-space extent comes from `viewHeight`, or from `scale`
+     * (e.g. 12500 for 1:12,500 with the model in meters).
+     *
+     * @example
+     *   builder.addLayout('A1', 841, 594, [0, 0, 0, 0], [{
+     *       center: [420, 297], width: 800, height: 560,
+     *       viewCenter: [519500, 1033500], scale: 12500,
+     *       frozenLayers: ['GRID'],
+     *   }]);
+     */
+    addLayout(name, paperWidth, paperHeight, margins = [10, 10, 10, 10], viewports = []) {
+        this._document.addLayout({
+            name, paperWidth, paperHeight, margins, viewports,
+        });
+    }
+    /**
+     * Draw into a paper space layout: every builder call made inside `draw`
+     * targets that layout. Works with layouts from the template (e.g.
+     * 'Layout1') and ones added with addLayout().
+     *
+     * @example
+     *   builder.onLayout('A1', b => {
+     *       b.addText('แผนที่แสดงตำแหน่งหมุดหลักฐาน', 300, 25, 8);
+     *       b.addTable([560, 200], [15, 30, 45, 45], 7, rows, 'TABLE', 2.5);
+     *   });
+     */
+    onLayout(name, draw) {
+        this._withTarget(this._document.paperspace(name), () => draw(this));
+    }
+    // ─── GeoReference ───
+    /**
+     * Set geographic coordinate reference for the drawing.
+     * Embeds CRS info into the DXF HEADER for GIS interoperability.
+     *
+     * @example
+     *   // UTM Zone 47N (Thailand)
+     *   builder.setGeoReference({
+     *       crsId: 'EPSG:32647',
+     *       designPoint: [0, 0],
+     *       referencePoint: [600000, 1700000],
+     *       northDirection: 0,
+     *       scaleFactor: 1,
+     *       coordinateType: 2,
+     *   });
+     */
+    setGeoReference(geoRef) {
+        this._document.setGeoReference(geoRef);
+    }
+    // ─── Serialization ───
+    /** Serialize to DXF string. ✅ Works everywhere. */
+    saveString() { return this._document.toDxfString(); }
+    /** Save to file (Node.js only). */
+    saveas(filePath) { this._document.saveas(filePath); }
+    /** Download DXF in browser (Angular). */
+    downloadAs(filename) { this._document.downloadAs(filename); }
+    // ─── Private Methods ───
+    _withTarget(target, fn) {
+        const previous = this._msp;
+        this._msp = target;
+        try {
+            fn();
+        }
+        finally {
+            this._msp = previous;
+        }
+    }
+    _ensureLayer(layer) {
+        if (!this._document.hasLayer(layer)) {
+            this._document.addLayer(layer, 7, 'CONTINUOUS');
+        }
+    }
+    _initializeLayers() {
+        this._document.addLayer('CANAL', 8, 'CONTINUOUS');
+        this._document.addLayer('DRAINAGE_CANAL', 7, 'CONTINUOUS');
+        this._document.addLayer('DITCH', 6, 'CONTINUOUS');
+        this._document.addLayer('BOUNDARY_LINE', 1, 'CONTINUOUS');
+        this._document.addLayer('LandPlot', 252, 'CONTINUOUS');
+        this._document.addLayer('แปลงเดิม', 252, 'CONTINUOUS');
+        this._document.addLayer('GRID', 253, 'CONTINUOUS');
+        this._document.addLayer('CONTOUR', 251, 'CONTINUOUS');
+        this._document.addLayer('ถนน', 252, 'CONTINUOUS');
+        this._document.addLayer('อ่างเก็บน้ำ หนอง บึง', 4, 'CONTINUOUS');
+        this._document.addLayer('TEXT', 7, 'CONTINUOUS');
+        this._document.addLayer('เลขแปลง', 7, 'CONTINUOUS');
+        this._document.addLayer('structure', 4, 'CONTINUOUS');
+        this._document.addLayer('STR_CYAN', 4, 'CONTINUOUS');
+        this._document.addLayer('0', 7, 'CONTINUOUS');
+    }
+    _drawFromRegistry(name, x, y, scale, rotation, layer) {
+        const blockDef = BLOCK_REGISTRY[name];
+        if (!blockDef)
+            return;
+        for (const entity of blockDef.entities) {
+            const entLayer = entity.layer || layer;
+            this._ensureLayer(entLayer);
+            if (entity.type === 'LINE' && entity.points) {
+                const p1 = rotatePoint(entity.points[0][0] * scale, entity.points[0][1] * scale, rotation, x, y);
+                const p2 = rotatePoint(entity.points[1][0] * scale, entity.points[1][1] * scale, rotation, x, y);
+                this._msp.add_line([p1[0], p1[1]], [p2[0], p2[1]], { layer: entLayer, color: entity.color });
+            }
+            else if (entity.type === 'CIRCLE' && entity.center) {
+                const center = rotatePoint(entity.center[0] * scale, entity.center[1] * scale, rotation, x, y);
+                this._msp.add_circle([center[0], center[1]], (entity.radius || 1) * scale, { layer: entLayer, color: entity.color });
+            }
+            else if (entity.type === 'LWPOLYLINE' && entity.points) {
+                const rotatedPoints = entity.points.map(p => {
+                    const rp = rotatePoint(p[0] * scale, p[1] * scale, rotation, x, y);
+                    return [rp[0], rp[1]];
+                });
+                this._msp.add_lwpolyline(rotatedPoints, { layer: entLayer, color: entity.color });
+            }
+        }
+    }
+}