@mlightcad/data-model 1.3.1 → 1.3.3

package/lib/converter/AcDbEntitiyConverter.js

@@ -1,659 +0,0 @@
-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 { AcGeCircArc2d, AcGeEllipseArc2d, AcGeLine2d, AcGeLoop2d, AcGeMathUtil, AcGePoint2d, AcGePoint3d, AcGePolyline2d, AcGeSpline3d, AcGeVector2d, AcGeVector3d } from '@mlightcad/geometry-engine';
-import { AcDb3PointAngularDimension, AcDbAlignedDimension, AcDbArc, AcDbBlockReference, AcDbCircle, AcDbDiametricDimension, AcDbEllipse, AcDbFace, AcDbHatch, AcDbLeader, AcDbLine, AcDbMText, AcDbOrdinateDimension, AcDbPoint, 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 == 'MTEXT') {
-            return this.convertMText(entity);
-        }
-        else if (entity.type == 'POLYLINE' || entity.type == 'LWPOLYLINE') {
-            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 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