///
///
declare module "copyright" {
export class FoundationRuntimeGeometryCopyright {
static toString(): string;
}
}
declare module "foundation/runtime/geometry/arithmetic/arrangement/ArrangementUitl" {
export class ArrangementUtil {
}
}
declare module "foundation/runtime/geometry/arithmetic/curvature/CurvatureUitl" {
export class CurvatureUtil {
}
}
declare module "foundation/runtime/geometry/arithmetic/draft/DraftUtil" {
import { Line2 } from 'foundation/runtime/math/Line2';
import { Vector2 } from 'foundation/runtime/math/Vector2';
export class DraftUtil {
dimLine(pointA: Vector2, pointB: Vector2, pointC: Vector2, horizontal: boolean): Line2;
offsetLineA(pointA: Vector2, pointB: Vector2, dis: number, reverse?: boolean): Line2;
offsetLineB(pointA: Vector2, pointB: Vector2, pointC: Vector2): Line2;
arcPtsExtend(arcCenter: Vector2, arcPt1: Vector2, arcPt2: Vector2, touchPt: Vector2, outPt1: Vector2, outPt2: Vector2): void;
}
}
declare module "foundation/runtime/geometry/arithmetic/extreme/ExtremeUitl" {
export class ExtremeUtil {
}
}
declare module "foundation/runtime/geometry/arithmetic/fitting/FittingUitl" {
export class FittingUtil {
}
}
declare module "foundation/runtime/geometry/arithmetic/geometrytest/geometry/GeometryStructure" {
import { Vector3 } from 'foundation/runtime/math/Vector3';
export type GLine = {
p1: Vector3;
p2: Vector3;
};
export class GLineAst {
ref: GLine;
}
export type GSegment = {
begin: Vector3;
end: Vector3;
};
export class GSegmentAst {
ref: GSegment;
}
export type GRay = {
begin: Vector3;
direction: Vector3;
};
export class GRayAst {
ref: GRay;
}
export type GTriangle = {
p1: Vector3;
p2: Vector3;
p3: Vector3;
};
export class GTriangleAst {
ref: GTriangle;
normal: Vector3;
}
export type GRectangle = {
leftUpper: Vector3;
rightUpper: Vector3;
leftLower: Vector3;
rightLower: Vector3;
};
export class GRectangleAst {
ref: GRectangle;
normal: Vector3;
}
export type GPolygon = {
points: Array;
};
export class GPolygonAst {
ref: GPolygon;
}
export type GCircle = {
center: Vector3;
radius: number;
normal: Vector3;
};
export class GCircleAst {
ref: GCircle;
}
export type GPlane = {
point: Vector3;
normal: Vector3;
};
export class GPlaneAst {
ref: GPlane;
}
export type GPolyhedron = {
points: Array;
};
export class GPolyhedronAst {
ref: GPolyhedron;
}
export type GSphere = {
center: Vector3;
radius: number;
};
export class GSphereAst {
ref: GSphere;
}
export type GBox3 = {
min: Vector3;
max: Vector3;
};
export class GBox3Ast {
ref: GBox3;
}
export type GObox3 = {
min: Vector3;
max: Vector3;
direction: Vector3;
};
export class GObox3Ast {
ref: GObox3;
}
}
declare module "foundation/runtime/geometry/arithmetic/geometrytest/math/GeometryAssistant" {
import { GRectangle } from "foundation/runtime/geometry/arithmetic/geometrytest/geometry/GeometryStructure";
export class GeometryAssistant {
static isRectangle(box2: GRectangle): boolean;
}
}
declare module "foundation/runtime/geometry/arithmetic/geometrytest/geometry/GeometryCheckUtil" {
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { GLine, GSegment, GRay, GTriangle, GRectangle, GBox3, GObox3, GPolygon, GCircle, GPlane, GSphere, GPolyhedron } from "foundation/runtime/geometry/arithmetic/geometrytest/geometry/GeometryStructure";
export class GeometryCheckUtil {
static pointPoint(point: Vector3, point2: Vector3): boolean;
static pointLine(point: Vector3, line: GLine): boolean;
static pointSegment(point: Vector3, segment: GSegment): boolean;
static pointRay(point: Vector3, ray: GRay): boolean;
static pointTriangle(point: Vector3, triangle: GTriangle): boolean;
static pointBox2(point: Vector3, box2: GRectangle): boolean;
static pointPolygon(point: Vector3, polygon: GPolygon): boolean;
static pointCircle(point: Vector3, circle: GCircle): boolean;
static pointPlane(point: Vector3, plane: GPlane): boolean;
static pointPolyhedron(point: Vector3, polyhedron: GPolyhedron): boolean;
static pointSphere(point: Vector3, sphere: GSphere): boolean;
static pointBox3(point: Vector3, box3: GBox3): boolean;
static pointObox3(point: Vector3, obox3: GObox3): boolean;
static lineLine(line1: GLine, line2: GLine): boolean;
static lineSegment(line: GLine, segment: GSegment): boolean;
static lineRay(line: GLine, ray: GRay): boolean;
static lineTriangle(line: GLine, triangle: GTriangle): boolean;
static lineBox2(line: GLine, box2: GRectangle): boolean;
static linePolygon(line: GLine, polygon: GPolygon): boolean;
static lineCircle(line: GLine, circle: GCircle): boolean;
static linePlane(line: GLine, plane: GPlane): boolean;
static linePolyhedron(line: GLine, polyhedron: GPolygon): boolean;
static lineBox3(line: GLine, box3: GBox3): boolean;
static lineObox3(line: GLine, obox3: GObox3): boolean;
static segmentSegment(segment: GSegment, segment2: GSegment): boolean;
static segmentRay(segment: GSegment, ray: GRay): boolean;
static segmentTriangle(segment: GSegment, triangle: GTriangle): boolean;
static segmentBox2(segment: GSegment, box2: GRectangle): boolean;
static segmentPolygon(segment: GSegment, polygon: GPolygon): boolean;
static segmentCircle(segment: GSegment, circle: GCircle): boolean;
static segmentPlane(segment: GSegment, plane: GPlane): boolean;
static segmentPolyhedron(segment: GSegment, polyhedron: GPolyhedron): boolean;
static segmentBox3(segment: GSegment, box3: GBox3): boolean;
static segmentObox3(segment: GSegment, obox3: GObox3): boolean;
static rayRay(ray: GRay, ray2: GRay): boolean;
static rayTriangle(ray: GRay, triangle: GTriangle): boolean;
static rayBox2(ray: GRay, box2: GRectangle): boolean;
static rayPolygon(ray: GRay, polygon: GPolygon): boolean;
static rayCircle(ray: GRay, circle: GCircle): boolean;
static rayPlane(ray: GRay, plane: GPlane): boolean;
static rayPolyhedron(ray: GRay, polyhedron: GPolyhedron): boolean;
static rayBox3(ray: GRay, box3: GBox3): boolean;
static rayObox3(ray: GRay, obox3: GObox3): boolean;
static triangleTriangle(triangle: GTriangle, triangle2: GTriangle): boolean;
static triangleBox2(triangle: GTriangle, box2: GRectangle): boolean;
static trianglePolygon(triangle: GTriangle, polygon: GPolygon): boolean;
static triangleCircle(triangle: GTriangle, circle: GCircle): boolean;
static trianglePlane(triangle: GTriangle, plane: GPlane): boolean;
static trianglePolyhedron(triangle: GTriangle, polyhedron: GPolyhedron): boolean;
static triangleBox3(triangle: GTriangle, box3: GBox3): boolean;
static triangleObox3(triangle: GTriangle, obox3: GObox3): boolean;
static box2Box2(box2: GRectangle, box22: GRectangle): boolean;
static box2Polygon(box2: GRectangle, polygon: GPolygon): boolean;
static box2Circle(box2: GRectangle, circle: GCircle): boolean;
static box2Plane(box2: GRectangle, plane: GPlane): boolean;
static box2Polyhedron(box2: GRectangle, polyhedron: GPolyhedron): boolean;
static box2Box3(box2: GRectangle, box3: GBox3): boolean;
static box2Obox3(box2: GRectangle, obox3: GObox3): boolean;
static polygonPolygon(polygon: GPolygon, polygon2: GPolygon): boolean;
static polygonCircle(polygon: GCircle, circle: GCircle): boolean;
static polygonPlane(polygon: GCircle, plane: GPlane): boolean;
static polygonPolyhedron(polygon: GCircle, polyhedron: GPolyhedron): boolean;
static polygonBox3(polygon: GCircle, box3: GBox3): boolean;
static polygonObox3(polygon: GCircle, obox3: GObox3): boolean;
static circleCircle(circle: GCircle, circle2: GCircle): boolean;
static circlePlane(circle: GCircle, plane: GPlane): boolean;
static circlePolyhedron(circle: GCircle, polyhedron: GPolyhedron): boolean;
static circleBox3(circle: GCircle, box3: GBox3): boolean;
static circleObox3(circle: GCircle, obox3: GObox3): boolean;
static planePlane(plane: GPlane, plane2: GPlane): boolean;
static planePolyhedron(plane: GPlane, polyhedron: GPolyhedron): boolean;
static planeBox3(plane: GPlane, box3: GBox3): boolean;
static planeObox3(plane: GPlane, obox3: GObox3): boolean;
static polyhedronPolyhedron(polyhedron: GPolyhedron, polyhedron2: GPolyhedron): boolean;
static polyhedronBox3(polyhedron: GPolyhedron, box3: GBox3): boolean;
static polyhedronObox3(polyhedron: GPolyhedron, obox3: GObox3): boolean;
static box3Box3(box3: GBox3, box32: GBox3): boolean;
static box3Obox3(box3: GBox3, obox3: GObox3): boolean;
static obox3Obox3(obox31: GObox3, obox32: GObox3): boolean;
}
}
declare module "foundation/runtime/geometry/arithmetic/geometrytest/geometry/IntersectionPointUtil" {
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { GLine, GSegment, GRay, GTriangle, GRectangle, GBox3, GObox3, GPolygon, GCircle, GPlane, GSphere, GPolyhedron } from "foundation/runtime/geometry/arithmetic/geometrytest/geometry/GeometryStructure";
export class IntersectionPointUtil {
static pointPoint(point: Vector3, point2: Vector3): any;
static pointLine(point: Vector3, line: GLine): any;
static pointSegment(point: Vector3, segment: GSegment): any;
static pointRay(point: Vector3, ray: GRay): any;
static pointTriangle(point: Vector3, triangle: GTriangle): any;
static pointBox2(point: Vector3, box2: GRectangle): any;
static pointPolygon(point: Vector3, polygon: GPolygon): any;
static pointCircle(point: Vector3, circle: GCircle): any;
static pointPlane(point: Vector3, plane: GPlane): any;
static pointPolyhedron(point: Vector3, polyhedron: GPolyhedron): any;
static pointSphere(point: Vector3, sphere: GSphere): any;
static pointBox3(point: Vector3, box3: GBox3): any;
static pointObox3(point: Vector3, obox3: GObox3): any;
static lineLine(line: GLine, line2: GLine): any;
static lineSegment(line: GLine, segment: GSegment): any;
static lineRay(line: GLine, ray: GRay): any;
static lineTriangle(line: GLine, triangle: GTriangle): any;
static lineBox2(line: GLine, box2: GRectangle): any;
static linePolygon(line: GLine, polygon: GPolygon): any;
static lineCircle(line: GLine, circle: GCircle): any;
static linePlane(line: GLine, plane: GPlane): any;
static linePolyhedron(line: GLine, polyhedron: GPolygon): any;
static lineBox3(line: GLine, box3: GBox3): any;
static lineObox3(line: GLine, obox3: GObox3): any;
static segmentSegment(segment: GSegment, segment2: GSegment): any;
static segmentRay(segment: GSegment, ray: GRay): any;
static segmentTriangle(segment: GSegment, triangle: GTriangle): any;
static segmentBox2(segment: GSegment, box2: GRectangle): any;
static segmentPolygon(segment: GSegment, polygon: GPolygon): any;
static segmentCircle(segment: GSegment, circle: GCircle): any;
static segmentPlane(segment: GSegment, plane: GPlane): any;
static segmentPolyhedron(segment: GSegment, polyhedron: GPolyhedron): any;
static segmentBox3(segment: GSegment, box3: GBox3): any;
static segmentObox3(segment: GSegment, obox3: GObox3): any;
static rayRay(ray: GRay, ray2: GRay): any;
static rayTriangle(ray: GRay, triangle: GTriangle): any;
static rayBox2(ray: GRay, box2: GRectangle): any;
static rayPolygon(ray: GRay, polygon: GPolygon): any;
static rayCircle(ray: GRay, circle: GCircle): any;
static rayPlane(ray: GRay, plane: GPlane): any;
static rayPolyhedron(ray: GRay, polyhedron: GPolyhedron): any;
static rayBox3(ray: GRay, box3: GBox3): any;
static rayObox3(ray: GRay, obox3: GObox3): any;
}
}
declare module "foundation/runtime/geometry/arithmetic/interpolation/InterpolationUitl" {
export class InterpolationUtil {
}
}
declare module "foundation/runtime/geometry/arithmetic/link/LinkUitl" {
export class LinkUtil {
}
}
declare module "foundation/runtime/geometry/arithmetic/tailor/TailorUitl" {
export class TailorUtil {
}
}
declare module "foundation/runtime/geometry/Geometric" {
import { DataStream } from 'cross/runtime/lang/stream/DataStream';
import { DataTypeEnum } from 'cross/runtime/lang/DataTypeEnum';
import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
import { Box3 } from 'foundation/runtime/math/Box3';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { PolynomialVector } from 'foundation/runtime/math/PolynomialVector';
import { Vector3 } from 'foundation/runtime/math/Vector3';
export class Geometric extends InstanceObject {
protected static _MaxSize: number;
protected static _SamplesNum: number;
reset(): void;
static get MaxSize(): number;
applyMatrix4(matrix: Matrix4): Geometric;
getCurvature(p: Vector3, v: Vector3): number;
getLerpPoint(...args: any[]): Vector3;
getLerpTangent(...args: any[]): any;
getLerpNormal(...args: any[]): Vector3;
getPointNormal(...args: any[]): Vector3;
getLerpT(...args: any[]): any;
getLocalMatrix(...args: any[]): Matrix4;
getLerpMatrix(...args: any[]): Matrix4;
getTangentPlane(...args: any[]): any;
getArrangementPoint(...args: any[]): Array;
getArrangement(...args: any[]): any;
fitting(...args: any[]): Geometric;
getExtreme(v: Vector3): Array;
getMax(v: Vector3): Vector3;
getMin(v: Vector3): Vector3;
getMinDistance(pt: Vector3, target?: Array): number;
clone(): Geometric;
protected clearDuplicateKeyPoints(keys: Array, tangents?: Array, tolerance?: number, lerptolerance?: number): Array;
projective(world?: Matrix4, proj?: Matrix4): Array;
view(world?: Matrix4, proj?: Matrix4): Array;
viewOutline(world?: Matrix4, proj?: Matrix4): Array;
outline(): Array;
isBrep(): boolean;
isPointInside(point: Vector3, tolerance?: number): boolean;
isPointOutside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
serialize(output: DataStream, dataCd?: DataTypeEnum): void;
unserialize(input: DataStream, dataCd?: DataTypeEnum): void;
}
export class Partition {
begin: number;
end: number;
constructor(begin?: number, end?: number);
}
export class Curve extends Geometric {
t2u(t: number): number;
u2t(u: number): number;
p2u(p: number): number;
u2p(u: number): number;
solveImplicitEquationToPolynomialVector(): PolynomialVector;
solveParameticEquation(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationFirstDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationFirstDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationSecondDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationSecondDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationRDerivative(r: number, u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
getParameticEquationBijectionPoint(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector3;
applyMatrix4(matrix: Matrix4): Curve;
clone(): Curve;
getReverseClone(): Curve;
getRDerivat(r: number, u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
getLerpPoint(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
getLerpTangent(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
getLerpNormal(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
getLerpBinNormal(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
getLerpFrenetMatrix(t: number, tolerance?: number, lerpTolerance?: number): Matrix4;
getLerpT(point: Vector3, tolerance?: number, lerpTolerance?: number): number;
getLerpTangentT(tangent: Vector3, tolerance?: number, lerpTolerance?: number): number;
getTangentP(point: Vector3, tolerance?: number, lerpTolerance?: number): Vector3;
getVerticalsT(point: Vector3, step?: number, tolerance?: number): Array;
protected binaryVerticalT(point: Vector3, startT: number, endT: number, startDot: number, endDot: number, tolerance?: number): number;
getPointDot(point: Vector3, t: number, tolerance?: number): number;
getExtreme(v: Vector3): Array;
get length(): number;
getLength(tolerance?: number): number;
getBox(step?: number, tolerance?: number): Box3;
fitting(...args: any[]): Curve;
getArrangement(start: number, end: number, count: number): Array;
getArrangementByStep(start: number, end: number, step: number): Array;
getArrangementByStepN(start: number, end: number, count: number, step: number): Array;
getArrangementBySteps(start: number, end: number, steps: Array): Array;
getArrangementByCountSteps(start: number, end: number, count: number, steps: Array): Array;
getArrangementByStepNCountSteps(start: number, end: number, count: number, step: number, steps: Array): Array;
getBeginPoint(): Vector3;
getEndPoint(): Vector3;
getBeginTangent(): Vector3;
getEndTangent(): Vector3;
getBeginMatrix(normal?: Vector3): Matrix4;
getEndMatrix(normal?: Vector3): Matrix4;
getLerpMatrix(t: number, n?: Vector3): Matrix4;
getLocalMatrix(n?: Vector3): Matrix4;
getKeyPoints(): Array;
getKeyTangents(): Array;
getKeys(isPassSmooth?: boolean, tolerance?: number, lerptolerance?: number): Array;
viewOutline(world?: Matrix4, proj?: Matrix4): Array;
projective(world?: Matrix4, proj?: Matrix4): Array;
outline(): Array;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): Curve;
cutt(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve;
cutu(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve;
extend(begin: Vector3, end: Vector3, tolerance?: number): Curve;
equalsPartOverlap(g: Curve): boolean;
nearlyEqualsPartOverlap(g: Curve, tolerance?: number): boolean;
equalsForm(g: Curve): boolean;
nearlyEqualsForm(g: Curve, tolerance?: number): boolean;
equalsCoincide(g: Curve): boolean;
nearlyEqualsCoincide(g: Curve, tolerance?: number): boolean;
equals(g: Curve): boolean;
nearlyEquals(g: Curve, tolerance?: number): boolean;
isInvalid(tolerance?: number): boolean;
isPointInside(point: Vector3, tolerance?: number): boolean;
isPointOutside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
getSamplesNum(tolerance?: number): number;
}
}
declare module "foundation/runtime/geometry/Curve3d" {
import { Box3 } from 'foundation/runtime/math/Box3';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Sphere } from 'foundation/runtime/math/Sphere';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { ArcCurve2d, Curve2d } from "foundation/runtime/geometry/Curve2d";
import { Curve } from "foundation/runtime/geometry/Geometric";
export type Cache = {
t: number;
point: Vector3;
tangent: Vector3;
};
export class Curve3d extends Curve {
applyMatrix4(matrix: Matrix4): Curve3d;
clone(): Curve3d;
getReverseClone(): Curve3d;
getCurves(): Array;
to2d(): any;
fitting(...args: any[]): Curve3d;
projective(): Array;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): Curve3d;
cutt(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve3d;
cutu(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve3d;
extend(begin: Vector3, end: Vector3, tolerance?: number): Curve3d;
singleSettingOut(p: Vector3, normal: Vector3): Curve3d;
equalsPartOverlap(g: Curve3d): boolean;
nearlyEqualsPartOverlap(g: Curve3d, tolerance?: number): boolean;
computeEnclosingSphere(tStart: number, tEnd: number, ptStart?: Vector3, ptEnd?: Vector3): Sphere;
computeEnclosingBBox(tStart: number, tEnd: number, ptStart?: Vector3, ptEnd?: Vector3): Box3;
get length(): number;
toBrep(): Array;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4, tolerance?: number, lerpTolerance?: number): Vector2;
}
export class SingleCurve3d extends Curve3d {
clone(): SingleCurve3d;
getReverseClone(): SingleCurve3d;
equalsPartOverlap(g: Curve3d): boolean;
nearlyEqualsPartOverlap(g: Curve3d, tolerance?: number): boolean;
equalsForm(g: Curve3d): boolean;
nearlyEqualsForm(g: Curve3d, tolerance?: number): boolean;
equalsCoincide(g: Curve3d): boolean;
nearlyEqualsCoincide(g: Curve3d, tolerance?: number): boolean;
equals(g: Curve3d): boolean;
nearlyEquals(g: Curve3d, tolerance?: number): boolean;
}
export class ArcCurve3d extends SingleCurve3d {
private _center;
private _begin;
private _normal;
private _local;
constructor(center?: Vector3, begin?: Vector3, normal?: Vector3);
isInvalid(tolerance?: number): boolean;
reset(): void;
get center(): Vector3;
set center(center: Vector3);
get begin(): Vector3;
set begin(begin: Vector3);
get normal(): Vector3;
set normal(normal: Vector3);
get radius(): number;
set radius(radius: number);
getMajorAxis(): Vector3;
getMinorAxis(major_axis?: Vector3): Vector3;
getLocalMatrix(): Matrix4;
applyMatrix4(matrix: Matrix4): Curve3d;
getLerpMatrix(t: number, n?: Vector3): Matrix4;
toArc(): ArcCurve3d;
to2d(): ArcCurve2d;
getMinDistance(pt: Vector3, target?: Array): number;
}
export type CacheMap = {
[key: number]: Cache;
};
export class IntCurve3d extends SingleCurve3d {
controls: Array;
points: Array;
protected _length: number;
_cache: CacheMap;
reset(): void;
clone(): IntCurve3d;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): IntCurve3d;
protected getRealLerpT(t: number): number;
getCacheByT(t: number): Cache;
getCacheByPoint(point: Vector3, tolerance?: number): Cache;
getCacheByTangent(tangent: Vector3, lerpTolerance?: number): Cache;
getLength(tolerance?: number): number;
get length(): number;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4, tolerance?: number, lerpTolerance?: number): Vector2;
getControlPolyline(): Curve3d;
}
export class ComplexCurve3d extends Curve3d {
curves: Array;
constructor(curves?: Array);
getLerpCurve(t: number, tolerance?: number, lerpTolerance?: number): {
c: SingleCurve3d;
t: number;
};
getLerpT(point: Vector3, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquation(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationFirstDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationFirstDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationSecondDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationSecondDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
clone(): ComplexCurve3d;
getReverseClone(): ComplexCurve3d;
getCurves(): Array;
getLocalMatrix(n?: Vector3): Matrix4;
equalsPartOverlap(g: Curve3d): boolean;
nearlyEqualsPartOverlap(g: Curve3d, tolerance?: number): boolean;
equalsForm(g: Curve3d): boolean;
nearlyEqualsForm(g: Curve3d, tolerance?: number): boolean;
equalsCoincide(g: Curve3d): boolean;
nearlyEqualsCoincide(g: Curve3d, tolerance?: number): boolean;
equals(g: Curve3d): boolean;
nearlyEquals(g: Curve3d, tolerance?: number): boolean;
}
}
declare module "foundation/runtime/geometry/relation/UVBlock" {
export type UVBlock = {
u0: number;
u1: number;
v0: number;
v1: number;
level: number;
};
}
declare module "foundation/runtime/geometry/Surface" {
import { Box3 } from 'foundation/runtime/math/Box3';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { PolynomialVector } from 'foundation/runtime/math/PolynomialVector';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { UVBlock } from "foundation/runtime/geometry/relation/UVBlock";
import { Geometric } from "foundation/runtime/geometry/Geometric";
import { SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { Polynomial } from 'foundation/runtime/math/Polynomial';
export class Surface extends Geometric {
protected _isOutside: boolean;
constructor();
get isOutside(): boolean;
set isOutside(isOutside: boolean);
tu2u(tu: number): number;
u2tu(u: number): number;
tv2v(tv: number): number;
v2tv(v: number): number;
pu2u(pu: number): number;
u2pu(u: number): number;
pv2v(pv: number): number;
v2pv(v: number): number;
solveImplicitEquationToPolynomialVector(): PolynomialVector;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
solveCurveTangentOnSurface(c: SingleCurve3d, t: number, point: Vector3, defineU: number, defineV: number, local?: Matrix4, localInvert?: Matrix4): Vector2;
getParameticEquationVCurve(u: number, local?: Matrix4, localInvert?: Matrix4): any;
getParameticEquationUCurve(v: number, local?: Matrix4, localInvert?: Matrix4): any;
getParameticEquationUMinVCurve(local?: Matrix4, localInvert?: Matrix4): any;
getParameticEquationVMinUCurve(local?: Matrix4, localInvert?: Matrix4): any;
getParameticEquationUMaxVCurve(local?: Matrix4, localInvert?: Matrix4): any;
getParameticEquationVMaxUCurve(local?: Matrix4, localInvert?: Matrix4): any;
getParameticEquationUTangent(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
getParameticEquationVTangent(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
getParameticEquationUVNormal(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
getParameticEquationMatrix(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Matrix4;
getParameticEquationBijectionPoint(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector3;
getMinDistance(pt: Vector3, target?: Array, local?: Matrix4, localInvert?: Matrix4): number;
getLocalMatrix(): Matrix4;
reset(): void;
getArea(tolerance?: number): number;
clone(): Surface;
fitting(...args: any[]): Surface;
getLerpNormal(u: number, v: number, tolerance?: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
getPointNormal(ponit: Vector3, tolerance?: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
getLerpMatrix(u: number, v: number, tolerance?: number, local?: Matrix4, localInvert?: Matrix4): Matrix4;
getLerpPoint(u: number, v: number, tolerance?: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
getLerpTangent(u: number, v: number, tolerance?: number, local?: Matrix4, localInvert?: Matrix4): any;
getLerpT(ponit: Vector3, tolerance?: number, local?: Matrix4, localInvert?: Matrix4): Vector2;
getTangentPlane(point: Vector3, tolerance?: number, local?: Matrix4, localInvert?: Matrix4): any;
viewOutline(world?: Matrix4, proj?: Matrix4): Array;
outline(): Array;
computeEnclosingBBox(tu0: number, tu1: number, tv0: number, tv1: number, ptuv00?: Vector3, ptuv10?: Vector3, ptuv01?: Vector3, ptuv11?: Vector3, localMatrix?: Matrix4, invertMatrix?: Matrix4): Box3;
computeUVNeighborBlocks(u: number, v: number, level: number, tolerance?: number): Array;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
isPointOutside(point: Vector3, tolerance?: number): boolean;
equalsPartOverlap(g: Surface): boolean;
nearlyEqualsPartOverlap(g: Surface, tolerance?: number): boolean;
equalsForm(g: Surface): boolean;
nearlyEqualsForm(g: Surface, tolerance?: number): boolean;
equalsCoincide(g: Surface): boolean;
nearlyEqualsCoincide(g: Surface, tolerance?: number): boolean;
equals(g: Surface): boolean;
nearlyEquals(g: Surface, tolerance?: number): boolean;
equalsPlaneMatrix(g: Surface): boolean;
nearlyEqualsPlaneMatrix(g: Surface, tolerance?: number): boolean;
getSamplesNum(tolerance?: number): Vector2;
}
export class SingleSurface extends Surface {
clone(): any;
isOutLinePositive(): boolean;
getImplicitPolynomial(): Polynomial;
}
export class Single3dSurface extends SingleSurface {
isOutLinePositive(): boolean;
clone(): any;
}
export class QuadricSurface extends Single3dSurface {
}
export class FirstOrderSurface extends Single3dSurface {
private _normal;
constructor(normal?: Vector3);
get normal(): Vector3;
applyMatrix4(matrix: Matrix4): Surface;
getPlane(): any;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
getParameticEquationVCurve(u: number, local?: Matrix4, localInvert?: Matrix4): any;
getParameticEquationUCurve(v: number, local?: Matrix4, localInvert?: Matrix4): any;
getParameticEquationUMinVCurve(local?: Matrix4, localInvert?: Matrix4): any;
getParameticEquationUMaxVCurve(local?: Matrix4, localInvert?: Matrix4): any;
getParameticEquationVMaxUCurve(local?: Matrix4, localInvert?: Matrix4): any;
equalsPartOverlap(g: Surface): boolean;
nearlyEqualsPartOverlap(g: Surface, tolerance?: number): boolean;
equalsPlaneMatrix(g: Surface): boolean;
nearlyEqualsPlaneMatrix(g: Surface, tolerance?: number): boolean;
parallelPlaneMatrix(g: Surface): boolean;
nearlyParallelPlaneMatrix(g: Surface, tolerance?: number): boolean;
getLerpNormal(u: number, v: number, tolerance?: number): Vector3;
getPointNormal(ponit: Vector3, tolerance?: number): Vector3;
}
export class Single2dSurface extends FirstOrderSurface {
isOutLinePositive(): boolean;
getPath(): any;
getSectionSurface(): any;
to3d(): any;
clone(): any;
}
export class ArcSurface extends QuadricSurface {
center: Vector3;
begin: Vector3;
normal: Vector3;
constructor(center?: Vector3, begin?: Vector3, normal?: Vector3);
reset(): void;
get radius(): number;
set radius(radius: number);
getMajorAxis(): Vector3;
getMinorAxis(): Vector3;
getLocalMatrix(): Matrix4;
applyMatrix4(matrix: Matrix4): Surface;
}
export class ComplexSurface extends Surface {
surface: SingleSurface;
getLerpNormal(u: number, v: number, tolerance?: number): Vector3;
getPointNormal(ponit: Vector3, tolerance?: number): Vector3;
}
}
declare module "foundation/runtime/geometry/Curve2d" {
import { Box2 } from 'foundation/runtime/math/Box2';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { Curve3d, SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { Curve } from "foundation/runtime/geometry/Geometric";
import { Surface } from "foundation/runtime/geometry/Surface";
export type Cache = {
t: number;
point: Vector3;
tangent: Vector3;
};
export class Curve2d extends Curve {
private _normal;
constructor();
get normal(): Vector3;
set normal(normal: Vector3);
applyMatrix4(matrix: Matrix4): Curve2d;
applyMatrix4Scale(matrix: Matrix4): Curve2d;
reset(): void;
clone(): Curve2d;
getCurves(): Array;
getReverseClone(): Curve2d;
to3d(): Curve3d;
from3d(g: Curve3d): void;
fitting(...args: any[]): Curve2d;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): Curve2d;
cutt(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve2d;
cutu(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve2d;
extend(begin: Vector3, end: Vector3, tolerance?: number): Curve2d;
singleSettingOut(p: Vector3): Curve2d;
getLerpMatrix(t: number, n?: Vector3): Matrix4;
equalsPartOverlap(g: Curve2d): boolean;
nearlyEqualsPartOverlap(g: Curve2d, tolerance?: number): boolean;
isPointInCurve(pt: Vector3, tolerance?: number): boolean;
computeEnclosingBBox(tStart: number, tEnd: number, ptStart?: Vector3, ptEnd?: Vector3): Box2;
toBrep(): Array;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
}
export class SingleCurve2d extends Curve2d {
to3d(): SingleCurve3d;
equalsPartOverlap(g: Curve2d): boolean;
nearlyEqualsPartOverlap(g: Curve2d, tolerance?: number): boolean;
equalsForm(g: Curve2d): boolean;
nearlyEqualsForm(g: Curve2d, tolerance?: number): boolean;
equalsCoincide(g: Curve2d): boolean;
nearlyEqualsCoincide(g: Curve2d, tolerance?: number): boolean;
equals(g: Curve2d): boolean;
nearlyEquals(g: Curve2d, tolerance?: number): boolean;
}
export class ArcCurve2d extends SingleCurve2d {
private _center;
private _begin;
private _local;
constructor(center?: Vector3, begin?: Vector3);
isInvalid(tolerance?: number): boolean;
reset(): void;
get normal(): Vector3;
set normal(normal: Vector3);
get center(): Vector3;
set center(center: Vector3);
get begin(): Vector3;
set begin(begin: Vector3);
get radius(): number;
set radius(radius: number);
getMajorAxis(): Vector3;
getMinorAxis(major_axis?: Vector3): Vector3;
getLocalMatrix(): Matrix4;
applyMatrix4(matrix: Matrix4): Curve2d;
toArc(): ArcCurve2d;
}
export type CacheMap = {
[key: number]: Cache;
};
export class IntCurve2d extends SingleCurve2d {
controls: Array;
protected _length: number;
protected _cache: CacheMap;
reset(): void;
clone(): IntCurve2d;
protected getRealLerpT(t: number): number;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
getControlPolyline(): Curve2d;
resetCache(): void;
getCacheByT(t: number): Cache;
getCacheByPoint(point: Vector3, tolerance?: number): Cache;
getCacheByTangent(tangent: Vector3, lerpTolerance?: number): Cache;
getLength(tolerance?: number): number;
get length(): number;
getExtreme(v: Vector3): Array;
}
export class ComplexCurve2d extends Curve2d {
curves: Array;
constructor(curves?: Array);
getLerpCurve(t: number, tolerance?: number, lerpTolerance?: number): {
c: SingleCurve2d;
t: number;
};
getLerpT(point: Vector3, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquation(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationFirstDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationFirstDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationSecondDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationSecondDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
clone(): ComplexCurve2d;
getCurves(): Array;
getLocalMatrix(): Matrix4;
equalsPartOverlap(g: Curve2d): boolean;
nearlyEqualsPartOverlap(g: Curve2d, tolerance?: number): boolean;
equalsForm(g: Curve2d): boolean;
nearlyEqualsForm(g: Curve2d, tolerance?: number): boolean;
equalsCoincide(g: Curve2d): boolean;
nearlyEqualsCoincide(g: Curve2d, tolerance?: number): boolean;
equals(g: Curve2d): boolean;
nearlyEquals(g: Curve2d, tolerance?: number): boolean;
isPointInCurve(pt: Vector3): boolean;
getExtreme(v: Vector3): Array;
getPlane(): Surface;
isPointInside(point: Vector3, tolerance?: number): boolean;
isPointOutside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
}
}
declare module "foundation/runtime/geometry/internal/InternalGeometricTypeUtil" {
import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
export class InternalGeometricTypeUtil {
static CLASS_CURVE2D_ELLIPSE: string;
static CLASS_CURVE3D_PATH: string;
protected static _types: Dictionary;
static get types(): Dictionary;
static registeClass(type: any): void;
static create(className: string, ...parameters: any[]): any;
}
}
declare module "foundation/runtime/geometry/internal/InternalGeometricTypeDeclare" {
export function InternalGeometricTypeDeclare(): (target: any) => void;
}
declare module "foundation/runtime/geometry/PointRelationEnum" {
export enum PointRelationEnum {
Unknown = 0,
In = 1,
On = 2
}
}
declare module "foundation/runtime/geometry/CurveUtil" {
import { Matrix3 } from 'foundation/runtime/math/Matrix3';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { Vector4 } from 'foundation/runtime/math/Vector4';
import { Curve2d } from "foundation/runtime/geometry/Curve2d";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
export class CurveUtilLerp {
static line(begin: Vector3, end: Vector3, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static circle(center: Vector3, begin: Vector3, normal: Vector3, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static circleArc(center: Vector3, begin: Vector3, radian: number, isPositive: boolean, normal: Vector3, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static ellipse(center: Vector3, begin: Vector3, axisRatio: number, normal: Vector3, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static ellipseArc(center: Vector3, begin: Vector3, axisRatio: number, angleBegin: number, radian: number, isPositive: boolean, normal: Vector3, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static bezier(controls: Array, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static bSpline(controls: Array, knots: Array, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static nurbs(controls: Array, knots: Array, weights: Array, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
private static bSplineBaseFunc;
}
export class CurveUtilTangent {
static line(begin: Vector3, end: Vector3, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static circle(center: Vector3, begin: Vector3, normal: Vector3, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static circleArc(center: Vector3, begin: Vector3, radian: number, isPositive: boolean, normal: Vector3, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static ellipse(center: Vector3, begin: Vector3, axisRatio: number, normal: Vector3, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static ellipseArc(center: Vector3, begin: Vector3, axisRatio: number, angleBegin: number, radian: number, isPositive: boolean, normal: Vector3, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static bezier(controls: Array, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static bSpline(controls: Array, knots: Array, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
static nurbs(controls: Array, knots: Array, weights: Array, t: number, tolerance?: number, lerpTolerance?: number): Vector3;
private static bSplineBaseFunc;
}
export class CurveUtilLerpT {
static line(point: Vector3, begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): number;
static circle(point: Vector3, center: Vector3, begin: Vector3, normal: Vector3, tolerance?: number, lerpTolerance?: number): number;
static circleArc(point: Vector3, center: Vector3, begin: Vector3, radian: number, isPositive: boolean, normal: Vector3, tolerance?: number, lerpTolerance?: number): number;
static ellipse(point: Vector3, center: Vector3, begin: Vector3, axisRatio: number, normal: Vector3, tolerance?: number, lerpTolerance?: number): number;
static ellipseArc(point: Vector3, center: Vector3, begin: Vector3, axisRatio: number, angleBegin: number, radian: number, isPositive: boolean, normal: Vector3, tolerance?: number, lerpTolerance?: number): number;
}
export class CurveFilter {
static removeCurve2dCoincide(curves: Array, tolerance?: number): Array;
static removeCurve3dCoincide(curves: Array, tolerance?: number): Array;
static clearCurve2dCoincide(curves: Array, tolerance?: number): Array;
static clearCurve3dCoincide(curves: Array, tolerance?: number): Array;
static removeCurve2dsRepeat(curves: Array, tolerance?: number, ref?: Array): Array;
static removeSameCurve2dsRepeat(curves: Array, tolerance?: number, ref?: Array): Array;
static removeInvalidCurves(curves: Array, tolerance?: number, ref?: Array): Array;
static splitCurve2ds(curves: Array, map?: any): any;
}
export class CurveUtilConics {
static matrix2coefficients(matrix: Matrix3): {
A: number;
B: number;
C: number;
D: number;
E: number;
F: number;
};
static coefficients2matrix(co: {
A: number;
B: number;
C: number;
D: number;
E: number;
F: number;
}): Matrix3;
static homo2normal(ptHomo: Vector3): Vector3;
static normal2homo(ptHomo: Vector3): Vector3;
static homo2normal3d(ptHomo: Vector4): Vector3;
static normal2homo3d(ptHomo: Vector3): Vector4;
static getIntersectionOfLineAndConic(conicMatrix: Matrix3, line: Vector3): Array;
static computeCommonPointsOfConics(matrixA: Matrix3, matrixB: Matrix3): Array;
static computeCommonTagentsOfConics(matrixA: Matrix3, matrixB: Matrix3): Array<{
line: Vector3;
tanptA: Vector3;
tanptB: Vector3;
}>;
static getConicTangentThroughPoint(matrix: Matrix3, pt: Vector3): Array<{
line: Vector3;
tanpt: Vector3;
}>;
static computeDecomposeOfDegenerateConic(matrix: Matrix3): {
value1: Vector3;
value2: Vector3;
};
}
export class CurveUtilSpace {
static computePlaneByPtAndNormal(pt: Vector3, normal: Vector3): Vector4;
static lineCurve3dXLineCurve3d(p0: Vector3, p1: Vector3, q0: Vector3, q1: Vector3, tolerance?: number): {
hasIntersect: boolean;
ptIntersect?: Vector3;
};
static computeLineXLineInSpace(point0_of_line0: Vector4, point1_of_line0: Vector4, point0_of_line1: Vector4, point1_of_line1: Vector4): {
pt0: Vector4;
pt1: Vector4;
};
static computeLineDirection(point0_of_line: Vector4, point1_of_line: Vector4): Vector3;
static computePlaneXLine(plane: Vector4, point0_of_line: Vector4, point1_of_line: Vector4): Vector4;
static computeNullSpaceVector4(v0: Vector4, v1: Vector4, v2: Vector4): Vector4;
}
}
declare module "foundation/runtime/geometry/curve2d/StraightCurve2d" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { StraightCurve3d } from "foundation/runtime/geometry/curve3d/StraightCurve3d";
import { PlaneSurface } from "foundation/runtime/geometry/surface/PlaneSurface";
import { SingleCurve2d } from "foundation/runtime/geometry/Curve2d";
import { LineCurve2d } from "foundation/runtime/geometry/curve2d/LineCurve2d";
export class StraightCurve2d extends SingleCurve2d {
origin: Vector3;
direction: Vector3;
constructor(origin?: Vector3, direction?: Vector3);
reset(): void;
t2u(t: number): number;
u2t(u: number): number;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
solveParameticEquation(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationFirstDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationFirstDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationSecondDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationSecondDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
applyMatrix4(matrix: Matrix4): StraightCurve2d;
getReverseClone(): StraightCurve2d;
clone(): StraightCurve2d;
getoriginPoint(): Vector3;
getdirectionPoint(): Vector3;
getLength(): number;
from3d(g: StraightCurve3d): void;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): LineCurve2d;
cutu(begin: number, end: number, tolerance?: number): LineCurve2d;
getLerpTangent(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
isBrep(): boolean;
getStraightLine(): Vector3;
getStraight(): StraightCurve2d;
isPointInside(point: Vector3, tolerance?: number): boolean;
isPointOutside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
getMinDistance(point: Vector3, target?: Array): number;
computePointDistance(pt: Vector3): number;
getPlane(): PlaneSurface;
}
}
declare module "foundation/runtime/geometry/curve3d/StraightCurve3d" {
import { Box3 } from 'foundation/runtime/math/Box3';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { StraightCurve2d } from "foundation/runtime/geometry/curve2d/StraightCurve2d";
import { Curve3d, SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { LineCurve3d } from "foundation/runtime/geometry/curve3d/LineCurve3d";
export class StraightCurve3d extends SingleCurve3d {
origin: Vector3;
direction: Vector3;
constructor(origin?: Vector3, direction?: Vector3);
reset(): void;
t2u(t: number): number;
u2t(u: number): number;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4, tolerance?: number, lerpTolerance?: number): Vector2;
solveParameticEquation(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationFirstDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationFirstDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationSecondDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationSecondDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
applyMatrix4(matrix: Matrix4): StraightCurve3d;
getReverseClone(): StraightCurve3d;
clone(): StraightCurve3d;
getoriginPoint(): Vector3;
getdirectionPoint(): Vector3;
getLength(): number;
to2d(): StraightCurve2d;
singleSettingOut(p: Vector3, normal: Vector3): StraightCurve3d;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): Curve3d;
cutu(begin: number, end: number, tolerance?: number): LineCurve3d;
getLerpTangent(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
isBrep(): boolean;
getStraight(): StraightCurve3d;
isPointInside(point: Vector3, tolerance?: number): boolean;
computeEnclosingBBox(tStart: number, tEnd: number, ptStart?: Vector3, ptEnd?: Vector3): Box3;
getMinDistance(point: Vector3, target?: Array): number;
computePointDistance(pt: Vector3): number;
}
}
declare module "foundation/runtime/geometry/curve3d/PathCurve3d" {
import { Box3 } from 'foundation/runtime/math/Box3';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PathCurve2d } from "foundation/runtime/geometry/curve2d/PathCurve2d";
import { Curve2d } from "foundation/runtime/geometry/Curve2d";
import { ComplexCurve3d, Curve3d, SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
export class PathCurve3d extends ComplexCurve3d {
static CLASS_NAME: string;
isClosed: boolean;
constructor(curves?: Array, isClosed?: boolean);
reset(): void;
getReverseClone(): PathCurve3d;
applyMatrix4(matrix: Matrix4): PathCurve3d;
clone(): PathCurve3d;
getBeginPoint(): Vector3;
getEndPoint(): Vector3;
getBeginTangent(): Vector3;
getEndTangent(): Vector3;
getLength(tolerance?: number): number;
getKeyPoints(): Array;
getLerpPoint(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
getLerpTangent(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
getTangentP(point: Vector3, tolerance?: number, lerpTolerance?: number): Vector3;
getLerps(tolerance?: number): Array;
to2d(): PathCurve2d;
projective(): Array;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): Curve3d;
cutt(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve3d;
cutu(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve3d;
extend(begin: Vector3, end: Vector3, tolerance?: number): Curve3d;
singleSettingOut(p: Vector3 | Array, normal: Vector3, isRigidBody?: boolean, isImaginary?: boolean, tolerance?: number, indexs?: Array): PathCurve3d;
montage(curves: Array, isRigidBody?: boolean, isImaginary?: boolean, indexs?: Array, tolerance?: number): PathCurve3d;
lineRelink(t?: number, lines?: Array, isAdd?: boolean, isLinkLine?: boolean, isLinkArc?: boolean, isLinkEillipArc?: boolean): PathCurve3d;
lineClose(t?: number): PathCurve3d;
computeLineClose(t?: number): boolean;
getBox(step?: number, tolerance?: number): Box3;
equals(g: PathCurve3d): boolean;
nearlyEquals(g: PathCurve3d, tolerance?: number): boolean;
isInvalid(tolerance?: number): boolean;
getCurves(): Array;
toBrep(): Array;
}
}
declare module "foundation/runtime/geometry/curve2d/PolylineCurve2d" {
import { Box2 } from 'foundation/runtime/math/Box2';
import { Box3 } from 'foundation/runtime/math/Box3';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PolylineCurve3d } from "foundation/runtime/geometry/curve3d/PolylineCurve3d";
import { PlaneSurface } from "foundation/runtime/geometry/surface/PlaneSurface";
import { ComplexCurve2d, Curve2d, SingleCurve2d } from "foundation/runtime/geometry/Curve2d";
import { PathCurve2d } from "foundation/runtime/geometry/curve2d/PathCurve2d";
export class PolylineCurve2d extends ComplexCurve2d {
points: Array;
constructor(points?: Array);
reset(): void;
applyMatrix4(matrix: Matrix4): PolylineCurve2d;
clone(): PolylineCurve2d;
getReverseClone(): PolylineCurve2d;
from3d(g: PolylineCurve3d): void;
to3d(): PolylineCurve3d;
private copy;
getBeginPoint(): Vector3;
getEndPoint(): Vector3;
getBeginTangent(): Vector3;
getEndTangent(): Vector3;
getLength(tolerance?: number): number;
getKeyPoints(): Array;
toPath(): PathCurve2d;
fromPath(path: PathCurve2d): void;
getCurves(): Array;
lineRelink(tolerance?: number): PolylineCurve2d;
getLerpPoint(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
getLerpT(point: Vector3, tolerance?: number, lerpTolerance?: number): number;
getLerpTangent(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): Curve2d;
cutt(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve2d;
cutu(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve2d;
extend(begin: Vector3, end: Vector3, tolerance?: number): Curve2d;
singleSettingOut(p: Vector3): PolylineCurve2d;
getBox(step?: number, tolerance?: number): Box3;
equals(g: PolylineCurve2d): boolean;
nearlyEquals(g: PolylineCurve2d, tolerance?: number): boolean;
getPlane(): PlaneSurface;
toBrep(): Array;
computeEnclosingBBox(tStart: number, tEnd: number, ptStart?: Vector3, ptEnd?: Vector3): Box2;
}
}
declare module "foundation/runtime/geometry/curve3d/PolylineCurve3d" {
import { Box3 } from 'foundation/runtime/math/Box3';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PolylineCurve2d } from "foundation/runtime/geometry/curve2d/PolylineCurve2d";
import { ComplexCurve3d, Curve3d, SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { PathCurve3d } from "foundation/runtime/geometry/curve3d/PathCurve3d";
export class PolylineCurve3d extends ComplexCurve3d {
points: Array;
constructor(points?: Array);
reset(): void;
applyMatrix4(matrix: Matrix4): PolylineCurve3d;
clone(): PolylineCurve3d;
getReverseClone(): PolylineCurve3d;
getBeginPoint(): Vector3;
getEndPoint(): Vector3;
getBeginTangent(): Vector3;
getEndTangent(): Vector3;
getLength(tolerance?: number): number;
getKeyPoints(): Array;
toPath(): PathCurve3d;
fromPath(path: PathCurve3d): void;
getCurves(): Array;
lineRelink(tolerance?: number): PolylineCurve3d;
getLerpPoint(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
getLerpT(point: Vector3, tolerance?: number, lerpTolerance?: number): number;
getLerpTangent(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
to2d(): PolylineCurve2d;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): Curve3d;
cutt(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve3d;
cutu(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve3d;
extend(begin: Vector3, end: Vector3, tolerance?: number): Curve3d;
singleSettingOut(p: Vector3, normal: Vector3): PolylineCurve3d;
getBox(step?: number, tolerance?: number): Box3;
equals(g: PolylineCurve3d): boolean;
nearlyEquals(g: PolylineCurve3d, tolerance?: number): boolean;
toBrep(): Array;
}
}
declare module "foundation/runtime/geometry/curve3d/PolygonCurve3d" {
import { Box3 } from 'foundation/runtime/math/Box3';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PolygonCurve2d } from "foundation/runtime/geometry/curve2d/PolygonCurve2d";
import { Curve3d, ComplexCurve3d, SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { PathCurve3d } from "foundation/runtime/geometry/curve3d/PathCurve3d";
import { PolylineCurve3d } from "foundation/runtime/geometry/curve3d/PolylineCurve3d";
export class PolygonCurve3d extends ComplexCurve3d {
points: Array;
constructor(points?: Array);
reset(): void;
orthogonal(tolerance?: number): PolygonCurve3d;
applyMatrix4(matrix: Matrix4): PolygonCurve3d;
clone(): PolygonCurve3d;
getReverseClone(): PolygonCurve3d;
getBeginPoint(): Vector3;
getEndPoint(): Vector3;
getBeginTangent(): Vector3;
getEndTangent(): Vector3;
getLength(_tolerance?: number): number;
getKeyPoints(): Array;
toPath(): PathCurve3d;
fromPath(path: PathCurve3d): void;
getCurves(): Array;
lineRelink(tolerance?: number): PolygonCurve3d;
getLerpPoint(t: number, tolerance?: number): Vector3;
getLerpT(point: Vector3, tolerance?: number, lerpTolerance?: number): number;
getLerpTangent(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
to2d(): PolygonCurve2d;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): Curve3d;
cutt(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve3d;
cutu(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve3d;
extend(begin: Vector3, end: Vector3, tolerance?: number): PolylineCurve3d;
isRectangle(): boolean;
singleSettingOut(p: Vector3, normal: Vector3): PolygonCurve3d;
getBox(step?: number, tolerance?: number): Box3;
isOutLinePositive(): boolean;
toPositive(): void;
toNegPositive(): void;
equals(g: PolygonCurve3d): boolean;
nearlyEquals(g: PolygonCurve3d, tolerance?: number): boolean;
toBrep(): Array;
}
}
declare module "foundation/runtime/geometry/curve2d/PolygonCurve2d" {
import { Box2 } from 'foundation/runtime/math/Box2';
import { Box3 } from 'foundation/runtime/math/Box3';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PolygonCurve3d } from "foundation/runtime/geometry/curve3d/PolygonCurve3d";
import { PlaneSurface } from "foundation/runtime/geometry/surface/PlaneSurface";
import { Curve2d, ComplexCurve2d, SingleCurve2d } from "foundation/runtime/geometry/Curve2d";
import { PathCurve2d } from "foundation/runtime/geometry/curve2d/PathCurve2d";
import { PolylineCurve2d } from "foundation/runtime/geometry/curve2d/PolylineCurve2d";
export class PolygonCurve2d extends ComplexCurve2d {
points: Array;
constructor(points?: Array);
reset(): void;
orthogonal(tolerance?: number): PolygonCurve2d;
applyMatrix4(matrix: Matrix4): PolygonCurve2d;
clone(): PolygonCurve2d;
getReverseClone(): PolygonCurve2d;
from3d(g: PolygonCurve3d): void;
from2dPoints(points: Array): void;
to3d(): PolygonCurve3d;
private copy;
getBeginPoint(): Vector3;
getEndPoint(): Vector3;
getBeginTangent(): Vector3;
getEndTangent(): Vector3;
getLength(tolerance?: number): number;
getKeyPoints(): Array;
toPath(): PathCurve2d;
fromPath(path: PathCurve2d): void;
getCurves(): Array;
lineRelink(tolerance?: number): PolygonCurve2d;
getLerpPoint(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
getLerpT(point: Vector3, tolerance?: number, lerpTolerance?: number): number;
getLerpTangent(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): Curve2d;
cutt(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve2d;
cutu(begin: number, end: number, tolerance?: number, lerpTolerance?: number): Curve2d;
isOutLinePositive(): boolean;
toPositive(): void;
toNegPositive(): void;
extend(begin: Vector3, end: Vector3, tolerance?: number): PolylineCurve2d;
getConvexPolygon(tolerance?: number): PolygonCurve2d;
isRectangle(): boolean;
singleSettingOut(p: Vector3): PolygonCurve2d;
getBox(step?: number, tolerance?: number): Box3;
equals(g: PolygonCurve2d): boolean;
nearlyEquals(g: PolygonCurve2d, tolerance?: number): boolean;
getPlane(): PlaneSurface;
toBrep(): Array;
computeEnclosingBBox(tStart: number, tEnd: number, ptStart?: Vector3, ptEnd?: Vector3): Box2;
}
}
declare module "foundation/runtime/geometry/PointRelation" {
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PointRelationEnum } from "foundation/runtime/geometry/PointRelationEnum";
export class PointRelation {
p: Vector3;
i1: PointRelationEnum;
i2: PointRelationEnum;
constructor(p?: Vector3, i1?: PointRelationEnum, i2?: PointRelationEnum);
}
}
declare module "foundation/runtime/geometry/Solid" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { BrepBodyOperation } from 'foundation/runtime/math/Operator';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { Geometric } from "foundation/runtime/geometry/Geometric";
import { SingleSurface } from "foundation/runtime/geometry/Surface";
export class Solid extends Geometric {
reset(): void;
getVolume(tolerance?: number): number;
clone(): Solid;
fitting(...args: any[]): Solid;
getLerpT(...args: any[]): Vector3;
viewOutline(world?: Matrix4, proj?: Matrix4): Array;
outline(): Array;
getCurves(): Array;
getPoints(): Array;
getFaces(): Array;
toBrepBody(data?: any, op?: BrepBodyOperation): any;
}
export class SingleSolid extends Solid {
}
export class ArcSolid extends SingleSolid {
center: Vector3;
begin: Vector3;
normal: Vector3;
constructor(center?: Vector3, begin?: Vector3, normal?: Vector3);
reset(): void;
get radius(): number;
set radius(radius: number);
getMajorAxis(): Vector3;
getMinorAxis(): Vector3;
getLocalMatrix(): Matrix4;
applyMatrix4(matrix: Matrix4): Solid;
}
export class ComplexSolid extends Solid {
}
}
declare module "foundation/runtime/geometry/relation/CurveRelationUtil" {
import { BooleanOperation } from 'foundation/runtime/math/Operator';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { Curve } from "foundation/runtime/geometry/Geometric";
export class CurveRelationUtil {
static boolean(a: Curve | Array, b: Curve | Array, op: BooleanOperation): Array;
static intersect(a: Curve, b: Curve, op: BooleanOperation): Array;
static union(a: Curve, b: Curve, op: BooleanOperation): Array;
static subtract(a: Curve, b: Curve, op: BooleanOperation): Array;
static isPointInCurve(p: Vector3, c: Curve, tolerance?: number): boolean;
static isPointOnCurve(p: Vector3, c: Curve, tolerance?: number): boolean;
static isPointOutCurve(p: Vector3, c: Curve, tolerance?: number): boolean;
}
}
declare module "foundation/runtime/geometry/curve2d/RayCurve2d" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { RayCurve3d } from "foundation/runtime/geometry/curve3d/RayCurve3d";
import { PlaneSurface } from "foundation/runtime/geometry/surface/PlaneSurface";
import { SingleCurve2d } from "foundation/runtime/geometry/Curve2d";
import { LineCurve2d } from "foundation/runtime/geometry/curve2d/LineCurve2d";
import { StraightCurve2d } from "foundation/runtime/geometry/curve2d/StraightCurve2d";
export class RayCurve2d extends SingleCurve2d {
origin: Vector3;
direction: Vector3;
constructor(origin?: Vector3, direction?: Vector3);
reset(): void;
t2u(t: number): number;
u2t(u: number): number;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
solveParameticEquation(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationFirstDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationFirstDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationSecondDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationSecondDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
applyMatrix4(matrix: Matrix4): RayCurve2d;
getReverseClone(): RayCurve2d;
clone(): RayCurve2d;
getoriginPoint(): Vector3;
getdirectionPoint(): Vector3;
getLength(): number;
from3d(g: RayCurve3d): void;
getLerpTangent(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
isBrep(): boolean;
getStraightLine(): Vector3;
getStraight(): StraightCurve2d;
isPointInside(point: Vector3, tolerance?: number): boolean;
isPointOutside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
getMinDistance(point: Vector3, target?: Array): number;
getPlane(): PlaneSurface;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): LineCurve2d;
cutu(begin: number, end: number, tolerance?: number, lerpTolerance?: number): LineCurve2d;
}
}
declare module "foundation/runtime/geometry/curve3d/RayCurve3d" {
import { Box3 } from 'foundation/runtime/math/Box3';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { RayCurve2d } from "foundation/runtime/geometry/curve2d/RayCurve2d";
import { SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { LineCurve3d } from "foundation/runtime/geometry/curve3d/LineCurve3d";
import { StraightCurve3d } from "foundation/runtime/geometry/curve3d/StraightCurve3d";
export class RayCurve3d extends SingleCurve3d {
origin: Vector3;
direction: Vector3;
constructor(origin?: Vector3, direction?: Vector3);
reset(): void;
t2u(t: number): number;
u2t(u: number): number;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4, tolerance?: number, lerpTolerance?: number): Vector2;
solveParameticEquation(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationFirstDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationFirstDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
solveParameticEquationSecondDerivative(u: number, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationSecondDerivativeInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): number;
applyMatrix4(matrix: Matrix4): RayCurve3d;
getReverseClone(): RayCurve3d;
clone(): RayCurve3d;
getoriginPoint(): Vector3;
getdirectionPoint(): Vector3;
getLength(): number;
to2d(): RayCurve2d;
cut(begin: Vector3, end: Vector3, tolerance?: number, lerpTolerance?: number): LineCurve3d;
cutu(begin: number, end: number, tolerance?: number): LineCurve3d;
singleSettingOut(p: Vector3, normal: Vector3): RayCurve3d;
getLerpTangent(t: number, tolerance?: number, lerpTolerance?: number): Vector3;
isBrep(): boolean;
getStraight(): StraightCurve3d;
computeEnclosingBBox(tStart: number, tEnd: number, ptStart?: Vector3, ptEnd?: Vector3): Box3;
}
}
declare module "foundation/runtime/geometry/Complex3dSurface" {
import { ComplexSurface, Single3dSurface } from "foundation/runtime/geometry/Surface";
export class Complex3dSurface extends ComplexSurface {
surface: Single3dSurface;
}
}
declare module "foundation/runtime/geometry/Complex2dSurface" {
import { Complex3dSurface } from "foundation/runtime/geometry/Complex3dSurface";
import { ComplexSurface, Single2dSurface } from "foundation/runtime/geometry/Surface";
export class Complex2dSurface extends ComplexSurface {
surface: Single2dSurface;
to3d(): Complex3dSurface;
}
}
declare module "foundation/runtime/geometry/surface/Section3dSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PathCurve3d } from "foundation/runtime/geometry/curve3d/PathCurve3d";
import { Curve3d, SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { FirstOrderSurface } from "foundation/runtime/geometry/Surface";
import { PlaneSurface } from "foundation/runtime/geometry/surface/PlaneSurface";
import { SectionSurface } from "foundation/runtime/geometry/surface/SectionSurface";
export class Section3dSurface extends FirstOrderSurface {
curves: Array;
constructor(curves?: Array, normal?: Vector3);
get isClosed(): boolean;
getLerpPoint(u: number, v: number, tolerance?: number): Vector3;
getLocalMatrix(): Matrix4;
reset(): void;
applyMatrix4(matrix: Matrix4): any;
clone(): Section3dSurface;
getKeyPoints(): Array;
getKeyTangents(): Array;
getKeys(isPassSmooth?: boolean): Array;
outline(): Array;
isOutLinePositive(): boolean;
toPositive(): void;
toNegPositive(): void;
getPath(): PathCurve3d;
getSectionSurface(): SectionSurface;
fromSectionSurface(section: SectionSurface): void;
to2d(): SectionSurface;
isRectangle(): boolean;
isZero(): boolean;
getExtreme(v: Vector3): Array;
getPlane(): PlaneSurface;
isPointOutside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
toIntact(): PlaneSurface;
getCurves(): Array;
}
}
declare module "foundation/runtime/geometry/surface/SectionSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PathCurve2d } from "foundation/runtime/geometry/curve2d/PathCurve2d";
import { Curve2d, SingleCurve2d } from "foundation/runtime/geometry/Curve2d";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { Single2dSurface } from "foundation/runtime/geometry/Surface";
import { PlaneSurface } from "foundation/runtime/geometry/surface/PlaneSurface";
import { Section3dSurface } from "foundation/runtime/geometry/surface/Section3dSurface";
export class SectionSurface extends Single2dSurface {
curves: Array;
constructor(curves?: Array);
get isClosed(): boolean;
reset(): void;
applyMatrix4(matrix: Matrix4): SectionSurface;
getArea(tolerance?: number): number;
clone(): SectionSurface;
getKeyPoints(): Array;
getKeyTangents(): Array;
getKeys(isPassSmooth?: boolean): Array;
outline(): Array;
isOutLinePositive(): boolean;
toPositive(): void;
toNegPositive(): void;
getPath(): PathCurve2d;
isRectangle(): boolean;
isZero(): boolean;
getExtreme(v: Vector3): Array;
getPlane(): PlaneSurface;
getLocalMatrix(): Matrix4;
isPointOutside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
toIntact(): PlaneSurface;
getCurves(): Array;
toBrep(isPositive?: boolean): SectionSurface;
getSectionSurface(): SectionSurface;
to3d(): Section3dSurface;
}
}
declare module "foundation/runtime/geometry/surface/ComplexHoleSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { Complex2dSurface } from "foundation/runtime/geometry/Complex2dSurface";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { Single2dSurface, SingleSurface, Surface } from "foundation/runtime/geometry/Surface";
import { ComplexHole3dSurface } from "foundation/runtime/geometry/surface/ComplexHole3dSurface";
export class ComplexHoleSurface extends Complex2dSurface {
surface: Single2dSurface;
holes: Array;
constructor(surface?: Single2dSurface, holes?: Array);
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
reset(): void;
applyMatrix4(matrix: Matrix4): ComplexHoleSurface;
toPositive(): void;
toNegPositive(): void;
clone(): ComplexHoleSurface;
outline(): Array;
getLocalMatrix(): Matrix4;
getLerpPoint(u: number, v: number, tolerance?: number): Vector3;
getSurfaces(): Array;
isPointOutside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
to3d(): ComplexHole3dSurface;
equalsPlaneMatrix(g: Surface): boolean;
nearlyEqualsPlaneMatrix(g: Surface, tolerance?: number): boolean;
}
}
declare module "foundation/runtime/geometry/surface/ComplexHole3dSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PathCurve3d } from "foundation/runtime/geometry/curve3d/PathCurve3d";
import { Complex3dSurface } from "foundation/runtime/geometry/Complex3dSurface";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { FirstOrderSurface, SingleSurface, Surface } from "foundation/runtime/geometry/Surface";
import { ComplexHoleSurface } from "foundation/runtime/geometry/surface/ComplexHoleSurface";
export class ComplexHole3dSurface extends Complex3dSurface {
surface: FirstOrderSurface;
holes: Array;
constructor(surface?: FirstOrderSurface, holes?: Array);
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
getPointNormal(ponit: Vector3, tolerance?: number): Vector3;
reset(): void;
applyMatrix4(matrix: Matrix4): ComplexHole3dSurface;
toPositive(): void;
toNegPositive(): void;
clone(): ComplexHole3dSurface;
outline(): Array;
getLocalMatrix(): Matrix4;
getLerpPoint(u: number, v: number, tolerance?: number): Vector3;
getSurfaces(): Array;
isPointOutside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
to2d(): ComplexHoleSurface;
getPaths(): Array;
equalsPlaneMatrix(g: Surface): boolean;
nearlyEqualsPlaneMatrix(g: Surface, tolerance?: number): boolean;
}
}
declare module "foundation/runtime/geometry/surface/PortionSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PathCurve3d } from "foundation/runtime/geometry/curve3d/PathCurve3d";
import { Complex3dSurface } from "foundation/runtime/geometry/Complex3dSurface";
import { Curve3d, SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { SingleSurface, Surface } from "foundation/runtime/geometry/Surface";
export class PortionSurface extends Complex3dSurface {
surface: SingleSurface;
curves: Array;
holes: Array>;
constructor(surface?: SingleSurface, curves?: Array, holes?: Array>);
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
getParameticEquationVCurve(u: number, local?: Matrix4, localInvert?: Matrix4): Curve3d;
getParameticEquationUCurve(v: number, local?: Matrix4, localInvert?: Matrix4): Curve3d;
getPointNormal(ponit: Vector3, tolerance?: number): Vector3;
getLerpPoint(u: number, v: number, tolerance?: number): Vector3;
getLocalMatrix(): Matrix4;
reset(): void;
applyMatrix4(matrix: Matrix4): PortionSurface;
clone(): PortionSurface;
outline(): Array;
viewOutline(world?: Matrix4, proj?: Matrix4): Array;
getPath(): PathCurve3d;
isPointOutside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
equalsPlaneMatrix(g: Surface): boolean;
nearlyEqualsPlaneMatrix(g: Surface, tolerance?: number): boolean;
}
}
declare module "foundation/runtime/geometry/surface/SliceSurface" {
import { Box3 } from 'foundation/runtime/math/Box3';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { UVBlock } from "foundation/runtime/geometry/relation/UVBlock";
import { SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { Single3dSurface, Surface } from "foundation/runtime/geometry/Surface";
export class SliceSurface extends Single3dSurface {
surface: Single3dSurface;
uLoop: boolean;
uMin: number;
uMax: number;
vLoop: boolean;
vMin: number;
vMax: number;
constructor(surface?: Single3dSurface, uLoop?: boolean, uMin?: number, uMax?: number, vLoop?: boolean, vMin?: number, vMax?: number);
tu2u(tu: number): number;
u2tu(u: number): number;
tv2v(tv: number): number;
v2tv(v: number): number;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
getParameticEquationVCurve(u: number, local?: Matrix4, localInvert?: Matrix4): any;
getParameticEquationUCurve(v: number, local?: Matrix4, localInvert?: Matrix4): any;
getLocalMatrix(): Matrix4;
getLerpNormal(u: number, v: number, tolerance?: number): Vector3;
getPointNormal(ponit: Vector3, tolerance?: number): Vector3;
getLerpPoint(u: number, v: number, tolerance?: number): Vector3;
applyMatrix4(matrix: Matrix4): SliceSurface;
clone(): SliceSurface;
outline(): Array;
viewOutline(world?: Matrix4, proj?: Matrix4): Array;
computeEnclosingBBox(tu0: number, tu1: number, tv0: number, tv1: number, ptuv00?: Vector3, ptuv10?: Vector3, ptuv01?: Vector3, ptuv11?: Vector3, localMatrix?: Matrix4, invertMatrix?: Matrix4): Box3;
computeUVNeighborBlocks(u: number, v: number, level: number, tolerance?: number): Array;
isPointOutside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
equalsPlaneMatrix(g: Surface): boolean;
nearlyEqualsPlaneMatrix(g: Surface, tolerance?: number): boolean;
}
}
declare module "foundation/runtime/geometry/solid/SphereSolid" {
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { ArcSolid } from "foundation/runtime/geometry/Solid";
export class SphereSolid extends ArcSolid {
clone(): SphereSolid;
outline(): Array;
}
}
declare module "foundation/runtime/geometry/surface/SphereSurface" {
import { Box3 } from 'foundation/runtime/math/Box3';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { UVBlock } from "foundation/runtime/geometry/relation/UVBlock";
import { SphereSolid } from "foundation/runtime/geometry/solid/SphereSolid";
import { Curve3d, SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { ArcSurface } from "foundation/runtime/geometry/Surface";
export class SphereSurface extends ArcSurface {
tu2u(tu: number): number;
u2tu(u: number): number;
tv2v(tv: number): number;
v2tv(v: number): number;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
solveParameticEquationSecondDerivative(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
getParameticEquationVCurve(u: number): Curve3d;
getParameticEquationUCurve(v: number): Curve3d;
getParameticEquationVTangent(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
getParameticEquationUMaxVCurve(): Curve3d;
getParameticEquationVMinUCurve(): Curve3d;
getParameticEquationVMaxUCurve(): Curve3d;
getArea(tolerance?: number): number;
clone(): SphereSurface;
toSolid(): SphereSolid;
private copy;
outline(): Array;
viewOutline(world?: Matrix4, proj?: Matrix4): Array;
getLerpPoint(u: number, v: number, tolerance?: number): Vector3;
isPointOutside(point: Vector3, tolerance?: number): boolean;
computeEnclosingBBox(tu0: number, tu1: number, tv0: number, tv1: number, ptuv00?: Vector3, ptuv10?: Vector3, ptuv01?: Vector3, ptuv11?: Vector3, localMatrix?: Matrix4, invertMatrix?: Matrix4): Box3;
computeUVNeighborBlocks(u: number, v: number, level: number, tolerance?: number): Array;
}
}
declare module "foundation/runtime/geometry/solid/RoundTableSolid" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { ArcSolid } from "foundation/runtime/geometry/Solid";
export class RoundTableSolid extends ArcSolid {
radiusTop: number;
height: number;
constructor(center?: Vector3, begin?: Vector3, normal?: Vector3, radiusTop?: number, height?: number);
reset(): void;
get radiusBottom(): number;
clone(): RoundTableSolid;
viewOutline(world?: Matrix4, proj?: Matrix4): Array;
outline(): Array;
}
}
declare module "foundation/runtime/geometry/solid/ConeSolid" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { ArcSolid } from "foundation/runtime/geometry/Solid";
export class ConeSolid extends ArcSolid {
height: number;
constructor(center?: Vector3, begin?: Vector3, normal?: Vector3, height?: number);
reset(): void;
clone(): ConeSolid;
viewOutline(world?: Matrix4, proj?: Matrix4): Array;
outline(): Array;
}
}
declare module "foundation/runtime/geometry/surface/ConeSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { ConeSolid } from "foundation/runtime/geometry/solid/ConeSolid";
import { Curve3d, SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { ArcSurface, Surface } from "foundation/runtime/geometry/Surface";
export class ConeSurface extends ArcSurface {
height: number;
constructor(center?: Vector3, begin?: Vector3, normal?: Vector3, height?: number);
tu2u(tu: number): number;
u2tu(u: number): number;
tv2v(tv: number): number;
v2tv(v: number): number;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
solveParameticEquationSecondDerivative(uv: Vector2, local?: Matrix4): Vector3;
getParameticEquationVCurve(u: number, local?: Matrix4, localInvert?: Matrix4): Curve3d;
getParameticEquationUCurve(v: number, local?: Matrix4, localInvert?: Matrix4): Curve3d;
getParameticEquationUMaxVCurve(local?: Matrix4, localInvert?: Matrix4): Curve3d;
getParameticEquationVMaxUCurve(local?: Matrix4, localInvert?: Matrix4): Curve3d;
reset(): void;
get cone(): number;
clone(): ConeSurface;
toSolid(): ConeSolid;
private copy;
outline(): Array;
viewOutline(world?: Matrix4, proj?: Matrix4): Array;
equalsPartOverlap(g: Surface): boolean;
nearlyEqualsPartOverlap(g: Surface, tolerance?: number): boolean;
equalsForm(g: Surface): boolean;
nearlyEqualsForm(g: Surface, tolerance?: number): boolean;
equalsCoincide(g: Surface): boolean;
nearlyEqualsCoincide(g: Surface, tolerance?: number): boolean;
equals(g: Surface): boolean;
nearlyEquals(g: Surface, tolerance?: number): boolean;
}
}
declare module "foundation/runtime/geometry/surface/RoundTableSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { RoundTableSolid } from "foundation/runtime/geometry/solid/RoundTableSolid";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { ArcSurface, Surface } from "foundation/runtime/geometry/Surface";
export class RoundTableSurface extends ArcSurface {
radiusTop: number;
height: number;
constructor(center?: Vector3, begin?: Vector3, normal?: Vector3, radiusTop?: number, height?: number);
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
solveParameticEquationSecondDerivative(param: Vector2): Vector3;
getParameticEquationVCurve(u: number, local?: Matrix4, localInvert?: Matrix4): Curve3d;
getParameticEquationUCurve(v: number, local?: Matrix4, localInvert?: Matrix4): Curve3d;
reset(): void;
get radiusBottom(): number;
get cone(): number;
clone(): RoundTableSurface;
toSolid(): RoundTableSolid;
private copy;
outline(): Array;
equalsPartOverlap(g: Surface): boolean;
nearlyEqualsPartOverlap(g: Surface, tolerance?: number): boolean;
equalsForm(g: Surface): boolean;
nearlyEqualsForm(g: Surface, tolerance?: number): boolean;
equalsCoincide(g: Surface): boolean;
nearlyEqualsCoincide(g: Surface, tolerance?: number): boolean;
equals(g: Surface): boolean;
nearlyEquals(g: Surface, tolerance?: number): boolean;
}
}
declare module "foundation/runtime/geometry/surface/EllipticCylinderSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { ArcSurface, Surface } from "foundation/runtime/geometry/Surface";
export class EllipticCylinderSurface extends ArcSurface {
height: number;
axisRatio: number;
constructor(center?: Vector3, begin?: Vector3, normal?: Vector3, axisRatio?: number, height?: number);
get end(): Vector3;
solveImplicitEquation(v: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
solveParameticEquationSecondDerivative(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
getParameticEquationVCurve(u: number): Curve3d;
getParameticEquationUCurve(v: number): Curve3d;
getParameticEquationUMaxVCurve(): Curve3d;
getParameticEquationVMaxUCurve(): Curve3d;
reset(): void;
clone(): EllipticCylinderSurface;
private copy;
getLerpPoint(u: number, v: number, tolerance?: number): Vector3;
getLerpNormal(u: number, v: number, tolerance?: number): Vector3;
outline(): Array;
equalsPartOverlap(g: Surface): boolean;
nearlyEqualsPartOverlap(g: Surface, tolerance?: number): boolean;
equalsForm(g: Surface): boolean;
nearlyEqualsForm(g: Surface, tolerance?: number): boolean;
equalsCoincide(g: Surface): boolean;
nearlyEqualsCoincide(g: Surface, tolerance?: number): boolean;
equals(g: Surface): boolean;
nearlyEquals(g: Surface, tolerance?: number): boolean;
}
}
declare module "foundation/runtime/geometry/surface/PolygonSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { CircleCurve2d } from "foundation/runtime/geometry/curve2d/CircleCurve2d";
import { PathCurve2d } from "foundation/runtime/geometry/curve2d/PathCurve2d";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { Single2dSurface } from "foundation/runtime/geometry/Surface";
import { PlaneSurface } from "foundation/runtime/geometry/surface/PlaneSurface";
import { SectionSurface } from "foundation/runtime/geometry/surface/SectionSurface";
export class PolygonSurface extends Single2dSurface {
points: Array;
constructor(points?: Array);
reset(): void;
applyMatrix4(matrix: Matrix4): PolygonSurface;
clone(): PolygonSurface;
getLocalMatrix(): Matrix4;
isOutLinePositive(): boolean;
toPositive(): void;
toNegPositive(): void;
getSectionSurface(): SectionSurface;
getPath(): PathCurve2d;
outline(): Array;
getPlane(): PlaneSurface;
toIntact(): PlaneSurface;
isPointOutside(point: Vector3, tolerance?: number): boolean;
getMaxInnerCircle(): CircleCurve2d;
toBrep(isPositive?: boolean): SectionSurface;
}
}
declare module "foundation/runtime/geometry/solid/StretchingSolid" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { BrepBody } from "foundation/runtime/geometry/brep/BrepBody";
import { ComplexHoleSurface } from "foundation/runtime/geometry/surface/ComplexHoleSurface";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { SingleSolid } from "foundation/runtime/geometry/Solid";
export class StretchingSolid extends SingleSolid {
static TOP: string;
static BOTTOM: string;
static SIDE: string;
section: ComplexHoleSurface;
height: number;
constructor(section?: ComplexHoleSurface, height?: number);
reset(): void;
applyMatrix4(matrix: Matrix4): StretchingSolid;
clone(): StretchingSolid;
outline(): Array;
toBrepBody(data?: any): BrepBody;
getLocalMatrix(): Matrix4;
}
}
declare module "foundation/runtime/geometry/surface/StretchingSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { StretchingSolid } from "foundation/runtime/geometry/solid/StretchingSolid";
import { Curve2d } from "foundation/runtime/geometry/Curve2d";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { Single3dSurface, Surface } from "foundation/runtime/geometry/Surface";
import { Section3dSurface } from "foundation/runtime/geometry/surface/Section3dSurface";
export class StretchingSurface extends Single3dSurface {
section: Curve2d;
height: number;
constructor(section?: Curve2d, height?: number);
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
solveParameticEquationSecondDerivative(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
getParameticEquationVCurve(u: number, local?: Matrix4, localInvert?: Matrix4): Curve3d;
getParameticEquationUCurve(v: number, local?: Matrix4, localInvert?: Matrix4): Curve3d;
getParameticEquationUMaxVCurve(): Curve3d;
getParameticEquationVMaxUCurve(): Curve3d;
reset(): void;
applyMatrix4(matrix: Matrix4): StretchingSurface;
clone(): StretchingSurface;
toSolid(): StretchingSolid;
private copy;
outline(): Array;
get normal(): Vector3;
getLocalMatrix(): Matrix4;
equalsPlaneMatrix(g: Surface): boolean;
nearlyEqualsPlaneMatrix(g: Surface, tolerance?: number): boolean;
getSectionSurface(): Section3dSurface;
equalsPartOverlap(g: Surface): boolean;
nearlyEqualsPartOverlap(g: Surface, tolerance?: number): boolean;
equalsForm(g: Surface): boolean;
nearlyEqualsForm(g: Surface, tolerance?: number): boolean;
equalsCoincide(g: Surface): boolean;
nearlyEqualsCoincide(g: Surface, tolerance?: number): boolean;
equals(g: Surface): boolean;
nearlyEquals(g: Surface, tolerance?: number): boolean;
}
}
declare module "foundation/runtime/geometry/solid/Sweeping3dSolid" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PathCurve3d } from "foundation/runtime/geometry/curve3d/PathCurve3d";
import { SectionSurface } from "foundation/runtime/geometry/surface/SectionSurface";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { SingleSolid } from "foundation/runtime/geometry/Solid";
export class Sweeping3dSolid extends SingleSolid {
path: PathCurve3d;
section: SectionSurface;
beginNormal: Vector3;
isRigidBody: boolean;
corneRadius: number;
constructor(path?: PathCurve3d, section?: SectionSurface, beginNormal?: Vector3, isRigidBody?: boolean, corneRadius?: number);
reset(): void;
applyMatrix4(matrix: Matrix4): Sweeping3dSolid;
clone(): Sweeping3dSolid;
outline(): Array;
getLocalMatrix(): Matrix4;
}
}
declare module "foundation/runtime/geometry/surface/Sweeping3dSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PathCurve3d } from "foundation/runtime/geometry/curve3d/PathCurve3d";
import { Sweeping3dSolid } from "foundation/runtime/geometry/solid/Sweeping3dSolid";
import { Curve2d } from "foundation/runtime/geometry/Curve2d";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { Single3dSurface } from "foundation/runtime/geometry/Surface";
export class Sweeping3dSurface extends Single3dSurface {
path: PathCurve3d;
section: Curve2d;
beginNormal: Vector3;
isRigidBody: boolean;
corneRadius: number;
constructor(path?: PathCurve3d, section?: Curve2d, beginNormal?: Vector3, isRigidBody?: boolean, corneRadius?: number);
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
solveParameticEquationInverse0(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
solveParameticEquationInverse1(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
solveParameticEquationInverse2(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
private getDis;
getParameticEquationUTangent(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
getParameticEquationVTangent(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
reset(): void;
getParameticEquationVCurve(u: number, local?: Matrix4, localInvert?: Matrix4): Curve3d;
getParameticEquationUCurve(v: number, local?: Matrix4, localInvert?: Matrix4): Curve3d;
applyMatrix4(matrix: Matrix4): Sweeping3dSurface;
clone(): Sweeping3dSurface;
toSolid(): Sweeping3dSolid;
private copy;
outline(): Array;
getLocalMatrix(): Matrix4;
}
}
declare module "foundation/runtime/geometry/solid/Sweeping2dSolid" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { BrepBodyOperation } from 'foundation/runtime/math/Operator';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { BrepBody } from "foundation/runtime/geometry/brep/BrepBody";
import { PathCurve2d } from "foundation/runtime/geometry/curve2d/PathCurve2d";
import { SectionSurface } from "foundation/runtime/geometry/surface/SectionSurface";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { SingleSolid } from "foundation/runtime/geometry/Solid";
export class Sweeping2dSolid extends SingleSolid {
static TOP: string;
static BOTTOM: string;
static SIDE: string;
path: PathCurve2d;
section: SectionSurface;
beginNormal: Vector3;
isRigidBody: boolean;
corneRadius: number;
constructor(path?: PathCurve2d, section?: SectionSurface, beginNormal?: Vector3, isRigidBody?: boolean, corneRadius?: number);
reset(): void;
applyMatrix4(matrix: Matrix4): Sweeping2dSolid;
clone(): Sweeping2dSolid;
outline(): Array;
outlineOfPath(): Array;
private outline1;
getLocalMatrix(): Matrix4;
toBrepBody(data?: any, op?: BrepBodyOperation): BrepBody;
}
}
declare module "foundation/runtime/geometry/surface/Sweeping2dSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PathCurve2d } from "foundation/runtime/geometry/curve2d/PathCurve2d";
import { UVBlock } from "foundation/runtime/geometry/relation/UVBlock";
import { Sweeping2dSolid } from "foundation/runtime/geometry/solid/Sweeping2dSolid";
import { Curve2d } from "foundation/runtime/geometry/Curve2d";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { Single3dSurface } from "foundation/runtime/geometry/Surface";
export class Sweeping2dSurface extends Single3dSurface {
path: PathCurve2d;
section: Curve2d;
beginNormal: Vector3;
isRigidBody: boolean;
corneRadius: number;
constructor(path?: PathCurve2d, section?: Curve2d, beginNormal?: Vector3, isRigidBody?: boolean, corneRadius?: number);
reset(): void;
applyMatrix4(matrix: Matrix4): Sweeping2dSurface;
clone(): Sweeping2dSurface;
toSolid(): Sweeping2dSolid;
private copy;
outline(): Array;
getLocalMatrix(): Matrix4;
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
getParameticEquationVCurve(u: number, local?: Matrix4, localInvert?: Matrix4): Curve3d;
getParameticEquationUCurve(v: number, local?: Matrix4, localInvert?: Matrix4): Curve3d;
getParameticEquationUTangent(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
getParameticEquationVTangent(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
computeUVNeighborBlocks(u: number, v: number, level: number, tolerance?: number): Array;
}
}
declare module "foundation/runtime/geometry/relation/CurveSurfaceRelationUtil" {
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { CircleCurve3d } from "foundation/runtime/geometry/curve3d/CircleCurve3d";
import { StraightCurve3d } from "foundation/runtime/geometry/curve3d/StraightCurve3d";
import { CylinderSurface } from "foundation/runtime/geometry/surface/CylinderSurface";
import { PlaneSurface } from "foundation/runtime/geometry/surface/PlaneSurface";
import { SphereSurface } from "foundation/runtime/geometry/surface/SphereSurface";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { Curve } from "foundation/runtime/geometry/Geometric";
import { PointRelation } from "foundation/runtime/geometry/PointRelation";
import { QuadricSurface, SingleSurface, Surface } from "foundation/runtime/geometry/Surface";
export class CurveSurfaceRelationUtil {
static intersection(c: Curve, s: Surface, tolerance?: number, lerpTolerance?: number): Array;
static realIntersection(c: Curve, s: Surface, tolerance?: number, lerpTolerance?: number): Array;
static realIntersectionWithUV(c: Curve, s: Surface, tolerance?: number): Array<{
pt: Vector3;
t: number;
u: number;
v: number;
}>;
static imaginaryIntersection(c: Curve, s: Surface, tolerance?: number, lerpTolerance?: number): Array;
static curveXQuadricReal(c: Curve3d, s: QuadricSurface, tolerance?: number, lerpTolerance?: number): Array;
private static bin;
private static bin1;
static curveXImplicitEquation(c: Curve3d, s: SingleSurface, tolerance?: number, lerpTolerance?: number): Array;
static straight3dXPlaneReal(c: StraightCurve3d, s: PlaneSurface, tolerance?: number, lerpTolerance?: number): Array;
static circle3dXPlaneFull(c: CircleCurve3d, s: PlaneSurface, tolerance?: number): Array;
static straight3dXSphereFull(c: StraightCurve3d, s: SphereSurface, tolerance?: number): Array;
static straight3dXCylinderFull(c: StraightCurve3d, s: CylinderSurface, tolerance?: number): Array;
static circle3dXSphereFull(c: CircleCurve3d, s: SphereSurface, tolerance?: number): Array;
static circle3dXCylinderFull(c: CircleCurve3d, s: CylinderSurface, tolerance?: number): Array;
static filterDuplicatePts(pts: Array, tolerance?: number): Array;
static curveInSurface(c: Curve, s: Surface, tolerance?: number, lerpTolerance?: number): Array;
static isCurveOnSurfacePotentially(c: Curve, s: Surface, tolerance?: number, lerpTolerance?: number): boolean;
static isCircleCurveOnSphereSurface(c: CircleCurve3d, s: SphereSurface, tolerance?: number): boolean;
static computePointToStraightDistance(pt: Vector3, c: StraightCurve3d): number;
static planeCutCurve3ds(plane: PlaneSurface, curves: Array, tolerance?: number, lerpTolerance?: number): Array;
static realIntersectionTestUsingBBox(curve: Curve3d, surface: Surface, tolerance?: number, lerpTolerance?: number): Array<{
pt: Vector3;
t: number;
u: number;
v: number;
}>;
static computeMinDistanceSquared(quad: {
p00: Vector3;
p10: Vector3;
p01: Vector3;
p11: Vector3;
}, line: {
p0: Vector3;
p1: Vector3;
}): number;
static computeLineTriangleIntersection(triangle: {
p0: Vector3;
p1: Vector3;
p2: Vector3;
}, line: {
p0: Vector3;
p1: Vector3;
}): {
intersected: boolean;
};
static computeMinDistanceSquaredOfPoints(ptArray111: Array, ptArray222: Array): number;
}
}
declare module "foundation/runtime/geometry/brep/BrepBody" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { Single3dSurface, Surface } from "foundation/runtime/geometry/Surface";
import { Brep, BrepLump, BrepVertice, BrepCoedge, BrepEdge, BrepFace, BrepShell, BrepLoop } from "foundation/runtime/geometry/brep/Brep";
export class BrepBody implements Brep {
private static _bodyId;
lumps: Array;
id: string;
data: any;
private _verticeId;
private _edgeId;
private _coedgeId;
private _loopId;
private _faceId;
private _shellId;
private _lumpId;
constructor(data?: any);
isValid(): boolean;
applyMatrix4(matrix: Matrix4): BrepBody;
clone(): BrepBody;
dispose(): void;
nearlyEquals(value: BrepBody, tolerance?: number): boolean;
isMyPoint(v: Vector3, tolerance?: number): boolean;
isMyCurve(c: SingleCurve3d, tolerance?: number): boolean;
isMySingle3dSurface(s: Single3dSurface, tolerance?: number): boolean;
getVerticeByPoint(v: Vector3, tolerance?: number): BrepVertice;
getCoedgeByCurve(c: SingleCurve3d, tolerance?: number): BrepCoedge;
getEdgeByCurve(c: SingleCurve3d, tolerance?: number): BrepEdge;
getFaceBySingle3dSurface(s: Single3dSurface, tolerance?: number): BrepFace;
getCoedgeByPoint(v: Vector3, tolerance?: number): BrepCoedge;
getEdgeByPoint(v: Vector3, tolerance?: number): BrepEdge;
addLump(lu: BrepLump): void;
addLumps(lus: Array): void;
removedLump(lu: BrepLump): void;
getVerticeId(): string;
getEdgeId(): string;
getCoedgeId(): string;
getLoopId(): string;
getFaceId(): string;
getShellId(): string;
getLumpId(): string;
static getBodyId(): string;
getLumps(): Array;
getShells(): Array;
getFaces(): Array;
getFaceCount(): number;
getFaceByName(name: string): BrepFace;
getFaceByDataAndName(data: any, name: string): BrepFace;
getFacesByDataAndName(data: any, name: string): Array;
getFacesByData(data: any): Array;
getEdges(): Array;
getVertices(): Array;
getLoops(): Array;
getCoedges(): Array;
isPointInside(point: Vector3, tolerance?: number): boolean;
isPointOutside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
getSeriesRegion(f: BrepFace, fs: Array, orders: Array, dones: Array): Array;
getAllSeriesRegion(orders: Array): Array>;
getAllSurface(): Array;
getAllSeriesSurface(tolerance?: number, isDigraph?: boolean): Array<{
surface: Surface;
faces: Array;
}>;
}
}
declare module "foundation/runtime/geometry/solid/BoxSolid" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Plane } from 'foundation/runtime/math/Plane';
import { Value3 } from 'foundation/runtime/math/Value3';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { BrepBody } from "foundation/runtime/geometry/brep/BrepBody";
import { LineCurve3d } from "foundation/runtime/geometry/curve3d/LineCurve3d";
import { SphereSurface } from "foundation/runtime/geometry/surface/SphereSurface";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { SingleSolid } from "foundation/runtime/geometry/Solid";
import { SingleSurface } from "foundation/runtime/geometry/Surface";
import { SphereSolid } from "foundation/runtime/geometry/solid/SphereSolid";
export class BoxSolid extends SingleSolid {
static PX: string;
static PY: string;
static PZ: string;
static NX: string;
static NY: string;
static NZ: string;
min: Vector3;
max: Vector3;
constructor(min?: Vector3, max?: Vector3);
get centerX(): number;
get centerY(): number;
get centerZ(): number;
get sizeX(): number;
get sizeY(): number;
get sizeZ(): number;
get sizeAbsX(): number;
get sizeAbsY(): number;
get sizeAbsZ(): number;
get sizeHalfX(): number;
get sizeHalfY(): number;
get sizeHalfZ(): number;
isEmpty(): boolean;
isZero(tolerance?: number): boolean;
isGreaterSize(size: Value3): boolean;
isSizeValid(limitX?: number, limitY?: number, limitZ?: number, limitVolume?: number): boolean;
equals(box: BoxSolid): boolean;
nearlyEquals(box: BoxSolid, tolerance?: number): boolean;
hasSamePart(box: BoxSolid): boolean;
nearlyHasSamePart(box: BoxSolid): boolean;
assign(value: BoxSolid): BoxSolid;
copy(value: BoxSolid): BoxSolid;
copySizeTo(value: Value3): BoxSolid;
set(min: Vector3, max: Vector3): BoxSolid;
setValue(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): BoxSolid;
setSize(sizeX: number, sizeY: number, sizeZ: number): BoxSolid;
setFromPoints(points: Array): BoxSolid;
setFromCenterAndSize(center: Vector3, size: Vector3): BoxSolid;
setFromArray(array: Array): BoxSolid;
containsPoint(point: Value3): boolean;
containsNearlyPoint(point: Value3, tolerance?: number): boolean;
containsInnerPoint(point: Value3): boolean;
containsNearlyInnerPoint(point: Value3, tolerance?: number): boolean;
containsNearlyFacePoint(point: Value3, tolerance?: number): boolean;
containsPoints(points: Array): boolean;
containsPointsExcludedCorner(points: Array): boolean;
containsPointsExcludedBoundary(points: Array): boolean;
nearlyContainsPoint(point: Vector3, tolerance?: number): boolean;
nearlySurfacesContainsPoint(point: Value3, tolerance?: number): boolean;
containsBox(box: BoxSolid): boolean;
isCorner(point: Value3): boolean;
isLine(point: Value3): boolean;
nearlyContainsBox(box: BoxSolid, tolerance?: number): boolean;
trunc(precision?: number): BoxSolid;
center(target?: Vector3): Vector3;
size(target?: Vector3): Vector3;
volumn(): number;
getPoints(targets?: Array): Array;
getLines(targets?: Array): Array;
getPlanes(targets?: Array): Array;
contactBox(box: BoxSolid): boolean;
nearlyContactBox(box: BoxSolid, tolerance?: number): boolean;
intersectsBox(box: BoxSolid): boolean;
intersectsBoxExactly(box: BoxSolid, tolerance?: number): boolean;
nearlyIntersectsBox(box: BoxSolid, tolerance?: number): boolean;
intersectsPlane(plane: Plane): boolean;
intersectsSphere(sphere: SphereSolid | SphereSurface): boolean;
intersect(box: BoxSolid): BoxSolid;
union(box: BoxSolid): BoxSolid;
translate(offset: Value3): BoxSolid;
translateCenter(position: Value3): BoxSolid;
multiplyScalar(value: number): BoxSolid;
expandByPoint(point: Value3): BoxSolid;
expandByPoints(points: Array): BoxSolid;
expandByBox(box: BoxSolid): BoxSolid;
expandByPointValue(x: number, y: number, z: number): BoxSolid;
expandByVector(vector: Value3): BoxSolid;
expandByScalar(scalar: number): BoxSolid;
distanceToPoint(point: Vector3): number;
clampPoint(point: Vector3, target?: Vector3): Vector3;
getParameter(point: Value3, target?: Vector3): Vector3;
getBoundingSphere(target?: SphereSolid | SphereSurface): SphereSolid | SphereSurface;
makeEmpty(): BoxSolid;
applyMatrix4(matrix: Matrix4): BoxSolid;
flipX(): BoxSolid;
flipY(): BoxSolid;
flipZ(): BoxSolid;
reset(minValue?: number, maxValue?: number): BoxSolid;
arrange(isSelf?: boolean): BoxSolid;
format(precision?: number): string;
parse(value: string): BoxSolid;
clone(): BoxSolid;
free(): BoxSolid;
dispose(): void;
static equals(box1: BoxSolid, box2: BoxSolid): boolean;
static nearlyEquals(value1: BoxSolid, value2: BoxSolid, tolerance?: number): boolean;
static contains(boxs: Array, box: BoxSolid): boolean;
static nearlyContains(boxs: Array, box: BoxSolid, tolerance?: number): boolean;
static intersect(box1: BoxSolid, box2: BoxSolid, target?: BoxSolid): BoxSolid;
outline(): Array;
getFaces(): Array;
toBrepBodyLikeStretching(data?: any): BrepBody;
toBrepBody(data?: any): BrepBody;
getLocalMatrix(): Matrix4;
toString(): string;
}
}
declare module "foundation/runtime/geometry/solid/EllipsoidSolid" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { ArcSolid } from "foundation/runtime/geometry/Solid";
export class EllipsoidSolid extends ArcSolid {
axisRatio1: number;
axisRatio2: number;
constructor(center?: Vector3, begin?: Vector3, normal?: Vector3, axisRatio1?: number, axisRatio2?: number);
reset(): void;
clone(): EllipsoidSolid;
get size(): Vector3;
set size(size: Vector3);
get isSphere(): boolean;
projective(world?: Matrix4, proj?: Matrix4): Array;
viewOutline(world?: Matrix4, proj?: Matrix4): Array;
outline(): Array;
}
}
declare module "foundation/runtime/geometry/surface/EllipsoidSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { EllipsoidSolid } from "foundation/runtime/geometry/solid/EllipsoidSolid";
import { Curve3d, SingleCurve3d } from "foundation/runtime/geometry/Curve3d";
import { ArcSurface } from "foundation/runtime/geometry/Surface";
export class EllipsoidSurface extends ArcSurface {
axisRatio1: number;
axisRatio2: number;
constructor(center?: Vector3, begin?: Vector3, normal?: Vector3, axisRatio1?: number, axisRatio2?: number);
tu2u(tu: number): number;
u2tu(u: number): number;
tv2v(tv: number): number;
v2tv(v: number): number;
solveImplicitEquation(point: Vector3, local?: Matrix4, localInvert?: Matrix4): number;
solveParameticEquation(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
solveParameticEquationInverse(v: Vector3, local?: Matrix4, localInvert?: Matrix4, isDefine?: boolean, tolerance?: number, lerpTolerance?: number): Vector2;
solveParameticEquationSecondDerivative(param: Vector2): Vector3;
getParameticEquationVCurve(u: number): Curve3d;
getParameticEquationUCurve(v: number): Curve3d;
getParameticEquationVTangent(uv: Vector2, local?: Matrix4, localInvert?: Matrix4): Vector3;
getParameticEquationUMaxVCurve(): Curve3d;
getParameticEquationVMinUCurve(): Curve3d;
getParameticEquationVMaxUCurve(): Curve3d;
get size(): Vector3;
set size(size: Vector3);
reset(): void;
get isSphere(): boolean;
clone(): EllipsoidSurface;
toSolid(): EllipsoidSolid;
private copy;
projective(world?: Matrix4, proj?: Matrix4): Array;
viewOutline(world?: Matrix4, proj?: Matrix4): Array;
outline(): Array;
}
}
declare module "foundation/runtime/geometry/surface/Polygon3dSurface" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PathCurve3d } from "foundation/runtime/geometry/curve3d/PathCurve3d";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { FirstOrderSurface } from "foundation/runtime/geometry/Surface";
import { PlaneSurface } from "foundation/runtime/geometry/surface/PlaneSurface";
import { Section3dSurface } from "foundation/runtime/geometry/surface/Section3dSurface";
export class Polygon3dSurface extends FirstOrderSurface {
points: Array;
constructor(points?: Array, normal?: Vector3);
reset(): void;
applyMatrix4(matrix: Matrix4): Polygon3dSurface;
clone(): Polygon3dSurface;
getLocalMatrix(): Matrix4;
isOutLinePositive(): boolean;
toPositive(): void;
toNegPositive(): void;
getSectionSurface(): Section3dSurface;
getPath(): PathCurve3d;
outline(): Array;
getPlane(): PlaneSurface;
isPointInside(point: Vector3, tolerance?: number): boolean;
isPointOnBorder(point: Vector3, tolerance?: number): boolean;
}
}
declare module "foundation/runtime/geometry/relation/SurfaceRelationUtil" {
import { GraphCycle } from 'foundation/runtime/math/Graph';
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { BooleanOperation } from 'foundation/runtime/math/Operator';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { PathCurve2d } from "foundation/runtime/geometry/curve2d/PathCurve2d";
import { NurbsCurve3d } from "foundation/runtime/geometry/curve3d/NurbsCurve3d";
import { ComplexHoleSurface } from "foundation/runtime/geometry/surface/ComplexHoleSurface";
import { ConeSurface } from "foundation/runtime/geometry/surface/ConeSurface";
import { CylinderSurface } from "foundation/runtime/geometry/surface/CylinderSurface";
import { EllipsoidSurface } from "foundation/runtime/geometry/surface/EllipsoidSurface";
import { EllipticCylinderSurface } from "foundation/runtime/geometry/surface/EllipticCylinderSurface";
import { PlaneSurface } from "foundation/runtime/geometry/surface/PlaneSurface";
import { Section3dSurface } from "foundation/runtime/geometry/surface/Section3dSurface";
import { SectionSurface } from "foundation/runtime/geometry/surface/SectionSurface";
import { SliceSurface } from "foundation/runtime/geometry/surface/SliceSurface";
import { SphereSurface } from "foundation/runtime/geometry/surface/SphereSurface";
import { Curve2d } from "foundation/runtime/geometry/Curve2d";
import { Curve3d } from "foundation/runtime/geometry/Curve3d";
import { Surface, SingleSurface, ComplexSurface, QuadricSurface, Single3dSurface, Single2dSurface } from "foundation/runtime/geometry/Surface";
import { USeg, UVPt, UVSurrounding, VSeg } from "foundation/runtime/geometry/relation/SurfaceUVBlockUtil";
import { UVBlock } from "foundation/runtime/geometry/relation/UVBlock";
type Point = {
f: number;
fn?: number;
isTangent: boolean;
t: Vector3;
tuv: Vector2;
p: Vector3;
setp?: number;
lastSetp?: number;
s1Normal?: Vector3;
s2Normal?: Vector3;
d: {
uvd: number;
td: number;
dis: number;
pdis: number;
dird: number;
};
};
export class GraphCycleSectionSurface {
cycle: GraphCycle;
section: SectionSurface;
}
class CurveSurfaceIntersectionCache_New {
cacheU: Map;
}>>;
cacheV: Map;
}>>;
protected isUSegType(seg: USeg | VSeg): seg is USeg;
hitCache(seg: USeg | VSeg): null | Array;
addCache(seg: USeg | VSeg, intersections: Array