fl-web-component 2.0.19-beta.3 → 2.1.1-beta.0

package/src/utils/dxf-parser/entities/dimension.js

@@ -0,0 +1,71 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'DIMENSION';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity;
+    entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 2: // Referenced block name
+            entity.block = curr.value;
+            break;
+        case 3: // Dimension style name
+            entity.styleName = curr.value;
+            break;
+        case 10: // X coordinate of 'first alignment point'
+            entity.anchorPoint = helpers.parsePoint(scanner);
+            break;
+        case 11:
+            entity.middleOfText = helpers.parsePoint(scanner);
+            break;
+        case 12: // Insertion point for clones of a dimension
+            entity.insertionPoint = helpers.parsePoint(scanner);
+            break;
+        case 13: // Definition point for linear and angular dimensions
+            entity.linearOrAngularPoint1 = helpers.parsePoint(scanner);
+            break;
+        case 14: // Definition point for linear and angular dimensions
+            entity.linearOrAngularPoint2 = helpers.parsePoint(scanner);
+            break;
+        case 15: // Definition point for diameter, radius, and angular dimensions
+            entity.diameterOrRadiusPoint = helpers.parsePoint(scanner);
+            break;
+        case 16: // Point defining dimension arc for angular dimensions
+            entity.arcPoint = helpers.parsePoint(scanner);
+            break;
+        case 70: // Dimension type
+            entity.dimensionType = curr.value;
+            break;
+        case 71: // 5 = Middle center
+            entity.attachmentPoint = curr.value;
+            break;
+        case 42: // Actual measurement
+            entity.actualMeasurement = curr.value;
+            break;
+        case 1: // Text entered by user explicitly
+            entity.text = curr.value;
+            break;
+        case 50: // Angle of rotated, horizontal, or vertical dimensions
+            entity.angle = curr.value;
+            break;
+        case 53: // Rotation angle of the dimension text away from its default orientation (the
+            //direction of the dimension line)
+            entity.textRotation = curr.value;
+            break;
+
+        default: // check common entity attributes
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+
+    return entity;
+};

package/src/utils/dxf-parser/entities/ellipse.js

@@ -0,0 +1,48 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'ELLIPSE';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity;
+    entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 10:
+            entity.center = helpers.parsePoint(scanner);
+            break;
+        case 11:
+            entity.majorAxisEndPoint = helpers.parsePoint(scanner);
+            break;
+        case 40:
+            entity.axisRatio = curr.value;
+            break;
+        case 41:
+            /* Already in radians. */
+            entity.startAngle = curr.value;
+            break;
+        case 42:
+            /* Already in radians. */
+            entity.endAngle = curr.value;
+            break;
+        case 2:
+            entity.name = curr.value;
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default: // check common entity attributes
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+
+        curr = scanner.next();
+    }
+
+    return entity;
+};

package/src/utils/dxf-parser/entities/hatch.js

@@ -0,0 +1,348 @@
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'HATCH';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity;
+    entity = { type: curr.value };
+
+    let numBoundaryLoops = 0;
+    let numDefinitionLines = 0;
+    let numSeedPoints = 0;
+
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if (curr.code === 0) break;
+
+        while (numBoundaryLoops > 0) {
+            const loop = ParseBoundaryLoop(curr, scanner)
+            if (loop) {
+                entity.boundaryLoops.push(loop);
+                numBoundaryLoops--;
+                curr = scanner.next();
+            } else {
+                numBoundaryLoops = 0
+            }
+        }
+
+        while (numDefinitionLines > 0) {
+            const line = ParseDefinitionLine(curr, scanner)
+            if (line) {
+                entity.definitionLines.push(line);
+                numDefinitionLines--;
+                curr = scanner.next();
+            } else {
+                numDefinitionLines = 0
+            }
+        }
+
+        while (numSeedPoints > 0) {
+            const pt = ParseSeedPoint(curr, scanner);
+            if (pt) {
+                entity.seedPoints.push(pt);
+                numSeedPoints--;
+                curr = scanner.next();
+            } else {
+                numSeedPoints = 0
+            }
+        }
+
+        if (curr.code === 0) break;
+
+        switch(curr.code) {
+
+        case 2: // Hatch pattern name
+            entity.patternName = curr.value;
+            break;
+
+        case 70: //Solid fill flag (solid fill = 1; pattern fill = 0)
+            entity.isSolid = curr.value != 0;
+            break;
+
+        case 91: // Number of boundary paths (loops)
+            numBoundaryLoops = curr.value;
+            if (numBoundaryLoops > 0) {
+                entity.boundaryLoops = []
+            }
+            break;
+
+        // Hatch style:
+        // 0 = Hatch “odd parity” area (Normal style)
+        // 1 = Hatch outermost area only (Outer style)
+        // 2 = Hatch through entire area (Ignore style)
+        case 75:
+            entity.hatchStyle = curr.value;
+            break;
+
+        //Hatch pattern type:
+        // 0 = User-defined; 1 = Predefined; 2 = Custom
+        case 76:
+            entity.patternType = curr.value;
+            break;
+
+        case 52: // Hatch pattern angle (pattern fill only)
+            entity.patternAngle = curr.value * Math.PI / 180;
+            break;
+
+        case 41: // Hatch pattern scale or spacing (pattern fill only)
+            entity.patternScale = curr.value;
+            break;
+
+        case 78: // Number of pattern definition lines
+            numDefinitionLines = curr.value;
+            if (numDefinitionLines > 0) {
+                entity.definitionLines = []
+            }
+            break;
+
+        case 98: // Number of seed points
+            numSeedPoints = curr.value;
+            if (numSeedPoints > 0) {
+                entity.seedPoints = []
+            }
+            break;
+
+        default: // check common entity attributes
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+
+    return entity;
+};
+
+function ParseBoundaryLoop(curr, scanner) {
+    let entity = null
+
+    const ParsePolyline = () => {
+        const pl = {vertices: [], isClosed: false};
+        let hasBulge = false;
+        let numVertices = 0;
+        while (true) {
+            if (numVertices > 0) {
+                for (let i = 0; i < numVertices; i++) {
+                    if (curr.code != 10) {
+                        break
+                    }
+                    const p = helpers.parsePoint(scanner)
+                    curr = scanner.next();
+                    if (curr.code == 42) {
+                        p.bulge = curr.value
+                        curr = scanner.next();
+                    }
+                    pl.vertices.push(p)
+                }
+                return pl
+            }
+
+            switch (curr.code) {
+            case 72:
+                hasBulge = curr.value;
+                break;
+            case 73:
+                pl.isClosed = curr.value;
+                break;
+            case 93:
+                numVertices = curr.value;
+                break;
+            default:
+                return pl;
+            }
+            curr = scanner.next();
+        }
+    }
+
+    const ParseEdge = () => {
+        if (curr.code != 72) {
+            return null
+        }
+        const e = {type: curr.value}
+        curr = scanner.next();
+        const isSpline = e.type == 4
+
+        while (true) {
+            switch (curr.code) {
+            case 10:
+                if (isSpline) {
+                    if (!e.controlPoints) {
+                        e.controlPoints = [];
+                    }
+                    e.controlPoints.push(helpers.parsePoint(scanner));
+                } else {
+                    e.start = helpers.parsePoint(scanner);
+                }
+                break;
+            case 11:
+                if (isSpline) {
+                    if (!e.fitPoints) {
+                        e.fitPoints = [];
+                    }
+                    e.fitPoints.push(helpers.parsePoint(scanner));
+                } else {
+                    e.end = helpers.parsePoint(scanner);
+                }
+                break;
+            case 40:
+                if (isSpline) {
+                    if (!e.knotValues) {
+                        e.knotValues = [];
+                    }
+                    e.knotValues.push(curr.value);
+                } else {
+                    e.radius = curr.value;
+                }
+                break;
+            case 50:
+                e.startAngle = curr.value * Math.PI / 180;
+                break;
+            case 51:
+                e.endAngle = curr.value * Math.PI / 180;
+                break;
+            case 73:
+                if (isSpline) {
+                    e.rational = curr.value;
+                } else {
+                    e.isCcw = curr.value;
+                }
+                break;
+            case 74:
+                e.periodic = curr.value;
+                break;
+            case 94:
+                e.degreeOfSplineCurve = curr.value;
+                break;
+
+            //XXX ignore some groups for now, mostly spline
+            case 95:
+            case 96:
+            case 40:
+            case 42:
+            case 97:
+                break;
+            default:
+                return e
+            }
+            curr = scanner.next();
+        }
+    }
+
+    let polylineParsed = false;
+    let numEdges = 0;
+    let numSourceRefs = 0;
+
+    while (true) {
+
+        if (!entity) {
+            if (curr.code != 92) {
+                return null
+            }
+            entity = {
+                type: curr.value,
+                isExternal: (curr.value & 1) != 0,
+                isOutermost: (curr.value & 16) != 0
+            }
+            curr = scanner.next()
+        }
+
+        if ((entity.type & 2) && !polylineParsed) {
+            entity.polyline = ParsePolyline()
+            polylineParsed = true
+        }
+
+        while (numEdges) {
+            const edge = ParseEdge()
+            if (edge) {
+                entity.edges.push(edge)
+                numEdges--
+            } else {
+                numEdges = 0;
+            }
+        }
+
+        while (numSourceRefs) {
+            if (curr.code == 330) {
+                entity.sourceRefs.push(curr.value)
+                numSourceRefs--
+                curr = scanner.next()
+            } else {
+                numSourceRefs = 0
+            }
+        }
+
+        switch (curr.code) {
+        case 93:
+            numEdges = curr.value
+            if (numEdges > 0) {
+                entity.edges = []
+            }
+            break;
+        case 97:
+            numSourceRefs = curr.value
+            if (numSourceRefs > 0) {
+                entity.sourceRefs = []
+            }
+            break;
+        default:
+            scanner.rewind()
+            return entity
+        }
+        curr = scanner.next()
+    }
+}
+
+function ParseDefinitionLine(curr, scanner) {
+    /* Assuming always starts from group 53. */
+    if (curr.code != 53) {
+        return null
+    }
+    const entity = {
+        angle: curr.value * Math.PI / 180,
+        base: {x: 0, y: 0},
+        offset: {x: 0, y: 0}
+    };
+    curr = scanner.next();
+
+    let numDashes = 0;
+    while (true) {
+        switch (curr.code) {
+        case 43:
+            entity.base.x = curr.value;
+            break;
+        case 44:
+            entity.base.y = curr.value;
+            break;
+        case 45:
+            entity.offset.x = curr.value;
+            break;
+        case 46:
+            entity.offset.y = curr.value;
+            break;
+        case 49:
+            if (numDashes > 0) {
+                entity.dashes.push(curr.value);
+                numDashes--;
+            }
+            break;
+        case 79:
+            numDashes = curr.value;
+            if (curr.value) {
+                entity.dashes = []
+            }
+            break;
+        default:
+            scanner.rewind();
+            return entity;
+        }
+        curr = scanner.next();
+    }
+}
+
+function ParseSeedPoint(curr, scanner) {
+    if (curr.code != 10) {
+        return null
+    }
+    return helpers.parsePoint(scanner);
+}

package/src/utils/dxf-parser/entities/insert.js

@@ -0,0 +1,57 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'INSERT';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity;
+    entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 2:
+            entity.name = curr.value;
+            break;
+        case 41:
+            entity.xScale = curr.value;
+            break;
+        case 42:
+            entity.yScale = curr.value;
+            break;
+        case 43:
+            entity.zScale = curr.value;
+            break;
+        case 10:
+            entity.position = helpers.parsePoint(scanner);
+            break;
+        case 50:
+            entity.rotation = curr.value;
+            break;
+        case 70:
+            entity.columnCount = curr.value;
+            break;
+        case 71:
+            entity.rowCount = curr.value;
+            break;
+        case 44:
+            entity.columnSpacing = curr.value;
+            break;
+        case 45:
+            entity.rowSpacing = curr.value;
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default: // check common entity attributes
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+
+    return entity;
+};

package/src/utils/dxf-parser/entities/line.js

@@ -0,0 +1,34 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'LINE';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity = { type: curr.value, vertices: [] };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 10: // X coordinate of point
+            entity.vertices.unshift(helpers.parsePoint(scanner));
+            break;
+        case 11:
+            entity.vertices.push(helpers.parsePoint(scanner));
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        case 100:
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+
+        curr = scanner.next();
+    }
+    return entity;
+};

package/src/utils/dxf-parser/entities/lwpolyline.js

@@ -0,0 +1,103 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'LWPOLYLINE';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity = { type: curr.value, vertices: [] },
+        numberOfVertices = 0;
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 38:
+            entity.elevation = curr.value;
+            break;
+        case 39:
+            entity.depth = curr.value;
+            break;
+        case 70: // 1 = Closed shape, 128 = plinegen?, 0 = default
+            entity.shape = ((curr.value & 1) === 1);
+            entity.hasContinuousLinetypePattern = ((curr.value & 128) === 128);
+            break;
+        case 90:
+            numberOfVertices = curr.value;
+            break;
+        case 10: // X coordinate of point
+            entity.vertices = parseLWPolylineVertices(numberOfVertices, scanner);
+            break;
+        case 43:
+            if(curr.value !== 0) entity.width = curr.value;
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+    return entity;
+};
+
+function parseLWPolylineVertices(n, scanner) {
+    if(!n || n <= 0) throw Error('n must be greater than 0 vertices');
+    var vertices = [], i;
+    var vertexIsStarted = false;
+    var vertexIsFinished = false;
+    var curr = scanner.lastReadGroup;
+
+    for(i = 0; i < n; i++) {
+        var vertex = {};
+        while(curr !== 'EOF') {
+            if(curr.code === 0 || vertexIsFinished) break;
+
+            switch(curr.code) {
+            case 10: // X
+                if(vertexIsStarted) {
+                    vertexIsFinished = true;
+                    continue;
+                }
+                vertex.x = curr.value;
+                vertexIsStarted = true;
+                break;
+            case 20: // Y
+                vertex.y = curr.value;
+                break;
+            case 30: // Z
+                vertex.z = curr.value;
+                break;
+            case 40: // start width
+                vertex.startWidth = curr.value;
+                break;
+            case 41: // end width
+                vertex.endWidth = curr.value;
+                break;
+            case 42: // bulge
+                if(curr.value != 0) vertex.bulge = curr.value;
+                break;
+            case 91: // vertex identifier
+                vertex.id = curr.value;
+                break;
+            default:
+                // if we do not hit known code return vertices.  Code might belong to entity
+                if (vertexIsStarted) {
+                    vertices.push(vertex);
+                }
+                scanner.rewind();
+                return vertices;
+            }
+            curr = scanner.next();
+        }
+        // See https://groups.google.com/forum/#!topic/comp.cad.autocad/9gn8s5O_w6E
+        vertices.push(vertex);
+        vertexIsStarted = false;
+        vertexIsFinished = false;
+    }
+    scanner.rewind();
+    return vertices;
+};