Merge pull request #57 from bitbybit-dev/develop

Develop

Author: matas-bitbybit-dev

README.md

@@ -24,15 +24,18 @@ Github Source Code - https://github.com/bitbybit-dev/app-examples/tree/main/reac
 # Closed Source Example Applications
 https://app-store.bitbybit.dev/terrace-furniture
 
-# Build package
-tsc -p tsconfig.bitbybit.json
+## Build package
+npm run build-p
 
-# Run Live Unit Tests
-npm run test
+## Run unit tests and generate test coverage
+npm run test-c
 
-# Run Live Unit Tests With Coverage
+## Run live unit tests and generate test coverage on save
 npm run test-c-l
 
+## Unit test coverage report online
+https://tests.bitbybit.dev/occt
+
 # Media Channels
 Discord: https://discord.gg/GSe3VMe  
 Youtube: https://www.youtube.com/@bitbybitdev?sub_confirmation=1  

lib/api/inputs/base-inputs.ts

@@ -10,6 +10,8 @@ export namespace Base {
     export type Vector3 = [number, number, number];
     export type Line2 = { start: Base.Point2, end: Base.Point2 };
     export type Line3 = { start: Base.Point3, end: Base.Point3 };
+    export type Polyline3 = { points: Base.Point3[], isClosed?: boolean };
+    export type Polyline2 = { points: Base.Point2[], isClosed?: boolean };
 
     // tslint:disable-next-line: no-namespace
     export enum skyboxEnum {

lib/api/inputs/occ-inputs.ts

@@ -136,10 +136,13 @@ export namespace OCCT {
         tri_indexes: number[];
         vertex_coord: number[];
         vertex_coord_vec: Base.Vector3[];
+        center_point: Base.Point3;
+        center_normal: Base.Vector3;
         uvs: number[];
     }
     export class DecomposedEdgeDto {
         edge_index: number;
+        middle_point: Base.Point3;
         vertex_coord: Base.Vector3[];
     }
     export class ShapesDto<T> {

lib/occ-service.ts

@@ -85,9 +85,14 @@ export class OCCTService {
                     tri_indexes: [],
                     vertex_coord_vec: [],
                     number_of_triangles: 0,
+                    center_point: undefined,
+                    center_normal: undefined,
                     face_index: faceIndex
                 };
 
+                thisFace.center_point = this.och.facesService.pointOnUV({ shape: myFace, paramU: 0.5, paramV: 0.5 });
+                thisFace.center_normal = this.och.facesService.normalOnUV({ shape: myFace, paramU: 0.5, paramV: 0.5 });
+
                 const pc = new this.occ.Poly_Connect_2(myT);
                 const triangulation = myT.get();
 
@@ -160,9 +165,11 @@ export class OCCTService {
         edges.forEach((myEdge, index) => {
             const thisEdge: Inputs.OCCT.DecomposedEdgeDto = {
                 vertex_coord: [],
+                middle_point: undefined,
                 edge_index: -1
             };
 
+            thisEdge.middle_point = this.och.edgesService.pointOnEdgeAtParam({ shape: myEdge, param: 0.5 });
             const aLocation = new this.occ.TopLoc_Location_1();
             const adaptorCurve = new this.occ.BRepAdaptor_Curve_2(myEdge);
             const tangDef = new this.occ.GCPnts_TangentialDeflection_2(adaptorCurve, inputs.precision, 0.1, 2, 1.0e-9, 1.0e-7);

lib/services/base/edges.service.ts

@@ -751,10 +751,14 @@ export class EdgesService {
         const curve = this.converterService.getGeomCurveFromEdge(edge, uMin, uMax);
         const gpPnt = this.entitiesService.gpPnt([0, 0, 0]);
         const param = this.vecHelper.remap(inputs.param, 0, 1, uMin, uMax);
-        curve.D0(param, gpPnt);
-        const pt: Base.Point3 = [gpPnt.X(), gpPnt.Y(), gpPnt.Z()];
-        gpPnt.delete();
-        return pt;
+        if (curve) {
+            curve.D0(param, gpPnt);
+            const pt: Base.Point3 = [gpPnt.X(), gpPnt.Y(), gpPnt.Z()];
+            gpPnt.delete();
+            return pt;
+        } else {
+            return undefined;
+        }
     }
 
     private reconstructCircleAndAlignBack(lin1Sols: gp_Circ2d[], sol: gp_Circ2d, alignOpt: Inputs.OCCT.AlignDto<TopoDS_Shape>, dir: Base.Vector3, pos: Base.Point3) {

lib/services/base/faces.service.ts

@@ -1007,15 +1007,19 @@ export class FacesService {
         const face = inputs.shape;
         const handle = this.occ.BRep_Tool.Surface_2(face);
         const surface = handle.get();
-        const { uMin, uMax, vMin, vMax } = this.getUVBounds(face);
-        const u = uMin + (uMax - uMin) * inputs.paramU;
-        const v = vMin + (vMax - vMin) * inputs.paramV;
-        const gpPnt = this.entitiesService.gpPnt([0, 0, 0]);
-        surface.D0(u, v, gpPnt);
-        const pt: Base.Point3 = [gpPnt.X(), gpPnt.Y(), gpPnt.Z()];
-        gpPnt.delete();
-        handle.delete();
-        return pt;
+        if (surface) {
+            const { uMin, uMax, vMin, vMax } = this.getUVBounds(face);
+            const u = uMin + (uMax - uMin) * inputs.paramU;
+            const v = vMin + (vMax - vMin) * inputs.paramV;
+            const gpPnt = this.entitiesService.gpPnt([0, 0, 0]);
+            surface.D0(u, v, gpPnt);
+            const pt: Base.Point3 = [gpPnt.X(), gpPnt.Y(), gpPnt.Z()];
+            gpPnt.delete();
+            handle.delete();
+            return pt;
+        } else {
+            return undefined;
+        }
     }
 
     normalOnUV(inputs: Inputs.OCCT.DataOnUVDto<TopoDS_Face>): Base.Vector3 {

lib/services/io.ts

@@ -67,6 +67,57 @@ export class OCCTIO {
         return result;
     }
 
+    saveShapeStl(inputs: Inputs.OCCT.SaveStlDto<TopoDS_Shape>): string {
+        const shapeToUse = inputs.shape;
+
+        // This could be made optional...
+        // Clean cached triangulation data for the shape.
+        // This allows to get lower res models out of higher res that was once computed and cached.
+        this.occ.BRepTools.Clean(shapeToUse, true);
+
+        let adjustedShape;
+        if (inputs.adjustYtoZ) {
+            const rotatedShape = this.och.transformsService.rotate({ shape: inputs.shape, axis: [1, 0, 0], angle: -90 });
+            adjustedShape = this.och.transformsService.mirrorAlongNormal(
+                { shape: rotatedShape, origin: [0, 0, 0], normal: [0, 0, 1] }
+            );
+            rotatedShape.delete();
+        }
+        const fileName = "x";
+        const writer = new this.occ.StlAPI_Writer();
+        let transferShape;
+        if (adjustedShape) {
+            transferShape = adjustedShape;
+        } else {
+            transferShape = shapeToUse;
+        }
+        const messageProgress = new this.occ.Message_ProgressRange_1();
+        let result: string;
+        const incrementalMeshBuilder = new this.occ.BRepMesh_IncrementalMesh_2(transferShape, inputs.precision, false, 0.5, false);
+
+        // Write the STL File to the virtual Emscripten Filesystem Temporarily
+        const writeResult = writer.Write(transferShape, fileName, messageProgress);
+        if (writeResult) {
+            // Read the STL File from the filesystem and clean up
+            const stlFile = this.occ.FS.readFile("/" + fileName, { encoding: "utf8" });
+            this.occ.FS.unlink("/" + fileName);
+            // Return the contents of the STL File
+            result = stlFile;
+        } else {
+            throw (new Error("Failed when writing stl file."));
+        }
+
+        if (adjustedShape) {
+            adjustedShape.delete();
+        }
+        messageProgress.delete();
+
+        if (incrementalMeshBuilder) {
+            incrementalMeshBuilder.Delete();
+        }
+        
+        return result;
+    }
 
     /** This function parses the ASCII contents of a `.STEP` or `.IGES`
      * File as a Shape into the `externalShapes` dictionary.

package-lock.json

@@ -1,6 +1,6 @@
 {
     "name": "@bitbybit-dev/occt",
-    "version": "0.17.3",
+    "version": "0.18.0",
     "description": "Bit By Bit Developers CAD algorithms using OpenCascade Technology kernel. Run in Node and in Browser.",
     "main": "index.js",
     "repository": {