Class Point

सादे संख्या एरे के रूप में पॉइंट। पॉइंट [x, y, z] है जिसमें Y ऊपर की ओर है, वेक्टर जैसा ही आकार, इसलिए दोनों को एक-दूसरे के मेथड में पास किया जा सकता है; 2D पॉइंट [x, y] है। हर मेथड नए पॉइंट या संख्याएँ लौटाता है और अपने इनपुट को कभी नहीं बदलता। कोण डिग्री में और लंबाइयाँ मॉडल इकाइयों में हैं।

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[]
किसी पॉइंट को तब हटाता है जब वह ठीक अपने से पहले वाले को दोहराता है; दूर स्थित वही पॉइंट रखा जाता है।

checkFirstAndLast चालू होने पर, पहले को दोहराने वाला अंतिम पॉइंट भी हटा दिया जाता है। एक-दूसरे से tolerance के भीतर के पॉइंट एक जैसे माने जाते हैं। उदाहरण: [[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
  पॉइंट, टॉलरेंस और क्या पहले और अंतिम की तुलना करनी है
Returns Point3[]
लगातार दोहराव रहित पॉइंट
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
x, y और z मानों से एक 3D पॉइंट बनाता है।

उदाहरण: x=10, y=5, z=3 -> [10,5,3]
Parameters
- inputs: PointXYZDto
  तीन मान
Returns Point3
पॉइंट [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
x और y मानों से एक 2D पॉइंट बनाता है।

उदाहरण: x=10, y=5 -> [10,5]
Parameters
- inputs: PointXYDto
  दो मान
Returns Point2
पॉइंट [x, y]
Example
```
const point = bitbybit.point.pointXY({ x: 10, y: 5 });
```
- Defined in bitbybit-docs.d.ts:56074

spiral

spiral(inputs: SpiralDto): Point3[]
XY प्लेन में एक लघुगणकीय सर्पिल के साथ पॉइंट बिछाता है, मूल बिंदु से बाहर की ओर radius तक।

numberPoints तय करता है कि कितने पॉइंट रखे जाएँ, phi और widening कि सर्पिल कितनी तेज़ी से खुलता है, और factor कि वक्र पर वह कहाँ से शुरू होता है। हर पॉइंट का z = 0 है।
Parameters
- inputs: SpiralDto
  पॉइंट की संख्या, त्रिज्या और सर्पिल का शेप
Returns Point3[]
सर्पिल के साथ के पॉइंट, केंद्र से बाहर की ओर
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[]
XY प्लेन में षट्भुजों के मधुकोश के केंद्र बिछाता है।

radiusHexagon षट्भुज के केंद्र से कोने तक की दूरी है; कॉलम X के साथ और पंक्तियाँ Y के साथ चलती हैं, हर दूसरी पंक्ति आधे कॉलम से खिसकी हुई। orientOnCenter ग्रिड को मूल बिंदु पर केंद्रित करता है, pointsOnGround उसे XZ प्लेन पर बिछाता है।
Parameters
- inputs: HexGridCentersDto
  षट्भुज का आकार, कितने कॉलम और पंक्तियाँ, और ग्रिड कहाँ रखना है
Returns Point3[]
केंद्र पॉइंट, पंक्ति दर पंक्ति
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
षट्भुजों का ऐसा मधुकोश बिछाता है जो दी गई चौड़ाई और ऊँचाई भरता है, षट्भुजों का आकार गिनतियों से तय करते हुए।

परिणाम में केंद्र पॉइंट और हर षट्भुज के छह कोने होते हैं। कोना ऊपर की ओर होता है जब तक flatTop सेट न हो; extend फ़्लैग बाहरी पंक्तियों को किनारों के पार खींचते हैं ताकि आयत बिना दाँतेदार सीमा के ढक जाए।
Parameters
- inputs: HexGridScaledToFitDto
  भरा जाने वाला क्षेत्र, षट्भुजों की संख्याएँ, ओरिएंटेशन और प्लेसमेंट विकल्प
Returns HexGridData
प्रत्येक षट्भुज के केंद्र और कोने के पॉइंट
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
तीन पॉइंट से गुज़रने वाले प्लेन के समकोण पर दिशा खोजता है, लंबाई 1 के साथ।

दिशा पहले पॉइंट से दूसरे और फिर तीसरे तक जाते हुए दाएँ हाथ के नियम का पालन करती है; reverseNormal उसे पलटता है। एक रेखा पर स्थित पॉइंट का कोई प्लेन नहीं होता, इसलिए परिणाम undefined है। उदाहरण: [0,0,0], [1,0,0], [0,1,0] -> [0,0,1]
Parameters
- inputs: ThreePointsNormalDto
  तीन पॉइंट और क्या परिणाम को पलटना है
Returns Vector3
इकाई नॉर्मल, या undefined जब पॉइंट एक ही लाइन पर हों
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
सबसे छोटा अक्ष-संरेखित बॉक्स खोजता है जो सभी पॉइंट को समेटता है।

परिणाम में न्यूनतम और अधिकतम कोने, केंद्र, और चौड़ाई (X), ऊँचाई (Y) और लंबाई (Z) होती है। उदाहरण: पॉइंट [[0,0,0], [10,5,3]] -> न्यूनतम [0,0,0], अधिकतम [10,5,3], केंद्र [5,2.5,1.5]
Parameters
- inputs: Bit.Inputs.Point.PointsDto
  घेरे जाने वाले पॉइंट
Returns BoundingBox
बाउंडिंग बॉक्स, उसके कोनों, केंद्र और आकारों के साथ
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
एक पॉइंट से सूची के निकटतम पॉइंट तक की दूरी मापता है।

उदाहरण: पॉइंट [0,0,0] और पॉइंट [[5,0,0], [10,0,0], [3,0,0]] -> 3
Parameters
- inputs: ClosestPointFromPointsDto
  वह पॉइंट जिससे मापना है और वे पॉइंट जिनमें खोजना है
Returns number
निकटतम पॉइंट तक की दूरी, मॉडल इकाइयों में
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
सूची में निकटतम पॉइंट की स्थिति खोजता है, 1 से गिनते हुए।

उदाहरण: पॉइंट [0,0,0] और पॉइंट [[5,0,0], [10,0,0], [3,0,0]] -> 3
Parameters
- inputs: ClosestPointFromPointsDto
  वह पॉइंट जिससे मापना है और वे पॉइंट जिनमें खोजना है
Returns number
निकटतम पॉइंट का 1-आधारित इंडेक्स
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
किसी दिए गए पॉइंट के लिए सूची का निकटतम पॉइंट खोजता है।

उदाहरण: पॉइंट [0,0,0] और पॉइंट [[5,0,0], [10,0,0], [3,0,0]] -> [3,0,0]
Parameters
- inputs: ClosestPointFromPointsDto
  वह पॉइंट जिससे मापना है और वे पॉइंट जिनमें खोजना है
Returns Point3
निकटतम पॉइंट
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
पॉइंट का औसत खोजता है, जो समान भार होने पर उनका द्रव्यमान केंद्र है।

उदाहरण: [[0,0,0], [10,0,0], [10,10,0]] -> [6.67,3.33,0]
Parameters
- inputs: Bit.Inputs.Point.PointsDto
  वे पॉइंट जिनका औसत निकालना है
Returns Point3
औसत पॉइंट
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
कोने में फ़िट होने वाला सबसे बड़ा फिलेट खोजता है: चाप दोनों खंडों को छूता है और उनके भीतर रहता है।

कोना end है; start और center वहाँ मिलने वाले दो खंडों के दूर के सिरे हैं। त्रिज्या छोटे खंड से सीमित होती है। सीधा या पीछे मुड़ा कोना, या tolerance से छोटा खंड, 0 देता है।
Parameters
- inputs: ThreePointsToleranceDto
  प्रत्येक सेगमेंट का दूर वाला सिरा, उनका साझा कोना, और टॉलरेंस
Returns number
सबसे बड़ी फिलेट त्रिज्या, मॉडल इकाइयों में
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
ऐसे कोने पर सबसे बड़ा फिलेट खोजता है जिसका चाप हर खंड को उसके निकट आधे के भीतर छूता है, ताकि पॉलीलाइन के पड़ोसी कोनों में से हर एक को बिना चापों के ओवरलैप हुए फिलेट किया जा सके।

कोना end है; start और center दो खंडों के दूर के सिरे हैं। सीधा या पीछे मुड़ा कोना, या tolerance से छोटा खंड, 0 देता है।
Parameters
- inputs: ThreePointsToleranceDto
  प्रत्येक सेगमेंट का दूर वाला सिरा, उनका साझा कोना, और टॉलरेंस
Returns number
आधे-सेगमेंट नियम के तहत सबसे बड़ी फिलेट त्रिज्या, मॉडल इकाइयों में
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[]
पॉलीलाइन के हर कोने के लिए सबसे बड़ा फिलेट खोजता है, हर एक अपने खंडों के निकट आधे तक सीमित ताकि फिलेट कभी ओवरलैप न हों।

checkLastWithFirst चालू होने पर, पॉलीलाइन बंद मानी जाती है और सिरों के दो कोने शामिल होते हैं। तीन से कम पॉइंट खाली सूची देते हैं।
Parameters
- inputs: PointsMaxFilletsHalfLineDto
  पॉलीलाइन के पॉइंट, क्या वह बंद है, और टॉलरेंस
Returns number[]
प्रत्येक कोने के लिए एक त्रिज्या, कोनों के क्रम में
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
एक ऐसी फिलेट त्रिज्या खोजता है जो पॉलीलाइन के हर कोने में फ़िट हो: आधे-खंड नियम के तहत प्रति-कोना अधिकतमों में सबसे छोटी।

checkLastWithFirst चालू होने पर, पॉलीलाइन बंद मानी जाती है। तीन से कम पॉइंट, या कोई भी कोना जो फिलेट की अनुमति नहीं देता, 0 देते हैं।
Parameters
- inputs: PointsMaxFilletsHalfLineDto
  पॉलीलाइन के पॉइंट, क्या वह बंद है, और टॉलरेंस
Returns number
वह त्रिज्या जो हर कोने में फ़िट होती है, मॉडल इकाइयों में
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
पॉइंट का X मान पढ़ता है।

उदाहरण: [5,10,3] -> 5
Parameters
- inputs: Bit.Inputs.Point.PointDto
  पॉइंट
Returns number
X मान
- Defined in bitbybit-docs.d.ts:56007

getY

getY(inputs: Bit.Inputs.Point.PointDto): number
पॉइंट का Y मान पढ़ता है, वह जो ऊपर की ओर इशारा करता है।

उदाहरण: [5,10,3] -> 10
Parameters
- inputs: Bit.Inputs.Point.PointDto
  पॉइंट
Returns number
Y मान
- Defined in bitbybit-docs.d.ts:56018

getZ

getZ(inputs: Bit.Inputs.Point.PointDto): number
पॉइंट का Z मान पढ़ता है।

उदाहरण: [5,10,3] -> 3
Parameters
- inputs: Bit.Inputs.Point.PointDto
  पॉइंट
Returns number
Z मान
- Defined in bitbybit-docs.d.ts:56029

measure

distance

distance(inputs: StartEndPointsDto): number
दो पॉइंट के बीच की सीधी दूरी मापता है।

उदाहरण: [0,0,0] से [3,4,0] -> 5
Parameters
- inputs: StartEndPointsDto
  दोनों पॉइंट
Returns number
दूरी, मॉडल इकाइयों में
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[]
एक पॉइंट से सूची के हर पॉइंट तक की दूरी मापता है।

उदाहरण: शुरुआत [0,0,0] और अंत पॉइंट [[3,0,0], [0,4,0], [5,0,0]] -> [3, 4, 5]
Parameters
- inputs: StartEndPointsListDto
  आरंभ पॉइंट और वे पॉइंट जिन तक मापना है
Returns number[]
प्रत्येक अंत पॉइंट के लिए एक दूरी, उसी क्रम में
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
बताता है कि दो पॉइंट एक टॉलरेंस से अधिक पास हैं या नहीं।

उदाहरण: [1.0000001, 2, 3] और [1, 2, 3] टॉलरेंस 1e-6 के साथ -> true
Parameters
- inputs: TwoPointsToleranceDto
  दोनों पॉइंट और टॉलरेंस
Returns boolean
true जब उनके बीच की दूरी टॉलरेंस से कम हो
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[]
पॉइंट को X से, फिर समान X के लिए Y से, फिर Z से क्रमबद्ध करता है।

उदाहरण: [[5,0,0], [1,0,0], [3,0,0]] -> [[1,0,0], [3,0,0], [5,0,0]]
Parameters
- inputs: Bit.Inputs.Point.PointsDto
  क्रमबद्ध किए जाने वाले पॉइंट
Returns Point3[]
पॉइंट की एक क्रमबद्ध प्रतिलिपि
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
एक पॉइंट पर एक ट्रांसफॉर्मेशन मैट्रिक्स, या क्रम में उनकी सूची, लागू करता है।

उदाहरण: पॉइंट [0,0,0] [5,5,0] के ट्रांसलेशन के साथ -> [5,5,0]
Parameters
- inputs: TransformPointDto
  पॉइंट और लागू किया जाने वाला ट्रांसफॉर्मेशन
Returns Point3
ट्रांसफॉर्म किया गया पॉइंट
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[]
हर पॉइंट पर वही ट्रांसफॉर्मेशन मैट्रिक्स, या क्रम में उनकी सूची, लागू करता है।

उदाहरण: पाँच पॉइंट 90 डिग्री रोटेशन के साथ -> सभी पाँच एक साथ घुमाए गए
Parameters
- inputs: TransformPointsDto
  पॉइंट और प्रत्येक पर लागू किया जाने वाला ट्रांसफॉर्मेशन
Returns Point3[]
ट्रांसफॉर्म किए गए पॉइंट, उसी क्रम में
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[]
हर पॉइंट पर एक अलग ट्रांसफॉर्मेशन लागू करता है: पहला ट्रांसफॉर्मेशन पहले पॉइंट पर, और इसी तरह आगे।

दोनों सूचियों की लंबाई समान होनी चाहिए, अन्यथा त्रुटि फेंकी जाती है। उदाहरण: तीन पॉइंट तीन ट्रांसलेशन के साथ -> हर पॉइंट अपने ट्रांसलेशन से हिलाया गया
Parameters
- inputs: TransformsForPointsDto
  पॉइंट और प्रत्येक पॉइंट के लिए एक ट्रांसफॉर्मेशन
Returns Point3[]
ट्रांसफॉर्म किए गए पॉइंट, उसी क्रम में
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[]
हर पॉइंट को एक ही वेक्टर से हिलाता है।

उदाहरण: पॉइंट [[0,0,0], [1,0,0]] [5,5,0] से -> [[5,5,0], [6,5,0]]
Parameters
- inputs: TranslatePointsDto
  पॉइंट और वह वेक्टर जितना उन्हें स्थानांतरित करना है
Returns Point3[]
स्थानांतरित पॉइंट, उसी क्रम में
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[]
हर पॉइंट को उसके अपने वेक्टर से हिलाता है: पहला पॉइंट पहले वेक्टर से, और इसी तरह आगे।

दोनों सूचियों की लंबाई समान होनी चाहिए, अन्यथा त्रुटि फेंकी जाती है। उदाहरण: तीन पॉइंट तीन वेक्टरों के साथ -> हर पॉइंट अपने वेक्टर से हिलाया गया
Parameters
- inputs: TranslatePointsWithVectorsDto
  पॉइंट और प्रत्येक पॉइंट के लिए एक वेक्टर
Returns Point3[]
स्थानांतरित पॉइंट, उसी क्रम में
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[]
हर पॉइंट को दी गई x, y और z मात्राओं से हिलाता है।

उदाहरण: पॉइंट [0,0,0] x=10, y=5, z=0 के साथ -> [10,5,0]
Parameters
- inputs: TranslateXYZPointsDto
  पॉइंट और प्रत्येक अक्ष के साथ स्थानांतरित करने की दूरी
Returns Point3[]
स्थानांतरित पॉइंट, उसी क्रम में
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[]
पॉइंट को किसी केंद्र से दूर या उसकी ओर स्केल करता है, प्रति अक्ष अपने गुणक के साथ।

उदाहरण: पॉइंट [10,0,0] केंद्र [5,0,0] के सापेक्ष गुणक [2,1,1] के साथ -> [15,0,0]
Parameters
- inputs: ScalePointsCenterXYZDto
  पॉइंट, वह केंद्र जिसके सापेक्ष स्केल करना है और प्रति अक्ष गुणांक
Returns Point3[]
स्केल किए गए पॉइंट, उसी क्रम में
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[]
पॉइंट को एक दिशा में, किसी केंद्र से मापकर, खींचता है; उस दिशा के आर-पार की दूरियाँ जैसी हैं वैसी रहती हैं।

उदाहरण: पॉइंट [10,0,0] केंद्र [0,0,0] से [1,0,0] की दिशा में स्केल 2 के साथ -> [20,0,0]
Parameters
- inputs: StretchPointsDirFromCenterDto
  पॉइंट, केंद्र, वह दिशा जिसके साथ खींचना है और गुणांक
Returns Point3[]
खींचे गए पॉइंट, उसी क्रम में
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[]
पॉइंट को किसी केंद्र से गुज़रने वाली अक्ष के चारों ओर घुमाता है।

कोण डिग्री में है और अक्ष के आपकी ओर इशारा करने पर वामावर्त घूमता है। उदाहरण: पॉइंट [10,0,0] [0,0,0] से गुज़रती Y अक्ष के चारों ओर 90 से -> [0,0,-10]
Parameters
- inputs: RotatePointsCenterAxisDto
  पॉइंट, अक्ष की दिशा, वह केंद्र जिससे वह गुज़रता है और कोण, डिग्री में
Returns Point3[]
घुमाए गए पॉइंट, उसी क्रम में
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[]
एक पॉइंट को दी गई संख्या में बार एक सूची में दोहराता है।

उदाहरण: पॉइंट [5,5,0] तीन बार -> [[5,5,0], [5,5,0], [5,5,0]]
Parameters
- inputs: MultiplyPointDto
  पॉइंट और कितनी प्रतिलिपियाँ बनानी हैं
Returns Point3[]
प्रतिलिपियों की सूची
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