@mlightcad/data-model 1.3.3 → 1.3.5

package/lib/converter/AcDbEntitiyConverter.js

@@ -0,0 +1,708 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { SmoothType, VertexFlag } from '@mlightcad/dxf-json';
+import { AcGeCircArc2d, AcGeEllipseArc2d, AcGeLine2d, AcGeLoop2d, AcGeMathUtil, AcGePoint2d, AcGePoint3d, AcGePolyline2d, AcGeSpline3d, AcGeVector2d, AcGeVector3d } from '@mlightcad/geometry-engine';
+import { AcDb2dPolyline, AcDb3dPolyline, AcDb3PointAngularDimension, AcDbAlignedDimension, AcDbArc, AcDbBlockReference, AcDbCircle, AcDbDiametricDimension, AcDbEllipse, AcDbFace, AcDbHatch, AcDbLeader, AcDbLine, AcDbMText, AcDbOrdinateDimension, AcDbPoint, AcDbPoly2dType, AcDbPoly3dType, AcDbPolyline, AcDbRadialDimension, AcDbRasterImage, AcDbRay, AcDbSpline, AcDbTable, AcDbText, AcDbTrace, AcDbViewport, AcDbWipeout, AcDbXline } from '../entity';
+/**
+ * Converts DXF entities to AcDbEntity objects.
+ *
+ * This class provides functionality to convert various DXF entity types
+ * (such as lines, circles, arcs, text, etc.) into their corresponding
+ * AcDbEntity objects. It handles the conversion of geometric data,
+ * properties, and attributes from DXF format to the internal database format.
+ *
+ * @example
+ * ```typescript
+ * const converter = new AcDbEntityConverter();
+ * const dxfEntity = { type: 'LINE', startPoint: [0, 0, 0], endPoint: [10, 10, 0] };
+ * const acDbEntity = converter.convert(dxfEntity);
+ * ```
+ */
+var AcDbEntityConverter = /** @class */ (function () {
+    function AcDbEntityConverter() {
+    }
+    /**
+     * Converts a DXF entity to an AcDbEntity.
+     *
+     * This method takes a DXF entity and converts it to the corresponding
+     * AcDbEntity type. It first creates the entity using createEntity(),
+     * then processes common attributes using processCommonAttrs().
+     *
+     * @param entity - The DXF entity to convert
+     * @returns The converted AcDbEntity, or null if conversion fails
+     *
+     * @example
+     * ```typescript
+     * const dxfLine = { type: 'LINE', startPoint: [0, 0, 0], endPoint: [10, 10, 0] };
+     * const acDbLine = converter.convert(dxfLine);
+     * if (acDbLine) {
+     *   console.log('Converted to:', acDbLine.type);
+     * }
+     * ```
+     */
+    AcDbEntityConverter.prototype.convert = function (entity) {
+        var dbEntity = this.createEntity(entity);
+        if (dbEntity) {
+            this.processCommonAttrs(entity, dbEntity);
+        }
+        return dbEntity;
+    };
+    /**
+     * Creates the corresponding drawing database entity from DXF format data.
+     *
+     * This method acts as a factory that routes DXF entities to their specific
+     * conversion methods based on the entity type. It handles all supported
+     * DXF entity types including geometric entities, text entities, and special entities.
+     *
+     * @param entity - Input entity data in DXF format
+     * @returns The converted drawing database entity, or null if the entity type is not supported
+     *
+     * @example
+     * ```typescript
+     * const dxfEntity = { type: 'CIRCLE', center: [0, 0, 0], radius: 5 };
+     * const acDbEntity = converter.createEntity(dxfEntity);
+     * ```
+     */
+    AcDbEntityConverter.prototype.createEntity = function (entity) {
+        if (entity.type == '3DFACE') {
+            return this.convertFace(entity);
+        }
+        else if (entity.type == 'ARC') {
+            return this.convertArc(entity);
+        }
+        else if (entity.type == 'CIRCLE') {
+            return this.convertCirle(entity);
+        }
+        else if (entity.type == 'DIMENSION') {
+            return this.convertDimension(entity);
+        }
+        else if (entity.type == 'ELLIPSE') {
+            return this.convertEllipse(entity);
+        }
+        else if (entity.type == 'HATCH') {
+            return this.convertHatch(entity);
+        }
+        else if (entity.type == 'IMAGE') {
+            return this.convertImage(entity);
+        }
+        else if (entity.type == 'LEADER') {
+            return this.convertLeader(entity);
+        }
+        else if (entity.type == 'LINE') {
+            return this.convertLine(entity);
+        }
+        else if (entity.type == 'LWPOLYLINE') {
+            return this.convertLWPolyline(entity);
+        }
+        else if (entity.type == 'MTEXT') {
+            return this.convertMText(entity);
+        }
+        else if (entity.type == 'POLYLINE') {
+            return this.convertPolyline(entity);
+        }
+        else if (entity.type == 'POINT') {
+            return this.convertPoint(entity);
+        }
+        else if (entity.type == 'RAY') {
+            return this.convertRay(entity);
+        }
+        else if (entity.type == 'SPLINE') {
+            return this.convertSpline(entity);
+        }
+        else if (entity.type == 'ACAD_TABLE') {
+            return this.convertTable(entity);
+        }
+        else if (entity.type == 'TEXT') {
+            return this.convertText(entity);
+        }
+        else if (entity.type == 'SOLID') {
+            return this.convertSolid(entity);
+        }
+        else if (entity.type == 'VIEWPORT') {
+            return this.convertViewport(entity);
+        }
+        else if (entity.type == 'WIPEOUT') {
+            return this.convertWipeout(entity);
+        }
+        else if (entity.type == 'XLINE') {
+            return this.convertXline(entity);
+        }
+        else if (entity.type == 'INSERT') {
+            return this.convertBlockReference(entity);
+        }
+        return null;
+    };
+    /**
+     * Converts a DXF 3DFACE entity to an AcDbFace.
+     *
+     * @param face - The DXF 3DFace entity to convert
+     * @returns The converted AcDbFace entity
+     */
+    AcDbEntityConverter.prototype.convertFace = function (face) {
+        var dbEntity = new AcDbFace();
+        face.vertices.forEach(function (vertex, index) {
+            return dbEntity.setVertexAt(index, vertex);
+        });
+        return dbEntity;
+    };
+    /**
+     * Converts a DXF arc entity to an AcDbArc.
+     *
+     * @param arc - The DXF arc entity to convert
+     * @returns The converted AcDbArc entity
+     *
+     * @example
+     * ```typescript
+     * const dxfArc = { type: 'ARC', center: [0, 0, 0], radius: 5, startAngle: 0, endAngle: 90 };
+     * const acDbArc = converter.convertArc(dxfArc);
+     * ```
+     */
+    AcDbEntityConverter.prototype.convertArc = function (arc) {
+        var dbEntity = new AcDbArc(arc.center, arc.radius, AcGeMathUtil.degToRad(arc.startAngle), AcGeMathUtil.degToRad(arc.endAngle));
+        return dbEntity;
+    };
+    /**
+     * Converts a DXF circle entity to an AcDbCircle.
+     *
+     * @param circle - The DXF circle entity to convert
+     * @returns The converted AcDbCircle entity
+     *
+     * @example
+     * ```typescript
+     * const dxfCircle = { type: 'CIRCLE', center: [0, 0, 0], radius: 5 };
+     * const acDbCircle = converter.convertCirle(dxfCircle);
+     * ```
+     */
+    AcDbEntityConverter.prototype.convertCirle = function (circle) {
+        var dbEntity = new AcDbCircle(circle.center, circle.radius);
+        return dbEntity;
+    };
+    /**
+     * Converts a DXF ellipse entity to an AcDbEllipse.
+     *
+     * @param ellipse - The DXF ellipse entity to convert
+     * @returns The converted AcDbEllipse entity
+     *
+     * @example
+     * ```typescript
+     * const dxfEllipse = { type: 'ELLIPSE', center: [0, 0, 0], majorAxisEndPoint: [5, 0, 0] };
+     * const acDbEllipse = converter.convertEllipse(dxfEllipse);
+     * ```
+     */
+    AcDbEntityConverter.prototype.convertEllipse = function (ellipse) {
+        var _a;
+        var majorAxis = new AcGeVector3d(ellipse.majorAxisEndPoint);
+        var majorAxisRadius = majorAxis.length();
+        var dbEntity = new AcDbEllipse(ellipse.center, (_a = ellipse.extrusionDirection) !== null && _a !== void 0 ? _a : AcGeVector3d.Z_AXIS, majorAxis, majorAxisRadius, majorAxisRadius * ellipse.axisRatio, ellipse.startAngle, ellipse.endAngle);
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertLine = function (line) {
+        var start = line.startPoint;
+        var end = line.endPoint;
+        var dbEntity = new AcDbLine(new AcGePoint3d(start.x, start.y, start.z || 0), new AcGePoint3d(end.x, end.y, end.z || 0));
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertSpline = function (spline) {
+        // Catch error to construct spline because it maybe one spline in one block.
+        // If don't catch the error, the block conversion may be interruptted.
+        try {
+            if (spline.numberOfControlPoints > 0 && spline.numberOfKnots > 0) {
+                return new AcDbSpline(spline.controlPoints, spline.knots, spline.weights, spline.degree, !!(spline.flag & 0x01));
+            }
+            else if (spline.numberOfFitPoints > 0) {
+                var fitPoints = this.numberArrayToPointArray(spline.fitPoints, spline.numberOfFitPoints);
+                if (fitPoints != null) {
+                    return new AcDbSpline(fitPoints, 'Uniform', spline.degree, !!(spline.flag & 0x01));
+                }
+            }
+        }
+        catch (error) {
+            console.log("Failed to convert spline with error: ".concat(error));
+        }
+        return null;
+    };
+    AcDbEntityConverter.prototype.convertPoint = function (point) {
+        var dbEntity = new AcDbPoint();
+        dbEntity.position = point.position;
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertSolid = function (solid) {
+        var dbEntity = new AcDbTrace();
+        solid.points.forEach(function (point, index) { return dbEntity.setPointAt(index, point); });
+        dbEntity.thickness = solid.thickness;
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertPolyline = function (polyline) {
+        // Polyline flag (bit-coded; default = 0):
+        // https://help.autodesk.com/view/OARX/2023/ENU/?guid=GUID-ABF6B778-BE20-4B49-9B58-A94E64CEFFF3
+        //
+        // 1 = This is a closed polyline (or a polygon mesh closed in the M direction)
+        // 2 = Curve-fit vertices have been added
+        // 4 = Spline-fit vertices have been added
+        // 8 = This is a 3D polyline
+        // 16 = This is a 3D polygon mesh
+        // 32 = The polygon mesh is closed in the N direction
+        // 64 = The polyline is a polyface mesh
+        // 128 = The linetype pattern is generated continuously around the vertices of this polyline
+        var isClosed = !!(polyline.flag & 0x01);
+        var is3dPolyline = !!(polyline.flag & 0x08);
+        // Filter out spline control points
+        var vertices = [];
+        var bulges = [];
+        polyline.vertices.map(function (vertex) {
+            var _a;
+            if (!(vertex.flag & VertexFlag.SPLINE_CONTROL_POINT)) {
+                vertices.push({
+                    x: vertex.x,
+                    y: vertex.y,
+                    z: vertex.z
+                });
+                bulges.push((_a = vertex.bulge) !== null && _a !== void 0 ? _a : 0);
+            }
+        });
+        if (is3dPolyline) {
+            var polyType = AcDbPoly3dType.SimplePoly;
+            if (polyline.flag & 0x04) {
+                if (polyline.smoothType == SmoothType.CUBIC) {
+                    polyType = AcDbPoly3dType.CubicSplinePoly;
+                }
+                else if (polyline.smoothType == SmoothType.QUADRATIC) {
+                    polyType = AcDbPoly3dType.QuadSplinePoly;
+                }
+            }
+            return new AcDb3dPolyline(polyType, vertices, isClosed);
+        }
+        else {
+            var polyType = AcDbPoly2dType.SimplePoly;
+            if (polyline.flag & 0x02) {
+                polyType = AcDbPoly2dType.FitCurvePoly;
+            }
+            else if (polyline.flag & 0x04) {
+                if (polyline.smoothType == SmoothType.CUBIC) {
+                    polyType = AcDbPoly2dType.CubicSplinePoly;
+                }
+                else if (polyline.smoothType == SmoothType.QUADRATIC) {
+                    polyType = AcDbPoly2dType.QuadSplinePoly;
+                }
+            }
+            return new AcDb2dPolyline(polyType, vertices, 0, isClosed, polyline.startWidth, polyline.endWidth, bulges);
+        }
+    };
+    AcDbEntityConverter.prototype.convertLWPolyline = function (polyline) {
+        var dbEntity = new AcDbPolyline();
+        dbEntity.closed = !!(polyline.flag & 0x01);
+        polyline.vertices.forEach(function (vertex, index) {
+            dbEntity.addVertexAt(index, new AcGePoint2d(vertex.x, vertex.y), vertex.bulge, vertex.startWidth, vertex.endWidth);
+        });
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertHatch = function (hatch) {
+        var _a;
+        var dbEntity = new AcDbHatch();
+        (_a = hatch.definitionLines) === null || _a === void 0 ? void 0 : _a.forEach(function (item) {
+            dbEntity.definitionLines.push({
+                angle: item.angle,
+                origin: item.base,
+                delta: item.offset,
+                dashPattern: item.numberOfDashLengths > 0 ? item.dashLengths : []
+            });
+        });
+        dbEntity.hatchStyle = hatch.hatchStyle;
+        dbEntity.patternName = hatch.patternName;
+        dbEntity.patternType = hatch.patternType;
+        dbEntity.patternAngle = hatch.patternAngle == null ? 0 : hatch.patternAngle;
+        dbEntity.patternScale = hatch.patternScale == null ? 0 : hatch.patternScale;
+        var paths = hatch.boundaryPaths;
+        paths.forEach(function (path) {
+            var flag = path.boundaryPathTypeFlag;
+            // Check whether it is a polyline
+            if (flag & 0x02) {
+                var polylinePath = path;
+                var polyline_1 = new AcGePolyline2d();
+                polyline_1.closed = polylinePath.isClosed;
+                polylinePath.vertices.forEach(function (vertex, index) {
+                    polyline_1.addVertexAt(index, {
+                        x: vertex.x,
+                        y: vertex.y,
+                        bulge: vertex.bulge
+                    });
+                });
+                dbEntity.add(polyline_1);
+            }
+            else {
+                var edgePath = path;
+                var loop_1 = new AcGeLoop2d();
+                edgePath.edges.forEach(function (edge) {
+                    if (edge.type == 1) {
+                        var line = edge;
+                        loop_1.add(new AcGeLine2d(line.start, line.end));
+                    }
+                    else if (edge.type == 2) {
+                        var arc = edge;
+                        loop_1.add(new AcGeCircArc2d(arc.center, arc.radius, AcGeMathUtil.degToRad(arc.startAngle || 0), AcGeMathUtil.degToRad(arc.endAngle || 0), !arc.isCCW));
+                    }
+                    else if (edge.type == 3) {
+                        var ellipse = edge;
+                        var majorAxis = new AcGeVector2d();
+                        majorAxis.subVectors(ellipse.end, ellipse.center);
+                        var majorAxisRadius = Math.sqrt(Math.pow(ellipse.end.x, 2) + Math.pow(ellipse.end.y, 2));
+                        // Property name 'lengthOfMinorAxis' is really confusing.
+                        // Actually length of minor axis means percentage of major axis length.
+                        var minorAxisRadius = majorAxisRadius * ellipse.lengthOfMinorAxis;
+                        var startAngle = AcGeMathUtil.degToRad(ellipse.startAngle || 0);
+                        var endAngle = AcGeMathUtil.degToRad(ellipse.endAngle || 0);
+                        var rotation = Math.atan2(ellipse.end.y, ellipse.end.x);
+                        if (!ellipse.isCCW) {
+                            // when clockwise, need to handle start/end angles
+                            startAngle = Math.PI * 2 - startAngle;
+                            endAngle = Math.PI * 2 - endAngle;
+                        }
+                        loop_1.add(new AcGeEllipseArc2d(__assign(__assign({}, ellipse.center), { z: 0 }), majorAxisRadius, minorAxisRadius, startAngle, endAngle, !ellipse.isCCW, rotation));
+                    }
+                    else if (edge.type == 4) {
+                        var spline = edge;
+                        if (spline.numberOfControlPoints > 0 && spline.numberOfKnots > 0) {
+                            var controlPoints = spline.controlPoints.map(function (item) {
+                                return {
+                                    x: item.x,
+                                    y: item.y,
+                                    z: 0
+                                };
+                            });
+                            var hasWeights_1 = true;
+                            var weights = spline.controlPoints.map(function (item) {
+                                if (item.weight == null)
+                                    hasWeights_1 = false;
+                                return item.weight || 1;
+                            });
+                            loop_1.add(new AcGeSpline3d(controlPoints, spline.knots, hasWeights_1 ? weights : undefined));
+                        }
+                        else if (spline.numberOfFitData > 0) {
+                            var fitPoints = spline.fitDatum.map(function (item) {
+                                return {
+                                    x: item.x,
+                                    y: item.y,
+                                    z: 0
+                                };
+                            });
+                            loop_1.add(new AcGeSpline3d(fitPoints, 'Uniform'));
+                        }
+                    }
+                });
+                dbEntity.add(loop_1);
+            }
+        });
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertTable = function (table) {
+        var dbEntity = new AcDbTable(table.name, table.rowCount, table.columnCount);
+        dbEntity.attachmentPoint =
+            table.attachmentPoint;
+        dbEntity.position.copy(table.startPoint);
+        table.columnWidthArr.forEach(function (width, index) {
+            return dbEntity.setColumnWidth(index, width);
+        });
+        table.rowHeightArr.forEach(function (height, index) {
+            return dbEntity.setRowHeight(index, height);
+        });
+        table.cells.forEach(function (cell, index) {
+            dbEntity.setCell(index, cell);
+        });
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertText = function (text) {
+        var _a, _b;
+        var dbEntity = new AcDbText();
+        dbEntity.textString = text.text;
+        dbEntity.styleName = text.styleName;
+        dbEntity.height = text.textHeight;
+        dbEntity.position.copy(text.startPoint);
+        dbEntity.rotation = AcGeMathUtil.degToRad(text.rotation || 0);
+        dbEntity.oblique = (_a = text.obliqueAngle) !== null && _a !== void 0 ? _a : 0;
+        dbEntity.thickness = text.thickness;
+        dbEntity.horizontalMode = text.halign;
+        dbEntity.verticalMode = text.valign;
+        dbEntity.widthFactor = (_b = text.xScale) !== null && _b !== void 0 ? _b : 1;
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertMText = function (mtext) {
+        var dbEntity = new AcDbMText();
+        dbEntity.contents = mtext.text;
+        if (mtext.styleName != null) {
+            dbEntity.styleName = mtext.styleName;
+        }
+        dbEntity.height = mtext.height;
+        dbEntity.width = mtext.width;
+        dbEntity.rotation = AcGeMathUtil.degToRad(mtext.rotation || 0);
+        dbEntity.location = mtext.insertionPoint;
+        dbEntity.attachmentPoint =
+            mtext.attachmentPoint;
+        if (mtext.direction) {
+            dbEntity.direction = new AcGeVector3d(mtext.direction);
+        }
+        dbEntity.drawingDirection =
+            mtext.drawingDirection;
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertLeader = function (leader) {
+        var dbEntity = new AcDbLeader();
+        leader.vertices.forEach(function (point) {
+            dbEntity.appendVertex(point);
+        });
+        dbEntity.hasArrowHead = leader.isArrowheadEnabled;
+        dbEntity.hasHookLine = leader.isHooklineExists;
+        dbEntity.isSplined = leader.isSpline;
+        dbEntity.dimensionStyle = leader.styleName;
+        dbEntity.annoType =
+            leader.leaderCreationFlag;
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertDimension = function (dimension) {
+        if (dimension.subclassMarker == 'AcDbAlignedDimension' ||
+            dimension.subclassMarker == 'AcDbRotatedDimension') {
+            var entity = dimension;
+            var dbEntity = new AcDbAlignedDimension(entity.subDefinitionPoint1, entity.subDefinitionPoint2, entity.definitionPoint);
+            dbEntity.rotation = AcGeMathUtil.degToRad(entity.rotationAngle || 0);
+            this.processDimensionCommonAttrs(dimension, dbEntity);
+            return dbEntity;
+        }
+        else if (dimension.subclassMarker == 'AcDb3PointAngularDimension') {
+            var entity = dimension;
+            var dbEntity = new AcDb3PointAngularDimension(entity.centerPoint, entity.subDefinitionPoint1, entity.subDefinitionPoint2, entity.definitionPoint);
+            this.processDimensionCommonAttrs(dimension, dbEntity);
+            return dbEntity;
+        }
+        else if (dimension.subclassMarker == 'AcDbOrdinateDimension') {
+            var entity = dimension;
+            var dbEntity = new AcDbOrdinateDimension(entity.subDefinitionPoint1, entity.subDefinitionPoint2);
+            this.processDimensionCommonAttrs(dimension, dbEntity);
+            return dbEntity;
+        }
+        else if (dimension.subclassMarker == 'AcDbRadialDimension') {
+            var entity = dimension;
+            var dbEntity = new AcDbRadialDimension(entity.definitionPoint, entity.centerPoint, entity.leaderLength);
+            this.processDimensionCommonAttrs(dimension, dbEntity);
+            return dbEntity;
+        }
+        else if (dimension.subclassMarker == 'AcDbDiametricDimension') {
+            var entity = dimension;
+            var dbEntity = new AcDbDiametricDimension(entity.definitionPoint, entity.centerPoint, entity.leaderLength);
+            this.processDimensionCommonAttrs(dimension, dbEntity);
+            return dbEntity;
+        }
+        return null;
+    };
+    AcDbEntityConverter.prototype.processImage = function (image, dbImage) {
+        dbImage.position.copy(image.position);
+        dbImage.brightness = image.brightness;
+        dbImage.contrast = image.contrast;
+        dbImage.fade = image.fade;
+        dbImage.isShownClipped = (image.flags | 0x0004) > 0;
+        dbImage.isImageShown = (image.flags | 0x0003) > 0;
+        dbImage.isImageTransparent = (image.flags | 0x0008) > 0;
+        dbImage.imageDefId = image.imageDefHandle;
+        dbImage.isClipped = image.isClipped;
+        image.clippingBoundaryPath.forEach(function (point) {
+            dbImage.clipBoundary.push(new AcGePoint2d(point));
+        });
+        // Calculate the scale factors
+        dbImage.width =
+            Math.sqrt(Math.pow(image.uPixel.x, 2) + Math.pow(image.uPixel.y, 2) + Math.pow(image.uPixel.z, 2)) * image.imageSize.x;
+        dbImage.height =
+            Math.sqrt(Math.pow(image.vPixel.x, 2) + Math.pow(image.vPixel.y, 2) + Math.pow(image.vPixel.z, 2)) * image.imageSize.y;
+        // Calculate the rotation angle
+        // Rotation is determined by the angle of the U-vector relative to the X-axis
+        dbImage.rotation = Math.atan2(image.uPixel.y, image.uPixel.x);
+    };
+    AcDbEntityConverter.prototype.convertImage = function (image) {
+        var dbImage = new AcDbRasterImage();
+        this.processImage(image, dbImage);
+        dbImage.clipBoundaryType =
+            image.clippingBoundaryType;
+        return dbImage;
+    };
+    AcDbEntityConverter.prototype.processWipeout = function (wipeout, dbWipeout) {
+        dbWipeout.position.copy(wipeout.position);
+        dbWipeout.brightness = wipeout.brightness;
+        dbWipeout.contrast = wipeout.contrast;
+        dbWipeout.fade = wipeout.fade;
+        dbWipeout.isShownClipped = (wipeout.displayFlag | 0x0004) > 0;
+        dbWipeout.isImageShown = (wipeout.displayFlag | 0x0003) > 0;
+        dbWipeout.isImageTransparent = (wipeout.displayFlag | 0x0008) > 0;
+        dbWipeout.imageDefId = wipeout.imageDefHardId;
+        dbWipeout.isClipped = wipeout.isClipping;
+        wipeout.boundary.forEach(function (point) {
+            dbWipeout.clipBoundary.push(new AcGePoint2d(point));
+        });
+        dbWipeout.clipBoundaryType =
+            wipeout.boundaryType;
+        // Calculate the scale factors
+        dbWipeout.width =
+            Math.sqrt(Math.pow(wipeout.uDirection.x, 2) +
+                Math.pow(wipeout.uDirection.y, 2) +
+                Math.pow(wipeout.uDirection.z, 2)) * wipeout.imageSize.x;
+        dbWipeout.height =
+            Math.sqrt(Math.pow(wipeout.vDirection.x, 2) +
+                Math.pow(wipeout.vDirection.y, 2) +
+                Math.pow(wipeout.vDirection.z, 2)) * wipeout.imageSize.y;
+        // Calculate the rotation angle
+        // Rotation is determined by the angle of the U-vector relative to the X-axis
+        dbWipeout.rotation = Math.atan2(wipeout.uDirection.y, wipeout.uDirection.x);
+    };
+    AcDbEntityConverter.prototype.convertWipeout = function (wipeout) {
+        var dbWipeout = new AcDbWipeout();
+        this.processWipeout(wipeout, dbWipeout);
+        return dbWipeout;
+    };
+    AcDbEntityConverter.prototype.convertViewport = function (viewport) {
+        var dbViewport = new AcDbViewport();
+        dbViewport.number = viewport.viewportId;
+        dbViewport.centerPoint.copy(viewport.viewportCenter);
+        dbViewport.height = viewport.height;
+        dbViewport.width = viewport.width;
+        dbViewport.viewCenter.copy(viewport.displayCenter);
+        dbViewport.viewHeight = viewport.viewHeight;
+        return dbViewport;
+    };
+    AcDbEntityConverter.prototype.convertRay = function (ray) {
+        var dbRay = new AcDbRay();
+        dbRay.basePoint.copy(ray.position);
+        dbRay.unitDir.copy(ray.direction);
+        return dbRay;
+    };
+    AcDbEntityConverter.prototype.convertXline = function (xline) {
+        var dbXline = new AcDbXline();
+        dbXline.basePoint.copy(xline.position);
+        dbXline.unitDir.copy(xline.direction);
+        return dbXline;
+    };
+    AcDbEntityConverter.prototype.convertBlockReference = function (blockReference) {
+        var _a;
+        var dbBlockReference = new AcDbBlockReference(blockReference.name);
+        if (blockReference.insertionPoint)
+            dbBlockReference.position.copy(blockReference.insertionPoint);
+        dbBlockReference.scaleFactors.x = blockReference.xScale || 1;
+        dbBlockReference.scaleFactors.y = blockReference.yScale || 1;
+        dbBlockReference.scaleFactors.z = blockReference.zScale || 1;
+        dbBlockReference.rotation =
+            blockReference.rotation != null
+                ? AcGeMathUtil.degToRad(blockReference.rotation)
+                : 0;
+        dbBlockReference.normal.copy((_a = blockReference.extrusionDirection) !== null && _a !== void 0 ? _a : { x: 0, y: 0, z: 1 });
+        return dbBlockReference;
+    };
+    AcDbEntityConverter.prototype.processDimensionCommonAttrs = function (entity, dbEntity) {
+        dbEntity.dimBlockId = entity.name;
+        dbEntity.textPosition.copy(entity.textPoint);
+        dbEntity.textRotation = entity.textRotation || 0;
+        if (entity.textLineSpacingFactor) {
+            dbEntity.textLineSpacingFactor = entity.textLineSpacingFactor;
+        }
+        if (entity.textLineSpacingStyle) {
+            dbEntity.textLineSpacingStyle =
+                entity.textLineSpacingStyle;
+        }
+        dbEntity.dimensionStyleName = entity.styleName;
+        dbEntity.dimensionText = entity.text || '';
+        dbEntity.measurement = entity.measurement;
+    };
+    /**
+     * Processes common attributes from a DXF entity to an AcDbEntity.
+     *
+     * This method copies common properties like layer, object ID, owner ID,
+     * linetype, lineweight, color, visibility, and transparency from the
+     * DXF entity to the corresponding AcDbEntity.
+     *
+     * @param entity - The source DXF entity
+     * @param dbEntity - The target AcDbEntity to populate
+     *
+     * @example
+     * ```typescript
+     * converter.processCommonAttrs(dxfEntity, acDbEntity);
+     * ```
+     */
+    AcDbEntityConverter.prototype.processCommonAttrs = function (entity, dbEntity) {
+        dbEntity.layer = entity.layer || '0';
+        // I found some dxf file may have entity without handle. If so, let's use objectId
+        // created by AcDbObject constructor instead.
+        if (entity.handle)
+            dbEntity.objectId = entity.handle;
+        dbEntity.ownerId = entity.ownerBlockRecordSoftId || '';
+        if (entity.lineType != null) {
+            dbEntity.lineType = entity.lineType;
+        }
+        if (entity.lineweight != null) {
+            dbEntity.lineWeight = entity.lineweight;
+        }
+        if (entity.lineTypeScale != null) {
+            dbEntity.linetypeScale = entity.lineTypeScale;
+        }
+        if (entity.color != null) {
+            dbEntity.color.color = entity.color;
+        }
+        if (entity.colorIndex != null) {
+            dbEntity.color.colorIndex = entity.colorIndex;
+        }
+        if (entity.colorName != null) {
+            dbEntity.color.colorName = entity.colorName;
+        }
+        if (entity.isVisible != null) {
+            dbEntity.visibility = entity.isVisible;
+        }
+        if (entity.transparency != null) {
+            dbEntity.transparency = entity.transparency;
+        }
+    };
+    /**
+     * Converts a number array to an array of 3D points.
+     *
+     * This utility method takes a flat array of numbers and converts it to
+     * an array of AcGePoint3dLike objects. It automatically detects whether
+     * the input represents 2D or 3D points based on the array length and
+     * number of points.
+     *
+     * @param numbers - Flat array of numbers representing point coordinates
+     * @param numberOfPoints - Expected number of points in the array
+     * @returns Array of AcGePoint3dLike objects, or undefined if the conversion fails
+     *
+     * @example
+     * ```typescript
+     * const numbers = [0, 0, 10, 10, 20, 20]; // 3 points in 2D
+     * const points = converter.numberArrayToPointArray(numbers, 3);
+     * // Returns: [{x: 0, y: 0, z: 0}, {x: 10, y: 10, z: 0}, {x: 20, y: 20, z: 0}]
+     * ```
+     */
+    AcDbEntityConverter.prototype.numberArrayToPointArray = function (numbers, numberOfPoints) {
+        var count = numbers.length;
+        var dimension = 0;
+        if (count / 2 == numberOfPoints) {
+            dimension = 2;
+        }
+        else if (count / 3 == numberOfPoints) {
+            dimension = 3;
+        }
+        if (dimension == 0)
+            return undefined;
+        var points = [];
+        for (var index = 0, size = count / dimension; index < size; ++index) {
+            points.push({
+                x: numbers[index * dimension],
+                y: numbers[index * dimension + 1],
+                z: dimension == 3 ? numbers[index * dimension + 2] : 0
+            });
+        }
+        return points;
+    };
+    return AcDbEntityConverter;
+}());
+export { AcDbEntityConverter };
+//# sourceMappingURL=AcDbEntitiyConverter.js.map