b3dkit 0.1.2__tar.gz → 0.1.3__tar.gz

{b3dkit-0.1.2 → b3dkit-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b3dkit
-Version: 0.1.2
+Version: 0.1.3
 Summary: build123d libraries and utilities
 Project-URL: Homepage, https://github.com/x0pherl/b3dkit
 Project-URL: Issues, https://github.com/x0pherl/b3dkit/issues
@@ -10,21 +10,21 @@ License-File: LICENSE
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-Requires-Dist: build123d>=0.0.1
-Requires-Dist: ocp-vscode
+Requires-Python: >=3.10
+Requires-Dist: build123d>=0.10.0
+Requires-Dist: ocp-vscode>=3.1.1
 Provides-Extra: dev
-Requires-Dist: pytest; extra == 'dev'
-Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-cov>=7.0.0; extra == 'dev'
+Requires-Dist: pytest>=9.0.2; extra == 'dev'
 Provides-Extra: docs
-Requires-Dist: markdown-include; extra == 'docs'
-Requires-Dist: mkdocs; extra == 'docs'
-Requires-Dist: mkdocs-material; extra == 'docs'
+Requires-Dist: markdown-include>=0.8.1; extra == 'docs'
+Requires-Dist: mkdocs-material>=9.7.6; extra == 'docs'
+Requires-Dist: mkdocs>=1.6.1; extra == 'docs'
 Provides-Extra: maintain
-Requires-Dist: build; extra == 'maintain'
-Requires-Dist: hatch-vcs; extra == 'maintain'
-Requires-Dist: hatchling; extra == 'maintain'
-Requires-Dist: twine; extra == 'maintain'
+Requires-Dist: build>=1.4.0; extra == 'maintain'
+Requires-Dist: hatch-vcs>=0.5.0; extra == 'maintain'
+Requires-Dist: hatchling>=1.29.0; extra == 'maintain'
+Requires-Dist: twine>=6.2.0; extra == 'maintain'
 Description-Content-Type: text/markdown
 
 # b3dkit Overview

{b3dkit-0.1.2 → b3dkit-0.1.3}/docs/basic_shapes.md

@@ -111,18 +111,26 @@ Creates an extruded diamond (4-sided polygon) that behaves like a cylinder. This
 DiamondCylinder(
     radius: float,
     height: float,
-    rotation: tuple = (0, 0, 0),
-    align: tuple = (Align.CENTER, Align.CENTER, Align.CENTER),
-    stretch: tuple = (1, 1, 1)
+    arc_size: float = 360,
+    stretch: tuple = (1, 1, 1),
+    rotation: RotationLike = (0, 0, 0),
+    align: Align | tuple[Align, Align, Align] | None = None,
+    mode: Mode = Mode.ADD,
 )
 ```
 
 **Arguments:**
 - `radius` (float): The radius of the circumscribed circle
 - `height` (float): The height of the extrusion
-- `rotation` (tuple, default=(0, 0, 0)): Rotation angles (X, Y, Z) in degrees
-- `align` (tuple, default=(Align.CENTER, Align.CENTER, Align.CENTER)): Alignment
+- `arc_size` (float, default=360): Angular sweep in degrees for the circular clipping sector used to intersect the base profile
 - `stretch` (tuple, default=(1, 1, 1)): Scaling factors (X, Y, Z)
+- `rotation` (RotationLike, default=(0, 0, 0)): Rotation angles (X, Y, Z) in degrees
+- `align` (Align | tuple[Align, Align, Align] | None, default=None): Alignment along X, Y, Z axes
+- `mode` (Mode, default=Mode.ADD): Boolean combination mode
+
+**Arc Size Behavior:**
+- `arc_size=360` produces the full diamond profile
+- `arc_size<360` clips the XY profile and reduces volume while preserving Z behavior from `height` and `stretch[2]`
 
 **Returns:**
 - `Part`: The diamond cylinder
@@ -165,10 +173,12 @@ Creates an extruded regular polygon that behaves like a cylinder.
 PolygonalCylinder(
     radius: float,
     height: float,
-    sides: int = 6,
-    rotation: tuple = (0, 0, 0),
-    align: tuple = (Align.CENTER, Align.CENTER, Align.CENTER),
-    stretch: tuple = (1, 1, 1)
+    side_count: int = 6,
+    arc_size: float = 360,
+    stretch: tuple = (1, 1, 1),
+    rotation: RotationLike = (0, 0, 0),
+    align: Align | tuple[Align, Align, Align] | None = None,
+    mode: Mode = Mode.ADD,
 )
 ```
 
@@ -176,12 +186,16 @@ PolygonalCylinder(
 **Arguments:**
 - `radius` (float): The radius of the circumscribed circle
 - `height` (float): The height of the extrusion
-- `sides` (int, default=6): Number of sides of the polygon
+- `side_count` (int, default=6): Number of sides of the polygon
+- `arc_size` (float, default=360): Angular sweep in degrees for the circular clipping sector used to intersect the base profile
 - `stretch` (tuple, default=(1, 1, 1)): Scaling factors (X, Y, Z)
-- `rotation` (RotationLike, optional): angles to rotate about axes. Defaults to (0, 0, 0)
-- `align` (Align | tuple[Align, Align, Align] | None, optional): align MIN, CENTER,
-        or MAX of object. Defaults to (Align.CENTER, Align.CENTER, Align.CENTER)
-- `mode` (Mode, optional): combine mode. Defaults to Mode.ADD
+- `rotation` (RotationLike, default=(0, 0, 0)): Angles to rotate about axes
+- `align` (Align | tuple[Align, Align, Align] | None, default=None): Align MIN, CENTER, or MAX on each axis
+- `mode` (Mode, default=Mode.ADD): Boolean combination mode
+
+**Arc Size Behavior:**
+- `arc_size=360` keeps the full regular polygonal profile
+- `arc_size<360` clips the XY profile and reduces volume while preserving Z behavior from `height` and `stretch[2]`
 
 
 ### RoundedCylinder

b3dkit-0.1.3/docs/hexwall.md

@@ -0,0 +1,128 @@
+# Hexagonal Patterns
+
+This module provides two part objects for creating hexagonal (honeycomb) patterns:
+
+- [`HexWall`](#hexwall) — a flat box with a hexagonal cutout pattern.
+- [`HexCylindrical`](#hexcylindrical) — a honeycomb of hexagonal holes wrapped around the curved surface of a cone or cylinder.
+
+## HexWall
+
+Part Object: `HexWall`
+
+Create a box with a hexagonal cutout pattern defined by length, width, and height, apothem, and wall thickness. This Part is useful for generating hexagonal patterns in 3D models.
+
+### Arguments
+
+- `length` (float): The length of the hexagonal wall.
+- `width` (float): The width of the hexagonal wall.
+- `height` (float): The height of the hexagonal wall.
+- `apothem` (float): The apothem (distance from the center to the midpoint of a side) of the hexagons.
+- `wall_thickness` (float): The thickness of the walls of the hexagons.
+- `align` (Union[Align, tuple[Align, Align, Align]], default=(Align.CENTER, Align.CENTER, Align.CENTER)): The alignment of the hexagonal wall. Can be a single `Align` value or a tuple of three `Align` values for x, y, and z alignment.
+- `inverse` (bool, default=False): If `True`, creates an inverse hexagonal pattern.
+
+### Returns
+
+- `Part`: The created hexagonal wall part.
+
+### Example
+
+```python
+from b3dkit import HexWall
+from build123d import Align
+
+# Create a hexagonal wall with specified dimensions and properties
+hex_wall = HexWall(
+    length=100,
+    width=100,
+    height=10,
+    apothem=5,
+    wall_thickness=1,
+    align=(Align.CENTER, Align.CENTER, Align.CENTER),
+    inverse=False
+)
+
+# Create an inverse hexagonal wall
+inverse_hex_wall = HexWall(
+    length=100,
+    width=100,
+    height=10,
+    apothem=5,
+    wall_thickness=1,
+    align=(Align.CENTER, Align.CENTER, Align.CENTER),
+    inverse=True
+)
+```
+
+## HexCylindrical
+
+Part Object: `HexCylindrical`
+
+Wraps a honeycomb of hexagonal holes around the curved surface of a `Cone` or `Cylinder`. It builds the hole geometry *only* — a `Part` containing one cutter per hole — so you subtract it from your solid to vent or lighten it.
+
+The holes are laid out row by row: `horizontal_count` holes run around the surface at each height, `vertical_count` rows stack up the slope starting `z_distance` above the base, and alternate rows are offset half a step for the honeycomb stagger. Each hex is projected onto the true surface so it follows the curvature, then thickened into a cutter.
+
+Each row is centered on a fixed meridian, so the pattern stays left/right symmetric as a cone tapers instead of drifting to one side. Rows that would climb past the top edge of the surface are dropped automatically.
+
+### Arguments
+
+- `cylindrical` (Cone | Cylinder): The cone or cylinder to wrap holes around. Assumed upright on the Z axis with its base at the bottom; its circular edges define the radius at each height. A pointed cone (top radius 0) is supported — its apex radius is inferred from the bounding box.
+- `hole_radius` (float): Radius of each hexagonal hole (the `RegularPolygon` radius).
+- `spacing_radius` (float): Hex cell radius controlling spacing; nearest holes are `2 * spacing_radius` apart (matching `HexLocations(radius=...)`).
+- `horizontal_count` (int): Number of holes around the surface in each row.
+- `vertical_count` (int): Number of rows stacked up the slope. Rows that fall off the top edge are skipped, so the actual number of rows may be fewer.
+- `thickness` (float): How far each cutter extends in/out of the surface. Set `thickness >= wall_thickness` to cut clean through a hollow wall.
+- `z_distance` (float): Height of the lowest row of holes, measured up from the bottom of the surface (not an absolute Z coordinate).
+- `rotation` (RotationLike, default=(0, 0, 0)): Angles to rotate about the axes.
+- `align` (Union[None, Align, tuple[Align, Align, Align]], default=None): Align MIN, CENTER, or MAX of the object.
+- `mode` (Mode, default=Mode.ADD): Combine mode used when the object is created inside an active build context.
+
+### Returns
+
+- `Part`: A part whose children are the hole cutters. Subtract it from your solid (e.g. `solid - HexCylindrical(...)`, or pass `mode=Mode.SUBTRACT` inside a build context) to make the holes.
+
+### Raises
+
+- `ValueError`: If `cylindrical` has no circular edge to derive a radius profile from (e.g. a `Box`).
+- `ValueError`: If no holes fit on the surface (e.g. `z_distance` starts at or above the top edge, or the surface is too short for the given spacing).
+
+### Example
+
+```python
+from b3dkit import HexCylindrical
+from build123d import Cone, Cylinder, Align
+
+# Vent a tapering cone with a honeycomb pattern
+cone = Cone(
+    bottom_radius=40,
+    top_radius=20,
+    height=60,
+    align=(Align.CENTER, Align.CENTER, Align.MIN),
+)
+holes = HexCylindrical(
+    cone,
+    hole_radius=2,
+    spacing_radius=4,
+    horizontal_count=16,
+    vertical_count=6,
+    thickness=4,        # >= wall thickness so the holes cut all the way through
+    z_distance=8,       # start the first row 8mm up from the base
+)
+vented_cone = cone - holes
+
+# The same call works on a straight cylinder (constant radius)
+cylinder = Cylinder(
+    radius=30,
+    height=60,
+    align=(Align.CENTER, Align.CENTER, Align.MIN),
+)
+vented_cylinder = cylinder - HexCylindrical(
+    cylinder,
+    hole_radius=2,
+    spacing_radius=4,
+    horizontal_count=20,
+    vertical_count=8,
+    thickness=4,
+    z_distance=6,
+)
+```

{b3dkit-0.1.2 → b3dkit-0.1.3}/pyproject.toml

@@ -1,37 +1,37 @@
 [project]
 name = "b3dkit"
-version = "0.1.2"
+version = "0.1.3"
 authors = [
   { name="x0pherl"},
 ]
 description = "build123d libraries and utilities"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
 dependencies = [
-  "build123d>=0.0.1",
-  "ocp_vscode",
+  "build123d>=0.10.0",
+  "ocp_vscode>=3.1.1",
 ]
 
 [project.optional-dependencies]
 dev = [
-  "pytest",
-  "pytest-cov",
+  "pytest>=9.0.2",
+  "pytest-cov>=7.0.0",
   ]
 maintain =[
-  "twine",
-  "hatch-vcs",
-  "hatchling",
-  "build",
+  "twine>=6.2.0",
+  "hatch-vcs>=0.5.0",
+  "hatchling>=1.29.0",
+  "build>=1.4.0",
 ]
 docs = [
-  "mkdocs",
-  "mkdocs-material",
-  "markdown-include",
+  "mkdocs>=1.6.1",
+  "mkdocs-material>=9.7.6",
+  "markdown-include>=0.8.1",
 ]
 
 [project.urls]
@@ -40,7 +40,7 @@ Issues = "https://github.com/x0pherl/b3dkit/issues"
 Documentation = "https://b3dkit.readthedocs.org"
 
 [build-system]
-requires = ["hatchling", "hatch-vcs"]
+requires = ["hatchling>=1.29.0", "hatch-vcs>=0.5.0"]
 
 build-backend = "hatchling.build"
 

{b3dkit-0.1.2 → b3dkit-0.1.3}/src/b3dkit/basic_shapes.py

@@ -25,6 +25,7 @@ from build123d import (
     JernArc,
     Line,
     Location,
+    Locations,
     Mode,
     Part,
     Plane,
@@ -127,7 +128,7 @@ def circular_intersection(radius: float, coordinate: float) -> float:
         - coordinate: a coordinate along one axis of the circle (must be a
             positive value less than the radius)
     """
-    if 0 > coordinate > radius:
+    if not (0 <= coordinate <= radius):
         raise ValueError("The x-coordinate cannot be greater than the radius.")
     return sqrt(radius**2 - coordinate**2)
 
@@ -218,6 +219,7 @@ class PolygonalCylinder(BasePartObject):
         radius: float,
         height: float,
         side_count: int = 6,
+        arc_size: float = 360,
         stretch: tuple = (1, 1, 1),
         rotation: RotationLike = (0, 0, 0),
         align: Union[None, Align, tuple[Align, Align, Align]] = None,
@@ -230,6 +232,7 @@ class PolygonalCylinder(BasePartObject):
             - radius: the radius of the cylinder
             - height: the height of the cylinder
             - side_count: the number of sides of the polygonal base (default is 6)
+            - arc_size: (float, optional) – angular size of cone. Defaults to 360.
             - stretch: scales the base polygon
             - rotation: the rotation of the cylinder
             - align: the alignment of the cylinder
@@ -239,14 +242,21 @@ class PolygonalCylinder(BasePartObject):
         validate_inputs(context, self)
 
         with BuildPart() as tube:
-            with BuildSketch():
+            with BuildSketch() as poly:
                 RegularPolygon(
                     radius=radius, side_count=side_count, align=tuplify(align, 2)
                 )
+                center = poly.sketch.face().center()
+                with Locations((center.X, center.Y)):
+                    Circle(
+                        radius=radius,
+                        arc_size=arc_size,
+                        align=None,
+                        mode=Mode.INTERSECT,
+                    ),
             extrude(amount=height * stretch[2])
-        super().__init__(
-            part=tube.part, rotation=rotation, align=tuplify(align, 3), mode=mode
-        )
+            scale(tube.part, by=(stretch[0], stretch[1], 1))
+        super().__init__(part=tube.part, rotation=rotation, align=align, mode=mode)
 
 
 class DiamondCylinder(PolygonalCylinder):
@@ -255,6 +265,7 @@ class DiamondCylinder(PolygonalCylinder):
         self,
         radius: float,
         height: float,
+        arc_size: float = 360,
         stretch: tuple = (1, 1, 1),
         rotation: RotationLike = (0, 0, 0),
         align: Union[None, Align, tuple[Align, Align, Align]] = None,
@@ -264,17 +275,19 @@ class DiamondCylinder(PolygonalCylinder):
         creates an extruded diamond that behaves like a cylinder
         -------
         arguments:
-            - radius: the radius of the cylinder
-            - height: the height of the cylinder
-            - rotation: the rotation of the cylinder
-            - align: the alignment of the cylinder (default
+            - radius: (float) - the radius of the cylinder
+            - height: (float) - the height of the cylinder
+            - arc_size: (float, optional) – angular size of cone. Defaults to 360.
+            - rotation: (RotationLike) - the rotation of the cylinder
+            - align: (Union[None, Align, tuple[Align, Align, Align]]) - the alignment of the cylinder (default
                     is (Align.CENTER, Align.CENTER, Align.CENTER) )
-            - mode: the mode to use when adding the part
+            - mode: (Mode) - the mode to use when adding the part
         """
         super().__init__(
             radius=radius,
             height=height,
             side_count=4,
+            arc_size=arc_size,
             stretch=stretch,
             rotation=rotation,
             align=align,
@@ -379,19 +392,14 @@ class TeardropCylinder(BasePartObject):
 if __name__ == "__main__":
 
     show(
-        DiamondTorus(
-            50,
-            2,
-        ),
-        reset_camera=Camera.KEEP,
-    )
-    show(
-        DiamondCylinder(
+        PolygonalCylinder(
             radius=50,
             height=200,
+            side_count=6,
+            arc_size=270,
             stretch=(1, 1, 1),
             rotation=(0, 0, 0),
-            align=(Align.MIN, Align.MIN, Align.CENTER),
+            align=(Align.CENTER, Align.CENTER, Align.MAX),
         ),
         reset_camera=Camera.KEEP,
     )

b3dkit-0.1.3/src/b3dkit/hexwall.py

@@ -0,0 +1,230 @@
+"""
+HexWall
+
+name: hexwall.py
+by:   x0pherl
+date: Jan 19th 2025
+
+desc:
+    This build123d python module creates a hexagonal pattern within a box, resulting
+    in a grid of hexagons.
+"""
+
+from math import sqrt
+from typing import Union
+
+from build123d import (
+    Align,
+    Axis,
+    BasePartObject,
+    Box,
+    BuildPart,
+    BuildSketch,
+    Cone,
+    Cylinder,
+    Edge,
+    GeomType,
+    HexLocations,
+    Locations,
+    Mode,
+    Part,
+    Plane,
+    RegularPolygon,
+    RotationLike,
+    extrude,
+    thicken,
+    tuplify,
+)
+from ocp_vscode import Camera, show
+
+
+class HexWall(BasePartObject):
+
+    def __init__(
+        self,
+        length: float,
+        width: float,
+        height: float,
+        apothem: float,
+        wall_thickness: float,
+        inverse=False,
+        rotation: RotationLike = (0, 0, 0),
+        align: Union[None, Align, tuple[Align, Align, Align]] = None,
+        mode: Mode = Mode.ADD,
+    ):
+        """
+        Part Object: hexwall
+        -------
+        arguments:
+            - length (float): box size
+            - width (float): box size
+            - height (float): box size
+            - apothem (float): the distance between two paralel edges of the hexagon
+            - rotation (RotationLike, optional): angles to rotate about axes. Defaults to (0, 0, 0)
+            - align (Align | tuple[Align, Align, Align] | None, optional): align MIN, CENTER,
+                or MAX of object. Defaults to (Align.CENTER, Align.CENTER, Align.CENTER)
+            - mode (Mode, optional): combine mode. Defaults to Mode.ADD
+        """
+        with BuildPart() as wall:
+            hexwall_radius = 2 * sqrt(3) / 3 * apothem
+            hexwall_xcount = int(length // ((sqrt(3) / 2 * apothem) / 2)) + 2
+            if hexwall_xcount % 2 == 0:
+                hexwall_xcount += 1
+            Box(length=length, width=width, height=height, align=tuplify(align, 3))
+            combine_mode = Mode.INTERSECT if inverse else Mode.SUBTRACT
+            with BuildPart(mode=combine_mode):
+                with BuildSketch(wall.faces().sort_by(Axis.Z)[0]) as sk:
+                    with HexLocations(
+                        radius=hexwall_radius,
+                        x_count=hexwall_xcount,
+                        y_count=int(width // apothem / 2) + 2,
+                        align=(Align.CENTER, Align.CENTER),
+                    ):
+                        RegularPolygon(
+                            radius=2 * sqrt(3) / 3 * (apothem - wall_thickness / 2),
+                            major_radius=False,
+                            side_count=6,
+                        )
+                extrude(sk.sketch, -height)
+        part = wall.part
+        part.label = "hexwall"
+
+        super().__init__(
+            part=part, rotation=rotation, align=tuplify(align, 3), mode=mode
+        )
+
+
+class HexCylindrical(BasePartObject):
+
+    def __init__(
+        self,
+        cylindrical: Cone | Cylinder,
+        hole_radius: float,
+        spacing_radius: float,
+        horizontal_count: int,
+        vertical_count: int,
+        thickness: float,
+        z_distance: float,
+        rotation: RotationLike = (0, 0, 0),
+        align: Union[None, Align, tuple[Align, Align, Align]] = None,
+        mode: Mode = Mode.ADD,
+    ):
+        """
+        Part Object: HexCylindrical
+        -------
+        Wraps a honeycomb of hexagonal holes around the cylindrical surface of a Cylinder
+        or Cone and returns the hole geometry *only* (the cutters), so the caller can remove
+        them elsewhere with ``mode=Mode.SUBTRACT``.
+
+        The holes are laid out row by row: ``horizontal_count`` holes run around the cone at each
+        height, ``vertical_count`` rows stack up the slope from ``z_distance``, and alternate
+        rows are offset half a step for a honeycomb stagger. Each hex is projected onto
+        the true cone surface (so it follows the curvature) and thickened into a cutter.
+
+        arguments:
+            - cylindrical (Part): the cone or cylinder to wrap holes around. Assumed upright on the
+                Z axis with its base at the bottom; its circular edges define the radius
+                at each height.
+            - hole_radius (float): radius of each hexagonal hole (RegularPolygon radius)
+            - spacing_radius (float): hex cell radius controlling spacing; nearest holes
+                are ``2 * spacing_radius`` apart (matches ``HexLocations(radius=...)``)
+            - horizontal_count (int): number of holes around the cone in each row
+            - vertical_count (int): number of rows stacked up the slope
+            - thickness (float): how far each cutter extends in/out of the surface; set
+                ``thickness >= wall_thickness`` to cut clean through a hollow cone wall
+            - z_distance (float): height of the lowest row of holes, measured up
+                from the bottom of the cone (not an absolute Z coordinate)
+            - rotation (RotationLike, optional): angles to rotate about axes. Defaults to
+                (0, 0, 0)
+            - align (Align | tuple[Align, Align, Align] | None, optional): align MIN,
+                CENTER, or MAX of object. Defaults to None
+            - mode (Mode, optional): combine mode. Defaults to Mode.ADD
+        """
+
+        # Derive the cone's radius-vs-height from its circular edges so any upright
+        # cone/frustum works (a pointed cone reduces to radius 0 at its apex).
+        circles = cylindrical.edges().filter_by(GeomType.CIRCLE).sort_by(Axis.Z)
+        if not circles:
+            raise ValueError(
+                "cone must have at least one circular edge to wrap holes around"
+            )
+        bottom = circles[0]
+        z_bottom, r_bottom = bottom.arc_center.Z, bottom.radius
+        if len(circles) >= 2:
+            z_top, r_top = circles[-1].arc_center.Z, circles[-1].radius
+        else:
+            z_top, r_top = cylindrical.bounding_box().max.Z, 0.0
+
+        def radius_at(z: float) -> float:
+            return r_bottom + (r_top - r_bottom) * (z - z_bottom) / (z_top - z_bottom)
+
+        # Honeycomb pitches: nearest-neighbour distance == 2 * spacing_radius, matching
+        # HexLocations(radius=spacing_radius). Rows run around (x), stacked up slope (y).
+        x_pitch = 2 * spacing_radius
+        y_pitch = spacing_radius * sqrt(3)
+
+        def hex_row(count: int) -> list[Part]:
+            """A flat row of ``count`` hex faces spaced by x_pitch along +X."""
+            with BuildSketch() as row_sketch:
+                with Locations(*[(i * x_pitch, 0) for i in range(count)]):
+                    RegularPolygon(hole_radius, side_count=6, major_radius=False)
+            return row_sketch.sketch.faces()
+
+        # Wrap one row onto the surface at each height, then thicken into cutters.
+        # Stop once a row climbs off the cone's surface: above the top edge the
+        # radius would extrapolate to zero/negative, which make_circle rejects.
+        cutters: list[Part] = []
+        for row in range(vertical_count):
+            z = z_bottom + z_distance + row * y_pitch
+            if not z_bottom <= z <= z_top:
+                break
+            r = radius_at(z)
+            if r <= 0:  # pragma: no cover - defensive: z-bound above already
+                break  # keeps r >= 0; only an exact-apex row could reach here
+            path = Edge.make_circle(r, Plane.XY.offset(z))
+
+            faces = hex_row(horizontal_count)
+            # project_faces anchors the row at faces[0].min.X and lays it out in one
+            # direction. Center the row's mean position on a fixed meridian so it grows
+            # symmetrically from the center instead of drifting to one side up the taper.
+            bboxes = [f.bounding_box() for f in faces]
+            first_min_x = bboxes[0].min.X
+            mean_center_x = sum((b.min.X + b.max.X) / 2 for b in bboxes) / len(bboxes)
+            center_offset = (mean_center_x - first_min_x) / path.length
+            stagger = (x_pitch / 2) / path.length if row % 2 else 0.0
+
+            projected = cylindrical.project_faces(
+                faces, path=path, start=0.5 - center_offset + stagger
+            )
+            cutters.extend(
+                thicken(face, amount=-thickness, both=False) for face in projected
+            )
+
+        # No rows fit on the surface (e.g. z_distance starts at/above the top, or
+        # the surface is too short for the given spacing). Fail clearly instead of
+        # letting BasePartObject choke on an empty shape downstream.
+        if not cutters:
+            raise ValueError(
+                "no hex holes fit on the surface; check z_distance, spacing_radius, "
+                "and the cone/cylinder height"
+            )
+
+        # Return the cutters as a single (un-fused) Part so the whole pattern can be
+        # subtracted in one boolean by the caller.
+        part = Part(children=cutters)
+        part.label = "hexcone"
+
+        super().__init__(
+            part=part, rotation=rotation, align=tuplify(align, 3), mode=mode
+        )
+
+
+if __name__ == "__main__":
+    # cone = Cone(100, 50, 100, align=(Align.CENTER, Align.CENTER, Align.MIN))
+    # cylinder = Cylinder(100, 100)
+
+    # part = cone
+    # hexsample = HexCylindrical(part, 1, 2, 20, 10, 2, 20)
+
+    # show(part, hexsample)
+    show(HexWall(100, 200, 3, 4, 1))