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

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

@@ -0,0 +1,57 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'MTEXT';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 3:
+        case 1:
+            entity.text ? entity.text += curr.value : entity.text = curr.value;
+            break;
+        case 10:
+            entity.position = helpers.parsePoint(scanner);
+            break;
+        case 11:
+            entity.direction = helpers.parsePoint(scanner);
+            break;
+        case 40:
+            //Note: this is the text height
+            entity.height = curr.value;
+            break;
+        case 41:
+            entity.width = curr.value;
+            break;
+        case 44:
+            entity.lineSpacing = curr.value;
+            break;
+        case 50:
+            entity.rotation = curr.value;
+            break;
+        case 7: // Text style name
+            entity.styleName = curr.value;
+            break;
+        case 71:
+            entity.attachmentPoint = curr.value;
+            break;
+        case 72:
+            entity.drawingDirection = curr.value;
+            break;
+        case 101:
+            helpers.skipEmbeddedObject(scanner);
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+    return entity;
+};

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

@@ -0,0 +1,35 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'POINT';
+
+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.position = helpers.parsePoint(scanner);
+            break;
+        case 39:
+            entity.thickness = curr.value;
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        case 100:
+            break;
+        default: // check common entity attributes
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+
+    return entity;
+};

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

@@ -0,0 +1,92 @@
+
+import * as helpers from "../ParseHelpers.js"
+import VertexParser from "./vertex.js";
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'POLYLINE';
+
+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: // always 0
+            break;
+        case 20: // always 0
+            break;
+        case 30: // elevation
+            break;
+        case 39: // thickness
+            entity.thickness = curr.value;
+            break;
+        case 40: // start width
+            break;
+        case 41: // end width
+            break;
+        case 70:
+            entity.shape = (curr.value & 1) !== 0;
+            entity.includesCurveFitVertices = (curr.value & 2) !== 0;
+            entity.includesSplineFitVertices = (curr.value & 4) !== 0;
+            entity.is3dPolyline = (curr.value & 8) !== 0;
+            entity.is3dPolygonMesh = (curr.value & 16) !== 0;
+            entity.is3dPolygonMeshClosed = (curr.value & 32) !== 0; // 32 = The polygon mesh is closed in the N direction
+            entity.isPolyfaceMesh = (curr.value & 64) !== 0;
+            entity.hasContinuousLinetypePattern = (curr.value & 128) !== 0;
+            break;
+        case 71: // Polygon mesh M vertex count
+            break;
+        case 72: // Polygon mesh N vertex count
+            break;
+        case 73: // Smooth surface M density
+            break;
+        case 74: // Smooth surface N density
+            break;
+        case 75: // Curves and smooth surface type
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+
+    entity.vertices = parsePolylineVertices(scanner, curr);
+
+    return entity;
+};
+
+function parsePolylineVertices(scanner, curr) {
+    var vertexParser = new VertexParser();
+
+    var vertices = [];
+    while (!scanner.isEOF()) {
+        if (curr.code === 0) {
+            if (curr.value === 'VERTEX') {
+                vertices.push(vertexParser.parseEntity(scanner, curr));
+                curr = scanner.lastReadGroup;
+            } else if (curr.value === 'SEQEND') {
+                parseSeqEnd(scanner, curr);
+                break;
+            }
+        }
+    }
+    return vertices;
+};
+
+function parseSeqEnd(scanner, curr) {
+    var entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr != 'EOF') {
+        if (curr.code == 0) break;
+        helpers.checkCommonEntityProperties(entity, curr, scanner);
+        curr = scanner.next();
+    }
+
+    return entity;
+};

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

@@ -0,0 +1,40 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'SOLID';
+
+EntityParser.prototype.parseEntity = function(scanner, currentGroup) {
+    var entity;
+    entity = { type: currentGroup.value };
+    entity.points = [];
+    currentGroup = scanner.next();
+    while(currentGroup !== 'EOF') {
+        if(currentGroup.code === 0) break;
+
+        switch(currentGroup.code) {
+        case 10:
+            entity.points[0] = helpers.parsePoint(scanner);
+            break;
+        case 11:
+            entity.points[1] = helpers.parsePoint(scanner);
+            break;
+        case 12:
+            entity.points[2] = helpers.parsePoint(scanner);
+            break;
+        case 13:
+            entity.points[3] = helpers.parsePoint(scanner);
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default: // check common entity attributes
+            helpers.checkCommonEntityProperties(entity, currentGroup, scanner);
+            break;
+        }
+        currentGroup = scanner.next();
+    }
+
+    return entity;
+};

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

@@ -0,0 +1,70 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'SPLINE';
+
+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:
+            if (!entity.controlPoints) entity.controlPoints = [];
+            entity.controlPoints.push(helpers.parsePoint(scanner));
+            break;
+        case 11:
+            if (!entity.fitPoints) entity.fitPoints = [];
+            entity.fitPoints.push(helpers.parsePoint(scanner));
+            break;
+        case 12:
+            entity.startTangent = helpers.parsePoint(scanner);
+            break;
+        case 13:
+            entity.endTangent = helpers.parsePoint(scanner);
+            break;
+        case 40:
+            if (!entity.knotValues) entity.knotValues = [];
+            entity.knotValues.push(curr.value);
+            break;
+        case 70:
+            if ((curr.value & 1) != 0) entity.closed = true;
+            if ((curr.value & 2) != 0) entity.periodic = true;
+            if ((curr.value & 4) != 0) entity.rational = true;
+            if ((curr.value & 8) != 0) entity.planar = true;
+            if ((curr.value & 16) != 0)
+            {
+                entity.planar = true;
+                entity.linear = true;
+            }
+            break;
+
+        case 71:
+            entity.degreeOfSplineCurve = curr.value;
+            break;
+        case 72:
+            entity.numberOfKnots = curr.value;
+            break;
+        case 73:
+            entity.numberOfControlPoints = curr.value;
+            break;
+        case 74:
+            entity.numberOfFitPoints = curr.value;
+            break;
+        case 210:
+            entity.extrusionDirection = helpers.parsePoint(scanner);
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+        curr = scanner.next();
+    }
+
+    return entity;
+};

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

@@ -0,0 +1,50 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'TEXT';
+
+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: // X coordinate of 'first alignment point'
+            entity.startPoint = helpers.parsePoint(scanner);
+            break;
+        case 11: // X coordinate of 'second alignment point'
+            entity.endPoint = helpers.parsePoint(scanner);
+            break;
+        case 40: // Text height
+            entity.textHeight = curr.value;
+            break;
+        case 41:
+            entity.xScale = curr.value;
+            break;
+        case 50: // Rotation in degrees
+            entity.rotation = curr.value;
+            break;
+        case 7: // Text style name
+            entity.styleName = curr.value;
+            break;
+        case 1: // Text
+            entity.text = curr.value;
+            break;
+        // NOTE: 72 and 73 are meaningless without 11 (second alignment point)
+        case 72: // Horizontal alignment
+            entity.halign = curr.value;
+            break;
+        case 73: // Vertical alignment
+            entity.valign = 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/vertex.js

@@ -0,0 +1,62 @@
+
+import * as helpers from "../ParseHelpers.js"
+
+export default function EntityParser() {}
+
+EntityParser.ForEntityName = 'VERTEX';
+
+EntityParser.prototype.parseEntity = function(scanner, curr) {
+    var entity = { type: curr.value };
+    curr = scanner.next();
+    while(curr !== 'EOF') {
+        if(curr.code === 0) break;
+
+        switch(curr.code) {
+        case 10:    // X
+            entity.x = curr.value;
+            break;
+        case 20: // Y
+            entity.y = curr.value;
+            break;
+        case 30: // Z
+            entity.z = curr.value;
+            break;
+        case 40: // start width
+            break;
+        case 41: // end width
+            break;
+        case 42: // bulge
+            if(curr.value != 0) entity.bulge = curr.value;
+            break;
+        case 70: // flags
+            entity.curveFittingVertex = (curr.value & 1) !== 0;
+            entity.curveFitTangent = (curr.value & 2) !== 0;
+            entity.splineVertex = (curr.value & 8) !== 0;
+            entity.splineControlPoint = (curr.value & 16) !== 0;
+            entity.threeDPolylineVertex = (curr.value & 32) !== 0;
+            entity.threeDPolylineMesh = (curr.value & 64) !== 0;
+            entity.polyfaceMeshVertex = (curr.value & 128) !== 0;
+            break;
+        case 50: // curve fit tangent direction
+            break;
+        case 71: // polyface mesh vertex index
+            entity.faces = [curr.value];
+            break;
+        case 72: // polyface mesh vertex index
+            entity.faces[1] = curr.value;
+            break;
+        case 73: // polyface mesh vertex index
+            entity.faces[2] = curr.value;
+            break;
+        case 74: // polyface mesh vertex index
+            entity.faces[3] = curr.value;
+            break;
+        default:
+            helpers.checkCommonEntityProperties(entity, curr, scanner);
+            break;
+        }
+
+        curr = scanner.next();
+    }
+    return entity;
+};

package/src/utils/threejs/measure-clear-distance.js

@@ -135,7 +135,7 @@ MeasureClearDistance.prototype = {
     const worldPts2 = localPts2.map(p => p.clone().applyMatrix4(wm2));
     let closestPair = this.findClosestPair(worldPts1, worldPts2);
     // 局部精细搜索
-    const radius = closestPair.distance * 2 + 0.1;
+    const radius = closestPair.distance * 4;
     const localPts1Fine = this.sampleLocal(obj1.object, obj1.instanceId, closestPair.point1, radius, 1000);
     const localPts2Fine = this.sampleLocal(obj2.object, obj2.instanceId, closestPair.point2, radius, 1000);
     const combined1 = worldPts1.filter(p => p.distanceTo(closestPair.point1) < radius).concat(localPts1Fine);