Klasse Point

Punkte als einfache Zahlen-Arrays. Ein Punkt ist [x, y, z] mit Y nach oben, in derselben Gestalt wie ein Vektor, sodass beide an die Methoden des jeweils anderen übergeben werden können; ein 2D-Punkt ist [x, y]. Jede Methode gibt neue Punkte oder Zahlen zurück und ändert nie ihre Eingaben. Winkel sind in Grad und Längen in Modelleinheiten.

Konstruktoren

constructor

new Point(
    geometryHelper: GeometryHelper,
    transforms: Bit.Transforms,
    vector: Bit.Vector,
    lists: Bit.Lists,
): Bit.Point
Parameter
- geometryHelper: GeometryHelper
- transforms: Bit.Transforms
- vector: Bit.Vector
- lists: Bit.Lists
Rückgabewert Bit.Point
- Definiert in bitbybit-docs.d.ts:55723

clean

removeConsecutiveDuplicates

removeConsecutiveDuplicates(inputs: RemoveConsecutiveDuplicatesDto): Point3[]
Entfernt einen Punkt, wenn er den direkt davor wiederholt; derselbe Punkt weiter entfernt wird behalten.

Mit checkFirstAndLast an wird auch ein letzter Punkt verworfen, der den ersten wiederholt. Punkte innerhalb von tolerance zueinander gelten als gleich. Beispiel: [[0,0,0], [0,0,0], [1,0,0], [1,0,0], [2,0,0]] -> [[0,0,0], [1,0,0], [2,0,0]]
Parameter
- inputs: RemoveConsecutiveDuplicatesDto
  Die Punkte, die Toleranz und ob der erste und der letzte verglichen werden
Rückgabewert Point3[]
Die Punkte ohne aufeinanderfolgende Wiederholungen
Example
```
const cleaned = bitbybit.point.removeConsecutiveDuplicates({
    points: [[0, 0, 0], [0, 0, 0], [1, 0, 0]],
    tolerance: 1e-7,
    checkFirstAndLast: false,
});
```
- Definiert in bitbybit-docs.d.ts:56231

create

pointXYZ

pointXYZ(inputs: PointXYZDto): Point3
Erzeugt einen 3D-Punkt aus seinen x-, y- und z-Werten.

Beispiel: x=10, y=5, z=3 -> [10,5,3]
Parameter
- inputs: PointXYZDto
  Die drei Werte
Rückgabewert Point3
Der Punkt [x, y, z]
Example
```
const point = bitbybit.point.pointXYZ({ x: 10, y: 5, z: 3 });
```
- Definiert in bitbybit-docs.d.ts:56059

pointXY

pointXY(inputs: PointXYDto): Point2
Erzeugt einen 2D-Punkt aus seinen x- und y-Werten.

Beispiel: x=10, y=5 -> [10,5]
Parameter
- inputs: PointXYDto
  Die beiden Werte
Rückgabewert Point2
Der Punkt [x, y]
Example
```
const point = bitbybit.point.pointXY({ x: 10, y: 5 });
```
- Definiert in bitbybit-docs.d.ts:56074

spiral

spiral(inputs: SpiralDto): Point3[]
Legt Punkte entlang einer logarithmischen Spirale in der XY-Ebene aus, vom Ursprung nach außen bis radius.

numberPoints legt fest, wie viele Punkte platziert werden, phi und widening, wie schnell sich die Spirale öffnet, und factor, wo entlang der Kurve sie beginnt. Jeder Punkt hat z = 0.
Parameter
- inputs: SpiralDto
  Die Punktanzahl, der Radius und die Form der Spirale
Rückgabewert Point3[]
Die Punkte entlang der Spirale, vom Zentrum nach außen
Example
```
const points = bitbybit.point.spiral({ phi: 0.9, numberPoints: 100, widening: 3, radius: 10, factor: 1 });
```
- Definiert in bitbybit-docs.d.ts:56091

hexGrid

hexGrid(inputs: HexGridCentersDto): Point3[]
Legt die Mittelpunkte einer Wabe aus Sechsecken in der XY-Ebene aus.

radiusHexagon ist der Abstand vom Mittelpunkt eines Sechsecks zu einer Ecke; Spalten verlaufen entlang X und Reihen entlang Y, jede zweite Reihe um eine halbe Spalte verschoben. orientOnCenter zentriert das Gitter auf dem Ursprung, pointsOnGround legt es auf die XZ-Ebene.
Parameter
- inputs: HexGridCentersDto
  Die Sechseckgröße, wie viele Spalten und Reihen, und wo das Gitter platziert wird
Rückgabewert Point3[]
Die Mittelpunkte, Reihe für Reihe
Example
```
const centers = bitbybit.point.hexGrid({ radiusHexagon: 1, nrHexagonsX: 5, nrHexagonsY: 4, orientOnCenter: true, pointsOnGround: false });
```
- Definiert in bitbybit-docs.d.ts:56108

hexGridScaledToFit

hexGridScaledToFit(inputs: HexGridScaledToFitDto): HexGridData
Legt eine Wabe aus Sechsecken aus, die eine gegebene Breite und Höhe füllt, wobei die Sechsecke nach den Anzahlen bemessen werden.

Das Ergebnis trägt die Mittelpunkte und die sechs Ecken jedes Sechsecks. Eine Ecke zeigt nach oben, sofern flatTop nicht gesetzt ist; die Extend-Flags strecken die äußeren Reihen über die Ränder hinaus, um das Rechteck ohne gezackten Rand abzudecken.
Parameter
- inputs: HexGridScaledToFitDto
  Der zu füllende Bereich, die Sechseckanzahlen, die Orientierung und die Platzierungsoptionen
Rückgabewert HexGridData
Die Mittelpunkte und die Eckpunkte jedes Sechsecks
Example
```
const grid = bitbybit.point.hexGridScaledToFit({
    width: 10,
    height: 10,
    nrHexagonsInWidth: 5,
    nrHexagonsInHeight: 5,
    flatTop: false,
    centerGrid: true,
});
```
- Definiert in bitbybit-docs.d.ts:56133

normalFromThreePoints

normalFromThreePoints(inputs: ThreePointsNormalDto): Vector3
Ermittelt die Richtung im rechten Winkel zur Ebene durch drei Punkte, mit Länge 1.

Die Richtung folgt der Rechte-Hand-Regel vom ersten Punkt über den zweiten zum dritten; reverseNormal kehrt sie um. Punkte auf einer Linie haben keine Ebene, daher ist das Ergebnis undefined. Beispiel: [0,0,0], [1,0,0], [0,1,0] -> [0,0,1]
Parameter
- inputs: ThreePointsNormalDto
  Die drei Punkte und ob das Ergebnis umgekehrt wird
Rückgabewert Vector3
Die Einheitsnormale oder undefined, wenn die Punkte auf einer Linie liegen
Example
```
const normal = bitbybit.point.normalFromThreePoints({
    point1: [0, 0, 0],
    point2: [1, 0, 0],
    point3: [0, 1, 0],
    reverseNormal: false,
});
```
- Definiert in bitbybit-docs.d.ts:56254

extract

boundingBoxOfPoints

boundingBoxOfPoints(inputs: Bit.Inputs.Point.PointsDto): BoundingBox
Ermittelt den kleinsten achsenparallelen Quader, der alle Punkte enthält.

Das Ergebnis trägt die Min- und Max-Ecken, den Mittelpunkt und die Breite (X), Höhe (Y) und Länge (Z). Beispiel: Punkte [[0,0,0], [10,5,3]] -> min [0,0,0], max [10,5,3], Mittelpunkt [5,2.5,1.5]
Parameter
- inputs: Bit.Inputs.Point.PointsDto
  Die einzuschließenden Punkte
Rückgabewert BoundingBox
Der Begrenzungsrahmen mit seinen Ecken, seinem Mittelpunkt und seinen Größen
Example
```
const box = bitbybit.point.boundingBoxOfPoints({ points: [[0, 0, 0], [10, 5, 3], [-2, 1, 1]] });
```
- Definiert in bitbybit-docs.d.ts:55906

closestPointFromPointsDistance

closestPointFromPointsDistance(inputs: ClosestPointFromPointsDto): number
Misst den Abstand von einem Punkt zum nächsten Punkt in einer Liste.

Beispiel: Punkt [0,0,0] und Punkte [[5,0,0], [10,0,0], [3,0,0]] -> 3
Parameter
- inputs: ClosestPointFromPointsDto
  Der Punkt, von dem aus gemessen wird, und die zu durchsuchenden Punkte
Rückgabewert number
Der Abstand zum nächsten Punkt, in Modelleinheiten
Example
```
const nearest = bitbybit.point.closestPointFromPointsDistance({ point: [0, 0, 0], points: [[5, 0, 0], [3, 0, 0]] });
```
- Definiert in bitbybit-docs.d.ts:55921

closestPointFromPointsIndex

closestPointFromPointsIndex(inputs: ClosestPointFromPointsDto): number
Ermittelt die Position des nächsten Punkts in einer Liste, gezählt ab 1.

Beispiel: Punkt [0,0,0] und Punkte [[5,0,0], [10,0,0], [3,0,0]] -> 3
Parameter
- inputs: ClosestPointFromPointsDto
  Der Punkt, von dem aus gemessen wird, und die zu durchsuchenden Punkte
Rückgabewert number
Der 1-basierte Index des nächsten Punkts
Example
```
const index = bitbybit.point.closestPointFromPointsIndex({ point: [0, 0, 0], points: [[5, 0, 0], [3, 0, 0]] });
```
- Definiert in bitbybit-docs.d.ts:55936

closestPointFromPoints

closestPointFromPoints(inputs: ClosestPointFromPointsDto): Point3
Ermittelt den einem gegebenen Punkt nächsten Punkt in einer Liste.

Beispiel: Punkt [0,0,0] und Punkte [[5,0,0], [10,0,0], [3,0,0]] -> [3,0,0]
Parameter
- inputs: ClosestPointFromPointsDto
  Der Punkt, von dem aus gemessen wird, und die zu durchsuchenden Punkte
Rückgabewert Point3
Der nächste Punkt
Example
```
const nearest = bitbybit.point.closestPointFromPoints({ point: [0, 0, 0], points: [[5, 0, 0], [3, 0, 0]] });
```
- Definiert in bitbybit-docs.d.ts:55951

averagePoint

averagePoint(inputs: Bit.Inputs.Point.PointsDto): Point3
Ermittelt den Durchschnitt der Punkte, der ihr Schwerpunkt ist, wenn sie gleich viel wiegen.

Beispiel: [[0,0,0], [10,0,0], [10,10,0]] -> [6.67,3.33,0]
Parameter
- inputs: Bit.Inputs.Point.PointsDto
  Die zu mittelnden Punkte
Rückgabewert Point3
Der Durchschnittspunkt
Example
```
const center = bitbybit.point.averagePoint({ points: [[0, 0, 0], [10, 0, 0], [10, 10, 0]] });
```
- Definiert in bitbybit-docs.d.ts:56044

fillet

maxFilletRadius

maxFilletRadius(inputs: ThreePointsToleranceDto): number
Ermittelt die größte Verrundung, die in eine Ecke passt: der Bogen berührt beide Segmente und bleibt innerhalb von ihnen.

Die Ecke ist end; start und center sind die fernen Enden der beiden Segmente, die dort zusammentreffen. Der Radius wird durch das kürzere Segment begrenzt. Eine gerade oder zurückgefaltete Ecke, oder ein Segment, das kürzer als tolerance ist, ergibt 0.
Parameter
- inputs: ThreePointsToleranceDto
  Das ferne Ende jedes Segments, die gemeinsame Ecke und die Toleranz
Rückgabewert number
Der größte Verrundungsradius, in Modelleinheiten
Example
```
const radius = bitbybit.point.maxFilletRadius({ start: [10, 0, 0], center: [0, 10, 0], end: [0, 0, 0], tolerance: 1e-7 });
```
- Definiert in bitbybit-docs.d.ts:56151

maxFilletRadiusHalfLine

maxFilletRadiusHalfLine(inputs: ThreePointsToleranceDto): number
Ermittelt die größte Verrundung an einer Ecke, deren Bogen jedes Segment innerhalb seiner näheren Hälfte berührt, sodass benachbarte Ecken einer Polylinie jeweils verrundet werden können, ohne dass sich die Bögen überlappen.

Die Ecke ist end; start und center sind die fernen Enden der beiden Segmente. Eine gerade oder zurückgefaltete Ecke, oder ein Segment, das kürzer als tolerance ist, ergibt 0.
Parameter
- inputs: ThreePointsToleranceDto
  Das ferne Ende jedes Segments, die gemeinsame Ecke und die Toleranz
Rückgabewert number
Der größte Verrundungsradius nach der Halbsegment-Regel, in Modelleinheiten
Example
```
const radius = bitbybit.point.maxFilletRadiusHalfLine({ start: [10, 0, 0], center: [0, 10, 0], end: [0, 0, 0], tolerance: 1e-7 });
```
- Definiert in bitbybit-docs.d.ts:56168

maxFilletsHalfLine

maxFilletsHalfLine(inputs: PointsMaxFilletsHalfLineDto): number[]
Ermittelt die größte Verrundung für jede Ecke einer Polylinie, jede auf die nähere Hälfte ihrer Segmente begrenzt, sodass sich die Verrundungen nie überlappen.

Mit checkLastWithFirst an wird die Polylinie als geschlossen behandelt und die beiden Ecken an den Enden werden einbezogen. Weniger als drei Punkte ergeben eine leere Liste.
Parameter
- inputs: PointsMaxFilletsHalfLineDto
  Die Polylinienpunkte, ob sie geschlossen ist, und die Toleranz
Rückgabewert number[]
Ein Radius pro Ecke, in der Reihenfolge der Ecken
Example
```
const radii = bitbybit.point.maxFilletsHalfLine({
    points: [[0, 0, 0], [10, 0, 0], [10, 10, 0], [0, 10, 0]],
    checkLastWithFirst: true,
    tolerance: 1e-7,
});
```
- Definiert in bitbybit-docs.d.ts:56189

safestPointsMaxFilletHalfLine

safestPointsMaxFilletHalfLine(inputs: PointsMaxFilletsHalfLineDto): number
Ermittelt einen Verrundungsradius, der in jede Ecke einer Polylinie passt: das kleinste der Maxima pro Ecke nach der Halbsegment-Regel.

Mit checkLastWithFirst an wird die Polylinie als geschlossen behandelt. Weniger als drei Punkte, oder eine Ecke, die keine Verrundung erlaubt, ergeben 0.
Parameter
- inputs: PointsMaxFilletsHalfLineDto
  Die Polylinienpunkte, ob sie geschlossen ist, und die Toleranz
Rückgabewert number
Der Radius, der an jede Ecke passt, in Modelleinheiten
Example
```
const radius = bitbybit.point.safestPointsMaxFilletHalfLine({
    points: [[0, 0, 0], [10, 0, 0], [10, 10, 0], [0, 10, 0]],
    checkLastWithFirst: true,
    tolerance: 1e-7,
});
```
- Definiert in bitbybit-docs.d.ts:56210

get

getX

getX(inputs: Bit.Inputs.Point.PointDto): number
Liest den X-Wert eines Punkts.

Beispiel: [5,10,3] -> 5
Parameter
- inputs: Bit.Inputs.Point.PointDto
  Der Punkt
Rückgabewert number
Der X-Wert
- Definiert in bitbybit-docs.d.ts:56007

getY

getY(inputs: Bit.Inputs.Point.PointDto): number
Liest den Y-Wert eines Punkts, den, der nach oben zeigt.

Beispiel: [5,10,3] -> 10
Parameter
- inputs: Bit.Inputs.Point.PointDto
  Der Punkt
Rückgabewert number
Der Y-Wert
- Definiert in bitbybit-docs.d.ts:56018

getZ

getZ(inputs: Bit.Inputs.Point.PointDto): number
Liest den Z-Wert eines Punkts.

Beispiel: [5,10,3] -> 3
Parameter
- inputs: Bit.Inputs.Point.PointDto
  Der Punkt
Rückgabewert number
Der Z-Wert
- Definiert in bitbybit-docs.d.ts:56029

measure

distance

distance(inputs: StartEndPointsDto): number
Misst den geradlinigen Abstand zwischen zwei Punkten.

Beispiel: [0,0,0] nach [3,4,0] -> 5
Parameter
- inputs: StartEndPointsDto
  Die beiden Punkte
Rückgabewert number
Der Abstand in Modelleinheiten
Example
```
const d = bitbybit.point.distance({ startPoint: [0, 0, 0], endPoint: [3, 4, 0] });
```
- Definiert in bitbybit-docs.d.ts:55966

distancesToPoints

distancesToPoints(inputs: StartEndPointsListDto): number[]
Misst den Abstand von einem Punkt zu jedem Punkt in einer Liste.

Beispiel: Start [0,0,0] und Endpunkte [[3,0,0], [0,4,0], [5,0,0]] -> [3, 4, 5]
Parameter
- inputs: StartEndPointsListDto
  Der Startpunkt und die Punkte, zu denen gemessen wird
Rückgabewert number[]
Ein Abstand pro Endpunkt, in derselben Reihenfolge
Example
```
const distances = bitbybit.point.distancesToPoints({ startPoint: [0, 0, 0], endPoints: [[3, 0, 0], [0, 4, 0]] });
```
- Definiert in bitbybit-docs.d.ts:55981

twoPointsAlmostEqual

twoPointsAlmostEqual(inputs: TwoPointsToleranceDto): boolean
Sagt, ob zwei Punkte näher beieinander liegen als eine Toleranz.

Beispiel: [1.0000001, 2, 3] und [1, 2, 3] mit Toleranz 1e-6 -> true
Parameter
- inputs: TwoPointsToleranceDto
  Die beiden Punkte und die Toleranz
Rückgabewert boolean
True, wenn der Abstand zwischen ihnen unter der Toleranz liegt
Example
```
const same = bitbybit.point.twoPointsAlmostEqual({ point1: [1, 2, 3], point2: [1, 2, 3.0000001], tolerance: 1e-6 });
```
- Definiert in bitbybit-docs.d.ts:56270

sort

sortPoints

sortPoints(inputs: Bit.Inputs.Point.PointsDto): Point3[]
Sortiert Punkte nach X, dann nach Y bei gleichem X, dann nach Z.

Beispiel: [[5,0,0], [1,0,0], [3,0,0]] -> [[1,0,0], [3,0,0], [5,0,0]]
Parameter
- inputs: Bit.Inputs.Point.PointsDto
  Die zu sortierenden Punkte
Rückgabewert Point3[]
Eine sortierte Kopie der Punkte
Example
```
const sorted = bitbybit.point.sortPoints({ points: [[5, 0, 0], [1, 0, 0], [3, 0, 0]] });
```
- Definiert in bitbybit-docs.d.ts:56285

transforms

transformPoint

transformPoint(inputs: TransformPointDto): Point3
Wendet eine Transformationsmatrix, oder eine Liste davon der Reihe nach, auf einen Punkt an.

Beispiel: Punkt [0,0,0] mit einer Verschiebung um [5,5,0] -> [5,5,0]
Parameter
- inputs: TransformPointDto
  Der Punkt und die anzuwendende Transformation
Rückgabewert Point3
Der transformierte Punkt
Example
```
const moved = bitbybit.point.transformPoint({
    point: [0, 0, 0],
    transformation: bitbybit.transforms.translationXYZ({ translation: [5, 5, 0] }),
});
```
- Definiert in bitbybit-docs.d.ts:55741

transformPoints

transformPoints(inputs: TransformPointsDto): Point3[]
Wendet dieselbe Transformationsmatrix, oder Liste davon der Reihe nach, auf jeden Punkt an.

Beispiel: fünf Punkte mit einer 90-Grad-Drehung -> alle fünf zusammen gedreht
Parameter
- inputs: TransformPointsDto
  Die Punkte und die auf jeden anzuwendende Transformation
Rückgabewert Point3[]
Die transformierten Punkte, in derselben Reihenfolge
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 }),
});
```
- Definiert in bitbybit-docs.d.ts:55759

transformsForPoints

transformsForPoints(inputs: TransformsForPointsDto): Point3[]
Wendet auf jeden Punkt eine andere Transformation an: die erste Transformation auf den ersten Punkt, und so weiter.

Die beiden Listen müssen gleich lang sein, sonst wird ein Fehler ausgelöst. Beispiel: drei Punkte mit drei Verschiebungen -> jeder Punkt um seine eigene Verschiebung bewegt
Parameter
- inputs: TransformsForPointsDto
  Die Punkte und eine Transformation pro Punkt
Rückgabewert Point3[]
Die transformierten Punkte, in derselben Reihenfolge
Example
```
const placed = bitbybit.point.transformsForPoints({
    points: [[0, 0, 0], [1, 0, 0]],
    transformation: bitbybit.transforms.translationsXYZ({ translations: [[0, 1, 0], [0, 2, 0]] }),
});
```
- Definiert in bitbybit-docs.d.ts:55779

translatePoints

translatePoints(inputs: TranslatePointsDto): Point3[]
Verschiebt jeden Punkt um denselben Vektor.

Beispiel: Punkte [[0,0,0], [1,0,0]] um [5,5,0] -> [[5,5,0], [6,5,0]]
Parameter
- inputs: TranslatePointsDto
  Die Punkte und der Vektor, um den sie verschoben werden
Rückgabewert Point3[]
Die verschobenen Punkte, in derselben Reihenfolge
Example
```
const moved = bitbybit.point.translatePoints({ points: [[0, 0, 0], [1, 0, 0]], translation: [5, 5, 0] });
```
- Definiert in bitbybit-docs.d.ts:55794

translatePointsWithVectors

translatePointsWithVectors(inputs: TranslatePointsWithVectorsDto): Point3[]
Verschiebt jeden Punkt um seinen eigenen Vektor: den ersten Punkt um den ersten Vektor, und so weiter.

Die beiden Listen müssen gleich lang sein, sonst wird ein Fehler ausgelöst. Beispiel: drei Punkte mit drei Vektoren -> jeder Punkt um seinen eigenen Vektor bewegt
Parameter
- inputs: TranslatePointsWithVectorsDto
  Die Punkte und ein Vektor pro Punkt
Rückgabewert Point3[]
Die verschobenen Punkte, in derselben Reihenfolge
Example
```
const moved = bitbybit.point.translatePointsWithVectors({
    points: [[0, 0, 0], [1, 0, 0]],
    translations: [[0, 1, 0], [0, 2, 0]],
});
```
- Definiert in bitbybit-docs.d.ts:55813

translateXYZPoints

translateXYZPoints(inputs: TranslateXYZPointsDto): Point3[]
Verschiebt jeden Punkt um die gegebenen x-, y- und z-Beträge.

Beispiel: Punkt [0,0,0] mit x=10, y=5, z=0 -> [10,5,0]
Parameter
- inputs: TranslateXYZPointsDto
  Die Punkte und der Abstand, um den entlang jeder Achse verschoben wird
Rückgabewert Point3[]
Die verschobenen Punkte, in derselben Reihenfolge
Example
```
const lifted = bitbybit.point.translateXYZPoints({ points: [[0, 0, 0], [1, 0, 0]], x: 0, y: 5, z: 0 });
```
- Definiert in bitbybit-docs.d.ts:55828

scalePointsCenterXYZ

scalePointsCenterXYZ(inputs: ScalePointsCenterXYZDto): Point3[]
Skaliert Punkte von einem Mittelpunkt weg oder zu ihm hin, mit eigenem Faktor pro Achse.

Beispiel: Punkt [10,0,0] um Mittelpunkt [5,0,0] mit Faktoren [2,1,1] -> [15,0,0]
Parameter
- inputs: ScalePointsCenterXYZDto
  Die Punkte, das Zentrum, um das skaliert wird, und der Faktor pro Achse
Rückgabewert Point3[]
Die skalierten Punkte, in derselben Reihenfolge
Example
```
const stretched = bitbybit.point.scalePointsCenterXYZ({
    points: [[10, 0, 0], [0, 10, 0]],
    center: [0, 0, 0],
    scaleXyz: [2, 1, 1],
});
```
- Definiert in bitbybit-docs.d.ts:55847

stretchPointsDirFromCenter

stretchPointsDirFromCenter(inputs: StretchPointsDirFromCenterDto): Point3[]
Streckt Punkte entlang einer Richtung, gemessen von einem Mittelpunkt; Abstände quer zu dieser Richtung bleiben, wie sie sind.

Beispiel: Punkt [10,0,0] von Mittelpunkt [0,0,0] entlang [1,0,0] mit Skalierung 2 -> [20,0,0]
Parameter
- inputs: StretchPointsDirFromCenterDto
  Die Punkte, das Zentrum, die Richtung, entlang der gestreckt wird, und der Faktor
Rückgabewert Point3[]
Die gestreckten Punkte, in derselben Reihenfolge
Example
```
const taller = bitbybit.point.stretchPointsDirFromCenter({
    points: [[0, 1, 0], [0, 2, 0]],
    center: [0, 0, 0],
    direction: [0, 1, 0],
    scale: 2,
});
```
- Definiert in bitbybit-docs.d.ts:55868

rotatePointsCenterAxis

rotatePointsCenterAxis(inputs: RotatePointsCenterAxisDto): Point3[]
Dreht Punkte um eine Achse, die durch einen Mittelpunkt verläuft.

Der Winkel ist in Grad und dreht gegen den Uhrzeigersinn, wenn die Achse auf Sie zeigt. Beispiel: Punkt [10,0,0] um die Y-Achse durch [0,0,0] um 90 -> [0,0,-10]
Parameter
- inputs: RotatePointsCenterAxisDto
  Die Punkte, die Achsenrichtung, das Zentrum, durch das sie verläuft, und der Winkel in Grad
Rückgabewert Point3[]
Die gedrehten Punkte, in derselben Reihenfolge
Example
```
const turned = bitbybit.point.rotatePointsCenterAxis({
    points: [[10, 0, 0]],
    center: [0, 0, 0],
    axis: [0, 1, 0],
    angle: 90,
});
```
- Definiert in bitbybit-docs.d.ts:55889

multiplyPoint

multiplyPoint(inputs: MultiplyPointDto): Point3[]
Wiederholt einen Punkt eine gegebene Anzahl von Malen in einer Liste.

Beispiel: Punkt [5,5,0] dreimal -> [[5,5,0], [5,5,0], [5,5,0]]
Parameter
- inputs: MultiplyPointDto
  Der Punkt und wie viele Kopien erstellt werden
Rückgabewert Point3[]
Die Liste der Kopien
Example
```
const copies = bitbybit.point.multiplyPoint({ point: [5, 5, 0], amountOfPoints: 3 });
```
- Definiert in bitbybit-docs.d.ts:55996

Klasse Point

Index

Konstruktoren

clean

create

extract

fillet

get

measure

sort

transforms

Konstruktoren

constructor

Parameter

Rückgabewert Bit.Point

clean

removeConsecutiveDuplicates

Parameter

Rückgabewert Point3[]

Example

create

pointXYZ

Parameter

Rückgabewert Point3

Example

pointXY

Parameter

Rückgabewert Point2

Example

spiral

Parameter

Rückgabewert Point3[]

Example

hexGrid

Parameter

Rückgabewert Point3[]

Example

hexGridScaledToFit

Parameter

Rückgabewert HexGridData

Example

normalFromThreePoints

Parameter

Rückgabewert Vector3

Example

extract

boundingBoxOfPoints

Parameter

Rückgabewert BoundingBox

Example

closestPointFromPointsDistance

Parameter

Rückgabewert number

Example

closestPointFromPointsIndex

Parameter

Rückgabewert number

Example

closestPointFromPoints

Parameter

Rückgabewert Point3

Example

averagePoint

Parameter

Rückgabewert Point3

Example

fillet

maxFilletRadius

Parameter

Rückgabewert number

Example

maxFilletRadiusHalfLine

Parameter

Rückgabewert number

Example

maxFilletsHalfLine

Parameter

Rückgabewert number[]

Example

safestPointsMaxFilletHalfLine