diff --git a/content/kcl-test-outputs/serial_test_example_fn_std-gdt-distance0.png b/content/kcl-test-outputs/serial_test_example_fn_std-gdt-distance0.png index 59570312..74546b9c 100644 Binary files a/content/kcl-test-outputs/serial_test_example_fn_std-gdt-distance0.png and b/content/kcl-test-outputs/serial_test_example_fn_std-gdt-distance0.png differ diff --git a/content/kcl-test-outputs/serial_test_example_fn_std-gdt-distance1.png b/content/kcl-test-outputs/serial_test_example_fn_std-gdt-distance1.png index 6217eef8..351863a8 100644 Binary files a/content/kcl-test-outputs/serial_test_example_fn_std-gdt-distance1.png and b/content/kcl-test-outputs/serial_test_example_fn_std-gdt-distance1.png differ diff --git a/content/kcl-test-outputs/serial_test_example_fn_std-gdt-distance2.png b/content/kcl-test-outputs/serial_test_example_fn_std-gdt-distance2.png index c8e62dfe..cdab4c48 100644 Binary files a/content/kcl-test-outputs/serial_test_example_fn_std-gdt-distance2.png and b/content/kcl-test-outputs/serial_test_example_fn_std-gdt-distance2.png differ diff --git a/content/pages/docs/kcl-lang/edge-references.md b/content/pages/docs/kcl-lang/edge-references.md new file mode 100644 index 00000000..a5255992 --- /dev/null +++ b/content/pages/docs/kcl-lang/edge-references.md @@ -0,0 +1,98 @@ +--- +title: "Face API Edge References" +excerpt: "Identifying edges by their surrounding faces in KCL." +layout: manual +--- + +The face API identifies an edge from the faces around it instead of relying on +the edge's position in a body's internal ordering. This makes references more +stable when earlier modeling operations change the body's topology. + +For most solid edges, the two adjacent faces uniquely identify the edge. Put +those faces in `sideFaces`: + +```kcl,norun +fillet( + body001, + radius = 2, + edges = [{ + sideFaces = [region001.tags.bottom, endCap] + }], +) +``` + +The faces in `sideFaces` run along the length of the edge. An operation can +split an edge into multiple edges that still have the same side faces. To select +one split, add an `endFaces` entry for a face touching the end of the intended +edge: + +```kcl,norun +{ + sideFaces = [region001.tags.bottom, region001.tags.right], + endFaces = [startCap] +} +``` + +Some solid-modeling topology can leave multiple edges with the same side and +end faces. In that case, `index` selects one of the remaining matches using a +zero-based index: + +```kcl,norun +{ + sideFaces = [region001.tags.bottom, endCap], + index = 1 +} +``` + +Prefer `sideFaces` alone when it is unambiguous. Add `endFaces` when an edge has +been split, and use `index` only when the face information still leaves more +than one match. When a Face API selection supplies an edge-reference object, +keep the fields it provides rather than converting the selection to legacy +edge helpers. + +An edge-reference object does not have to identify exactly one edge. A broader +reference can intentionally match multiple edges so that an operation applies +to all of them. Add `endFaces` or `index` only when the operation should target +a smaller subset of those matches. + +Surface bodies do not always provide two side faces or useful end faces. Their +edge references can therefore contain a single `sideFaces` entry and rely on +`index` more often to choose a boundary edge. + +The same edge-reference object can be used by operations such as `fillet`, +`chamfer`, `revolve`, `helix`, and `mirror3d` where their parameter accepts an +edge. + +Sketch segments remain direct references, such as `sketch001.line1`. Edge +reference objects are for edges on generated bodies, where adjacent face tags +provide a stable description of the intended geometry. + +## Edges involving generated faces + +Fillets and chamfers create new faces that can form part of edges used by later +operations. Add `tag` to the edge-treatment operation to name its generated +face, then use that tag in the later edge reference. The existing operation +produces the face and should remain in the model; selecting one of its generated +faces does not mean replacing the operation itself. + +For example, this fillet targets the edge shared by the existing chamfer face +and the extrusion's end cap: + +```kcl,norun +chamfer001 = chamfer( + body001, + edges = [{ + sideFaces = [region001.tags.right, region001.tags.bottom] + }], + length = 4, + tag = $chamferFace, +) + +fillet001 = fillet( + body001, + edges = [{ + sideFaces = [chamferFace, endCap] + }], + radius = 2, +) +``` diff --git a/content/pages/docs/kcl-lang/index.md b/content/pages/docs/kcl-lang/index.md index fa50e40c..2eec33ee 100644 --- a/content/pages/docs/kcl-lang/index.md +++ b/content/pages/docs/kcl-lang/index.md @@ -18,6 +18,7 @@ things in a more tutorial fashion. See also our documentation of the [standard l * [Arrays and ranges](/docs/kcl-lang/arrays) * [Enums](/docs/kcl-lang/enums) * [Sketch on Face](/docs/kcl-lang/sketch-on-face) +* [Edge references](/docs/kcl-lang/edge-references) * [Projects and modules](/docs/kcl-lang/modules) * [Attributes](/docs/kcl-lang/attributes) * [Python-to-KCL Cheat Sheet](/docs/kcl-lang/python-cheat-sheet) diff --git a/content/pages/docs/kcl-samples/angle-gauge/main.kcl b/content/pages/docs/kcl-samples/angle-gauge/main.kcl index 9c52acf7..31d14b95 100644 --- a/content/pages/docs/kcl-samples/angle-gauge/main.kcl +++ b/content/pages/docs/kcl-samples/angle-gauge/main.kcl @@ -46,13 +46,13 @@ gaugeProfileSketch = sketch(on = XY) { vertical(lowerRightOuterEdge) horizontalDistance([ - bottomOuterEdge.end, - bottomOuterEdge.start -]) == gaugeDepth + bottomOuterEdge.end, + bottomOuterEdge.start + ]) == gaugeDepth verticalDistance([ - lowerRightOuterEdge.end, - lowerRightOuterEdge.start -]) == lowerCutoutStartY + lowerRightOuterEdge.end, + lowerRightOuterEdge.start + ]) == lowerCutoutStartY // Angled cutout profile. cutoutAngledEdge = line(start = [var 1.5in, var 0.19in], end = [var 0.5in, var 0.37in]) @@ -89,18 +89,18 @@ gaugeProfileSketch = sketch(on = XY) { horizontal(cutoutAngleReferenceEdge) vertical(cutoutLeftVerticalEdge) angleDimension( - lines = [ - cutoutAngleReferenceEdge, - cutoutAngledEdge - ], - sector = 1, -) == cutoutAngle + lines = [ + cutoutAngleReferenceEdge, + cutoutAngledEdge + ], + sector = 1, + ) == cutoutAngle horizontalDistance([cutoutTopEdge.start, cutoutTopEdge.end]) == cutoutDepth verticalDistance([ - rightCutoutConstructionEdge.end, - rightCutoutConstructionEdge.start -]) == cutoutWidth + rightCutoutConstructionEdge.end, + rightCutoutConstructionEdge.start + ]) == cutoutWidth verticalDistance([leftOuterEdge.start, leftOuterEdge.end]) == gaugeWidth coincident([ rightCutoutConstructionEdge.end, diff --git a/content/pages/docs/kcl-samples/bracket-with-slot/main.kcl b/content/pages/docs/kcl-samples/bracket-with-slot/main.kcl index aad494ca..ff963067 100644 --- a/content/pages/docs/kcl-samples/bracket-with-slot/main.kcl +++ b/content/pages/docs/kcl-samples/bracket-with-slot/main.kcl @@ -133,9 +133,9 @@ tabHoleSketch = sketch(on = tabHolePlane) { ]) horizontal(countersinkGuide) horizontalDistance([ - countersinkGuide.start, - countersinkGuide.end -]) == countersinkOuterDiameter / 2 + countersinkGuide.start, + countersinkGuide.end + ]) == countersinkOuterDiameter / 2 coincident([ fastenerCircle.center, @@ -246,9 +246,9 @@ slotProfile = sketch(on = XY) { vertical(rightBottomGuide) horizontalDistance([ - slotCenterline.start, - slotCenterline.end -]) == slotOverallLength + slotCenterline.start, + slotCenterline.end + ]) == slotOverallLength radius(arc2) == slotWidth / 2 radius(arc4) == slotWidth / 2 coincident([ diff --git a/content/pages/docs/kcl-samples/ceiling-fan/main.kcl b/content/pages/docs/kcl-samples/ceiling-fan/main.kcl index 7458b78d..095fdd47 100644 --- a/content/pages/docs/kcl-samples/ceiling-fan/main.kcl +++ b/content/pages/docs/kcl-samples/ceiling-fan/main.kcl @@ -143,23 +143,23 @@ bladeProfile = sketch(on = bladePlane) { verticalDistance([bladeAxisSpan.start, bladeAxisSpan.end]) == bladeSpanLength - bladeTipRadius verticalDistance([bladeAxisTip.start, bladeAxisTip.end]) == bladeTipRadius horizontalDistance([ - rootGuideRight.start, - rootGuideRight.end -]) == bladeRootHalfWidth + rootGuideRight.start, + rootGuideRight.end + ]) == bladeRootHalfWidth horizontalDistance([rootGuideLeft.start, rootGuideLeft.end]) == bladeRootHalfWidth horizontalDistance([ - neckGuideRight.start, - neckGuideRight.end -]) == bladeNeckHalfWidth + neckGuideRight.start, + neckGuideRight.end + ]) == bladeNeckHalfWidth horizontalDistance([neckGuideLeft.start, neckGuideLeft.end]) == bladeNeckHalfWidth horizontalDistance([ - tipCenterGuideRight.start, - tipCenterGuideRight.end -]) == bladeTipFlatHalfWidth + tipCenterGuideRight.start, + tipCenterGuideRight.end + ]) == bladeTipFlatHalfWidth horizontalDistance([ - tipCenterGuideLeft.start, - tipCenterGuideLeft.end -]) == bladeTipFlatHalfWidth + tipCenterGuideLeft.start, + tipCenterGuideLeft.end + ]) == bladeTipFlatHalfWidth } // Step 2: extrude the solved blade blank. @@ -199,9 +199,9 @@ voidProfile = sketch(on = YZ) { vertical(outerEdge) tangent([bottomEdge, innerArc]) verticalDistance([ - baseOffsetGuide.start, - baseOffsetGuide.end -]) == voidCutoutBottomOffset + baseOffsetGuide.start, + baseOffsetGuide.end + ]) == voidCutoutBottomOffset verticalDistance([arcRiseGuide.start, arcRiseGuide.end]) == voidCutoutHeight horizontalDistance([topEdge.start, topEdge.end]) == voidCutoutLength diff --git a/content/pages/docs/kcl-samples/cold-plate/main.kcl b/content/pages/docs/kcl-samples/cold-plate/main.kcl index e5794ee5..20d74e79 100644 --- a/content/pages/docs/kcl-samples/cold-plate/main.kcl +++ b/content/pages/docs/kcl-samples/cold-plate/main.kcl @@ -314,42 +314,42 @@ copperTubePath = sketch(on = offsetPlane(XY, offset = tubeDiameter)) { horizontalDistance([inletGuide.start, inletGuide.end]) == tubeInletX verticalDistance([inletGuide.start, inletGuide.end]) == tubeLowerPassY horizontalDistance([ - rightLowerLoopGuide.start, - rightLowerLoopGuide.end -]) == tubeRightLoopX + rightLowerLoopGuide.start, + rightLowerLoopGuide.end + ]) == tubeRightLoopX verticalDistance([ - rightLowerLoopGuide.start, - rightLowerLoopGuide.end -]) == tubeLowerLoopCenterY + rightLowerLoopGuide.start, + rightLowerLoopGuide.end + ]) == tubeLowerLoopCenterY horizontalDistance([leftLoopGuide.start, leftLoopGuide.end]) == tubeLeftLoopX verticalDistance([leftLoopGuide.start, leftLoopGuide.end]) == 0in horizontalDistance([ - rightUpperLoopGuide.start, - rightUpperLoopGuide.end -]) == tubeRightLoopX + rightUpperLoopGuide.start, + rightUpperLoopGuide.end + ]) == tubeRightLoopX verticalDistance([ - rightUpperLoopGuide.start, - rightUpperLoopGuide.end -]) == tubeUpperLoopCenterY + rightUpperLoopGuide.start, + rightUpperLoopGuide.end + ]) == tubeUpperLoopCenterY horizontalDistance([outletGuide.start, outletGuide.end]) == tubeInletX verticalDistance([outletGuide.start, outletGuide.end]) == tubeUpperPassY distance([ - rightLowerArcStartGuide.start, - rightLowerArcStartGuide.end -]) == bendRadius + rightLowerArcStartGuide.start, + rightLowerArcStartGuide.end + ]) == bendRadius equalLength([ rightLowerArcStartGuide, rightLowerArcEndGuide ]) distance([ - leftArcStartGuide.start, - leftArcStartGuide.end -]) == bendRadius + leftArcStartGuide.start, + leftArcStartGuide.end + ]) == bendRadius equalLength([leftArcStartGuide, leftArcEndGuide]) distance([ - rightUpperArcStartGuide.start, - rightUpperArcStartGuide.end -]) == bendRadius + rightUpperArcStartGuide.start, + rightUpperArcStartGuide.end + ]) == bendRadius equalLength([ rightUpperArcStartGuide, rightUpperArcEndGuide @@ -389,21 +389,21 @@ brazedCapProfile = sketch(on = YZ) { tangent([arc3, line4]) vertical(line4) horizontalDistance([ - bottomCenterGuide.start, - bottomCenterGuide.end -]) == secondGrooveCenterY + bottomCenterGuide.start, + bottomCenterGuide.end + ]) == secondGrooveCenterY verticalDistance([ - bottomCenterGuide.start, - bottomCenterGuide.end -]) == grooveFloorZ + bottomCenterGuide.start, + bottomCenterGuide.end + ]) == grooveFloorZ horizontalDistance([ - topCenterGuide.start, - topCenterGuide.end -]) == secondGrooveCenterY + topCenterGuide.start, + topCenterGuide.end + ]) == secondGrooveCenterY verticalDistance([ - topCenterGuide.start, - topCenterGuide.end -]) == plateTopZ + tubeDiameter * 0.75 + topCenterGuide.start, + topCenterGuide.end + ]) == plateTopZ + tubeDiameter * 0.75 distance([line2.start, line2.end]) == grooveWallHeight equalLength([line2, line4]) radius(arc3) == tubeOuterRadius @@ -453,13 +453,13 @@ tubeSectionSketch = sketch(on = offsetPlane(YZ, offset = tubeInletX)) { horizontalDistance([centerGuide.start, centerGuide.end]) == tubeLowerPassY verticalDistance([centerGuide.start, centerGuide.end]) == grooveFloorZ horizontalDistance([ - outerRadiusGuide.start, - outerRadiusGuide.end -]) == tubeOuterRadius + outerRadiusGuide.start, + outerRadiusGuide.end + ]) == tubeOuterRadius horizontalDistance([ - innerRadiusGuide.start, - innerRadiusGuide.end -]) == tubeInnerRadius + innerRadiusGuide.start, + innerRadiusGuide.end + ]) == tubeInnerRadius } tubeSectionProfile = region(segments = [tubeSectionSketch.outerCircle]) diff --git a/content/pages/docs/kcl-samples/counterdrilled-weldment/main.kcl b/content/pages/docs/kcl-samples/counterdrilled-weldment/main.kcl index 3f1bf97d..1e873c06 100644 --- a/content/pages/docs/kcl-samples/counterdrilled-weldment/main.kcl +++ b/content/pages/docs/kcl-samples/counterdrilled-weldment/main.kcl @@ -63,9 +63,9 @@ plateSketch = sketch(on = XY) { ]) horizontal(innerHoleRadiusGuide) horizontalDistance([ - innerHoleRadiusGuide.start, - innerHoleRadiusGuide.end -]) == tubeInnerDiameter / 2 + innerHoleRadiusGuide.start, + innerHoleRadiusGuide.end + ]) == tubeInnerDiameter / 2 radius(innerHole) == tubeInnerDiameter / 2 } @@ -110,9 +110,9 @@ holeSeedSketch = sketch(on = holeSeedPlane) { horizontalDistance([holeOffsetX.start, holeOffsetX.end]) == -boltSpacingX / 2 verticalDistance([holeOffsetY.start, holeOffsetY.end]) == -boltSpacingY / 2 horizontalDistance([ - holeRadiusGuide.start, - holeRadiusGuide.end -]) == boltDiameter / 2 + holeRadiusGuide.start, + holeRadiusGuide.end + ]) == boltDiameter / 2 radius(holeCircle) == boltDiameter / 2 } @@ -161,9 +161,9 @@ counterdrillSeedSketch = sketch(on = holeSeedPlane) { horizontalDistance([holeOffsetX.start, holeOffsetX.end]) == -boltSpacingX / 2 verticalDistance([holeOffsetY.start, holeOffsetY.end]) == -boltSpacingY / 2 horizontalDistance([ - counterdrillRadiusGuide.start, - counterdrillRadiusGuide.end -]) == counterdrillDiameter / 2 + counterdrillRadiusGuide.start, + counterdrillRadiusGuide.end + ]) == counterdrillDiameter / 2 radius(counterdrillCircle) == counterdrillDiameter / 2 } @@ -217,13 +217,13 @@ pinholeSketch = sketch(on = YZ) { vertical(pinholeCenterGuide) horizontal(pinholeRadiusGuide) verticalDistance([ - pinholeCenterGuide.start, - pinholeCenterGuide.end -]) == pinholeHeight + pinholeCenterGuide.start, + pinholeCenterGuide.end + ]) == pinholeHeight horizontalDistance([ - pinholeRadiusGuide.start, - pinholeRadiusGuide.end -]) == boltDiameter / 2 + pinholeRadiusGuide.start, + pinholeRadiusGuide.end + ]) == boltDiameter / 2 radius(pinholeCircle) == boltDiameter / 2 } @@ -253,13 +253,13 @@ centralTubeSketch = sketch(on = offsetPlane(XY, offset = stockThickness)) { horizontal(outerRadiusGuide) horizontal(innerRadiusGuide) horizontalDistance([ - outerRadiusGuide.start, - outerRadiusGuide.end -]) == tubeOuterRadius + outerRadiusGuide.start, + outerRadiusGuide.end + ]) == tubeOuterRadius horizontalDistance([ - innerRadiusGuide.start, - innerRadiusGuide.end -]) == tubeInnerDiameter / 2 + innerRadiusGuide.start, + innerRadiusGuide.end + ]) == tubeInnerDiameter / 2 radius(outerCircle) == tubeOuterRadius radius(innerCircle) == tubeInnerDiameter / 2 } diff --git a/content/pages/docs/kcl-samples/countersunk-plate/main.kcl b/content/pages/docs/kcl-samples/countersunk-plate/main.kcl index e40324a8..da63c7d0 100644 --- a/content/pages/docs/kcl-samples/countersunk-plate/main.kcl +++ b/content/pages/docs/kcl-samples/countersunk-plate/main.kcl @@ -108,9 +108,9 @@ plateSketch = sketch(on = XY) { horizontal(rightSpacingGuide) equalLength([leftSpacingGuide, rightSpacingGuide]) horizontalDistance([ - leftSpacingGuide.start, - rightSpacingGuide.end -]) == boltSpacing + leftSpacingGuide.start, + rightSpacingGuide.end + ]) == boltSpacing radius(leftEndArc) == endLobeRadius radius(rightEndArc) == endLobeRadius diff --git a/content/pages/docs/kcl-samples/crash-box/main.kcl b/content/pages/docs/kcl-samples/crash-box/main.kcl index ef74e742..7d71322e 100644 --- a/content/pages/docs/kcl-samples/crash-box/main.kcl +++ b/content/pages/docs/kcl-samples/crash-box/main.kcl @@ -55,13 +55,13 @@ crashBoxProfile = sketch(on = XY) { horizontalDistance([bottomEdge.start, bottomEdge.end]) == crashBoxOuterWidth verticalDistance([leftEdge.end, leftEdge.start]) == crashBoxOuterWidth verticalDistance([ - verticalCenterGuide.end, - verticalCenterGuide.start -]) == crashBoxOuterWidth / 2 + verticalCenterGuide.end, + verticalCenterGuide.start + ]) == crashBoxOuterWidth / 2 horizontalDistance([ - horizontalCenterGuide.start, - horizontalCenterGuide.end -]) == crashBoxOuterWidth / 2 + horizontalCenterGuide.start, + horizontalCenterGuide.end + ]) == crashBoxOuterWidth / 2 } crashBoxRegion = region(segments = [ diff --git a/content/pages/docs/kcl-samples/curtain-wall-anchor-plate/main.kcl b/content/pages/docs/kcl-samples/curtain-wall-anchor-plate/main.kcl index 0a0473f3..915b239a 100644 --- a/content/pages/docs/kcl-samples/curtain-wall-anchor-plate/main.kcl +++ b/content/pages/docs/kcl-samples/curtain-wall-anchor-plate/main.kcl @@ -131,9 +131,9 @@ slotProfile = sketch(on = XY) { vertical(rightBottomGuide) horizontalDistance([ - slotCenterline.start, - slotCenterline.end -]) == wideHoleLength - wideHoleWidth + slotCenterline.start, + slotCenterline.end + ]) == wideHoleLength - wideHoleWidth radius(arc2) == wideHoleWidth / 2 radius(arc4) == wideHoleWidth / 2 coincident([ @@ -207,9 +207,9 @@ boltHeadProfile = sketch(on = XY) { ]) horizontal(boltHeadRadiusGuide) horizontalDistance([ - boltHeadRadiusGuide.start, - boltHeadRadiusGuide.end -]) == boltHeadRadius + boltHeadRadiusGuide.start, + boltHeadRadiusGuide.end + ]) == boltHeadRadius } boltHeadRegion = region( @@ -317,9 +317,9 @@ nutProfile = sketch(on = faceOf(clampPlateBody, face = START)) { coincident([nutCircle.start, nutRadiusGuide.end]) horizontal(nutRadiusGuide) horizontalDistance([ - nutRadiusGuide.start, - nutRadiusGuide.end -]) == nutRadius + nutRadiusGuide.start, + nutRadiusGuide.end + ]) == nutRadius } nutRegion = region(segments = [nutProfile.line1, nutProfile.line2], direction = CW) diff --git a/content/pages/docs/kcl-samples/enclosure/main.kcl b/content/pages/docs/kcl-samples/enclosure/main.kcl index c25865f0..9e4d4a14 100644 --- a/content/pages/docs/kcl-samples/enclosure/main.kcl +++ b/content/pages/docs/kcl-samples/enclosure/main.kcl @@ -156,9 +156,9 @@ lidSketch = sketch(on = lidPlane) { horizontalDistance([line1.start, holeRectBottom.start]) == innerOffset verticalDistance([line1.start, holeRectBottom.start]) == innerOffset distance([ - holeRectBottom.start, - holeRectBottom.end -]) == holeSpanX + holeRectBottom.start, + holeRectBottom.end + ]) == holeSpanX distance([holeRectRight.start, holeRectRight.end]) == holeSpanY holeGuideFrontLeft = line(start = [var 13mm, var 13mm], end = [var 17mm, var 13mm], construction = true) @@ -168,9 +168,9 @@ lidSketch = sketch(on = lidPlane) { ]) horizontal(holeGuideFrontLeft) distance([ - holeGuideFrontLeft.start, - holeGuideFrontLeft.end -]) == holeDia + holeGuideFrontLeft.start, + holeGuideFrontLeft.end + ]) == holeDia holeFrontLeft = circle(start = [var 17mm, var 13mm], center = [var 13mm, var 13mm]) coincident([ holeFrontLeft.center, @@ -188,9 +188,9 @@ lidSketch = sketch(on = lidPlane) { ]) horizontal(holeGuideFrontRight) distance([ - holeGuideFrontRight.start, - holeGuideFrontRight.end -]) == holeDia + holeGuideFrontRight.start, + holeGuideFrontRight.end + ]) == holeDia holeFrontRight = circle(start = [var 116mm, var 13mm], center = [var 112mm, var 13mm]) coincident([ holeFrontRight.center, @@ -208,9 +208,9 @@ lidSketch = sketch(on = lidPlane) { ]) horizontal(holeGuideBackRight) distance([ - holeGuideBackRight.start, - holeGuideBackRight.end -]) == holeDia + holeGuideBackRight.start, + holeGuideBackRight.end + ]) == holeDia holeBackRight = circle(start = [var 116mm, var 162mm], center = [var 112mm, var 162mm]) coincident([ holeBackRight.center, @@ -228,9 +228,9 @@ lidSketch = sketch(on = lidPlane) { ]) horizontal(holeGuideBackLeft) distance([ - holeGuideBackLeft.start, - holeGuideBackLeft.end -]) == holeDia + holeGuideBackLeft.start, + holeGuideBackLeft.end + ]) == holeDia holeBackLeft = circle(start = [var 17mm, var 162mm], center = [var 13mm, var 162mm]) coincident([ holeBackLeft.center, @@ -317,9 +317,9 @@ lidLipSketch = sketch(on = faceOf(lidPlate, face = END)) { horizontalDistance([line1.start, holeRectBottom.start]) == lidLipHoleOffset verticalDistance([line1.start, holeRectBottom.start]) == lidLipHoleOffset distance([ - holeRectBottom.start, - holeRectBottom.end -]) == holeSpanX + holeRectBottom.start, + holeRectBottom.end + ]) == holeSpanX distance([holeRectRight.start, holeRectRight.end]) == holeSpanY holeGuideFrontLeft = line(start = [var 163mm, var 13mm], end = [var 170mm, var 13mm], construction = true) @@ -329,9 +329,9 @@ lidLipSketch = sketch(on = faceOf(lidPlate, face = END)) { ]) horizontal(holeGuideFrontLeft) distance([ - holeGuideFrontLeft.start, - holeGuideFrontLeft.end -]) == lidLipClearanceRadius + holeGuideFrontLeft.start, + holeGuideFrontLeft.end + ]) == lidLipClearanceRadius holeFrontLeft = circle(start = [var 170mm, var 13mm], center = [var 163mm, var 13mm]) coincident([ holeFrontLeft.center, @@ -349,9 +349,9 @@ lidLipSketch = sketch(on = faceOf(lidPlate, face = END)) { ]) horizontal(holeGuideFrontRight) distance([ - holeGuideFrontRight.start, - holeGuideFrontRight.end -]) == lidLipClearanceRadius + holeGuideFrontRight.start, + holeGuideFrontRight.end + ]) == lidLipClearanceRadius holeFrontRight = circle(start = [var 269mm, var 13mm], center = [var 262mm, var 13mm]) coincident([ holeFrontRight.center, @@ -369,9 +369,9 @@ lidLipSketch = sketch(on = faceOf(lidPlate, face = END)) { ]) horizontal(holeGuideBackRight) distance([ - holeGuideBackRight.start, - holeGuideBackRight.end -]) == lidLipClearanceRadius + holeGuideBackRight.start, + holeGuideBackRight.end + ]) == lidLipClearanceRadius holeBackRight = circle(start = [var 269mm, var 162mm], center = [var 262mm, var 162mm]) coincident([ holeBackRight.center, @@ -389,9 +389,9 @@ lidLipSketch = sketch(on = faceOf(lidPlate, face = END)) { ]) horizontal(holeGuideBackLeft) distance([ - holeGuideBackLeft.start, - holeGuideBackLeft.end -]) == lidLipClearanceRadius + holeGuideBackLeft.start, + holeGuideBackLeft.end + ]) == lidLipClearanceRadius holeBackLeft = circle(start = [var 170mm, var 162mm], center = [var 163mm, var 162mm]) coincident([ holeBackLeft.center, diff --git a/content/pages/docs/kcl-samples/flange/main.kcl b/content/pages/docs/kcl-samples/flange/main.kcl index 728d180b..5b5d4b0c 100644 --- a/content/pages/docs/kcl-samples/flange/main.kcl +++ b/content/pages/docs/kcl-samples/flange/main.kcl @@ -98,41 +98,41 @@ baseProfile = sketch(on = XY) { vertical(bottomRadiusGuide) distance([ - outerRadiusGuide.start, - outerRadiusGuide.end -]) == baseRadius + outerRadiusGuide.start, + outerRadiusGuide.end + ]) == baseRadius horizontalDistance([ - rightCenterGuide.start, - rightCenterGuide.end -]) == mountingHolePlacementRadius + rightCenterGuide.start, + rightCenterGuide.end + ]) == mountingHolePlacementRadius verticalDistance([ - topCenterGuide.start, - topCenterGuide.end -]) == mountingHolePlacementRadius + topCenterGuide.start, + topCenterGuide.end + ]) == mountingHolePlacementRadius horizontalDistance([ - leftCenterGuide.start, - leftCenterGuide.end -]) == -mountingHolePlacementRadius + leftCenterGuide.start, + leftCenterGuide.end + ]) == -mountingHolePlacementRadius verticalDistance([ - bottomCenterGuide.start, - bottomCenterGuide.end -]) == -mountingHolePlacementRadius + bottomCenterGuide.start, + bottomCenterGuide.end + ]) == -mountingHolePlacementRadius distance([ - rightRadiusGuide.start, - rightRadiusGuide.end -]) == mountingHoleRadius + rightRadiusGuide.start, + rightRadiusGuide.end + ]) == mountingHoleRadius distance([ - topRadiusGuide.start, - topRadiusGuide.end -]) == mountingHoleRadius + topRadiusGuide.start, + topRadiusGuide.end + ]) == mountingHoleRadius distance([ - leftRadiusGuide.start, - leftRadiusGuide.end -]) == mountingHoleRadius + leftRadiusGuide.start, + leftRadiusGuide.end + ]) == mountingHoleRadius distance([ - bottomRadiusGuide.start, - bottomRadiusGuide.end -]) == mountingHoleRadius + bottomRadiusGuide.start, + bottomRadiusGuide.end + ]) == mountingHoleRadius } baseRegion = region(segments = [baseProfile.outerCircle]) diff --git a/content/pages/docs/kcl-samples/flat-bladed-impeller/main.kcl b/content/pages/docs/kcl-samples/flat-bladed-impeller/main.kcl index f7fcd24c..846e879e 100644 --- a/content/pages/docs/kcl-samples/flat-bladed-impeller/main.kcl +++ b/content/pages/docs/kcl-samples/flat-bladed-impeller/main.kcl @@ -72,9 +72,9 @@ disk = sketch(on = diskPlane) { horizontal(diskRadiusGuide) distance([ - diskRadiusGuide.start, - diskRadiusGuide.end -]) == outerRadius + diskRadiusGuide.start, + diskRadiusGuide.end + ]) == outerRadius } region002 = region(segments = [disk.circle1]) @@ -92,9 +92,9 @@ hubCircle = sketch(on = faceOf(backPlate, face = END)) { horizontal(hubRadiusGuide) distance([ - hubRadiusGuide.start, - hubRadiusGuide.end -]) == hubOutsideDiameter / 2 + hubRadiusGuide.start, + hubRadiusGuide.end + ]) == hubOutsideDiameter / 2 } region003 = region(segments = [hubCircle.circle1]) @@ -112,9 +112,9 @@ boreCircle = sketch(on = faceOf(backPlate, face = START)) { horizontal(boreRadiusGuide) distance([ - boreRadiusGuide.start, - boreRadiusGuide.end -]) == boreDiameter / 2 + boreRadiusGuide.start, + boreRadiusGuide.end + ]) == boreDiameter / 2 } region004 = region(segments = [boreCircle.circle1]) diff --git a/content/pages/docs/kcl-samples/gallows-bracket/main.kcl b/content/pages/docs/kcl-samples/gallows-bracket/main.kcl index 9d1ad607..374923c0 100644 --- a/content/pages/docs/kcl-samples/gallows-bracket/main.kcl +++ b/content/pages/docs/kcl-samples/gallows-bracket/main.kcl @@ -59,9 +59,9 @@ beamProfileSketch = sketch(on = -XZ) { coincident([beamBottomOuter.start, ORIGIN]) horizontalDistance([ - beamBottomOuter.start, - beamBottomOuter.end -]) == ironWidth + beamBottomOuter.start, + beamBottomOuter.end + ]) == ironWidth verticalDistance([beamOuterLip.start, beamOuterLip.end]) == -ironThickness horizontalDistance([beamCloseEdge.end, beamInnerTop.end]) == ironThickness verticalDistance([beamCloseEdge.end, beamOuterWeb.start]) == -ironWidth @@ -127,21 +127,21 @@ verticalProfileSketch = sketch(on = -XZ) { coincident([verticalBottomOuter.start, ORIGIN]) horizontalDistance([ - verticalBottomOuter.start, - verticalBottomOuter.end -]) == ironWidth + verticalBottomOuter.start, + verticalBottomOuter.end + ]) == ironWidth verticalDistance([ - verticalOuterLip.start, - verticalOuterLip.end -]) == -ironThickness + verticalOuterLip.start, + verticalOuterLip.end + ]) == -ironThickness horizontalDistance([ - verticalCloseEdge.end, - verticalInnerTop.end -]) == ironThickness + verticalCloseEdge.end, + verticalInnerTop.end + ]) == ironThickness verticalDistance([ - verticalCloseEdge.end, - verticalOuterWeb.start -]) == -ironWidth + verticalCloseEdge.end, + verticalOuterWeb.start + ]) == -ironWidth } verticalRegion = region(segments = [ @@ -186,25 +186,25 @@ verticalEndMiterSketch = sketch(on = XY) { horizontalDistance([ORIGIN, verticalEndMiterEdge.start]) == verticalEndMiterStartX verticalDistance([ORIGIN, verticalEndMiterEdge.start]) == verticalEndMiterStartY horizontalDistance([ - verticalEndMiterEdge.start, - verticalEndMiterEdge.end -]) == verticalEndMiterRun + verticalEndMiterEdge.start, + verticalEndMiterEdge.end + ]) == verticalEndMiterRun verticalDistance([ - verticalEndMiterEdge.start, - verticalEndMiterEdge.end -]) == -verticalEndMiterRise + verticalEndMiterEdge.start, + verticalEndMiterEdge.end + ]) == -verticalEndMiterRise verticalDistance([ - verticalEndRightEdge.start, - verticalEndRightEdge.end -]) == verticalEndMiterRise + csgFriendlyOffset + verticalEndRightEdge.start, + verticalEndRightEdge.end + ]) == verticalEndMiterRise + csgFriendlyOffset horizontalDistance([ - verticalEndTopEdge.start, - verticalEndTopEdge.end -]) == -verticalEndMiterRun + verticalEndTopEdge.start, + verticalEndTopEdge.end + ]) == -verticalEndMiterRun verticalDistance([ - verticalEndLeftEdge.start, - verticalEndLeftEdge.end -]) == -csgFriendlyOffset + verticalEndLeftEdge.start, + verticalEndLeftEdge.end + ]) == -csgFriendlyOffset } verticalEndMiterRegion = region(segments = [ @@ -252,17 +252,17 @@ verticalHoleSketch = sketch(on = verticalHolePlane) { horizontal(verticalHoleRadiusGuide) horizontalDistance([ - verticalHoleOffsetAcross.start, - verticalHoleOffsetAcross.end -]) == -ironWidth / 2 + verticalHoleOffsetAcross.start, + verticalHoleOffsetAcross.end + ]) == -ironWidth / 2 verticalDistance([ - verticalHoleOffsetUp.start, - verticalHoleOffsetUp.end -]) == bottomBoltOffset + verticalHoleOffsetUp.start, + verticalHoleOffsetUp.end + ]) == bottomBoltOffset horizontalDistance([ - verticalHoleRadiusGuide.start, - verticalHoleRadiusGuide.end -]) == clearanceBoltRadius + verticalHoleRadiusGuide.start, + verticalHoleRadiusGuide.end + ]) == clearanceBoltRadius radius(verticalHoleCircle) == clearanceBoltRadius } @@ -322,21 +322,21 @@ horizontalProfileSketch = sketch(on = -XZ) { coincident([horizontalBottomOuter.start, ORIGIN]) horizontalDistance([ - horizontalBottomOuter.start, - horizontalBottomOuter.end -]) == ironWidth + horizontalBottomOuter.start, + horizontalBottomOuter.end + ]) == ironWidth verticalDistance([ - horizontalOuterLip.start, - horizontalOuterLip.end -]) == -ironThickness + horizontalOuterLip.start, + horizontalOuterLip.end + ]) == -ironThickness horizontalDistance([ - horizontalCloseEdge.end, - horizontalInnerTop.end -]) == ironThickness + horizontalCloseEdge.end, + horizontalInnerTop.end + ]) == ironThickness verticalDistance([ - horizontalCloseEdge.end, - horizontalOuterWeb.start -]) == -ironWidth + horizontalCloseEdge.end, + horizontalOuterWeb.start + ]) == -ironWidth } horizontalRegion = region(segments = [ @@ -381,25 +381,25 @@ horizontalStartMiterSketch = sketch(on = XY) { horizontalDistance([ORIGIN, horizontalStartMiterEdge.start]) == horizontalStartMiterStartX verticalDistance([ORIGIN, horizontalStartMiterEdge.start]) == horizontalStartMiterStartY horizontalDistance([ - horizontalStartMiterEdge.start, - horizontalStartMiterEdge.end -]) == horizontalStartMiterRun + horizontalStartMiterEdge.start, + horizontalStartMiterEdge.end + ]) == horizontalStartMiterRun verticalDistance([ - horizontalStartMiterEdge.start, - horizontalStartMiterEdge.end -]) == horizontalStartMiterRise + horizontalStartMiterEdge.start, + horizontalStartMiterEdge.end + ]) == horizontalStartMiterRise verticalDistance([ - horizontalStartRightEdge.start, - horizontalStartRightEdge.end -]) == -(horizontalStartMiterRise + csgFriendlyOffset) + horizontalStartRightEdge.start, + horizontalStartRightEdge.end + ]) == -(horizontalStartMiterRise + csgFriendlyOffset) horizontalDistance([ - horizontalStartBottomEdge.start, - horizontalStartBottomEdge.end -]) == -horizontalStartMiterRun + horizontalStartBottomEdge.start, + horizontalStartBottomEdge.end + ]) == -horizontalStartMiterRun verticalDistance([ - horizontalStartLeftEdge.start, - horizontalStartLeftEdge.end -]) == csgFriendlyOffset + horizontalStartLeftEdge.start, + horizontalStartLeftEdge.end + ]) == csgFriendlyOffset } horizontalStartMiterRegion = region(segments = [ @@ -450,17 +450,17 @@ horizontalHoleSketch = sketch(on = horizontalHolePlane) { horizontal(horizontalHoleRadiusGuide) horizontalDistance([ - horizontalHoleOffsetForward.start, - horizontalHoleOffsetForward.end -]) == depth - (ironWidth / 2) + horizontalHoleOffsetForward.start, + horizontalHoleOffsetForward.end + ]) == depth - (ironWidth / 2) verticalDistance([ - horizontalHoleOffsetAcross.start, - horizontalHoleOffsetAcross.end -]) == -ironWidth / 2 + horizontalHoleOffsetAcross.start, + horizontalHoleOffsetAcross.end + ]) == -ironWidth / 2 horizontalDistance([ - horizontalHoleRadiusGuide.start, - horizontalHoleRadiusGuide.end -]) == clearanceBoltRadius + horizontalHoleRadiusGuide.start, + horizontalHoleRadiusGuide.end + ]) == clearanceBoltRadius radius(horizontalHoleCircle) == clearanceBoltRadius } @@ -507,15 +507,15 @@ strutProfileSketch = sketch(on = -XZ) { coincident([strutBottomOuter.start, ORIGIN]) horizontalDistance([ - strutBottomOuter.start, - strutBottomOuter.end -]) == strutSectionWidth + strutBottomOuter.start, + strutBottomOuter.end + ]) == strutSectionWidth verticalDistance([strutOuterLip.start, strutOuterLip.end]) == -ironThickness horizontalDistance([strutCloseEdge.end, strutInnerTop.end]) == ironThickness verticalDistance([ - strutCloseEdge.end, - strutOuterWeb.start -]) == -strutSectionWidth + strutCloseEdge.end, + strutOuterWeb.start + ]) == -strutSectionWidth } strutRegion = region(segments = [ @@ -560,25 +560,25 @@ strutStartMiterSketch = sketch(on = XY) { horizontalDistance([ORIGIN, strutStartMiterEdge.start]) == strutStartMiterStartX verticalDistance([ORIGIN, strutStartMiterEdge.start]) == strutStartMiterStartY horizontalDistance([ - strutStartMiterEdge.start, - strutStartMiterEdge.end -]) == strutStartMiterRun + strutStartMiterEdge.start, + strutStartMiterEdge.end + ]) == strutStartMiterRun verticalDistance([ - strutStartMiterEdge.start, - strutStartMiterEdge.end -]) == strutStartMiterRise + strutStartMiterEdge.start, + strutStartMiterEdge.end + ]) == strutStartMiterRise verticalDistance([ - strutStartRightEdge.start, - strutStartRightEdge.end -]) == -(strutStartMiterRise + csgFriendlyOffset) + strutStartRightEdge.start, + strutStartRightEdge.end + ]) == -(strutStartMiterRise + csgFriendlyOffset) horizontalDistance([ - strutStartBottomEdge.start, - strutStartBottomEdge.end -]) == -strutStartMiterRun + strutStartBottomEdge.start, + strutStartBottomEdge.end + ]) == -strutStartMiterRun verticalDistance([ - strutStartLeftEdge.start, - strutStartLeftEdge.end -]) == csgFriendlyOffset + strutStartLeftEdge.start, + strutStartLeftEdge.end + ]) == csgFriendlyOffset } strutStartMiterRegion = region(segments = [ @@ -631,25 +631,25 @@ strutEndMiterSketch = sketch(on = XY) { horizontalDistance([ORIGIN, strutEndMiterEdge.start]) == strutEndMiterStartX verticalDistance([ORIGIN, strutEndMiterEdge.start]) == strutEndMiterStartY horizontalDistance([ - strutEndMiterEdge.start, - strutEndMiterEdge.end -]) == strutEndMiterRun + strutEndMiterEdge.start, + strutEndMiterEdge.end + ]) == strutEndMiterRun verticalDistance([ - strutEndMiterEdge.start, - strutEndMiterEdge.end -]) == -strutEndMiterRise + strutEndMiterEdge.start, + strutEndMiterEdge.end + ]) == -strutEndMiterRise verticalDistance([ - strutEndRightEdge.start, - strutEndRightEdge.end -]) == strutEndMiterRise + csgFriendlyOffset + strutEndRightEdge.start, + strutEndRightEdge.end + ]) == strutEndMiterRise + csgFriendlyOffset horizontalDistance([ - strutEndTopEdge.start, - strutEndTopEdge.end -]) == -strutEndMiterRun + strutEndTopEdge.start, + strutEndTopEdge.end + ]) == -strutEndMiterRun verticalDistance([ - strutEndLeftEdge.start, - strutEndLeftEdge.end -]) == -csgFriendlyOffset + strutEndLeftEdge.start, + strutEndLeftEdge.end + ]) == -csgFriendlyOffset } strutEndMiterRegion = region(segments = [ diff --git a/content/pages/docs/kcl-samples/gas-impeller/main.kcl b/content/pages/docs/kcl-samples/gas-impeller/main.kcl index e1710fe0..088eab53 100644 --- a/content/pages/docs/kcl-samples/gas-impeller/main.kcl +++ b/content/pages/docs/kcl-samples/gas-impeller/main.kcl @@ -45,9 +45,9 @@ hubAndBladeEnvelopeSketch = sketch(on = YZ) { coincident([shaftRadiusGuide.end, baseFloor.end]) horizontal(shaftRadiusGuide) horizontalDistance([ - shaftRadiusGuide.start, - shaftRadiusGuide.end -]) == shaftBoreDiameter / 2 + shaftRadiusGuide.start, + shaftRadiusGuide.end + ]) == shaftBoreDiameter / 2 verticalDistance([shaftWall.start, shaftWall.end]) == impellerHeight horizontalDistance([hubTopLand.start, hubTopLand.end]) == shaftBoreDiameter / 3 @@ -157,9 +157,9 @@ hubAndBladeEnvelopeSketch = sketch(on = YZ) { vertical(bladeEnvelopeTipCenterlineGuide) horizontal(bladeEnvelopeTipRadiusGuide) horizontalDistance([ - shaftRadiusGuide.start, - baseFloor.start -]) == impellerDiameter / 2 + shaftRadiusGuide.start, + baseFloor.start + ]) == impellerDiameter / 2 hubShoulderRadiusGuide = line(start = [var 7.33mm, var 59mm], end = [var 7.33mm, var 60mm]) coincident([ @@ -171,9 +171,9 @@ hubAndBladeEnvelopeSketch = sketch(on = YZ) { hubShoulderBlendArc.end ]) verticalDistance([ - hubShoulderRadiusGuide.end, - hubShoulderRadiusGuide.start -]) == -1 + hubShoulderRadiusGuide.end, + hubShoulderRadiusGuide.start + ]) == -1 } // Revolved bodies from the shared sketch @@ -237,17 +237,17 @@ bladeCutterSketch = sketch(on = XY) { vertical(bladeCutterOuterEdge) vertical(bladeCutterInnerEdge) horizontalDistance([ - bladeCutterInnerRadiusGuide.start, - bladeCutterInnerRadiusGuide.end -]) == shaftBoreDiameter / 2 + bladeCutterInnerRadiusGuide.start, + bladeCutterInnerRadiusGuide.end + ]) == shaftBoreDiameter / 2 horizontalDistance([ - bladeCutterBottomEdge.start, - bladeCutterBottomEdge.end -]) == impellerDiameter / 2 + bladeCutterBottomEdge.start, + bladeCutterBottomEdge.end + ]) == impellerDiameter / 2 verticalDistance([ - bladeCutterOuterEdge.start, - bladeCutterOuterEdge.end -]) == bladeSectionThickness + bladeCutterOuterEdge.start, + bladeCutterOuterEdge.end + ]) == bladeSectionThickness } // Blade cutter solid diff --git a/content/pages/docs/kcl-samples/gingerbread-man/main.kcl b/content/pages/docs/kcl-samples/gingerbread-man/main.kcl index 47048676..03ef3553 100644 --- a/content/pages/docs/kcl-samples/gingerbread-man/main.kcl +++ b/content/pages/docs/kcl-samples/gingerbread-man/main.kcl @@ -97,13 +97,13 @@ bodySketch = sketch(on = XY) { equalLength([line9, line12]) distance([centerline.start, centerline.end]) == 549mm verticalDistance([ - torsoRiseGuide.start, - torsoRiseGuide.end -]) == 57mm + torsoRiseGuide.start, + torsoRiseGuide.end + ]) == 57mm horizontalDistance([ - torsoReachGuide.start, - torsoReachGuide.end -]) == 77mm + torsoReachGuide.start, + torsoReachGuide.end + ]) == 77mm } bodyRegion = region(segments = [ bodySketch.line1, @@ -152,13 +152,13 @@ innerMouthSketch = sketch(on = decorationPlane) { vertical(mouthRiseGuide) horizontal(mouthReachGuide) verticalDistance([ - mouthRiseGuide.start, - mouthRiseGuide.end -]) == 401mm + mouthRiseGuide.start, + mouthRiseGuide.end + ]) == 401mm horizontalDistance([ - mouthReachGuide.start, - mouthReachGuide.end -]) == 41mm + mouthReachGuide.start, + mouthReachGuide.end + ]) == 41mm coincident([arc1.start, arc4.start]) } innerMouthRegion = region(segments = [ @@ -191,13 +191,13 @@ mouthSketch = sketch(on = decorationPlane) { vertical(mouthRiseGuide) horizontal(mouthReachGuide) verticalDistance([ - mouthRiseGuide.start, - mouthRiseGuide.end -]) == 405.86mm + mouthRiseGuide.start, + mouthRiseGuide.end + ]) == 405.86mm horizontalDistance([ - mouthReachGuide.start, - mouthReachGuide.end -]) == 37.56mm + mouthReachGuide.start, + mouthReachGuide.end + ]) == 37.56mm coincident([arc4.start, arc1.start]) } mouthRegion = region(segments = [ @@ -264,13 +264,13 @@ eyebrowSketch = sketch(on = decorationPlane) { vertical(eyebrowRiseGuide) horizontal(eyebrowReachGuide) verticalDistance([ - eyebrowRiseGuide.start, - eyebrowRiseGuide.end -]) == 503.47mm + eyebrowRiseGuide.start, + eyebrowRiseGuide.end + ]) == 503.47mm horizontalDistance([ - eyebrowReachGuide.start, - eyebrowReachGuide.end -]) == 37.9mm + eyebrowReachGuide.start, + eyebrowReachGuide.end + ]) == 37.9mm arc5 = arc(start = [var -86.17mm, var 485mm], end = [var -73.02mm, var 483.5mm], center = [var -79.72mm, var 483.11mm]) coincident([arc5.start, arc3.end]) coincident([arc5.end, arc1.end]) @@ -368,9 +368,9 @@ cuffSketch = sketch(on = decorationPlane) { horizontal(cuffReachGuide) verticalDistance([cuffRiseGuide.start, cuffRiseGuide.end]) == 184.88mm horizontalDistance([ - cuffReachGuide.start, - cuffReachGuide.end -]) == 224.97mm + cuffReachGuide.start, + cuffReachGuide.end + ]) == 224.97mm coincident([arc6.start, arc1.start]) } cuffRegion = region(segments = [cuffSketch.arc1, cuffSketch.arc2], direction = CW) diff --git a/content/pages/docs/kcl-samples/lego/main.kcl b/content/pages/docs/kcl-samples/lego/main.kcl index c3c63015..c96d39a0 100644 --- a/content/pages/docs/kcl-samples/lego/main.kcl +++ b/content/pages/docs/kcl-samples/lego/main.kcl @@ -63,13 +63,13 @@ pegSeedSketch = sketch(on = pegSketchPlane) { coincident([pegCenterGuide.end, ORIGIN]) radius(pegCircle) == bumpDiam / 2 horizontalDistance([ - pegCenterGuide.start, - pegCenterGuide.end -]) == -pegCenterX + pegCenterGuide.start, + pegCenterGuide.end + ]) == -pegCenterX verticalDistance([ - pegCenterGuide.start, - pegCenterGuide.end -]) == -pegCenterY + pegCenterGuide.start, + pegCenterGuide.end + ]) == -pegCenterY } pegRegion = region(segments = [pegSeedSketch.pegCircle]) pegSeed = extrude(pegRegion, length = bumpHeight, method = NEW) @@ -94,13 +94,13 @@ tubeSeedSketch = sketch(on = tubeSketchPlane) { coincident([tubeCenterGuide.end, ORIGIN]) radius(tubeCircle) == bumpDiam / 2 horizontalDistance([ - tubeCenterGuide.start, - tubeCenterGuide.end -]) == -tubeCenterX + tubeCenterGuide.start, + tubeCenterGuide.end + ]) == -tubeCenterX verticalDistance([ - tubeCenterGuide.start, - tubeCenterGuide.end -]) == -tubeCenterY + tubeCenterGuide.start, + tubeCenterGuide.end + ]) == -tubeCenterY } tubeRegion = region(segments = [tubeSeedSketch.tubeCircle]) tubeSeed = extrude(tubeRegion, length = bumpHeight, method = NEW) diff --git a/content/pages/docs/kcl-samples/m4-hex-socket-countersunk-head-screw/main.kcl b/content/pages/docs/kcl-samples/m4-hex-socket-countersunk-head-screw/main.kcl index 2a8310c2..f9c96ffb 100644 --- a/content/pages/docs/kcl-samples/m4-hex-socket-countersunk-head-screw/main.kcl +++ b/content/pages/docs/kcl-samples/m4-hex-socket-countersunk-head-screw/main.kcl @@ -38,9 +38,9 @@ boltProfileSketch = sketch(on = XY) { horizontalDistance([shankTopEdge.end, shankTopEdge.start]) == boltShankDiameter / 2 horizontalDistance([headTopEdge.start, headTopEdge.end]) == boltHeadDiameter / 2 verticalDistance([ - headTransitionEdge.start, - headTransitionEdge.end -]) == boltHeadTransitionHeight + headTransitionEdge.start, + headTransitionEdge.end + ]) == boltHeadTransitionHeight } hexSocketSketch = sketch(on = XZ) { @@ -97,9 +97,9 @@ hexSocketSketch = sketch(on = XZ) { ]) horizontal(socketRadiusGuide) horizontalDistance([ - socketRadiusGuide.start, - socketRadiusGuide.end -]) == socketRadius + socketRadiusGuide.start, + socketRadiusGuide.end + ]) == socketRadius coincident([topFacet.end, upperLeftFacet.start]) coincident([ socketRadiusGuide.end, diff --git a/content/pages/docs/kcl-samples/pipe-elbow-90deg/main.kcl b/content/pages/docs/kcl-samples/pipe-elbow-90deg/main.kcl index c23b0cc7..cdf7e055 100644 --- a/content/pages/docs/kcl-samples/pipe-elbow-90deg/main.kcl +++ b/content/pages/docs/kcl-samples/pipe-elbow-90deg/main.kcl @@ -28,9 +28,9 @@ elbowSectionSketch = sketch(on = XY) { ]) horizontal(elbowCenterGuide) horizontalDistance([ - elbowCenterGuide.start, - elbowCenterGuide.end -]) == elbowCenterlineBendRadius + elbowCenterGuide.start, + elbowCenterGuide.end + ]) == elbowCenterlineBendRadius elbowInnerCircle = circle(start = [var 93.57mm, var 17.89mm], center = [var 62.79mm, var 0.22mm]) coincident([ @@ -54,9 +54,9 @@ flangeSketch = sketch(on = YZ) { ]) vertical(flangeCenterGuide) verticalDistance([ - flangeCenterGuide.start, - flangeCenterGuide.end -]) == elbowCenterlineBendRadius + flangeCenterGuide.start, + flangeCenterGuide.end + ]) == elbowCenterlineBendRadius flangeInnerCircle = circle(start = [var 37.73mm, var 77.31mm], center = [var 0mm, var 63mm]) coincident([ flangeInnerCircle.center, @@ -85,13 +85,13 @@ boltHoleSketch = sketch(on = YZ) { horizontal(boltHoleCenterGuide) vertical(boltHoleOffsetGuide) horizontalDistance([ - boltHoleCenterGuide.start, - boltHoleCenterGuide.end -]) == boltCircleDiameter / 2 + boltHoleCenterGuide.start, + boltHoleCenterGuide.end + ]) == boltCircleDiameter / 2 verticalDistance([ - boltHoleOffsetGuide.start, - boltHoleOffsetGuide.end -]) == elbowCenterlineBendRadius + boltHoleOffsetGuide.start, + boltHoleOffsetGuide.end + ]) == elbowCenterlineBendRadius radius(boltHoleCircle) == boltHoleDiameter / 2 } diff --git a/content/pages/docs/kcl-samples/surgical-drill-guide/main.kcl b/content/pages/docs/kcl-samples/surgical-drill-guide/main.kcl index e3503916..ce5c306a 100644 --- a/content/pages/docs/kcl-samples/surgical-drill-guide/main.kcl +++ b/content/pages/docs/kcl-samples/surgical-drill-guide/main.kcl @@ -52,9 +52,9 @@ handleProfile = sketch(on = YZ) { tangent([returnEdge, heelArc]) equalLength([base, topFace]) distance([ - arcCenterGuide.start, - arcCenterGuide.end -]) == stockThickness + bendRadius + arcCenterGuide.start, + arcCenterGuide.end + ]) == stockThickness + bendRadius radius(frontBend) == bendRadius horizontalDistance([base.start, base.end]) == handleLength verticalDistance([frontFace.start, frontFace.end]) == stockThickness @@ -206,13 +206,13 @@ grip01Sketch = sketch(on = offsetPlane(XZ, offset = firstBitAxisOffset + 16)) { horizontal(innerRadiusGuide) distance([centerGuide.start, centerGuide.end]) == firstBitAxisY horizontalDistance([ - outerRadiusGuide.start, - outerRadiusGuide.end -]) == gripOuterRadius + outerRadiusGuide.start, + outerRadiusGuide.end + ]) == gripOuterRadius horizontalDistance([ - innerRadiusGuide.start, - innerRadiusGuide.end -]) == bitSize01 + innerRadiusGuide.start, + innerRadiusGuide.end + ]) == bitSize01 } grip01Region = region(segments = [grip01Sketch.outerCircle]) hide(grip01Sketch) @@ -328,13 +328,13 @@ grip02Sketch = sketch(on = offsetPlane(XY, offset = -3)) { horizontal(innerRadiusGuide) distance([centerGuide.start, centerGuide.end]) == handleLength horizontalDistance([ - outerRadiusGuide.start, - outerRadiusGuide.end -]) == gripOuterRadius + outerRadiusGuide.start, + outerRadiusGuide.end + ]) == gripOuterRadius horizontalDistance([ - innerRadiusGuide.start, - innerRadiusGuide.end -]) == bitSize02 + innerRadiusGuide.start, + innerRadiusGuide.end + ]) == bitSize02 } grip02Region = region(segments = [grip02Sketch.outerCircle]) hide(grip02Sketch) diff --git a/content/pages/docs/kcl-samples/thermal-block-insert/main.kcl b/content/pages/docs/kcl-samples/thermal-block-insert/main.kcl index 274fc388..54ee8e78 100644 --- a/content/pages/docs/kcl-samples/thermal-block-insert/main.kcl +++ b/content/pages/docs/kcl-samples/thermal-block-insert/main.kcl @@ -126,9 +126,9 @@ tongueShape = sketch(on = XY) { equalLength([fall1, fall2, fall3, fall4, fall5]) horizontalDistance([ - leftCenterGuide.start, - leftCenterGuide.end -]) == insertLength / 2 + leftCenterGuide.start, + leftCenterGuide.end + ]) == insertLength / 2 verticalDistance([leftWall.start, leftWall.end]) == blockHalfThickness horizontalDistance([flat1.start, flat1.end]) == tongueLength horizontalDistance([rise1.end, rise1.start]) == tongueSetback @@ -241,9 +241,9 @@ grooveShape = sketch(on = XY) { equalLength([fall1, fall2, fall3, fall4, fall5]) horizontalDistance([ - leftCenterGuide.start, - leftCenterGuide.end -]) == insertLength / 2 + leftCenterGuide.start, + leftCenterGuide.end + ]) == insertLength / 2 verticalDistance([leftWall.start, leftWall.end]) == -grooveDepth horizontalDistance([flat1.start, flat1.end]) == tongueLength horizontalDistance([rise1.end, rise1.start]) == tongueSetback diff --git a/content/pages/docs/kcl-samples/tube-manifold/main.kcl b/content/pages/docs/kcl-samples/tube-manifold/main.kcl index 849c347d..1da6734f 100644 --- a/content/pages/docs/kcl-samples/tube-manifold/main.kcl +++ b/content/pages/docs/kcl-samples/tube-manifold/main.kcl @@ -26,9 +26,9 @@ portBoreSketch = sketch(on = XY) { horizontal(portRadiusGuide) distance([ - portRadiusGuide.start, - portRadiusGuide.end -]) == portDiameter / 2 - wallThickness + portRadiusGuide.start, + portRadiusGuide.end + ]) == portDiameter / 2 - wallThickness } portBoreRegion = region(segments = [portBoreSketch.portBore]) @@ -130,37 +130,37 @@ bodyProfile = sketch(on = XY) { horizontal(mainInnerRun) distance([ - frontAxisGuide.start, - frontAxisGuide.end -]) == portHeight + frontAxisGuide.start, + frontAxisGuide.end + ]) == portHeight distance([endCapGuide.start, endCapGuide.end]) == portCount * portSpacing distance([ - frontInnerRadiusGuide.start, - frontInnerRadiusGuide.end -]) == bodyDiameter / 2 - wallThickness + frontInnerRadiusGuide.start, + frontInnerRadiusGuide.end + ]) == bodyDiameter / 2 - wallThickness distance([frontWall.start, frontWall.end]) == wallThickness distance([frontOuterRun.start, frontOuterRun.end]) == beadDepth distance([beadSpanGuide.start, beadSpanGuide.end]) == beadRadius * 2 distance([ - beadRadiusGuide.start, - beadRadiusGuide.end -]) == beadRadius + beadRadiusGuide.start, + beadRadiusGuide.end + ]) == beadRadius distance([ - outerTopRadiusGuide.start, - outerTopRadiusGuide.end -]) == bodyDiameter / 2 + outerTopRadiusGuide.start, + outerTopRadiusGuide.end + ]) == bodyDiameter / 2 distance([ - outerSideRadiusGuide.start, - outerSideRadiusGuide.end -]) == bodyDiameter / 2 + outerSideRadiusGuide.start, + outerSideRadiusGuide.end + ]) == bodyDiameter / 2 distance([ - innerTopRadiusGuide.start, - innerTopRadiusGuide.end -]) == bodyDiameter / 2 - wallThickness + innerTopRadiusGuide.start, + innerTopRadiusGuide.end + ]) == bodyDiameter / 2 - wallThickness distance([ - innerSideRadiusGuide.start, - innerSideRadiusGuide.end -]) == bodyDiameter / 2 - wallThickness + innerSideRadiusGuide.start, + innerSideRadiusGuide.end + ]) == bodyDiameter / 2 - wallThickness } bodyRegion = region(segments = [ @@ -192,9 +192,9 @@ bodyCutSketch = sketch(on = YZ) { horizontal(bodyCutRadiusGuide) distance([ - bodyCutRadiusGuide.start, - bodyCutRadiusGuide.end -]) == bodyDiameter / 2 + bodyCutRadiusGuide.start, + bodyCutRadiusGuide.end + ]) == bodyDiameter / 2 } bodyCutRegion = region(segments = [bodyCutSketch.bodyCutCircle]) @@ -240,9 +240,9 @@ portProfile = sketch(on = YZ) { distance([upperWall.start, upperWall.end]) == beadDepth distance([beadSpanGuide.start, beadSpanGuide.end]) == beadRadius * 2 distance([ - beadRadiusGuide.start, - beadRadiusGuide.end -]) == beadRadius + beadRadiusGuide.start, + beadRadiusGuide.end + ]) == beadRadius } portRegion = region(point = [portDiameter / 4, portHeight / 2], sketch = portProfile) diff --git a/content/pages/docs/kcl-samples/utility-sink/main.kcl b/content/pages/docs/kcl-samples/utility-sink/main.kcl index 2bcd04a0..732eaec7 100644 --- a/content/pages/docs/kcl-samples/utility-sink/main.kcl +++ b/content/pages/docs/kcl-samples/utility-sink/main.kcl @@ -430,9 +430,9 @@ tapPlateSketch = sketch(on = offsetPlane(XY, offset = tableHeight)) { verticalDistance([centerYGuide.start, centerYGuide.end]) == tableDepth - 55 horizontalDistance([centerXGuide.start, centerXGuide.end]) == blockWidth / 2 distance([ - tapPlateCircle.center, - tapPlateCircle.start -]) == 40 + tapPlateCircle.center, + tapPlateCircle.start + ]) == 40 } tapPlateRegion = region(segments = [tapPlateSketch.tapPlateCircle]) @@ -471,9 +471,9 @@ tapPillarSketch = sketch(on = offsetPlane(XY, offset = tableHeight)) { verticalDistance([centerYGuide.start, centerYGuide.end]) == tableDepth - 55 horizontalDistance([centerXGuide.start, centerXGuide.end]) == blockWidth / 2 distance([ - tapPillarCircle.center, - tapPillarCircle.start -]) == 15 + tapPillarCircle.center, + tapPillarCircle.start + ]) == 15 } tapPillarRegion = region(segments = [tapPillarSketch.tapPillarCircle]) @@ -509,9 +509,9 @@ tapNoseSketch = sketch(on = offsetPlane(XZ, offset = 55 - tableDepth)) { verticalDistance([heightGuide.start, heightGuide.end]) == tableHeight + 100 horizontalDistance([centerXGuide.start, centerXGuide.end]) == blockWidth / 2 distance([ - tapNoseCircle.center, - tapNoseCircle.start -]) == 10 + tapNoseCircle.center, + tapNoseCircle.start + ]) == 10 } tapNoseRegion = region(segments = [tapNoseSketch.tapNoseCircle]) @@ -550,9 +550,9 @@ tapHandleSketch = sketch(on = offsetPlane(XZ, offset = 55 - tableDepth)) { verticalDistance([heightGuide.start, heightGuide.end]) == tableHeight + 150 horizontalDistance([centerXGuide.start, centerXGuide.end]) == blockWidth / 2 distance([ - tapHandleCircle.center, - tapHandleCircle.start -]) == 4 + tapHandleCircle.center, + tapHandleCircle.start + ]) == 4 } tapHandleRegion = region(segments = [tapHandleSketch.tapHandleCircle]) @@ -719,19 +719,19 @@ handleProfilePath = sketch(on = handlePlane) { horizontal(topSpanGuide) horizontalDistance([ - startOffsetGuide.start, - startOffsetGuide.end -]) == handleOffset + startOffsetGuide.start, + startOffsetGuide.end + ]) == handleOffset distance([leftLeg.start, leftLeg.end]) == handleLengthSegmentA equalLength([leftLeg, rightLeg]) distance([ - leftRadiusGuide.start, - leftRadiusGuide.end -]) == handleFillet + leftRadiusGuide.start, + leftRadiusGuide.end + ]) == handleFillet distance([ - rightRadiusGuide.start, - rightRadiusGuide.end -]) == handleFillet + rightRadiusGuide.start, + rightRadiusGuide.end + ]) == handleFillet distance([grip.start, grip.end]) == handleLengthSegmentB horizontalDistance([topSpanGuide.start, topSpanGuide.end]) == handleWidth radius(leftArc) == handleFillet @@ -764,9 +764,9 @@ handleSectionProfile = sketch(on = XZ) { verticalDistance([heightGuide.start, heightGuide.end]) == handleHeightAboveTheFloor horizontalDistance([centerXGuide.start, centerXGuide.end]) == handleOffset distance([ - sectionCircle.center, - sectionCircle.start -]) == 2 + sectionCircle.center, + sectionCircle.start + ]) == 2 } handleSection = region(segments = [handleSectionProfile.sectionCircle]) diff --git a/content/pages/docs/kcl-samples/wheel-hub/main.kcl b/content/pages/docs/kcl-samples/wheel-hub/main.kcl index e24e22c5..6333a6ab 100644 --- a/content/pages/docs/kcl-samples/wheel-hub/main.kcl +++ b/content/pages/docs/kcl-samples/wheel-hub/main.kcl @@ -155,13 +155,13 @@ trimProfile = sketch(on = XY) { vertical(line4) verticalDistance([ - startHeightGuide.start, - startHeightGuide.end -]) == -hubSpacing / 4 + startHeightGuide.start, + startHeightGuide.end + ]) == -hubSpacing / 4 horizontalDistance([ - startOffsetGuide.start, - startOffsetGuide.end -]) == rotorBore / 2 + startOffsetGuide.start, + startOffsetGuide.end + ]) == rotorBore / 2 distance([line1.start, line1.end]) == lugSpacing / 3 angleDimension(lines = [startOffsetGuide, line1], sector = 1, labelPosition = [2.17in, -0.69in]) == 10deg distance([line2.start, line2.end]) == hubSpacing * 1.5 @@ -206,13 +206,13 @@ mountingFlangeProfile = sketch(on = flangePlane) { horizontal(outerRadiusGuide) horizontal(centerBoreRadiusGuide) distance([ - outerRadiusGuide.start, - outerRadiusGuide.end -]) == flangeOuterRadius + outerRadiusGuide.start, + outerRadiusGuide.end + ]) == flangeOuterRadius distance([ - centerBoreRadiusGuide.start, - centerBoreRadiusGuide.end -]) == flangeBoreRadius + centerBoreRadiusGuide.start, + centerBoreRadiusGuide.end + ]) == flangeBoreRadius radius(outerCircle) == flangeOuterRadius radius(centerBoreCircle) == flangeBoreRadius } @@ -331,9 +331,9 @@ boltHeadProfile = sketch(on = faceOf(mountingFlange, face = START)) { horizontal(boltHeadRadiusGuide) horizontalDistance([centerGuide.start, centerGuide.end]) == -lugSpacing / 2 horizontalDistance([ - boltHeadRadiusGuide.start, - boltHeadRadiusGuide.end -]) == lugThreadDiameter / 1.25 + boltHeadRadiusGuide.start, + boltHeadRadiusGuide.end + ]) == lugThreadDiameter / 1.25 } boltHeadRegion = region(segments = [ diff --git a/content/pages/docs/kcl-std/functions/std-gdt-angularity.md b/content/pages/docs/kcl-std/functions/std-gdt-angularity.md index 19869102..51814199 100644 --- a/content/pages/docs/kcl-std/functions/std-gdt-angularity.md +++ b/content/pages/docs/kcl-std/functions/std-gdt-angularity.md @@ -92,9 +92,9 @@ stampedProfile = sketch(on = XY) { distance([flangeEnd.start, flangeEnd.end]) == thickness distance([innerFlange.start, innerFlange.end]) == flangeLength - bendStartX distance([ - controlledSurface.start, - controlledSurface.end -]) == legLength + controlledSurface.start, + controlledSurface.end + ]) == legLength distance([tabEnd.start, tabEnd.end]) == thickness distance([outerSurface.start, outerSurface.end]) == legLength parallel([controlledSurface, outerSurface]) @@ -173,9 +173,9 @@ stampedProfile = sketch(on = XY) { distance([flangeEnd.start, flangeEnd.end]) == thickness distance([innerFlange.start, innerFlange.end]) == flangeLength - bendStartX distance([ - controlledSurface.start, - controlledSurface.end -]) == legLength + controlledSurface.start, + controlledSurface.end + ]) == legLength distance([tabEnd.start, tabEnd.end]) == thickness distance([outerSurface.start, outerSurface.end]) == legLength parallel([controlledSurface, outerSurface]) diff --git a/content/pages/docs/kcl-std/functions/std-helix.md b/content/pages/docs/kcl-std/functions/std-helix.md index af94b8cd..a3ab7c32 100644 --- a/content/pages/docs/kcl-std/functions/std-helix.md +++ b/content/pages/docs/kcl-std/functions/std-helix.md @@ -29,7 +29,7 @@ helix( | `angleStart` | [`number(Angle)`](/docs/kcl-std/types/std-types-number) | Start angle. | Yes | | `ccw` | [`bool`](/docs/kcl-std/types/std-types-bool) | Is the helix rotation counter clockwise? The default is `false`. | No | | `radius` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Radius of the helix. | No | -| `axis` | [`Axis3d`](/docs/kcl-std/types/std-types-Axis3d) or [`Edge`](/docs/kcl-std/types/std-types-Edge) or [`Segment`](/docs/kcl-std/types/std-types-Segment) or [`any`](/docs/kcl-std/types/std-types-any) | Axis to use for the helix. Can be an Axis3d, an Edge, or a Segment when not using a cylinder. Experimental face API: edge reference objects (e.g. `{ sideFaces = [faceTag1, faceTag2] }`) are not ready for generated or user-facing KCL yet; prefer Axis3d, Edge, or Segment until point-and-click and migration support ships. | No | +| `axis` | [`Axis3d`](/docs/kcl-std/types/std-types-Axis3d) or [`Edge`](/docs/kcl-std/types/std-types-Edge) or [`Segment`](/docs/kcl-std/types/std-types-Segment) or [`any`](/docs/kcl-std/types/std-types-any) | Axis to use for the helix. Can be an Axis3d, an Edge, a Segment, or an edge reference object when not using a cylinder. Edge reference objects use `sideFaces`, e.g. `{ sideFaces = [faceTag1, faceTag2] }`. | No | | `length` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Length of the helix. This is not necessary if the helix is created around an edge. If not given the length of the edge is used. | No | | `cylinder` | [`Solid`](/docs/kcl-std/types/std-types-Solid) | Cylinder to create the helix on. | No | diff --git a/content/pages/docs/kcl-std/functions/std-sketch-getBoundedEdge.md b/content/pages/docs/kcl-std/functions/std-sketch-getBoundedEdge.md index 370333ae..472a701c 100644 --- a/content/pages/docs/kcl-std/functions/std-sketch-getBoundedEdge.md +++ b/content/pages/docs/kcl-std/functions/std-sketch-getBoundedEdge.md @@ -23,7 +23,7 @@ getBoundedEdge( | Name | Type | Description | Required | |----------|------|-------------|----------| | `solid` | [`Solid`](/docs/kcl-std/types/std-types-Solid) | The solid that the edge belongs to. | Yes | -| `edge` | [`Edge`](/docs/kcl-std/types/std-types-Edge) or [`any`](/docs/kcl-std/types/std-types-any) | The edge to bound. This can be a tagged edge or an edge ID from `edgeId(...)`. Experimental face API: edge reference objects (e.g. `{ sideFaces = [faceTag1, faceTag2], endFaces = [...], index = 0 }`) are not ready for generated or user-facing KCL yet; prefer tagged edges or `edgeId(...)` until point-and-click and migration support ships. | Yes | +| `edge` | [`Edge`](/docs/kcl-std/types/std-types-Edge) or [`any`](/docs/kcl-std/types/std-types-any) | The edge to bound. This can be a tagged edge, an edge ID from `edgeId(...)`, or an edge reference object. Edge reference objects use `sideFaces`, e.g. `{ sideFaces = [faceTag1, faceTag2], endFaces = [...], index = 0 }`. | Yes | | `lowerBound` | [`number(_)`](/docs/kcl-std/types/std-types-number) | A lower percentage bound of the edge, must be between 0 and 1 inclusive. Defaults to 0. | No | | `upperBound` | [`number(_)`](/docs/kcl-std/types/std-types-number) | A upper percentage bound of the edge, must be between 0 and 1 inclusive. Defaults to 1. | No | diff --git a/content/pages/docs/kcl-std/functions/std-sketch-revolve.md b/content/pages/docs/kcl-std/functions/std-sketch-revolve.md index 7dccea38..93d0a33f 100644 --- a/content/pages/docs/kcl-std/functions/std-sketch-revolve.md +++ b/content/pages/docs/kcl-std/functions/std-sketch-revolve.md @@ -40,7 +40,7 @@ way (i.e. scaled differently along each axis). | Name | Type | Description | Required | |----------|------|-------------|----------| | `sketches` | [[`Sketch`](/docs/kcl-std/types/std-types-Sketch) or [`Segment`](/docs/kcl-std/types/std-types-Segment); 1+] | The sketch or set of sketches that should be revolved, or solved sketch segments for a surface revolve. | Yes | -| `axis` | [`Axis2d`](/docs/kcl-std/types/std-types-Axis2d) or [`Edge`](/docs/kcl-std/types/std-types-Edge) or [`Segment`](/docs/kcl-std/types/std-types-Segment) or [`any`](/docs/kcl-std/types/std-types-any) | Axis of revolution. Can be an Axis2d, an Edge, or a solved Segment. Experimental face API: edge reference objects (e.g. `{ sideFaces = [faceTag1, faceTag2] }`) are not ready for generated or user-facing KCL yet; prefer Axis2d, Edge, or Segment until point-and-click and migration support ships. | Yes | +| `axis` | [`Axis2d`](/docs/kcl-std/types/std-types-Axis2d) or [`Edge`](/docs/kcl-std/types/std-types-Edge) or [`Segment`](/docs/kcl-std/types/std-types-Segment) or [`any`](/docs/kcl-std/types/std-types-any) | Axis of revolution. Can be an Axis2d, an Edge, a solved Segment, or an edge reference object. Edge reference objects use `sideFaces`, e.g. `{ sideFaces = [faceTag1, faceTag2] }`. | Yes | | `angle` | [`number(Angle)`](/docs/kcl-std/types/std-types-number) | Angle to revolve (in degrees). Default is 360. | No | | `tolerance` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Defines the smallest distance below which two entities are considered coincident, intersecting, coplanar, or similar. For most use cases, it should not be changed from its default value of 10^-7 millimeters. | No | | `symmetric` | [`bool`](/docs/kcl-std/types/std-types-bool) | If true, the extrusion will happen symmetrically around the sketch. Otherwise, the extrusion will happen on only one side of the sketch. | No | diff --git a/content/pages/docs/kcl-std/functions/std-solid-blend.md b/content/pages/docs/kcl-std/functions/std-solid-blend.md index a5544dc2..af01f441 100644 --- a/content/pages/docs/kcl-std/functions/std-solid-blend.md +++ b/content/pages/docs/kcl-std/functions/std-solid-blend.md @@ -13,14 +13,14 @@ blend(@edges: [BoundedEdge | TaggedEdge | any; 2]): Solid Or blend the full edges directly with tagged edges (no `getBoundedEdge`): -Experimental face API: edge specifier objects are supported for testing, but are not ready for generated or user-facing KCL yet; prefer tagged edges or bounded edges until point-and-click and migration support ships. +Edge specifier objects are also supported. Sketch block tags work too: ### Arguments | Name | Type | Description | Required | |----------|------|-------------|----------| -| `edges` | [[`BoundedEdge`](/docs/kcl-std/types/std-types-BoundedEdge) or [`TaggedEdge`](/docs/kcl-std/types/std-types-TaggedEdge) or [`any`](/docs/kcl-std/types/std-types-any); 2] | The two edges that will be blended. Tagged edges blend the full edge length. Experimental face API: edge specifier objects (`{ sideFaces = [...], endFaces? = [...], index? = 0 }`) are not ready for generated or user-facing KCL yet; prefer tagged edges or bounded edges until point-and-click and migration support ships. | Yes | +| `edges` | [[`BoundedEdge`](/docs/kcl-std/types/std-types-BoundedEdge) or [`TaggedEdge`](/docs/kcl-std/types/std-types-TaggedEdge) or [`any`](/docs/kcl-std/types/std-types-any); 2] | The two edges that will be blended. Tagged edges blend the full edge length. Edge specifier objects can also be used, e.g. `{ sideFaces = [...], endFaces? = [...], index? = 0 }`. | Yes | ### Returns diff --git a/content/pages/docs/kcl-std/functions/std-solid-chamfer.md b/content/pages/docs/kcl-std/functions/std-solid-chamfer.md index 81ac122e..f2fba1b0 100644 --- a/content/pages/docs/kcl-std/functions/std-solid-chamfer.md +++ b/content/pages/docs/kcl-std/functions/std-solid-chamfer.md @@ -33,7 +33,7 @@ a sharp, straight transitional edge. | `solid` | [`Solid`](/docs/kcl-std/types/std-types-Solid) | The solid whose edges should be chamfered | Yes | | `length` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Chamfering cuts away two faces to create a third face. This is the length to chamfer away from each face. The larger this length to chamfer away, the larger the new face will be. | Yes | | `tags` | [[`Edge`](/docs/kcl-std/types/std-types-Edge); 1+] | The paths you want to chamfer (legacy API) | No | -| `edges` | [[`any`](/docs/kcl-std/types/std-types-any)] | **Experimental.** Experimental face API. Do not use in generated or user-facing KCL yet; prefer `tags` until point-and-click and migration support ships. Array of edge references; each element is an object with: - `sideFaces`: [Face | Tag; 1+] - Adjacent faces that share the edge(s) to chamfer - `endFaces?`: [Face | Tag] - Optional faces to disambiguate when multiple edges share the same two faces - `index?`: number(Count) - Optional index when multiple edges share the same faces (0-based) | No | +| `edges` | [[`any`](/docs/kcl-std/types/std-types-any)] | Array of edge references; each element is an object with: - `sideFaces`: [Face | Tag; 1+] - Adjacent faces that share the edge(s) to chamfer - `endFaces?`: [Face | Tag] - Optional faces to disambiguate when multiple edges share the same two faces - `index?`: number(Count) - Optional index when multiple edges share the same faces (0-based) | No | | `secondLength` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Chamfering cuts away two faces to create a third face. If this argument isn't given, the lengths chamfered away from both the first and second face are both given by `length`. If this argument _is_ given, it determines how much is cut away from the second face. Incompatible with `angle`. | No | | `angle` | [`number(Angle)`](/docs/kcl-std/types/std-types-number) | Chamfering cuts away two faces to create a third face. This argument determines the angle between the two cut edges. Requires `length`, incompatible with `secondLength`. The valid range is 0deg < angle < 90deg. | No | | `tag` | [`TagDecl`](/docs/kcl-std/types/std-types-TagDecl) | Create a new tag which refers to this chamfer | No | diff --git a/content/pages/docs/kcl-std/functions/std-solid-fillet.md b/content/pages/docs/kcl-std/functions/std-solid-fillet.md index 088d98d1..280f512e 100644 --- a/content/pages/docs/kcl-std/functions/std-solid-fillet.md +++ b/content/pages/docs/kcl-std/functions/std-solid-fillet.md @@ -32,7 +32,7 @@ will smoothly blend the transition. | `solid` | [`Solid`](/docs/kcl-std/types/std-types-Solid) | The solid whose edges should be filletted | Yes | | `radius` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | The radius of the fillet | Yes | | `tags` | [[`Edge`](/docs/kcl-std/types/std-types-Edge); 1+] | The paths you want to fillet (legacy API) | No | -| `edges` | [[`any`](/docs/kcl-std/types/std-types-any)] | **Experimental.** Experimental face API. Do not use in generated or user-facing KCL yet; prefer `tags` until point-and-click and migration support ships. Array of edge references; each element is an object with: - `sideFaces`: [Face | Tag; 1+] - Adjacent faces that share the edge(s) to fillet - `endFaces?`: [Face | Tag] - Optional faces to disambiguate when multiple edges share the same two faces - `index?`: number(Count) - Optional index when multiple edges share the same faces (0-based) | No | +| `edges` | [[`any`](/docs/kcl-std/types/std-types-any)] | Array of edge references; each element is an object with: - `sideFaces`: [Face | Tag; 1+] - Adjacent faces that share the edge(s) to fillet - `endFaces?`: [Face | Tag] - Optional faces to disambiguate when multiple edges share the same two faces - `index?`: number(Count) - Optional index when multiple edges share the same faces (0-based) | No | | `tolerance` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Defines the smallest distance below which two entities are considered coincident, intersecting, coplanar, or similar. For most use cases, it should not be changed from its default value of 10^-7 millimeters. | No | | `tag` | [`TagDecl`](/docs/kcl-std/types/std-types-TagDecl) | Create a new tag which refers to this fillet | No | | `legacyMethod` | [`bool`](/docs/kcl-std/types/std-types-bool) | **Deprecated as of KCL 2.0.** **Removed in KCL 3.0.** You probably shouldn't set this or care about this, it's for opting back into an older version of an engine algorithm. If true, revert to older engine SSI algorithm. Defaults to false. | No | @@ -211,9 +211,9 @@ sketch001 = sketch(on = XY) { distance([seg01.start, seg01.end]) == 80 distance([topRightInset.start, topRightInset.end]) == 26.43mm distance([ - innerRightDrop.start, - innerRightDrop.end -]) == 50 + innerRightDrop.start, + innerRightDrop.end + ]) == 50 distance([lowerSpan.start, lowerSpan.end]) == 273.67mm distance([innerLeftRise.start, innerLeftRise.end]) == 50 distance([topLeftInset.start, topLeftInset.end]) == 26.98mm @@ -288,9 +288,9 @@ sketch001 = sketch(on = XY) { distance([seg01.start, seg01.end]) == 80 distance([topRightInset.start, topRightInset.end]) == 26.43mm distance([ - innerRightDrop.start, - innerRightDrop.end -]) == 50 + innerRightDrop.start, + innerRightDrop.end + ]) == 50 distance([lowerSpan.start, lowerSpan.end]) == 273.67mm distance([innerLeftRise.start, innerLeftRise.end]) == 50 distance([topLeftInset.start, topLeftInset.end]) == 26.98mm