@bitbybit-dev/occt/lib/services/shapes/face.js

Bit By Bit Developers CAD algorithms using OpenCascade Technology kernel. Run in Node and in Browser.

import * as Inputs from "../../api/inputs/inputs";
export class OCCTFace {
    constructor(occ, och) {
        this.occ = occ;
        this.och = och;
    }
    fromBaseTriangle(inputs) {
        const wire = this.och.wiresService.createPolygonWire({ points: inputs.triangle });
        return this.createFaceFromWire({ shape: wire, planar: true });
    }
    fromBaseMesh(inputs) {
        const faces = [];
        inputs.mesh.forEach((triangle) => {
            try {
                faces.push(this.fromBaseTriangle({ triangle }));
            }
            catch (e) {
                console.warn("Failed to make face for triangle", triangle);
            }
        });
        return faces.flat();
    }
    createFaceFromWire(inputs) {
        return this.och.facesService.createFaceFromWire(inputs);
    }
    createFaceFromWireOnFace(inputs) {
        return this.och.facesService.createFaceFromWireOnFace(inputs);
    }
    createFacesFromWiresOnFace(inputs) {
        return this.och.facesService.createFacesFromWiresOnFace(inputs);
    }
    createFaceFromWires(inputs) {
        return this.och.facesService.createFaceFromWires(inputs);
    }
    createFacesFromWires(inputs) {
        return this.och.facesService.createFacesFromWires(inputs);
    }
    createFaceFromWiresOnFace(inputs) {
        return this.och.facesService.createFaceFromWiresOnFace(inputs);
    }
    faceFromSurface(inputs) {
        return this.och.facesService.faceFromSurface(inputs);
    }
    faceFromSurfaceAndWire(inputs) {
        return this.och.facesService.faceFromSurfaceAndWire(inputs);
    }
    getUMinBound(inputs) {
        return this.och.facesService.getUMinBound(inputs);
    }
    getUMaxBound(inputs) {
        return this.och.facesService.getUMaxBound(inputs);
    }
    getVMinBound(inputs) {
        return this.och.facesService.getVMinBound(inputs);
    }
    getVMaxBound(inputs) {
        return this.och.facesService.getVMaxBound(inputs);
    }
    subdivideToPointsControlled(inputs) {
        return this.och.facesService.subdivideToPointsControlled(inputs);
    }
    subdivideToPoints(inputs) {
        return this.och.facesService.subdivideToPoints(inputs);
    }
    subdivideToWires(inputs) {
        return this.och.facesService.subdivideToWires(inputs);
    }
    subdivideToRectangleWires(inputs) {
        return this.och.facesService.subdivideToRectangleWires(inputs);
    }
    subdivideToRectangleHoles(inputs) {
        return this.och.facesService.subdivideToRectangleHoles(inputs);
    }
    subdivideToHexagonWires(inputs) {
        return this.och.facesService.subdivideToHexagonWires(inputs);
    }
    subdivideToHexagonHoles(inputs) {
        return this.och.facesService.subdivideToHexagonHoles(inputs);
    }
    subdivideToNormals(inputs) {
        return this.och.facesService.subdivideToNormals(inputs);
    }
    subdivideToPointsOnParam(inputs) {
        return this.och.facesService.subdivideToPointsOnParam(inputs);
    }
    wireAlongParam(inputs) {
        return this.och.facesService.wireAlongParam(inputs);
    }
    wiresAlongParams(inputs) {
        return this.och.facesService.wiresAlongParams(inputs);
    }
    subdivideToUVOnParam(inputs) {
        return this.och.facesService.subdivideToUVOnParam(inputs);
    }
    subdivideToUV(inputs) {
        return this.och.facesService.subdivideToUV(inputs);
    }
    uvOnFace(inputs) {
        return this.och.facesService.uvOnFace(inputs);
    }
    pointsOnUVs(inputs) {
        return this.och.facesService.pointsOnUVs(inputs);
    }
    normalsOnUVs(inputs) {
        return this.och.facesService.normalsOnUVs(inputs);
    }
    pointOnUV(inputs) {
        return this.och.facesService.pointOnUV(inputs);
    }
    normalOnUV(inputs) {
        return this.och.facesService.faceNormalOnUV(inputs);
    }
    createPolygonFace(inputs) {
        return this.och.facesService.createPolygonFace(inputs);
    }
    createCircleFace(inputs) {
        return this.och.entitiesService.createCircle(inputs.radius, inputs.center, inputs.direction, Inputs.OCCT.typeSpecificityEnum.face);
    }
    hexagonsInGrid(inputs) {
        const hexagonWires = this.och.wiresService.hexagonsInGrid(inputs);
        return this.och.facesService.createFacesFromWires({ shapes: hexagonWires, planar: true });
    }
    createEllipseFace(inputs) {
        return this.och.entitiesService.createEllipse(inputs.radiusMinor, inputs.radiusMajor, inputs.center, inputs.direction, Inputs.OCCT.typeSpecificityEnum.face);
    }
    createSquareFace(inputs) {
        return this.och.facesService.createSquareFace(inputs);
    }
    createRectangleFace(inputs) {
        return this.och.facesService.createRectangleFace(inputs);
    }
    createFaceFromMultipleCircleTanWireCollections(inputs) {
        return this.och.facesService.createFaceFromMultipleCircleTanWireCollections(inputs);
    }
    createFaceFromMultipleCircleTanWires(inputs) {
        return this.och.facesService.createFaceFromMultipleCircleTanWires(inputs);
    }
    getFace(inputs) {
        return this.och.shapeGettersService.getFace(inputs);
    }
    getFaces(inputs) {
        return this.och.shapeGettersService.getFaces(inputs);
    }
    reversedFace(inputs) {
        const face = inputs.shape;
        const reversed = face.Reversed();
        const result = this.och.converterService.getActualTypeOfShape(reversed);
        reversed.delete();
        return result;
    }
    getFaceArea(inputs) {
        return this.och.facesService.getFaceArea(inputs);
    }
    getFacesAreas(inputs) {
        return this.och.facesService.getFacesAreas(inputs);
    }
    getFaceCenterOfMass(inputs) {
        return this.och.facesService.getFaceCenterOfMass(inputs);
    }
    getFacesCentersOfMass(inputs) {
        return this.och.facesService.getFacesCentersOfMass(inputs);
    }
    filterFacePoints(inputs) {
        return this.och.facesService.filterFacePoints(inputs);
    }
    filterFacesPoints(inputs) {
        let res = inputs.shapes.map(s => this.och.facesService.filterFacePoints(Object.assign(Object.assign({}, inputs), { shape: s })));
        if (inputs.flatPointsArray) {
            res = res.flat();
        }
        return res;
    }
}