simple angular dimension

Author: matas-bitbybit-dev

packages/dev/babylonjs/lib/api/bitbybit-base.ts

@@ -87,7 +87,7 @@ export class BitByBitBase {
         this.color = new Color(this.math);
         this.line = new Line(this.context, geometryHelper);
         this.transforms = new Transforms(this.vector, this.math);
-        this.point = new Point(geometryHelper, this.transforms);
+        this.point = new Point(geometryHelper, this.transforms, this.vector);
         this.polyline = new Polyline(this.context, geometryHelper);
         this.verb = new Verb(this.context, geometryHelper, this.math);
         this.time = new Time(this.context);

packages/dev/base/lib/api/services/point.ts

@@ -1,6 +1,7 @@
 import { GeometryHelper } from "./geometry-helper";
 import * as Inputs from "../inputs";
 import { Transforms } from "./transforms";
+import { Vector } from "./vector";
 
 /**
  * Contains various methods for points. Point in bitbybit is simply an array containing 3 numbers for [x, y, z].
@@ -10,7 +11,7 @@ import { Transforms } from "./transforms";
 
 export class Point {
 
-    constructor(private readonly geometryHelper: GeometryHelper, private readonly transforms: Transforms) { }
+    constructor(private readonly geometryHelper: GeometryHelper, private readonly transforms: Transforms, private readonly vector: Vector) { }
 
     /**
      * Transforms the single point
@@ -450,7 +451,7 @@ export class Point {
             nz = -nz;
         }
 
-        return [nx, ny, nz];
+        return this.vector.normalized({ vector: [nx, ny, nz] }) as Inputs.Base.Vector3;
     }
 
     private closestPointFromPointData(inputs: Inputs.Point.ClosestPointFromPointsDto): {

packages/dev/base/lib/api/services/text.test.ts

@@ -13,7 +13,7 @@ describe("Text unit tests", () => {
         const math = new MathBitByBit();
         const vector = new Vector(math, geometryHelper);
         const transforms = new Transforms(vector, math);
-        const points = new Point(geometryHelper, transforms);
+        const points = new Point(geometryHelper, transforms, vector);
         text = new TextBitByBit(points);
     });
 

packages/dev/occt-worker/lib/api/occt/dimensions.ts

@@ -20,4 +20,16 @@ export class OCCTDimensions {
     simpleLinearLengthDimension(inputs: Inputs.OCCT.SimpleLinearLengthDimensionDto): Promise<Inputs.OCCT.TopoDSCompoundPointer> {
         return this.occWorkerManager.genericCallToWorkerPromise("dimensions.simpleLinearLengthDimension", inputs);
     }
+
+    /**
+     * Creates simple angular dimension
+     * @param inputs two points, direction, label size, label normal direction, offset, and unit suffix, decimal rounding place
+     * @returns compound wires representing dimension
+     * @group simple
+     * @shortname angular dimension
+     * @drawable true
+     */
+    simpleAngularDimension(inputs: Inputs.OCCT.SimpleAngularDimensionDto): Promise<Inputs.OCCT.TopoDSCompoundPointer> {
+        return this.occWorkerManager.genericCallToWorkerPromise("dimensions.simpleAngularDimension", inputs);
+    }
 }

packages/dev/occt/lib/api/inputs/occ-inputs.ts

@@ -6029,6 +6029,93 @@ export namespace OCCT {
          * @step 0.1
          */
         labelOffset? = 0.3;
+    }
+    export class SimpleAngularDimensionDto {
+        constructor(direction1?: Base.Point3, direction2?: Base.Point3, center?: Base.Point3, radius?: number, offsetFromCenter?: number, crossingSize?: number, radians?: boolean, labelSuffix?: string, labelSize?: number, labelOffset?: number) {
+            if (direction1 !== undefined) { this.direction1 = direction1; }
+            if (direction2 !== undefined) { this.direction2 = direction2; }
+            if (center !== undefined) { this.center = center; }
+            if( radius !== undefined) { this.radius = radius; }
+            if (offsetFromCenter !== undefined) { this.offsetFromCenter = offsetFromCenter; }
+            if (crossingSize !== undefined) { this.extraSize = crossingSize; }
+            if (radians !== undefined) { this.radians = radians; }
+            if (labelSuffix !== undefined) { this.labelSuffix = labelSuffix; }
+            if (labelSize !== undefined) { this.labelSize = labelSize; }
+            if (labelOffset !== undefined) { this.labelOffset = labelOffset; }
+        }
 
+        /**
+         * The first direction for dimension
+         * @default [1, 0, 0]
+         */
+        direction1: Base.Point3 = [1, 0, 0];
+        /**
+         * The second direction for dimension
+         * @default [0, 0, 1]
+         */
+        direction2: Base.Point3 = [0, 0, 1];
+        /**
+         * The center point for dimension
+         * @default [0, 0, 0]
+         */
+        center: Base.Point3 = [0, 0, 0];
+        /**
+         * The dimension radius
+         * @default 4
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+         */
+        radius = 4;
+        /**
+         * Offset from center
+         * @default 0.5
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        offsetFromCenter = 0.5;
+        /**
+         * The dimension crossing size
+         * @default 0
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+         */
+        extraSize = 0;
+        /**
+         * The dimension label decimal places
+         * @default 2
+         * @minimum 0
+         * @maximum Infinity
+         * @step 1
+         */
+        decimalPlaces = 2;
+        /**
+         * The dimension label suffix
+         * @default (deg)
+         */
+        labelSuffix = "(deg)";
+        /**
+         * The dimension label size
+         * @default 0.1
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+         */
+        labelSize = 0.1;
+        /**
+         * The dimension label offset
+         * @default 0.3
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        labelOffset = 0.3;
+        /**
+         * If true the angle is in radians
+         * @default false
+         */
+        radians = false;
     }
 }

packages/dev/occt/lib/occ-helper.ts

@@ -63,7 +63,7 @@ export class OccHelper {
         this.math = new MathBitByBit();
         this.vector = new Vector(this.math, this.geometryHelper);
         this.transforms = new Transforms(this.vector, this.math);
-        this.point = new Point(this.geometryHelper, this.transforms);
+        this.point = new Point(this.geometryHelper, this.transforms, this.vector);
         this.textService = new TextBitByBit(this.point);
 
         this.occRefReturns = new OCCReferencedReturns(occ);
@@ -85,7 +85,7 @@ export class OccHelper {
             this.enumService, this.entitiesService, this.converterService, this.geomService, this.edgesService, this.textService, this.operationsService);
 
         this.dimensionsService = new DimensionsService(this.vector, this.point, this.transformsService,
-            this.converterService, this.wiresService);
+            this.converterService, this.entitiesService, this.edgesService, this.wiresService);
 
         this.verticesService.wiresService = this.wiresService;
 

packages/dev/occt/lib/services/base/dimensions.service.ts

@@ -1,11 +1,14 @@
 import {
     TopoDS_Compound,
+    TopoDS_Edge,
 } from "../../../bitbybit-dev-occt/bitbybit-dev-occt";
 import * as Inputs from "../../api/inputs/inputs";
 import { TransformsService } from "./transforms.service";
 import { ConverterService } from "./converter.service";
 import { WiresService } from "./wires.service";
 import { Point, Vector } from "@bitbybit-dev/base";
+import { EdgesService } from "./edges.service";
+import { EntitiesService } from "./entities.service";
 
 export class DimensionsService {
 
@@ -14,6 +17,8 @@ export class DimensionsService {
         private readonly point: Point,
         private readonly transformsService: TransformsService,
         private readonly converterService: ConverterService,
+        private readonly entitiesService: EntitiesService,
+        private readonly edgesService: EdgesService,
         private readonly wiresService: WiresService
     ) { }
 
@@ -115,4 +120,97 @@ export class DimensionsService {
         return res;
     }
 
+    simpleAngularDimension(inputs: Inputs.OCCT.SimpleAngularDimensionDto): TopoDS_Compound {
+        const normDir1 = this.vector.normalized({ vector: inputs.direction1 });
+        const endVec = this.vector.mul({ vector: normDir1, scalar: inputs.radius }) as Inputs.Base.Point3;
+        const endPt = this.point.translatePoints({
+            points: [endVec],
+            translation: inputs.center,
+        })[0];
+        const line1WithExt = this.wiresService.createLineWireWithExtensions({
+            start: inputs.center,
+            end: endPt,
+            extensionStart: -inputs.offsetFromCenter,
+            extensionEnd: inputs.extraSize,
+        });
+
+        const normDir2 = this.vector.normalized({ vector: inputs.direction2 });
+        const endVec2 = this.vector.mul({ vector: normDir2, scalar: inputs.radius }) as Inputs.Base.Point3;
+        const endPt2 = this.point.translatePoints({
+            points: [endVec2],
+            translation: inputs.center,
+        })[0];
+        const line2WithExt = this.wiresService.createLineWireWithExtensions({
+            start: inputs.center,
+            end: endPt2,
+            extensionStart: -inputs.offsetFromCenter,
+            extensionEnd: inputs.extraSize,
+        });
+
+        const normalThreePoints = this.point.normalFromThreePoints({
+            point1: inputs.center,
+            point2: endPt,
+            point3: endPt2,
+            reverseNormal: true,
+        });
+        
+        const normalThreePointsRev = this.point.normalFromThreePoints({
+            point1: inputs.center,
+            point2: endPt,
+            point3: endPt2,
+            reverseNormal: false,
+        });
+
+        const circ = this.entitiesService.createCircle(inputs.radius, inputs.center, normalThreePointsRev, Inputs.OCCT.typeSpecificityEnum.edge) as TopoDS_Edge;
+        const arc = this.edgesService.arcFromCircleAndTwoPoints({
+            circle: circ,
+            start: endPt,
+            end: endPt2,
+            sense: false,
+        });
+        const wireArc = this.wiresService.createWireFromEdge({ shape: arc });
+
+        const midPt = this.wiresService.midPointOnWire({ shape: wireArc });
+        const angleDeg = this.vector.angleBetween({
+            first: inputs.direction1,
+            second: inputs.direction2,
+        }) as number;
+
+        const txtOpt = new Inputs.OCCT.TextWiresDto();
+        txtOpt.text = angleDeg.toFixed(inputs.decimalPlaces) + " " + inputs.labelSuffix;
+        txtOpt.xOffset = 0;
+        txtOpt.yOffset = 0;
+        txtOpt.height = inputs.labelSize;
+        txtOpt.centerOnOrigin = true;
+        const txt = this.wiresService.textWiresWithData(txtOpt);
+       
+        const vectorToMid = this.vector.sub({
+            first: midPt,
+            second: inputs.center,
+        }) as Inputs.Base.Vector3;
+        const normVecToMid = this.vector.normalized({ vector: vectorToMid }) as Inputs.Base.Vector3;
+        
+        const alignedLabelTxtToDir = this.transformsService.alignNormAndAxis({
+            shape: txt.compound,
+            fromOrigin: [0, 0, 0],
+            fromNorm: [0, 1, 0],
+            fromAx: [0, 0, 1],
+            toOrigin: [0, 0, 0],
+            toNorm: normalThreePoints,
+            toAx: normVecToMid,
+        });
+        const offsetLabelVec = this.vector.mul({ vector: normVecToMid, scalar: inputs.labelOffset });
+        const addToDir = this.vector.add({
+            first: midPt,
+            second: offsetLabelVec,
+        }) as Inputs.Base.Vector3;
+        const labelTransformed = this.transformsService.translate({
+            shape: alignedLabelTxtToDir,
+            translation: addToDir
+        });
+
+        const res = this.converterService.makeCompound({ shapes: [line1WithExt, line2WithExt, wireArc, labelTransformed] });
+        return res;
+    }
+
 }

packages/dev/occt/lib/services/dimensions.ts

@@ -14,4 +14,8 @@ export class OCCTDimensions {
         return this.och.dimensionsService.simpleLinearLengthDimension(inputs);
     }
 
+    simpleAngularDimension(inputs: Inputs.OCCT.SimpleAngularDimensionDto): TopoDS_Compound {
+        return this.och.dimensionsService.simpleAngularDimension(inputs);
+    }
+    
 }

packages/dev/threejs/lib/api/bitbybit-base.ts

@@ -74,7 +74,7 @@ export class BitByBitBase {
         this.color = new Color(this.math);
         this.line = new Line(this.context, geometryHelper);
         this.transforms = new Transforms(this.vector, this.math);
-        this.point = new Point(geometryHelper,  this.transforms);
+        this.point = new Point(geometryHelper,  this.transforms, this.vector);
         this.polyline = new Polyline(this.context, geometryHelper);
         this.verb = new Verb(this.context, geometryHelper, this.math);
         this.time = new Time(this.context);