@bitbybit-dev/occt
Version:
Bit By Bit Developers CAD algorithms using OpenCascade Technology kernel. Run in Node and in Browser.
1,751 lines • 139 kB
TypeScript
import { Base } from "./inputs";
export declare namespace OCCT {
type GeomCurvePointer = {
hash: number;
type: string;
};
type Geom2dCurvePointer = {
hash: number;
type: string;
};
type GeomSurfacePointer = {
hash: number;
type: string;
};
type TopoDSVertexPointer = {
hash: number;
type: string;
};
type TopoDSEdgePointer = {
hash: number;
type: string;
};
type TopoDSWirePointer = {
hash: number;
type: string;
};
type TopoDSFacePointer = {
hash: number;
type: string;
};
type TopoDSShellPointer = {
hash: number;
type: string;
};
type TopoDSSolidPointer = {
hash: number;
type: string;
};
type TopoDSCompSolidPointer = {
hash: number;
type: string;
};
type TopoDSCompoundPointer = {
hash: number;
type: string;
};
type TopoDSShapePointer = TopoDSVertexPointer | TopoDSEdgePointer | TopoDSWirePointer | TopoDSFacePointer | TopoDSShellPointer | TopoDSSolidPointer | TopoDSCompoundPointer;
enum joinTypeEnum {
arc = "arc",
intersection = "intersection",
tangent = "tangent"
}
enum bRepOffsetModeEnum {
skin = "skin",
pipe = "pipe",
rectoVerso = "rectoVerso"
}
enum approxParametrizationTypeEnum {
approxChordLength = "approxChordLength",
approxCentripetal = "approxCentripetal",
approxIsoParametric = "approxIsoParametric"
}
enum directionEnum {
outside = "outside",
inside = "inside",
middle = "middle"
}
enum fileTypeEnum {
iges = "iges",
step = "step"
}
enum topAbsOrientationEnum {
forward = "forward",
reversed = "reversed",
internal = "internal",
external = "external"
}
enum topAbsStateEnum {
in = "in",
out = "out",
on = "on",
unknown = "unknown"
}
enum shapeTypeEnum {
unknown = "unknown",
vertex = "vertex",
edge = "edge",
wire = "wire",
face = "face",
shell = "shell",
solid = "solid",
compSolid = "compSolid",
compound = "compound",
shape = "shape"
}
enum gccEntPositionEnum {
unqualified = "unqualified",
enclosing = "enclosing",
enclosed = "enclosed",
outside = "outside",
noqualifier = "noqualifier"
}
enum positionResultEnum {
keepSide1 = "keepSide1",
keepSide2 = "keepSide2",
all = "all"
}
enum circleInclusionEnum {
none = "none",
keepSide1 = "keepSide1",
keepSide2 = "keepSide2"
}
enum twoCircleInclusionEnum {
none = "none",
outside = "outside",
inside = "inside",
outsideInside = "outsideInside",
insideOutside = "insideOutside"
}
enum fourSidesStrictEnum {
outside = "outside",
inside = "inside",
outsideInside = "outsideInside",
insideOutside = "insideOutside"
}
enum twoSidesStrictEnum {
outside = "outside",
inside = "inside"
}
enum combinationCirclesForFaceEnum {
allWithAll = "allWithAll",
inOrder = "inOrder",
inOrderClosed = "inOrderClosed"
}
enum typeSpecificityEnum {
curve = 0,
edge = 1,
wire = 2,
face = 3
}
enum pointProjectionTypeEnum {
all = "all",
closest = "closest",
furthest = "furthest",
closestAndFurthest = "closestAndFurthest"
}
enum geomFillTrihedronEnum {
isCorrectedFrenet = "isCorrectedFrenet",
isFixed = "isFixed",
isFrenet = "isFrenet",
isConstantNormal = "isConstantNormal",
isDarboux = "isDarboux",
isGuideAC = "isGuideAC",
isGuidePlan = "isGuidePlan",
isGuideACWithContact = "isGuideACWithContact",
isGuidePlanWithContact = "isGuidePlanWithContact",
isDiscreteTrihedron = "isDiscreteTrihedron"
}
class DecomposedMeshDto {
constructor(faceList?: DecomposedFaceDto[], edgeList?: DecomposedEdgeDto[]);
/**
* Face list for decomposed faces
*/
faceList: DecomposedFaceDto[];
/**
* Edge list for decomposed edges
*/
edgeList: DecomposedEdgeDto[];
/**
* The points list in a shape that includes vertex shapes
*/
pointsList: Base.Point3[];
}
class DecomposedFaceDto {
face_index: number;
normal_coord: number[];
number_of_triangles: number;
tri_indexes: number[];
vertex_coord: number[];
vertex_coord_vec: Base.Vector3[];
center_point: Base.Point3;
center_normal: Base.Vector3;
uvs: number[];
}
class DecomposedEdgeDto {
edge_index: number;
middle_point: Base.Point3;
vertex_coord: Base.Vector3[];
}
class ShapesDto<T> {
constructor(shapes?: T[]);
/**
* The OCCT shapes
* @default undefined
*/
shapes: T[];
}
class PointDto {
constructor(point?: Base.Point3);
/**
* The point
* @default [0, 0, 0]
*/
point: Base.Point3;
}
class XYZDto {
constructor(x?: number, y?: number, z?: number);
/**
* X coord
* @default 0
* @minimum -Infinity
* @maximum Infinity
* @step 0.1
*/
x: number;
/**
* Y coord
* @default 0
* @minimum -Infinity
* @maximum Infinity
* @step 0.1
*/
y: number;
/**
* Z coord
* @default 0
* @minimum -Infinity
* @maximum Infinity
* @step 0.1
*/
z: number;
}
class PointsDto {
constructor(points?: Base.Point3[]);
/**
* The point
* @default undefined
*/
points: Base.Point3[];
}
class ConstraintTanLinesFromPtToCircleDto<T> {
constructor(circle?: T, point?: Base.Point3, tolerance?: number, positionResult?: positionResultEnum, circleRemainder?: circleInclusionEnum);
/**
* The circle for tangent points
* @default undefined
*/
circle: T;
/**
* The point from which to find the lines
* @default undefined
*/
point: Base.Point3;
/**
* tolerance
* @default 1e-7
* @minimum 0
* @maximum Infinity
* @step 0.00001
*/
tolerance: number;
/**
* Filters resulting lines by position
* @default all
*/
positionResult: positionResultEnum;
/**
* Splits provided circle on tangent points and adds it to the solutions
* This only works when number of solutions contains 2 lines, when solution involves more than 4 lines, this option will be ignored.
* @default none
*/
circleRemainder: circleInclusionEnum;
}
class ConstraintTanLinesFromTwoPtsToCircleDto<T> {
constructor(circle?: T, point1?: Base.Point3, point2?: Base.Point3, tolerance?: number, positionResult?: positionResultEnum, circleRemainder?: circleInclusionEnum);
/**
* The circle for tangent points
* @default undefined
*/
circle: T;
/**
* The point from which to find the lines
* @default undefined
*/
point1: Base.Point3;
/**
* The point from which to find the lines
* @default undefined
*/
point2: Base.Point3;
/**
* tolerance
* @default 1e-7
* @minimum 0
* @maximum Infinity
* @step 0.00001
*/
tolerance: number;
/**
* Filters resulting lines by position
* @default all
*/
positionResult: positionResultEnum;
/**
* Splits provided circle on tangent points and adds it to the solutions
* This only works when number of solutions contains 2 lines, when solution involves more than 4 lines, this option will be ignored.
* @default none
*/
circleRemainder: circleInclusionEnum;
}
class ConstraintTanLinesOnTwoCirclesDto<T> {
constructor(circle1?: T, circle2?: T, tolerance?: number, positionResult?: positionResultEnum, circleRemainders?: twoCircleInclusionEnum);
/**
* The first circle for tangential lines
* @default undefined
*/
circle1: T;
/**
* The second circle for tangential lines
* @default undefined
*/
circle2: T;
/**
* tolerance
* @default 1e-7
* @minimum 0
* @maximum Infinity
* @step 0.00001
*/
tolerance: number;
/**
* Filters resulting lines by position relative to circles
* @default all
*/
positionResult: positionResultEnum;
/**
* Splits provided circles on tangent points and returns those as part of the solutions
* This only works when number of solutions is limited to 2 lines, when solution involves more than 4 lines, this option will be ignored.
* @default none
*/
circleRemainders: twoCircleInclusionEnum;
}
class ConstraintTanCirclesOnTwoCirclesDto<T> {
constructor(circle1?: T, circle2?: T, tolerance?: number, radius?: number);
/**
* The first circle for tangential lines
* @default undefined
*/
circle1: T;
/**
* The second circle for tangential lines
* @default undefined
*/
circle2: T;
/**
* tolerance
* @default 1e-7
* @minimum 0
* @maximum Infinity
* @step 0.00001
*/
tolerance: number;
/**
* Radius of the circles being constructed
* @default 0.3
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
radius: number;
}
class ConstraintTanCirclesOnCircleAndPntDto<T> {
constructor(circle?: T, point?: Base.Point3, tolerance?: number, radius?: number);
/**
* The first circle for tangential lines
* @default undefined
*/
circle: T;
/**
* The second circle for tangential lines
* @default undefined
*/
point: Base.Point3;
/**
* tolerance
* @default 1e-7
* @minimum 0
* @maximum Infinity
* @step 0.00001
*/
tolerance: number;
/**
* Radius of the circles being constructed
* @default 0.3
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
radius: number;
}
class CurveAndSurfaceDto<T, U> {
constructor(curve?: T, surface?: U);
/**
* Curve
* @default undefined
*/
curve: T;
/**
* Surface
* @default undefined
*/
surface: U;
}
class FilletTwoEdgesInPlaneDto<T> {
constructor(edge1?: T, edge2?: T, planeOrigin?: Base.Point3, planeDirection?: Base.Vector3, radius?: number, solution?: number);
/**
* First OCCT edge to fillet
* @default undefined
*/
edge1: T;
/**
* Second OCCT edge to fillet
* @default undefined
*/
edge2: T;
/**
* Plane origin that is also used to find the closest solution if two solutions exist.
* @default [0, 0, 0]
*/
planeOrigin: Base.Point3;
/**
* Plane direction for fillet
* @default [0, 1, 0]
*/
planeDirection: Base.Vector3;
/**
* Radius of the fillet
* @default 0.3
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
radius: number;
/**
* if solution is -1 planeOrigin chooses a particular fillet in case of several fillets may be constructed (for example, a circle intersecting a segment in 2 points). Put the intersecting (or common) point of the edges
* @default -1
* @optional true
*/
solution?: number;
}
class ClosestPointsOnShapeFromPointsDto<T> {
constructor(shape?: T, points?: Base.Point3[]);
/**
* The OCCT shape
* @default undefined
*/
shape: T;
/**
* The list of points
* @default undefined
*/
points: Base.Point3[];
}
class BoundingBoxDto {
constructor(bbox?: BoundingBoxPropsDto);
/**
* Bounding box
* @default undefined
*/
bbox?: BoundingBoxPropsDto;
}
class BoundingBoxPropsDto {
constructor(min?: Base.Point3, max?: Base.Point3, center?: Base.Point3, size?: Base.Vector3);
/**
* Minimum point of the bounding box
* @default [0, 0, 0]
*/
min: Base.Point3;
/**
* Maximum point of the bounding box
* @default [0, 0, 0]
*/
max: Base.Point3;
/**
* Center point of the bounding box
* @default [0, 0, 0]
*/
center: Base.Point3;
/**
* Size of the bounding box
* @default [0, 0, 0]
*/
size: Base.Vector3;
}
class BoundingSpherePropsDto {
constructor(center?: Base.Point3, radius?: number);
/**
* Center point of the bounding box
* @default [0, 0, 0]
*/
center: Base.Point3;
/**
* Radius of the bounding sphere
* @default 0
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
radius: number;
}
class SplitWireOnPointsDto<T> {
constructor(shape?: T, points?: Base.Point3[]);
/**
* The OCCT wire shape
* @default undefined
*/
shape: T;
/**
* The list of points
* @default undefined
*/
points: Base.Point3[];
}
class ClosestPointsOnShapesFromPointsDto<T> {
constructor(shapes?: T[], points?: Base.Point3[]);
/**
* The OCCT shapes
* @default undefined
*/
shapes: T[];
/**
* The list of points
* @default undefined
*/
points: Base.Point3[];
}
class ClosestPointsBetweenTwoShapesDto<T> {
constructor(shape1?: T, shape2?: T);
/**
* First OCCT shape
* @default undefined
*/
shape1: T;
/**
* Second OCCT shape
* @default undefined
*/
shape2: T;
}
class FaceFromSurfaceAndWireDto<T, U> {
constructor(surface?: T, wire?: U, inside?: boolean);
/**
* Surface from which to create a face
* @default undefined
*/
surface: T;
/**
* Wire that represents a boundary on the surface to delimit the face
* @default undefined
*/
wire: U;
/**
* Indicates wether face should be created inside or outside the wire
* @default true
*/
inside: boolean;
}
class WireOnFaceDto<T, U> {
constructor(wire?: T, face?: U);
/**
* Wire to place on face
* @default undefined
*/
wire: T;
/**
* Face on which the wire will be placed
* @default undefined
*/
face: U;
}
class DrawShapeDto<T> {
/**
* Provide options without default values
*/
constructor(shape?: T, faceOpacity?: number, edgeOpacity?: number, edgeColour?: Base.Color, faceMaterial?: Base.Material, faceColour?: Base.Color, edgeWidth?: number, drawEdges?: boolean, drawFaces?: boolean, drawVertices?: boolean, vertexColour?: Base.Color, vertexSize?: number, precision?: number, drawEdgeIndexes?: boolean, edgeIndexHeight?: number, edgeIndexColour?: Base.Color, drawFaceIndexes?: boolean, faceIndexHeight?: number, faceIndexColour?: Base.Color);
/**
* Brep OpenCascade geometry
* @default undefined
*/
shape?: T;
/**
* Face opacity value between 0 and 1
* @default 1
* @minimum 0
* @maximum 1
* @step 0.1
*/
faceOpacity: number;
/**
* Edge opacity value between 0 and 1
* @default 1
* @minimum 0
* @maximum 1
* @step 0.1
*/
edgeOpacity: number;
/**
* Hex colour string for the edges
* @default #ffffff
*/
edgeColour: Base.Color;
/**
* Face material
* @default undefined
* @optional true
*/
faceMaterial?: Base.Material;
/**
* Hex colour string for face colour
* @default #ff0000
*/
faceColour: Base.Color;
/**
* Edge width
* @default 2
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
edgeWidth: number;
/**
* You can turn off drawing of edges via this property
* @default true
*/
drawEdges: boolean;
/**
* You can turn off drawing of faces via this property
* @default true
*/
drawFaces: boolean;
/**
* You can turn off drawing of vertexes via this property
* @default false
*/
drawVertices: boolean;
/**
* Color of the vertices that will be drawn
* @default #ff00ff
*/
vertexColour: string;
/**
* The size of a vertices that will be drawn
* @default 0.03
* @minimum 0
* @maximum Infinity
* @step 0.01
*/
vertexSize: number;
/**
* Precision of the mesh that will be generated for the shape, lower number will mean more triangles
* @default 0.01
* @minimum 0
* @maximum Infinity
* @step 0.01
*/
precision: number;
/**
* Draw index of edges in space
* @default false
*/
drawEdgeIndexes: boolean;
/**
* Indicates the edge index height if they are drawn
* @default 0.06
* @minimum 0
* @maximum Infinity
* @step 0.01
*/
edgeIndexHeight: number;
/**
* Edge index colour if the edges are drawn
* @default #ff00ff
*/
edgeIndexColour: Base.Color;
/**
* Draw indexes of faces in space
* @default false
*/
drawFaceIndexes: boolean;
/**
* Indicates the edge index height if they are drawn
* @default 0.06
* @minimum 0
* @maximum Infinity
* @step 0.01
*/
faceIndexHeight: number;
/**
* Edge index colour if the edges are drawn
* @default #0000ff
*/
faceIndexColour: Base.Color;
}
class DrawShapesDto<T> {
/**
* Provide options without default values
*/
constructor(shapes?: T[], faceOpacity?: number, edgeOpacity?: number, edgeColour?: Base.Color, faceMaterial?: Base.Material, faceColour?: Base.Color, edgeWidth?: number, drawEdges?: boolean, drawFaces?: boolean, drawVertices?: boolean, vertexColour?: Base.Color, vertexSize?: number, precision?: number, drawEdgeIndexes?: boolean, edgeIndexHeight?: number, edgeIndexColour?: Base.Color, drawFaceIndexes?: boolean, faceIndexHeight?: number, faceIndexColour?: Base.Color);
/**
* Brep OpenCascade geometry
* @default undefined
*/
shapes: T[];
/**
* Face opacity value between 0 and 1
* @default 1
* @minimum 0
* @maximum 1
* @step 0.1
*/
faceOpacity: number;
/**
* Edge opacity value between 0 and 1
* @default 1
* @minimum 0
* @maximum 1
* @step 0.1
*/
edgeOpacity: number;
/**
* Hex colour string for the edges
* @default #ffffff
*/
edgeColour: Base.Color;
/**
* Face material
* @default undefined
* @optional true
*/
faceMaterial?: Base.Material;
/**
* Hex colour string for face colour
* @default #ff0000
*/
faceColour: Base.Color;
/**
* Edge width
* @default 2
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
edgeWidth: number;
/**
* You can turn off drawing of edges via this property
* @default true
*/
drawEdges: boolean;
/**
* You can turn off drawing of faces via this property
* @default true
*/
drawFaces: boolean;
/**
* You can turn off drawing of vertexes via this property
* @default false
*/
drawVertices: boolean;
/**
* Color of the vertices that will be drawn
* @default #ff00ff
*/
vertexColour: string;
/**
* The size of a vertices that will be drawn
* @default 0.03
* @minimum 0
* @maximum Infinity
* @step 0.01
*/
vertexSize: number;
/**
* Precision of the mesh that will be generated for the shape, lower number will mean more triangles
* @default 0.01
* @minimum 0
* @maximum Infinity
* @step 0.01
*/
precision: number;
/**
* Draw index of edges in space
* @default false
*/
drawEdgeIndexes: boolean;
/**
* Indicates the edge index height if they are drawn
* @default 0.06
* @minimum 0
* @maximum Infinity
* @step 0.01
*/
edgeIndexHeight: number;
/**
* Edge index colour if the edges are drawn
* @default #ff00ff
*/
edgeIndexColour: Base.Color;
/**
* Draw indexes of faces in space
* @default false
*/
drawFaceIndexes: boolean;
/**
* Indicates the edge index height if they are drawn
* @default 0.06
* @minimum 0
* @maximum Infinity
* @step 0.01
*/
faceIndexHeight: number;
/**
* Edge index colour if the edges are drawn
* @default #0000ff
*/
faceIndexColour: Base.Color;
}
class FaceSubdivisionDto<T> {
/**
* Provide options without default values
*/
constructor(shape?: T, nrDivisionsU?: number, nrDivisionsV?: number, shiftHalfStepU?: boolean, removeStartEdgeU?: boolean, removeEndEdgeU?: boolean, shiftHalfStepV?: boolean, removeStartEdgeV?: boolean, removeEndEdgeV?: boolean);
/**
* Brep OpenCascade geometry
* @default undefined
*/
shape: T;
/**
* Number of points that will be added on U direction
* @default 10
* @minimum 1
* @maximum Infinity
* @step 1
*/
nrDivisionsU: number;
/**
* Number of points that will be added on V direction
* @default 10
* @minimum 1
* @maximum Infinity
* @step 1
*/
nrDivisionsV: number;
/**
* Sometimes you want to shift your points half way the step distance, especially on periodic surfaces
* @default false
*/
shiftHalfStepU: boolean;
/**
* Removes start edge points on U
* @default false
*/
removeStartEdgeU: boolean;
/**
* Removes end edge points on U
* @default false
*/
removeEndEdgeU: boolean;
/**
* Sometimes you want to shift your points half way the step distance, especially on periodic surfaces
* @default false
*/
shiftHalfStepV: boolean;
/**
* Removes start edge points on V
* @default false
*/
removeStartEdgeV: boolean;
/**
* Removes end edge points on V
* @default false
*/
removeEndEdgeV: boolean;
}
class FaceSubdivisionToWiresDto<T> {
/**
* Provide options without default values
*/
constructor(shape?: T, nrDivisions?: number, isU?: boolean, shiftHalfStep?: boolean, removeStart?: boolean, removeEnd?: boolean);
/**
* Openascade Face
* @default undefined
*/
shape: T;
/**
* Number of points that will be added on U direction
* @default 10
* @minimum 1
* @maximum Infinity
* @step 1
*/
nrDivisions: number;
/**
* Linear subdivision direction true - U, false - V
* @default true
*/
isU: boolean;
/**
* Sometimes you want to shift your wires half way the step distance, especially on periodic surfaces
* @default false
*/
shiftHalfStep: boolean;
/**
* Removes start wire
* @default false
*/
removeStart: boolean;
/**
* Removes end wire
* @default false
*/
removeEnd: boolean;
}
class FaceSubdivideToRectangleWiresDto<T> {
/**
* Provide options without default values
*/
constructor(shape?: T, nrRectanglesU?: number, nrRectanglesV?: number, scalePatternU?: number[], scalePatternV?: number[], filletPattern?: number[], inclusionPattern?: boolean[], offsetFromBorderU?: number, offsetFromBorderV?: number);
/**
* Openascade Face
* @default undefined
*/
shape: T;
/**
* Number of rectangles on U direction
* @default 10
* @minimum 1
* @maximum Infinity
* @step 1
*/
nrRectanglesU: number;
/**
* Number of rectangles on V direction
* @default 10
* @minimum 1
* @maximum Infinity
* @step 1
*/
nrRectanglesV: number;
/**
* Rectangle scale pattern on u direction - numbers between 0 and 1, if 1 or undefined is used, no scaling is applied
* @default undefined
* @optional true
*/
scalePatternU: number[];
/**
* Rectangle scale pattern on v direction - numbers between 0 and 1, if 1 or undefined is used, no scaling is applied
* @default undefined
* @optional true
*/
scalePatternV: number[];
/**
* Rectangle fillet scale pattern - numbers between 0 and 1, if 0 is used, no fillet is applied,
* if 1 is used, the fillet will be exactly half of the length of the shorter side of the rectangle
* @default undefined
* @optional true
*/
filletPattern: number[];
/**
* Rectangle inclusion pattern - true means that the rectangle will be included,
* false means that the rectangle will be removed from the face
* @default undefined
* @optional true
*/
inclusionPattern: boolean[];
/**
* If offset on U is bigger then 0 we will use a smaller space for rectangles to be placed. This means that even rectangle of U param 1 will be offset from the face border
* That is often required to create a pattern that is not too close to the face border
* It should not be bigger then half of the total width of the face as that will create problems
* @default 0
* @minimum 0
* @maximum 0.5
* @step 0.01
*/
offsetFromBorderU: number;
/**
* If offset on V is bigger then 0 we will use a smaller space for rectangles to be placed. This means that even rectangle of V param 1 will be offset from the face border
* That is often required to create a pattern that is not too close to the face border
* It should not be bigger then half of the total width of the face as that will create problems
* @default 0
* @minimum 0
* @maximum 0.5
* @step 0.01
*/
offsetFromBorderV: number;
}
class FaceSubdivideToRectangleHolesDto<T> {
/**
* Provide options without default values
*/
constructor(shape?: T, nrRectanglesU?: number, nrRectanglesV?: number, scalePatternU?: number[], scalePatternV?: number[], filletPattern?: number[], inclusionPattern?: boolean[], holesToFaces?: boolean, offsetFromBorderU?: number, offsetFromBorderV?: number);
/**
* Openascade Face
* @default undefined
*/
shape: T;
/**
* Number of rectangles on U direction
* @default 10
* @minimum 1
* @maximum Infinity
* @step 1
*/
nrRectanglesU: number;
/**
* Number of rectangles on V direction
* @default 10
* @minimum 1
* @maximum Infinity
* @step 1
*/
nrRectanglesV: number;
/**
* Rectangle scale pattern on u direction - numbers between 0 and 1, if 1 or undefined is used, no scaling is applied
* @default undefined
* @optional true
*/
scalePatternU: number[];
/**
* Rectangle scale pattern on v direction - numbers between 0 and 1, if 1 or undefined is used, no scaling is applied
* @default undefined
* @optional true
*/
scalePatternV: number[];
/**
* Rectangle fillet scale pattern - numbers between 0 and 1, if 0 is used, no fillet is applied,
* if 1 is used, the fillet will be exactly half of the length of the shorter side of the rectangle
* @default undefined
* @optional true
*/
filletPattern: number[];
/**
* Rectangle inclusion pattern - true means that the rectangle will be included,
* false means that the rectangle will be removed from the face
* @default undefined
* @optional true
*/
inclusionPattern: boolean[];
/**
* If true, we will also output the faces for all the rectangles. The first face in the result will be the original face with holes punched, while the rest will be the rectangles
* @default false
*/
holesToFaces: boolean;
/**
* If offset on U is bigger then 0 we will use a smaller space for rectangles to be placed. This means that even rectangle of U param 1 will be offset from the face border
* That is often required to create a pattern that is not too close to the face border
* It should not be bigger then half of the total width of the face as that will create problems
* @default 0
* @minimum 0
* @maximum 0.5
* @step 0.01
*/
offsetFromBorderU: number;
/**
* If offset on V is bigger then 0 we will use a smaller space for rectangles to be placed. This means that even rectangle of V param 1 will be offset from the face border
* That is often required to create a pattern that is not too close to the face border
* It should not be bigger then half of the total width of the face as that will create problems
* @default 0
* @minimum 0
* @maximum 0.5
* @step 0.01
*/
offsetFromBorderV: number;
}
class FaceSubdivisionControlledDto<T> {
/**
* Provide options without default values
*/
constructor(shape?: T, nrDivisionsU?: number, nrDivisionsV?: number, shiftHalfStepNthU?: number, shiftHalfStepUOffsetN?: number, removeStartEdgeNthU?: number, removeStartEdgeUOffsetN?: number, removeEndEdgeNthU?: number, removeEndEdgeUOffsetN?: number, shiftHalfStepNthV?: number, shiftHalfStepVOffsetN?: number, removeStartEdgeNthV?: number, removeStartEdgeVOffsetN?: number, removeEndEdgeNthV?: number, removeEndEdgeVOffsetN?: number);
/**
* Brep OpenCascade geometry
* @default undefined
*/
shape: T;
/**
* Number of subdivisions on U direction
* @default 10
* @minimum 1
* @maximum Infinity
* @step 1
*/
nrDivisionsU: number;
/**
* Number of subdivisions on V direction
* @default 10
* @minimum 1
* @maximum Infinity
* @step 1
*/
nrDivisionsV: number;
/**
* Shift half step every nth U row
* @default 0
* @minimum 0
* @maximum Infinity
* @step 1
*/
shiftHalfStepNthU: number;
/**
* Offset for shift half step every nth U row
* @default 0
* @minimum 0
* @maximum Infinity
* @step 1
*/
shiftHalfStepUOffsetN: number;
/**
* Removes start edge points on U
* @default 0
* @minimum 0
* @maximum Infinity
* @step 1
*/
removeStartEdgeNthU: number;
/**
* Offset for remove start edge points on U
* @default 0
* @minimum 0
* @maximum Infinity
* @step 1
*/
removeStartEdgeUOffsetN: number;
/**
* Removes end edge points on U
* @default 0
* @minimum 0
* @maximum Infinity
* @step 1
*/
removeEndEdgeNthU: number;
/**
* Offset for remove end edge points on U
* @default 0
* @minimum 0
* @maximum Infinity
* @step 1
*/
removeEndEdgeUOffsetN: number;
/**
* Shift half step every nth V row
* @default 0
* @minimum 0
* @maximum Infinity
* @step 1
*/
shiftHalfStepNthV: number;
/**
* Offset for shift half step every nth V row
* @default 0
* @minimum 0
* @maximum Infinity
* @step 1
*/
shiftHalfStepVOffsetN: number;
/**
* Removes start edge points on V
* @default 0
* @minimum 0
* @maximum Infinity
* @step 1
*/
removeStartEdgeNthV: number;
/**
* Offset for remove start edge points on V
* @default 0
* @minimum 0
* @maximum Infinity
* @step 1
*/
removeStartEdgeVOffsetN: number;
/**
* Removes end edge points on V
* @default 0
* @minimum 0
* @maximum Infinity
* @step 1
*/
removeEndEdgeNthV: number;
/**
* Offset for remove end edge points on V
* @default 0
* @minimum 0
* @maximum Infinity
* @step 1
*/
removeEndEdgeVOffsetN: number;
}
class FaceLinearSubdivisionDto<T> {
/**
* Provide options without default values
*/
constructor(shape?: T, isU?: boolean, param?: number, nrPoints?: number, shiftHalfStep?: boolean, removeStartPoint?: boolean, removeEndPoint?: boolean);
/**
* Brep OpenCascade geometry
* @default undefined
*/
shape: T;
/**
* Linear subdivision direction true - U, false - V
* @default true
*/
isU: boolean;
/**
* Param on direction 0 - 1
* @default 0.5
* @minimum 0
* @maximum 1
* @step 0.1
*/
param: number;
/**
* Number of subdivisions on opposite direction
* @default 10
* @minimum 1
* @maximum Infinity
* @step 1
*/
nrPoints: number;
/**
* Sometimes you want to shift your points half way the step distance, especially on periodic surfaces
* @default false
*/
shiftHalfStep: boolean;
/**
* Removes first point
* @default false
*/
removeStartPoint: boolean;
/**
* Removes last point
* @default false
*/
removeEndPoint: boolean;
}
class WireAlongParamDto<T> {
/**
* Provide options without default values
*/
constructor(shape?: T, isU?: boolean, param?: number);
/**
* Brep OpenCascade geometry
* @default undefined
*/
shape: T;
/**
* Linear subdivision direction true - U, false - V
* @default true
*/
isU: boolean;
/**
* Param on direction 0 - 1
* @default 0.5
* @minimum 0
* @maximum 1
* @step 0.1
*/
param: number;
}
class WiresAlongParamsDto<T> {
/**
* Provide options without default values
*/
constructor(shape?: T, isU?: boolean, params?: number[]);
/**
* Brep OpenCascade geometry
* @default undefined
*/
shape: T;
/**
* Linear subdivision direction true - U, false - V
* @default true
*/
isU: boolean;
/**
* Params on direction 0 - 1
* @default undefined
*/
params: number[];
}
class DataOnUVDto<T> {
/**
* Provide options without default values
*/
constructor(shape?: T, paramU?: number, paramV?: number);
/**
* Brep OpenCascade geometry
* @default undefined
*/
shape: T;
/**
* Param on U direction 0 to 1
* @default 0.5
* @minimum 0
* @maximum 1
* @step 0.1
*/
paramU: number;
/**
* Param on V direction 0 to 1
* @default 0.5
* @minimum 0
* @maximum 1
* @step 0.1
*/
paramV: number;
}
class DataOnUVsDto<T> {
/**
* Provide options without default values
*/
constructor(shape?: T, paramsUV?: [number, number][]);
/**
* Brep OpenCascade geometry
* @default undefined
*/
shape: T;
/**
* Params uv
* @default [[0.5, 0.5]]
*/
paramsUV: [number, number][];
}
class PolygonDto {
constructor(points?: Base.Point3[]);
/**
* Points points
* @default undefined
*/
points: Base.Point3[];
}
class PolygonsDto {
constructor(polygons?: PolygonDto[], returnCompound?: boolean);
/**
* Polygons
* @default undefined
*/
polygons: PolygonDto[];
/**
* Indicates whether the shapes should be returned as a compound
*/
returnCompound: boolean;
}
class PolylineDto {
constructor(points?: Base.Point3[]);
/**
* Points points
* @default undefined
*/
points: Base.Point3[];
}
class PolylinesDto {
constructor(polylines?: PolylineDto[], returnCompound?: boolean);
/**
* Polylines
* @default undefined
*/
polylines: PolylineDto[];
/**
* Indicates whether the shapes should be returned as a compound
*/
returnCompound: boolean;
}
class SquareDto {
constructor(size?: number, center?: Base.Point3, direction?: Base.Vector3);
/**
* size of square
* @default 1
* @minimum 0
* @maximum Infinity
* @step 1
*/
size: number;
/**
* Center of the square
* @default [0, 0, 0]
*/
center: Base.Point3;
/**
* Direction of the square
* @default [0, 1, 0]
*/
direction: Base.Vector3;
}
class RectangleDto {
constructor(width?: number, length?: number, center?: Base.Point3, direction?: Base.Vector3);
/**
* width of the rectangle
* @default 1
* @minimum 0
* @maximum Infinity
* @step 1
*/
width: number;
/**
* Height of the rectangle
* @default 2
* @minimum 0
* @maximum Infinity
* @step 1
*/
length: number;
/**
* Center of the rectangle
* @default [0, 0, 0]
*/
center: Base.Point3;
/**
* Direction of the rectangle
* @default [0, 1, 0]
*/
direction: Base.Vector3;
}
class LPolygonDto {
constructor(widthFirst?: number, lengthFirst?: number, widthSecond?: number, lengthSecond?: number, align?: directionEnum, rotation?: number, center?: Base.Point3, direction?: Base.Vector3);
/**
* Width of the first side of L polygon
* @default 1
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
widthFirst: number;
/**
* Length of the first side of L polygon
* @default 2
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
lengthFirst: number;
/**
* Width of the second side of L polygon
* @default 0.5
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
widthSecond: number;
/**
* Length of the second side of L polygon
* @default 2
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
lengthSecond: number;
/**
* Indicates if the L polygon should be aligned inside/outside or middle
* @default outside
*/
align: directionEnum;
/**
* Rotation of the L polygon
* @default 0
* @minimum 0
* @maximum Infinity
* @step 15
*/
rotation: number;
/**
* Center of the L polygon
* @default [0, 0, 0]
*/
center: Base.Point3;
/**
* Direction of the L polygon
* @default [0, 1, 0]
*/
direction: Base.Vector3;
}
class BoxDto {
constructor(width?: number, length?: number, height?: number, center?: Base.Point3, originOnCenter?: boolean);
/**
* Width of the box
* @default 1
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
width: number;
/**
* Length of the box
* @default 2
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
length: number;
/**
* Height of the box
* @default 3
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
height: number;
/**
* Center of the box
* @default [0, 0, 0]
*/
center: Base.Point3;
/**
* Force origin to be on the center of the cube
* @default true
*/
originOnCenter?: boolean;
}
class CubeDto {
constructor(size?: number, center?: Base.Point3, originOnCenter?: boolean);
/**
* Size of the cube
* @default 1
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
size: number;
/**
* Center of the box
* @default [0, 0, 0]
*/
center: Base.Point3;
/**
* Force origin to be on the center of the cube
* @default true
*/
originOnCenter?: boolean;
}
class BoxFromCornerDto {
constructor(width?: number, length?: number, height?: number, corner?: Base.Point3);
/**
* Width of the box
* @default 1
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
width: number;
/**
* Length of the box
* @default 2
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
length: number;
/**
* Height of the box
* @default 3
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
height: number;
/**
* Corner of the box
* @default [0, 0, 0]
*/
corner: Base.Point3;
}
class SphereDto {
constructor(radius?: number, center?: Base.Point3);
/**
* Radius of the sphere
* @default 1
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
radius: number;
/**
* Center of the sphere
* @default [0, 0, 0]
*/
center: Base.Point3;
}
class ConeDto {
constructor(radius1?: number, radius2?: number, height?: number, angle?: number, center?: Base.Point3, direction?: Base.Vector3);
/**
* First radius of the cone
* @default 2
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
radius1: number;
/**
* Second radius of the cone
* @default 1
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
radius2: number;
/**
* Height of the cone
* @default 2
* @minimum 0
* @maximum Infinity
* @step 0.1
*/
height: number;
/**
* Angle of the cone
* @default 360
* @minimum 0
* @maximum 360
* @step 1
*/
angle: number;
/**
* Center of the cone
* @default [0, 0, 0]
*/
center: Base.Point3;
/**
* Direction of the cone
* @default [0, 1, 0]
*/
direction: Base.Point3;
}
class LineDto {
constructor(start?: Base.Point3, end?: Base.Point3);
/**
* Start of the line
* @default [0, 0, 0]
*/
start: Base.Point3;
/**
* End of the line
* @default [0, 1, 0]
*/
end: Base.Point3;
}
class LinesDto {
constructor(lines?: LineDto[], returnCompound?: boolean);
/**
* Lines
* @default undefined
*/
lines: LineDto[];
/**
* Indicates whether the shapes should be returned as a compound
*/
returnCompound: boolean;
}
class ArcEdgeTwoPointsTangentDto {
constructor(start?: Base.Point3, tangentVec?: Base.Vector3, end?: Base.Point3);
/**
* Start of the arc
* @default [0, 0, 0]
*/
start: Base.Point3;
/**
* Tangent vector on first point of the edge
* @default [0, 1, 0]
*/
tangentVec: Base.Vector3;
/**
* End of the arc
* @default [0, 0, 1]
*/
end: Base.Point3;
}
class ArcEdgeCircleTwoPointsDto<T> {
constructor(circle?: T, start?: Base.Point3, end?: Base.Point3, sense?: boolean);
/**
* Circular edge
* @default undefined
*/
circle: T;
/**
* Start of the arc on the circle
* @default [0, 0, 0]
*/
start: Base.Point3;
/**
* End of the arc on the circle
* @default [0, 0, 1]
*/
end: Base.Point3;
/**
* If true will sense the direction
* @default true
*/
sense: boolean;
}
class ArcEdgeCircleTwoAnglesDto<T> {
constructor(circle?: T, alphaAngle1?: number, alphaAngle2?: number, sense?: boolean);
/**
* Circular edge
* @default undefined
*/
circle: T;
/**
* First angle
* @default 0
* @minimum -Infinity
* @maximum Infinity
* @step 1
*/
alphaAngle1: number;
/**
* End angle
* @default 90
* @minimum -Infinity
* @maximum Infinity
* @step 1
*/
alphaAngle2: number;
/**
* If true will sense the direction
* @default true
*/
sense: boolean;
}
class ArcEdgeCirclePointAngleDto<T> {
constructor(circle?: T, alphaAngle?: number, alphaAngle2?: number, sense?: boolean);
/**
* Circular edge
* @default undefined
*/
circle: T;
/**
* Point on the circle from where to start the arc
* @default undefined
*/
point: Base.Point3;
/**
* Angle from point
* @default 90
* @minimum -Infinity
* @maximum Infinity
* @step 1
*/
alphaAngle: number;
/**
* If true will sense the direction
* @default true
*/
sense: boolean;
}
clas