Class Point

Pontos como arrays de números simples. Um ponto é [x, y, z] com Y a apontar para cima, a mesma forma que um vetor, pelo que os dois podem ser passados aos métodos um do outro; um ponto 2D é [x, y]. Cada método devolve novos pontos ou números e nunca altera as suas entradas. Os ângulos estão em graus e os comprimentos em unidades do modelo.

Constructors

constructor

new Point(
    geometryHelper: GeometryHelper,
    transforms: Bit.Transforms,
    vector: Bit.Vector,
    lists: Bit.Lists,
): Bit.Point
Parameters
- geometryHelper: GeometryHelper
- transforms: Bit.Transforms
- vector: Bit.Vector
- lists: Bit.Lists
Returns Bit.Point
- Defined in bitbybit-docs.d.ts:55723

clean

removeConsecutiveDuplicates

removeConsecutiveDuplicates(inputs: RemoveConsecutiveDuplicatesDto): Point3[]
Remove um ponto quando repete o imediatamente anterior; o mesmo ponto mais adiante é mantido.

Com checkFirstAndLast ligado, um último ponto que repita o primeiro também é descartado. Pontos dentro de tolerance uns dos outros contam como o mesmo. Exemplo: [[0,0,0], [0,0,0], [1,0,0], [1,0,0], [2,0,0]] -> [[0,0,0], [1,0,0], [2,0,0]]
Parameters
- inputs: RemoveConsecutiveDuplicatesDto
  Os pontos, a tolerância e se deve comparar o primeiro com o último
Returns Point3[]
Os pontos sem repetições consecutivas
Example
```
const cleaned = bitbybit.point.removeConsecutiveDuplicates({
    points: [[0, 0, 0], [0, 0, 0], [1, 0, 0]],
    tolerance: 1e-7,
    checkFirstAndLast: false,
});
```
- Defined in bitbybit-docs.d.ts:56231

create

pointXYZ

pointXYZ(inputs: PointXYZDto): Point3
Constrói um ponto 3D a partir dos seus valores x, y e z.

Exemplo: x=10, y=5, z=3 -> [10,5,3]
Parameters
- inputs: PointXYZDto
  Os três valores
Returns Point3
O ponto [x, y, z]
Example
```
const point = bitbybit.point.pointXYZ({ x: 10, y: 5, z: 3 });
```
- Defined in bitbybit-docs.d.ts:56059

pointXY

pointXY(inputs: PointXYDto): Point2
Constrói um ponto 2D a partir dos seus valores x e y.

Exemplo: x=10, y=5 -> [10,5]
Parameters
- inputs: PointXYDto
  Os dois valores
Returns Point2
O ponto [x, y]
Example
```
const point = bitbybit.point.pointXY({ x: 10, y: 5 });
```
- Defined in bitbybit-docs.d.ts:56074

spiral

spiral(inputs: SpiralDto): Point3[]
Dispõe pontos ao longo de uma espiral logarítmica no plano XY, da origem para fora até radius.

numberPoints define quantos pontos são colocados, phi e widening quão depressa a espiral abre, e factor onde ao longo da curva ela começa. Todos os pontos têm z = 0.
Parameters
- inputs: SpiralDto
  O número de pontos, o raio e a forma da espiral
Returns Point3[]
Os pontos ao longo da espiral, do centro para fora
Example
```
const points = bitbybit.point.spiral({ phi: 0.9, numberPoints: 100, widening: 3, radius: 10, factor: 1 });
```
- Defined in bitbybit-docs.d.ts:56091

hexGrid

hexGrid(inputs: HexGridCentersDto): Point3[]
Dispõe os centros de um favo de mel de hexágonos no plano XY.

radiusHexagon é a distância do centro de um hexágono a um canto; as colunas correm ao longo de X e as filas ao longo de Y, com cada segunda fila deslocada meia coluna. orientOnCenter centra a grelha na origem, pointsOnGround deita-a no plano XZ.
Parameters
- inputs: HexGridCentersDto
  O tamanho do hexágono, quantas colunas e linhas, e onde colocar a grelha
Returns Point3[]
Os pontos centrais, linha a linha
Example
```
const centers = bitbybit.point.hexGrid({ radiusHexagon: 1, nrHexagonsX: 5, nrHexagonsY: 4, orientOnCenter: true, pointsOnGround: false });
```
- Defined in bitbybit-docs.d.ts:56108

hexGridScaledToFit

hexGridScaledToFit(inputs: HexGridScaledToFitDto): HexGridData
Dispõe um favo de mel de hexágonos que preenche uma dada largura e altura, dimensionando os hexágonos a partir das contagens.

O resultado traz os pontos centrais e os seis cantos de cada hexágono. Um canto aponta para cima a menos que flatTop esteja definido; os indicadores de extensão esticam as filas exteriores para lá das margens para cobrir o retângulo sem uma borda dentada.
Parameters
- inputs: HexGridScaledToFitDto
  A área a preencher, as contagens de hexágonos, a orientação e as opções de colocação
Returns HexGridData
Os centros e os pontos dos cantos de cada hexágono
Example
```
const grid = bitbybit.point.hexGridScaledToFit({
    width: 10,
    height: 10,
    nrHexagonsInWidth: 5,
    nrHexagonsInHeight: 5,
    flatTop: false,
    centerGrid: true,
});
```
- Defined in bitbybit-docs.d.ts:56133

normalFromThreePoints

normalFromThreePoints(inputs: ThreePointsNormalDto): Vector3
Encontra a direção perpendicular ao plano que passa por três pontos, com comprimento 1.

A direção segue a regra da mão direita indo do primeiro ponto para o segundo e para o terceiro; reverseNormal inverte-a. Pontos numa só linha não têm plano, por isso o resultado é undefined. Exemplo: [0,0,0], [1,0,0], [0,1,0] -> [0,0,1]
Parameters
- inputs: ThreePointsNormalDto
  Os três pontos e se deve inverter o resultado
Returns Vector3
A normal unitária, ou undefined quando os pontos estão numa só linha
Example
```
const normal = bitbybit.point.normalFromThreePoints({
    point1: [0, 0, 0],
    point2: [1, 0, 0],
    point3: [0, 1, 0],
    reverseNormal: false,
});
```
- Defined in bitbybit-docs.d.ts:56254

extract

boundingBoxOfPoints

boundingBoxOfPoints(inputs: Bit.Inputs.Point.PointsDto): BoundingBox
Encontra a menor caixa alinhada com os eixos que contém todos os pontos.

O resultado traz os cantos mínimo e máximo, o centro, e a largura (X), a altura (Y) e o comprimento (Z). Exemplo: pontos [[0,0,0], [10,5,3]] -> min [0,0,0], max [10,5,3], centro [5,2.5,1.5]
Parameters
- inputs: Bit.Inputs.Point.PointsDto
  Os pontos a englobar
Returns BoundingBox
A caixa delimitadora com os seus cantos, centro e tamanhos
Example
```
const box = bitbybit.point.boundingBoxOfPoints({ points: [[0, 0, 0], [10, 5, 3], [-2, 1, 1]] });
```
- Defined in bitbybit-docs.d.ts:55906

closestPointFromPointsDistance

closestPointFromPointsDistance(inputs: ClosestPointFromPointsDto): number
Mede a distância de um ponto ao ponto mais próximo numa lista.

Exemplo: ponto [0,0,0] e pontos [[5,0,0], [10,0,0], [3,0,0]] -> 3
Parameters
- inputs: ClosestPointFromPointsDto
  O ponto a partir do qual medir e os pontos a pesquisar
Returns number
A distância ao ponto mais próximo, em unidades do modelo
Example
```
const nearest = bitbybit.point.closestPointFromPointsDistance({ point: [0, 0, 0], points: [[5, 0, 0], [3, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:55921

closestPointFromPointsIndex

closestPointFromPointsIndex(inputs: ClosestPointFromPointsDto): number
Encontra a posição do ponto mais próximo numa lista, a contar de 1.

Exemplo: ponto [0,0,0] e pontos [[5,0,0], [10,0,0], [3,0,0]] -> 3
Parameters
- inputs: ClosestPointFromPointsDto
  O ponto a partir do qual medir e os pontos a pesquisar
Returns number
O índice, a começar em 1, do ponto mais próximo
Example
```
const index = bitbybit.point.closestPointFromPointsIndex({ point: [0, 0, 0], points: [[5, 0, 0], [3, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:55936

closestPointFromPoints

closestPointFromPoints(inputs: ClosestPointFromPointsDto): Point3
Encontra o ponto mais próximo numa lista de um dado ponto.

Exemplo: ponto [0,0,0] e pontos [[5,0,0], [10,0,0], [3,0,0]] -> [3,0,0]
Parameters
- inputs: ClosestPointFromPointsDto
  O ponto a partir do qual medir e os pontos a pesquisar
Returns Point3
O ponto mais próximo
Example
```
const nearest = bitbybit.point.closestPointFromPoints({ point: [0, 0, 0], points: [[5, 0, 0], [3, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:55951

averagePoint

averagePoint(inputs: Bit.Inputs.Point.PointsDto): Point3
Encontra a média dos pontos, que é o seu centro de massa quando pesam o mesmo.

Exemplo: [[0,0,0], [10,0,0], [10,10,0]] -> [6.67,3.33,0]
Parameters
- inputs: Bit.Inputs.Point.PointsDto
  Os pontos a calcular a média
Returns Point3
O ponto médio
Example
```
const center = bitbybit.point.averagePoint({ points: [[0, 0, 0], [10, 0, 0], [10, 10, 0]] });
```
- Defined in bitbybit-docs.d.ts:56044

fillet

maxFilletRadius

maxFilletRadius(inputs: ThreePointsToleranceDto): number
Encontra o maior arredondamento que cabe num canto: o arco toca ambos os segmentos e fica dentro deles.

O canto é end; start e center são as extremidades afastadas dos dois segmentos que aí se encontram. O raio é limitado pelo segmento mais curto. Um canto reto ou dobrado sobre si, ou um segmento mais curto do que tolerance, dá 0.
Parameters
- inputs: ThreePointsToleranceDto
  A extremidade distante de cada segmento, o canto que partilham, e a tolerância
Returns number
O maior raio de arredondamento, em unidades do modelo
Example
```
const radius = bitbybit.point.maxFilletRadius({ start: [10, 0, 0], center: [0, 10, 0], end: [0, 0, 0], tolerance: 1e-7 });
```
- Defined in bitbybit-docs.d.ts:56151

maxFilletRadiusHalfLine

maxFilletRadiusHalfLine(inputs: ThreePointsToleranceDto): number
Encontra o maior arredondamento num canto cujo arco toca cada segmento dentro da sua metade mais próxima, de modo que cantos vizinhos de uma polilinha podem ser arredondados sem que os arcos se sobreponham.

O canto é end; start e center são as extremidades afastadas dos dois segmentos. Um canto reto ou dobrado sobre si, ou um segmento mais curto do que tolerance, dá 0.
Parameters
- inputs: ThreePointsToleranceDto
  A extremidade distante de cada segmento, o canto que partilham, e a tolerância
Returns number
O maior raio de arredondamento segundo a regra do meio segmento, em unidades do modelo
Example
```
const radius = bitbybit.point.maxFilletRadiusHalfLine({ start: [10, 0, 0], center: [0, 10, 0], end: [0, 0, 0], tolerance: 1e-7 });
```
- Defined in bitbybit-docs.d.ts:56168

maxFilletsHalfLine

maxFilletsHalfLine(inputs: PointsMaxFilletsHalfLineDto): number[]
Encontra o maior arredondamento para cada canto de uma polilinha, cada um limitado à metade mais próxima dos seus segmentos para que os arredondamentos nunca se sobreponham.

Com checkLastWithFirst ligado, a polilinha é tratada como fechada e os dois cantos nas extremidades são incluídos. Menos de três pontos dão uma lista vazia.
Parameters
- inputs: PointsMaxFilletsHalfLineDto
  Os pontos da polilinha, se está fechada, e a tolerância
Returns number[]
Um raio por canto, pela ordem dos cantos
Example
```
const radii = bitbybit.point.maxFilletsHalfLine({
    points: [[0, 0, 0], [10, 0, 0], [10, 10, 0], [0, 10, 0]],
    checkLastWithFirst: true,
    tolerance: 1e-7,
});
```
- Defined in bitbybit-docs.d.ts:56189

safestPointsMaxFilletHalfLine

safestPointsMaxFilletHalfLine(inputs: PointsMaxFilletsHalfLineDto): number
Encontra um raio de arredondamento que cabe em todos os cantos de uma polilinha: o menor dos máximos por canto segundo a regra do meio segmento.

Com checkLastWithFirst ligado, a polilinha é tratada como fechada. Menos de três pontos, ou qualquer canto que não permita arredondamento, dão 0.
Parameters
- inputs: PointsMaxFilletsHalfLineDto
  Os pontos da polilinha, se está fechada, e a tolerância
Returns number
O raio que cabe em todos os cantos, em unidades do modelo
Example
```
const radius = bitbybit.point.safestPointsMaxFilletHalfLine({
    points: [[0, 0, 0], [10, 0, 0], [10, 10, 0], [0, 10, 0]],
    checkLastWithFirst: true,
    tolerance: 1e-7,
});
```
- Defined in bitbybit-docs.d.ts:56210

get

getX

getX(inputs: Bit.Inputs.Point.PointDto): number
Lê o valor X de um ponto.

Exemplo: [5,10,3] -> 5
Parameters
- inputs: Bit.Inputs.Point.PointDto
  O ponto
Returns number
O valor X
- Defined in bitbybit-docs.d.ts:56007

getY

getY(inputs: Bit.Inputs.Point.PointDto): number
Lê o valor Y de um ponto, o que aponta para cima.

Exemplo: [5,10,3] -> 10
Parameters
- inputs: Bit.Inputs.Point.PointDto
  O ponto
Returns number
O valor Y
- Defined in bitbybit-docs.d.ts:56018

getZ

getZ(inputs: Bit.Inputs.Point.PointDto): number
Lê o valor Z de um ponto.

Exemplo: [5,10,3] -> 3
Parameters
- inputs: Bit.Inputs.Point.PointDto
  O ponto
Returns number
O valor Z
- Defined in bitbybit-docs.d.ts:56029

measure

distance

distance(inputs: StartEndPointsDto): number
Mede a distância em linha reta entre dois pontos.

Exemplo: [0,0,0] para [3,4,0] -> 5
Parameters
- inputs: StartEndPointsDto
  Os dois pontos
Returns number
A distância em unidades do modelo
Example
```
const d = bitbybit.point.distance({ startPoint: [0, 0, 0], endPoint: [3, 4, 0] });
```
- Defined in bitbybit-docs.d.ts:55966

distancesToPoints

distancesToPoints(inputs: StartEndPointsListDto): number[]
Mede a distância de um ponto a cada ponto numa lista.

Exemplo: início [0,0,0] e pontos finais [[3,0,0], [0,4,0], [5,0,0]] -> [3, 4, 5]
Parameters
- inputs: StartEndPointsListDto
  O ponto inicial e os pontos até aos quais medir
Returns number[]
Uma distância por ponto final, pela mesma ordem
Example
```
const distances = bitbybit.point.distancesToPoints({ startPoint: [0, 0, 0], endPoints: [[3, 0, 0], [0, 4, 0]] });
```
- Defined in bitbybit-docs.d.ts:55981

twoPointsAlmostEqual

twoPointsAlmostEqual(inputs: TwoPointsToleranceDto): boolean
Indica se dois pontos estão mais próximos um do outro do que uma tolerância.

Exemplo: [1.0000001, 2, 3] e [1, 2, 3] com tolerância 1e-6 -> true
Parameters
- inputs: TwoPointsToleranceDto
  Os dois pontos e a tolerância
Returns boolean
True quando a distância entre eles é inferior à tolerância
Example
```
const same = bitbybit.point.twoPointsAlmostEqual({ point1: [1, 2, 3], point2: [1, 2, 3.0000001], tolerance: 1e-6 });
```
- Defined in bitbybit-docs.d.ts:56270

sort

sortPoints

sortPoints(inputs: Bit.Inputs.Point.PointsDto): Point3[]
Ordena pontos por X, depois por Y para X igual, depois por Z.

Exemplo: [[5,0,0], [1,0,0], [3,0,0]] -> [[1,0,0], [3,0,0], [5,0,0]]
Parameters
- inputs: Bit.Inputs.Point.PointsDto
  Os pontos a ordenar
Returns Point3[]
Uma cópia ordenada dos pontos
Example
```
const sorted = bitbybit.point.sortPoints({ points: [[5, 0, 0], [1, 0, 0], [3, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:56285

transforms

transformPoint

transformPoint(inputs: TransformPointDto): Point3
Aplica uma matriz de transformação, ou uma lista delas por ordem, a um ponto.

Exemplo: ponto [0,0,0] com uma translação de [5,5,0] -> [5,5,0]
Parameters
- inputs: TransformPointDto
  O ponto e a transformação a aplicar
Returns Point3
O ponto transformado
Example
```
const moved = bitbybit.point.transformPoint({
    point: [0, 0, 0],
    transformation: bitbybit.transforms.translationXYZ({ translation: [5, 5, 0] }),
});
```
- Defined in bitbybit-docs.d.ts:55741

transformPoints

transformPoints(inputs: TransformPointsDto): Point3[]
Aplica a mesma matriz de transformação, ou lista delas por ordem, a todos os pontos.

Exemplo: cinco pontos com uma rotação de 90 graus -> todos os cinco rodados em conjunto
Parameters
- inputs: TransformPointsDto
  Os pontos e a transformação a aplicar a cada um
Returns Point3[]
Os pontos transformados, pela mesma ordem
Example
```
const rotated = bitbybit.point.transformPoints({
    points: [[1, 0, 0], [2, 0, 0]],
    transformation: bitbybit.transforms.rotationCenterAxis({ center: [0, 0, 0], axis: [0, 1, 0], angle: 90 }),
});
```
- Defined in bitbybit-docs.d.ts:55759

transformsForPoints

transformsForPoints(inputs: TransformsForPointsDto): Point3[]
Aplica uma transformação diferente a cada ponto: a primeira transformação ao primeiro ponto, e assim por diante.

As duas listas têm de ter o mesmo comprimento, ou é lançado um erro. Exemplo: três pontos com três translações -> cada ponto movido pela sua própria translação
Parameters
- inputs: TransformsForPointsDto
  Os pontos e uma transformação por ponto
Returns Point3[]
Os pontos transformados, pela mesma ordem
Example
```
const placed = bitbybit.point.transformsForPoints({
    points: [[0, 0, 0], [1, 0, 0]],
    transformation: bitbybit.transforms.translationsXYZ({ translations: [[0, 1, 0], [0, 2, 0]] }),
});
```
- Defined in bitbybit-docs.d.ts:55779

translatePoints

translatePoints(inputs: TranslatePointsDto): Point3[]
Move todos os pontos pelo mesmo vetor.

Exemplo: pontos [[0,0,0], [1,0,0]] por [5,5,0] -> [[5,5,0], [6,5,0]]
Parameters
- inputs: TranslatePointsDto
  Os pontos e o vetor pelo qual os deslocar
Returns Point3[]
Os pontos deslocados, pela mesma ordem
Example
```
const moved = bitbybit.point.translatePoints({ points: [[0, 0, 0], [1, 0, 0]], translation: [5, 5, 0] });
```
- Defined in bitbybit-docs.d.ts:55794

translatePointsWithVectors

translatePointsWithVectors(inputs: TranslatePointsWithVectorsDto): Point3[]
Move cada ponto pelo seu próprio vetor: o primeiro ponto pelo primeiro vetor, e assim por diante.

As duas listas têm de ter o mesmo comprimento, ou é lançado um erro. Exemplo: três pontos com três vetores -> cada ponto movido pelo seu próprio vetor
Parameters
- inputs: TranslatePointsWithVectorsDto
  Os pontos e um vetor por ponto
Returns Point3[]
Os pontos deslocados, pela mesma ordem
Example
```
const moved = bitbybit.point.translatePointsWithVectors({
    points: [[0, 0, 0], [1, 0, 0]],
    translations: [[0, 1, 0], [0, 2, 0]],
});
```
- Defined in bitbybit-docs.d.ts:55813

translateXYZPoints

translateXYZPoints(inputs: TranslateXYZPointsDto): Point3[]
Move todos os pontos pelas quantidades x, y e z dadas.

Exemplo: ponto [0,0,0] com x=10, y=5, z=0 -> [10,5,0]
Parameters
- inputs: TranslateXYZPointsDto
  Os pontos e a distância a deslocar ao longo de cada eixo
Returns Point3[]
Os pontos deslocados, pela mesma ordem
Example
```
const lifted = bitbybit.point.translateXYZPoints({ points: [[0, 0, 0], [1, 0, 0]], x: 0, y: 5, z: 0 });
```
- Defined in bitbybit-docs.d.ts:55828

scalePointsCenterXYZ

scalePointsCenterXYZ(inputs: ScalePointsCenterXYZDto): Point3[]
Escala pontos a afastar-se ou a aproximar-se de um centro, com o seu próprio fator por eixo.

Exemplo: ponto [10,0,0] em torno do centro [5,0,0] com fatores [2,1,1] -> [15,0,0]
Parameters
- inputs: ScalePointsCenterXYZDto
  Os pontos, o centro em torno do qual escalar e o fator por eixo
Returns Point3[]
Os pontos escalados, pela mesma ordem
Example
```
const stretched = bitbybit.point.scalePointsCenterXYZ({
    points: [[10, 0, 0], [0, 10, 0]],
    center: [0, 0, 0],
    scaleXyz: [2, 1, 1],
});
```
- Defined in bitbybit-docs.d.ts:55847

stretchPointsDirFromCenter

stretchPointsDirFromCenter(inputs: StretchPointsDirFromCenterDto): Point3[]
Estica pontos ao longo de uma direção, medida a partir de um centro; as distâncias transversais a essa direção ficam como estão.

Exemplo: ponto [10,0,0] a partir do centro [0,0,0] ao longo de [1,0,0] com escala 2 -> [20,0,0]
Parameters
- inputs: StretchPointsDirFromCenterDto
  Os pontos, o centro, a direção ao longo da qual esticar e o fator
Returns Point3[]
Os pontos esticados, pela mesma ordem
Example
```
const taller = bitbybit.point.stretchPointsDirFromCenter({
    points: [[0, 1, 0], [0, 2, 0]],
    center: [0, 0, 0],
    direction: [0, 1, 0],
    scale: 2,
});
```
- Defined in bitbybit-docs.d.ts:55868

rotatePointsCenterAxis

rotatePointsCenterAxis(inputs: RotatePointsCenterAxisDto): Point3[]
Roda pontos em torno de um eixo que passa por um centro.

O ângulo está em graus e roda no sentido anti-horário quando o eixo aponta para si. Exemplo: ponto [10,0,0] em torno do eixo Y por [0,0,0] com 90 -> [0,0,-10]
Parameters
- inputs: RotatePointsCenterAxisDto
  Os pontos, a direção do eixo, o centro por onde passa e o ângulo em graus
Returns Point3[]
Os pontos rodados, pela mesma ordem
Example
```
const turned = bitbybit.point.rotatePointsCenterAxis({
    points: [[10, 0, 0]],
    center: [0, 0, 0],
    axis: [0, 1, 0],
    angle: 90,
});
```
- Defined in bitbybit-docs.d.ts:55889

multiplyPoint

multiplyPoint(inputs: MultiplyPointDto): Point3[]
Repete um ponto um dado número de vezes numa lista.

Exemplo: ponto [5,5,0] três vezes -> [[5,5,0], [5,5,0], [5,5,0]]
Parameters
- inputs: MultiplyPointDto
  O ponto e quantas cópias fazer
Returns Point3[]
A lista de cópias
Example
```
const copies = bitbybit.point.multiplyPoint({ point: [5, 5, 0], amountOfPoints: 3 });
```
- Defined in bitbybit-docs.d.ts:55996

Class Point

Index

Constructors

clean

create

extract

fillet

get

measure

sort

transforms

Constructors

constructor

Parameters

Returns Bit.Point

clean

removeConsecutiveDuplicates

Parameters

Returns Point3[]

Example

create

pointXYZ

Parameters

Returns Point3

Example

pointXY

Parameters

Returns Point2

Example

spiral

Parameters

Returns Point3[]

Example

hexGrid

Parameters

Returns Point3[]

Example

hexGridScaledToFit

Parameters

Returns HexGridData

Example

normalFromThreePoints

Parameters

Returns Vector3

Example

extract

boundingBoxOfPoints

Parameters

Returns BoundingBox

Example

closestPointFromPointsDistance

Parameters

Returns number

Example

closestPointFromPointsIndex

Parameters

Returns number

Example

closestPointFromPoints

Parameters

Returns Point3

Example

averagePoint

Parameters

Returns Point3

Example

fillet

maxFilletRadius

Parameters

Returns number

Example

maxFilletRadiusHalfLine

Parameters

Returns number

Example

maxFilletsHalfLine

Parameters

Returns number[]

Example

safestPointsMaxFilletHalfLine