Class Point

Points sous forme de simples tableaux de nombres. Un point est [x, y, z] avec Y pointant vers le haut, la même forme qu'un vecteur, de sorte que les deux peuvent être passés aux méthodes l'un de l'autre ; un point 2D est [x, y]. Chaque méthode renvoie de nouveaux points ou nombres et ne modifie jamais ses entrées. Les angles sont en degrés et les longueurs en unités du modèle.

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[]
Supprime un point quand il répète celui juste avant lui ; le même point plus loin est conservé.

Avec checkFirstAndLast actif, un dernier point qui répète le premier est aussi supprimé. Des points à moins de tolerance l'un de l'autre comptent comme identiques. Exemple : [[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
  Les points, la tolérance et s'il faut comparer le premier et le dernier
Returns Point3[]
Les points sans répétitions consécutives
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
Construit un point 3D à partir de ses valeurs x, y et z.

Exemple : x=10, y=5, z=3 -> [10,5,3]
Parameters
- inputs: PointXYZDto
  Les trois valeurs
Returns Point3
Le point [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
Construit un point 2D à partir de ses valeurs x et y.

Exemple : x=10, y=5 -> [10,5]
Parameters
- inputs: PointXYDto
  Les deux valeurs
Returns Point2
Le point [x, y]
Example
```
const point = bitbybit.point.pointXY({ x: 10, y: 5 });
```
- Defined in bitbybit-docs.d.ts:56074

spiral

spiral(inputs: SpiralDto): Point3[]
Dispose des points le long d'une spirale logarithmique dans le plan XY, de l'origine vers l'extérieur jusqu'à radius.

numberPoints règle le nombre de points placés, phi et widening la vitesse à laquelle la spirale s'ouvre, et factor où le long de la courbe elle commence. Chaque point a z = 0.
Parameters
- inputs: SpiralDto
  Le nombre de points, le rayon et la forme de la spirale
Returns Point3[]
Les points le long de la spirale, du centre vers l'extérieur
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[]
Dispose les centres d'un nid d'abeilles d'hexagones dans le plan XY.

radiusHexagon est la distance du centre d'un hexagone à un coin ; les colonnes suivent X et les rangées Y, une rangée sur deux décalée d'une demi-colonne. orientOnCenter centre la grille sur l'origine, pointsOnGround la pose sur le plan XZ.
Parameters
- inputs: HexGridCentersDto
  La taille des hexagones, le nombre de colonnes et de rangées, et où placer la grille
Returns Point3[]
Les points centraux, rangée par rangée
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
Dispose un nid d'abeilles d'hexagones qui remplit une largeur et une hauteur données, en dimensionnant les hexagones d'après les nombres.

Le résultat porte les points centraux et les six coins de chaque hexagone. Un coin pointe vers le haut sauf si flatTop est défini ; les indicateurs d'extension étirent les rangées extérieures au-delà des bords pour couvrir le rectangle sans bordure dentelée.
Parameters
- inputs: HexGridScaledToFitDto
  La zone à remplir, les nombres d'hexagones, l'orientation et les options de placement
Returns HexGridData
Les centres et les points de coin de chaque hexagone
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
Trouve la direction perpendiculaire au plan passant par trois points, de longueur 1.

La direction suit la règle de la main droite en allant du premier point au deuxième puis au troisième ; reverseNormal l'inverse. Des points alignés n'ont pas de plan, le résultat est donc undefined. Exemple : [0,0,0], [1,0,0], [0,1,0] -> [0,0,1]
Parameters
- inputs: ThreePointsNormalDto
  Les trois points et s'il faut inverser le résultat
Returns Vector3
La normale unitaire, ou undefined quand les points sont alignés
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
Trouve la plus petite boîte alignée sur les axes qui contient tous les points.

Le résultat porte les coins min et max, le centre, et la largeur (X), la hauteur (Y) et la longueur (Z). Exemple : points [[0,0,0], [10,5,3]] -> min [0,0,0], max [10,5,3], centre [5,2.5,1.5]
Parameters
- inputs: Bit.Inputs.Point.PointsDto
  Les points à englober
Returns BoundingBox
La boîte englobante avec ses coins, son centre et ses tailles
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
Mesure la distance d'un point au point le plus proche d'une liste.

Exemple : point [0,0,0] et points [[5,0,0], [10,0,0], [3,0,0]] -> 3
Parameters
- inputs: ClosestPointFromPointsDto
  Le point depuis lequel mesurer et les points à parcourir
Returns number
La distance jusqu'au point le plus proche, en unités du modèle
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
Trouve la position du point le plus proche dans une liste, en comptant à partir de 1.

Exemple : point [0,0,0] et points [[5,0,0], [10,0,0], [3,0,0]] -> 3
Parameters
- inputs: ClosestPointFromPointsDto
  Le point depuis lequel mesurer et les points à parcourir
Returns number
L'index (à partir de 1) du point le plus proche
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
Trouve le point d'une liste le plus proche d'un point donné.

Exemple : point [0,0,0] et points [[5,0,0], [10,0,0], [3,0,0]] -> [3,0,0]
Parameters
- inputs: ClosestPointFromPointsDto
  Le point depuis lequel mesurer et les points à parcourir
Returns Point3
Le point le plus proche
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
Trouve la moyenne des points, qui est leur centre de masse quand ils pèsent le même poids.

Exemple : [[0,0,0], [10,0,0], [10,10,0]] -> [6.67,3.33,0]
Parameters
- inputs: Bit.Inputs.Point.PointsDto
  Les points à moyenner
Returns Point3
Le point moyen
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
Trouve le plus grand congé qui tient dans un coin : l'arc touche les deux segments et reste à l'intérieur d'eux.

Le coin est end ; start et center sont les extrémités éloignées des deux segments qui s'y rejoignent. Le rayon est limité par le segment le plus court. Un coin droit ou replié, ou un segment plus court que tolerance, donne 0.
Parameters
- inputs: ThreePointsToleranceDto
  L'extrémité éloignée de chaque segment, le coin qu'ils partagent, et la tolérance
Returns number
Le plus grand rayon de congé, en unités du modèle
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
Trouve le plus grand congé à un coin dont l'arc touche chaque segment dans sa moitié la plus proche, de sorte que les coins voisins d'une polyligne peuvent chacun recevoir un congé sans que les arcs se chevauchent.

Le coin est end ; start et center sont les extrémités éloignées des deux segments. Un coin droit ou replié, ou un segment plus court que tolerance, donne 0.
Parameters
- inputs: ThreePointsToleranceDto
  L'extrémité éloignée de chaque segment, le coin qu'ils partagent, et la tolérance
Returns number
Le plus grand rayon de congé selon la règle du demi-segment, en unités du modèle
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[]
Trouve le plus grand congé pour chaque coin d'une polyligne, chacun limité à la moitié la plus proche de ses segments pour que les congés ne se chevauchent jamais.

Avec checkLastWithFirst actif, la polyligne est traitée comme fermée et les deux coins aux extrémités sont inclus. Moins de trois points donnent une liste vide.
Parameters
- inputs: PointsMaxFilletsHalfLineDto
  Les points de la polyligne, si elle est fermée, et la tolérance
Returns number[]
Un rayon par coin, dans l'ordre des coins
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
Trouve un seul rayon de congé qui convient à chaque coin d'une polyligne : le plus petit des maximums par coin selon la règle du demi-segment.

Avec checkLastWithFirst actif, la polyligne est traitée comme fermée. Moins de trois points, ou tout coin qui n'admet aucun congé, donnent 0.
Parameters
- inputs: PointsMaxFilletsHalfLineDto
  Les points de la polyligne, si elle est fermée, et la tolérance
Returns number
Le rayon qui convient à chaque coin, en unités du modèle
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
Lit la valeur X d'un point.

Exemple : [5,10,3] -> 5
Parameters
- inputs: Bit.Inputs.Point.PointDto
  Le point
Returns number
La valeur X
- Defined in bitbybit-docs.d.ts:56007

getY

getY(inputs: Bit.Inputs.Point.PointDto): number
Lit la valeur Y d'un point, celle qui pointe vers le haut.

Exemple : [5,10,3] -> 10
Parameters
- inputs: Bit.Inputs.Point.PointDto
  Le point
Returns number
La valeur Y
- Defined in bitbybit-docs.d.ts:56018

getZ

getZ(inputs: Bit.Inputs.Point.PointDto): number
Lit la valeur Z d'un point.

Exemple : [5,10,3] -> 3
Parameters
- inputs: Bit.Inputs.Point.PointDto
  Le point
Returns number
La valeur Z
- Defined in bitbybit-docs.d.ts:56029

measure

distance

distance(inputs: StartEndPointsDto): number
Mesure la distance en ligne droite entre deux points.

Exemple : [0,0,0] vers [3,4,0] -> 5
Parameters
- inputs: StartEndPointsDto
  Les deux points
Returns number
La distance en unités du modèle
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[]
Mesure la distance d'un point à chaque point d'une liste.

Exemple : départ [0,0,0] et points d'arrivée [[3,0,0], [0,4,0], [5,0,0]] -> [3, 4, 5]
Parameters
- inputs: StartEndPointsListDto
  Le point de départ et les points jusqu'auxquels mesurer
Returns number[]
Une distance par point d'arrivée, dans le même ordre
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
Indique si deux points sont plus proches l'un de l'autre qu'une tolérance.

Exemple : [1.0000001, 2, 3] et [1, 2, 3] avec une tolérance de 1e-6 -> true
Parameters
- inputs: TwoPointsToleranceDto
  Les deux points et la tolérance
Returns boolean
Vrai quand la distance entre eux est inférieure à la tolérance
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[]
Trie les points par X, puis par Y à X égal, puis par Z.

Exemple : [[5,0,0], [1,0,0], [3,0,0]] -> [[1,0,0], [3,0,0], [5,0,0]]
Parameters
- inputs: Bit.Inputs.Point.PointsDto
  Les points à trier
Returns Point3[]
Une copie triée des points
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
Applique une matrice de transformation, ou une liste de matrices dans l'ordre, à un point.

Exemple : point [0,0,0] avec une translation de [5,5,0] -> [5,5,0]
Parameters
- inputs: TransformPointDto
  Le point et la transformation à appliquer
Returns Point3
Le point transformé
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[]
Applique la même matrice de transformation, ou liste de matrices dans l'ordre, à chaque point.

Exemple : cinq points avec une rotation de 90 degrés -> les cinq tournés ensemble
Parameters
- inputs: TransformPointsDto
  Les points et la transformation à appliquer à chacun
Returns Point3[]
Les points transformés, dans le même ordre
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[]
Applique une transformation différente à chaque point : la première transformation au premier point, et ainsi de suite.

Les deux listes doivent avoir la même longueur, sinon une erreur est levée. Exemple : trois points avec trois translations -> chaque point déplacé de sa propre translation
Parameters
- inputs: TransformsForPointsDto
  Les points et une transformation par point
Returns Point3[]
Les points transformés, dans le même ordre
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[]
Déplace chaque point du même vecteur.

Exemple : points [[0,0,0], [1,0,0]] de [5,5,0] -> [[5,5,0], [6,5,0]]
Parameters
- inputs: TranslatePointsDto
  Les points et le vecteur de déplacement
Returns Point3[]
Les points déplacés, dans le même ordre
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[]
Déplace chaque point de son propre vecteur : le premier point du premier vecteur, et ainsi de suite.

Les deux listes doivent avoir la même longueur, sinon une erreur est levée. Exemple : trois points avec trois vecteurs -> chaque point déplacé de son propre vecteur
Parameters
- inputs: TranslatePointsWithVectorsDto
  Les points et un vecteur par point
Returns Point3[]
Les points déplacés, dans le même ordre
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[]
Déplace chaque point des quantités x, y et z données.

Exemple : point [0,0,0] avec x=10, y=5, z=0 -> [10,5,0]
Parameters
- inputs: TranslateXYZPointsDto
  Les points et la distance de déplacement le long de chaque axe
Returns Point3[]
Les points déplacés, dans le même ordre
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[]
Met des points à l'échelle en s'éloignant ou en se rapprochant d'un centre, avec son propre facteur par axe.

Exemple : point [10,0,0] autour du centre [5,0,0] avec les facteurs [2,1,1] -> [15,0,0]
Parameters
- inputs: ScalePointsCenterXYZDto
  Les points, le centre de la mise à l'échelle et le facteur par axe
Returns Point3[]
Les points mis à l'échelle, dans le même ordre
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[]
Étire des points le long d'une direction, mesurée depuis un centre ; les distances transversales à cette direction restent telles quelles.

Exemple : point [10,0,0] depuis le centre [0,0,0] le long de [1,0,0] avec une échelle de 2 -> [20,0,0]
Parameters
- inputs: StretchPointsDirFromCenterDto
  Les points, le centre, la direction de l'étirement et le facteur
Returns Point3[]
Les points étirés, dans le même ordre
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[]
Tourne des points autour d'un axe passant par un centre.

L'angle est en degrés et tourne dans le sens antihoraire quand l'axe pointe vers vous. Exemple : point [10,0,0] autour de l'axe Y passant par [0,0,0] de 90 -> [0,0,-10]
Parameters
- inputs: RotatePointsCenterAxisDto
  Les points, la direction de l'axe, le centre par lequel il passe et l'angle en degrés
Returns Point3[]
Les points tournés, dans le même ordre
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[]
Répète un point un nombre donné de fois dans une liste.

Exemple : point [5,5,0] trois fois -> [[5,5,0], [5,5,0], [5,5,0]]
Parameters
- inputs: MultiplyPointDto
  Le point et le nombre de copies à faire
Returns Point3[]
La liste des copies
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