yapCAD 0.5.0__py2.py3-none-any.whl → 0.5.1__py2.py3-none-any.whl

yapcad/geom3d_util.py

@@ -81,6 +81,7 @@ icaIndices = [ [1,11,3],[3,11,5],[5,11,7],[7,11,9],[9,11,1],
                [0,2,4],[0,4,6],[0,6,8],[0,8,10],[0,10,2] ]
 
 vertexHash = {}
+_vertexHash_owner = None
 def addVertex(nv,nn,verts,normals):
     """
     Utility function that takes a vertex and associated normal and a
@@ -91,18 +92,29 @@ def addVertex(nv,nn,verts,normals):
 
     returns the index, and the (potentiall updated) lists
     """
-    global vertexHash
-    if len(verts) == 0:
+    global vertexHash, _vertexHash_owner
+    owner_id = id(verts)
+    if _vertexHash_owner != owner_id or len(verts) == 0:
         vertexHash = {}
+        _vertexHash_owner = owner_id
 
     found = False
-    vkey = f"{nv[0]:.2f}{nv[1]:.2f}{nv[2]:.2f}"
+    # Normalize tiny values to avoid "-0.00" != "0.00" hash key mismatch
+    x = 0.0 if abs(nv[0]) < epsilon else nv[0]
+    y = 0.0 if abs(nv[1]) < epsilon else nv[1]
+    z = 0.0 if abs(nv[2]) < epsilon else nv[2]
+    vkey = f"{x:.2f}{y:.2f}{z:.2f}"
     if vkey in vertexHash:
         found = True
         inds = vertexHash[vkey]
+        valid_inds = []
         for i in inds:
+            if i >= len(verts):
+                continue
             if vclose(nv,verts[i]):
                 return i,verts,normals
+            valid_inds.append(i)
+        vertexHash[vkey] = valid_inds
             
     verts.append(nv)
     normals.append(nn)
@@ -347,20 +359,32 @@ def conic(baser,topr,height, center=point(0,0,0),angr=10):
                      ['procedure',call])
     else:
         topP = add(center,point(0,0,height))
-        conV = [ topP ] + baseV
+        # Only use perimeter vertices (baseV[1:]), skip the center point
+        conV = [ topP ] + baseV[1:]
         ll = len(conV)
-        conN = [[0,0,1,0]]
+        # Initialize all normals to a default value
+        conN = [[0,0,1,0] for _ in range(ll)]
         conF = []
 
-        for i in range(1,ll):
-            p0= conV[0]
-            p1= conV[(i-1)%ll]
-            p2= conV[(i+1)%ll]
+        # ll = apex(1) + perimeter vertices(36) = 37
+        # Perimeter vertex indices: 1 to ll-1
+        num_perimeter = ll - 1
+        for i in range(1, ll):
+            p0 = conV[0]  # apex
+            # Wrap indices within perimeter range [1, ll-1]
+            prev_idx = ((i - 2) % num_perimeter) + 1
+            next_idx = (i % num_perimeter) + 1
+            p1 = conV[prev_idx]
+            p2 = conV[next_idx]
 
-            conF.append([0,i,(i+1)%ll])
-            pp,n0 = tri2p0n([p0,p1,p2])
+            try:
+                pp, n0 = tri2p0n([p0, p1, p2])
+            except ValueError:
+                # Skip degenerate faces near the apex
+                continue
 
-            conN.append(n0)
+            conF.append([0, i, next_idx])
+            conN[i] = n0
 
         conS = surface(conV,conN,conF)
 
@@ -384,28 +408,112 @@ def makeRevolutionSurface(contour,zStart,zEnd,steps,arcSamples=36):
 
     degStep = 360.0/arcSamples
     radStep = pi2/arcSamples
+
+    # Pre-compute cos/sin values to avoid floating point errors at the seam
+    # Explicitly ensure that index 0 uses exact values
+    angle_cos = []
+    angle_sin = []
+    for i in range(arcSamples):
+        if i == 0:
+            angle_cos.append(1.0)
+            angle_sin.append(0.0)
+        else:
+            angle = i * radStep
+            angle_cos.append(math.cos(angle))
+            angle_sin.append(math.sin(angle))
+
+    # Check if we need pole caps
+    r_start = contour(zStart)
+    r_end = contour(zEnd)
+    need_start_cap = r_start < epsilon * 10
+    need_end_cap = r_end < epsilon * 10
+
+    # Add pole vertices if needed
+    start_pole_idx = None
+    end_pole_idx = None
+    if need_start_cap:
+        pole_point = [0.0, 0.0, zStart, 1.0]
+        pole_normal = [0.0, 0.0, -1.0, 0.0]  # Points downward for bottom pole
+        start_pole_idx, sV, sN = addVertex(pole_point, pole_normal, sV, sN)
+
+    if need_end_cap:
+        pole_point = [0.0, 0.0, zEnd, 1.0]
+        pole_normal = [0.0, 0.0, 1.0, 0.0]  # Points upward for top pole
+        end_pole_idx, sV, sN = addVertex(pole_point, pole_normal, sV, sN)
+
     for i in range(steps):
         z = i*zD+zStart
         r0 = contour(z)
         r1 = contour(z+zD)
-        if r0 < epsilon*10:
-            r0 = epsilon*10
-        if r1 < epsilon*10:
-            r1 = epsilon*10
+
+        # Handle pole caps
+        if i == 0 and need_start_cap:
+            # Create triangular faces from pole to first ring
+            if r1 < epsilon:
+                r1 = epsilon
+            for j in range(arcSamples):
+                a1_idx = j
+                a2_idx = (j+1) % arcSamples
+
+                pp1 = [angle_cos[a1_idx]*r1, angle_sin[a1_idx]*r1, z+zD, 1.0]
+                pp2 = [angle_cos[a2_idx]*r1, angle_sin[a2_idx]*r1, z+zD, 1.0]
+
+                try:
+                    _, n = tri2p0n([sV[start_pole_idx], pp1, pp2])
+                except ValueError:
+                    continue
+
+                k1, sV, sN = addVertex(pp1, n, sV, sN)
+                k2, sV, sN = addVertex(pp2, n, sV, sN)
+                sF.append([start_pole_idx, k1, k2])
+            continue
+
+        if i == steps - 1 and need_end_cap:
+            # Create triangular faces from last ring to pole
+            if r0 < epsilon:
+                r0 = epsilon
+            for j in range(arcSamples):
+                a1_idx = j
+                a2_idx = (j+1) % arcSamples
+
+                p1 = [angle_cos[a1_idx]*r0, angle_sin[a1_idx]*r0, z, 1.0]
+                p2 = [angle_cos[a2_idx]*r0, angle_sin[a2_idx]*r0, z, 1.0]
+
+                try:
+                    _, n = tri2p0n([p1, sV[end_pole_idx], p2])
+                except ValueError:
+                    continue
+
+                k1, sV, sN = addVertex(p1, n, sV, sN)
+                k2, sV, sN = addVertex(p2, n, sV, sN)
+                sF.append([k1, end_pole_idx, k2])
+            continue
+
+        # Regular quad strips for non-pole sections
+        if r0 < epsilon:
+            r0 = epsilon
+        if r1 < epsilon:
+            r1 = epsilon
+
         for j in range(arcSamples):
-            a0 = (j-1)*radStep
-            a1 = j*radStep
-            a2 = (j+1)*radStep
+            # Use pre-computed values with proper wrapping
+            a0_idx = (j-1) % arcSamples
+            a1_idx = j
+            a2_idx = (j+1) % arcSamples
 
-            p0 = [math.cos(a0)*r0,math.sin(a0)*r0,z,1.0]
-            p1 = [math.cos(a1)*r0,math.sin(a1)*r0,z,1.0]
-            p2 = [math.cos(a2)*r0,math.sin(a2)*r0,z,1.0]
+            p0 = [angle_cos[a0_idx]*r0, angle_sin[a0_idx]*r0, z, 1.0]
+            p1 = [angle_cos[a1_idx]*r0, angle_sin[a1_idx]*r0, z, 1.0]
+            p2 = [angle_cos[a2_idx]*r0, angle_sin[a2_idx]*r0, z, 1.0]
 
-            pp1 = [math.cos(a1)*r1,math.sin(a1)*r1,z+zD,1.0]
-            pp2 = [math.cos(a2)*r1,math.sin(a2)*r1,z+zD,1.0]
+            pp1 = [angle_cos[a1_idx]*r1, angle_sin[a1_idx]*r1, z+zD, 1.0]
+            pp2 = [angle_cos[a2_idx]*r1, angle_sin[a2_idx]*r1, z+zD, 1.0]
+
+            try:
+                p,n = tri2p0n([p0,p2,pp1])
+            except ValueError:
+                # Skip degenerate faces
+                continue
 
-            p,n = tri2p0n([p0,p2,pp1])
-            
             k1,sV,sN = addVertex(p1,n,sV,sN)
             k2,sV,sN = addVertex(p2,n,sV,sN)
             k3,sV,sN = addVertex(pp2,n,sV,sN)
@@ -499,14 +607,51 @@ def extrude(surf,distance,direction=vect(0,0,1,0)):
 
     loops = []
     if s2[4]:
-        loops.append(s2[4])
-    loops.extend([loop for loop in s2[5] if loop])
+        loops.append(list(s2[4]))
+    loops.extend([list(loop) for loop in s2[5] if loop])
 
     stripV = s2[1] + s1[1]  # vertices for the edge strips
     stripN = [vect(0, 0, 1, 0)] * len(stripV)  # placeholder normals
     stripF: list[list[int]] = []
     offset = len(s2[1])
 
+    def _project(idx):
+        point3 = stripV[idx]
+        return point3[0], point3[1]
+
+    if surf[3]:
+        try:
+            tri = surf[3][0]
+            basis = tri2p0n([surf[1][tri[0]], surf[1][tri[1]], surf[1][tri[2]]], basis=True)
+            if basis:
+                forward = basis[2]
+
+                def _project(idx):  # type: ignore[redefinition]
+                    vec = forward.mul(stripV[idx])
+                    return vec[0], vec[1]
+        except Exception:  # pragma: no cover
+            pass
+
+    def loop_area(loop):
+        if len(loop) < 3:
+            return 0.0
+        area = 0.0
+        for i in range(len(loop)):
+            x0, y0 = _project(loop[i])
+            x1, y1 = _project(loop[(i + 1) % len(loop)])
+            area += x0 * y1 - x1 * y0
+        return area / 2.0
+
+    if loops:
+        outer_area = loop_area(loops[0])
+        if outer_area < 0:
+            loops[0].reverse()
+            outer_area = -outer_area
+        outer_sign = 1 if outer_area >= 0 else -1
+        for loop in loops[1:]:
+            if loop_area(loop) * outer_sign > 0:
+                loop.reverse()
+
     for bndry in loops:
         if len(bndry) < 2:
             continue
@@ -534,8 +679,319 @@ def extrude(surf,distance,direction=vect(0,0,1,0)):
     return solid([s2,strip,s1],
                  [],
                  ['procedure',call])
-    
-        
+
+
+
+def _loft_surface(lower_loop, upper_loop, invert=False):
+    """Create a surface connecting two loops.
+
+    Args:
+        lower_loop: List of points forming the lower loop (must be open, not closed)
+        upper_loop: List of points forming the upper loop (must be open, not closed)
+        invert: If True, reverse the face winding order
+
+    Returns:
+        A yapCAD surface connecting the two loops with triangle strips
+    """
+
+    if not lower_loop or not upper_loop:
+        raise ValueError('invalid loops passed to loft surface')
+    lower = [point(p) for p in lower_loop]
+    upper = [point(p) for p in upper_loop]
+    if len(lower) != len(upper):
+        raise ValueError('loop length mismatch in loft surface')
+
+    vertices = lower + upper
+    normals = [[0, 0, 1, 0] for _ in vertices]
+    faces = []
+    count = len(lower)
+
+    for idx in range(count):
+        j0 = idx
+        j1 = (idx + 1) % count
+        j2 = j1 + count
+        j3 = idx + count
+
+        tri1 = [j0, j1, j2]
+        tri2 = [j0, j2, j3]
+        if invert:
+            tri1 = list(reversed(tri1))
+            tri2 = list(reversed(tri2))
+
+        try:
+            _, normal = tri2p0n([vertices[tri1[0]],
+                                 vertices[tri1[1]],
+                                 vertices[tri1[2]]])
+        except ValueError:
+            continue
+
+        for vid in {tri1[0], tri1[1], tri1[2], tri2[0], tri2[1], tri2[2]}:
+            normals[vid] = normal
+
+        faces.append(tri1)
+        faces.append(tri2)
+
+    return surface(vertices, normals, faces)
+
+
         
 
     
+
+def _circle_loop(center_xy, radius, minang):
+    arc_geom = [arc(point(center_xy[0], center_xy[1]), radius)]
+    loop = geomlist2poly(arc_geom, minang=minang, minlen=0.0)
+    if not loop:
+        raise ValueError('failed to generate circle loop')
+    return loop
+
+
+def tube(outer_diameter, wall_thickness, length,
+         center=None, *, base_point=None, minang=5.0, include_caps=True):
+    """Create a cylindrical tube solid.
+
+    ``base_point`` (or legacy ``center`` argument) identifies the base of the
+    cylindrical wall, i.e. the plane where ``z == base_point[2]``.
+    """
+
+    if base_point is not None and center is not None:
+        raise ValueError('specify only base_point (preferred) or center, not both')
+    if base_point is None:
+        base_point = center if center is not None else point(0, 0, 0)
+    if len(base_point) < 3:
+        raise ValueError('base_point must contain x, y, z components')
+    base_point = point(base_point)
+
+    if wall_thickness <= epsilon:
+        raise ValueError('wall thickness must be positive')
+
+    outer_radius = outer_diameter / 2.0
+    inner_radius = outer_radius - wall_thickness
+    if inner_radius <= epsilon:
+        raise ValueError('wall thickness too large for tube')
+
+    base_z = base_point[2]
+    center_xy = (base_point[0], base_point[1])
+
+    base_loop_xy = _circle_loop(center_xy, outer_radius, minang)
+    inner_loop_xy = list(reversed(_circle_loop(center_xy, inner_radius, minang)))
+
+    base_surface, _ = poly2surfaceXY(base_loop_xy, holepolys=[inner_loop_xy])
+    base_surface = reversesurface(base_surface)
+    base_surface = translatesurface(base_surface, point(0, 0, base_z))
+
+    top_surface, _ = poly2surfaceXY(base_loop_xy, holepolys=[inner_loop_xy])
+    top_surface = translatesurface(top_surface, point(0, 0, base_z + length))
+
+    outer_base = [point(p[0], p[1], base_z, 1.0) for p in base_loop_xy[:-1]]
+    inner_base = [point(p[0], p[1], base_z, 1.0) for p in inner_loop_xy[:-1]]
+    outer_top = [point(p[0], p[1], base_z + length, 1.0) for p in base_loop_xy[:-1]]
+    inner_top = [point(p[0], p[1], base_z + length, 1.0) for p in inner_loop_xy[:-1]]
+
+    outer_side = _loft_surface(outer_base, outer_top)
+    inner_side = _loft_surface(inner_top, inner_base, invert=True)
+
+    call = f"yapcad.geom3d_util.tube({outer_diameter}, {wall_thickness}, {length}, base_point={base_point})"
+    surfaces = [base_surface, outer_side, top_surface, inner_side]
+    if not include_caps:
+        surfaces = [outer_side, inner_side]
+    return solid(surfaces,
+                 [],
+                 ['procedure', call])
+
+
+def conic_tube(bottom_outer_diameter, top_outer_diameter, wall_thickness,
+               length, center=None, *, base_point=None, minang=5.0, include_caps=True):
+    """Create a conic tube with varying outer diameter.
+
+    ``base_point`` (or ``center`` legacy argument) marks the axial base of the
+    frustum (the larger-diameter end when stacked)."""
+
+    if base_point is not None and center is not None:
+        raise ValueError('specify only base_point (preferred) or center, not both')
+    if base_point is None:
+        base_point = center if center is not None else point(0, 0, 0)
+    base_point = point(base_point)
+
+    if wall_thickness <= epsilon:
+        raise ValueError('wall thickness must be positive')
+
+    r0_outer = bottom_outer_diameter / 2.0
+    r1_outer = top_outer_diameter / 2.0
+    r0_inner = r0_outer - wall_thickness
+    r1_inner = r1_outer - wall_thickness
+    if r0_inner <= epsilon or r1_inner <= epsilon:
+        raise ValueError('wall thickness too large for conic tube')
+
+    base_z = base_point[2]
+    center_xy = (base_point[0], base_point[1])
+
+    base_outer_loop = _circle_loop(center_xy, r0_outer, minang)
+    base_inner_loop = list(reversed(_circle_loop(center_xy, r0_inner, minang)))
+
+    top_outer_loop = _circle_loop(center_xy, r1_outer, minang)
+    top_inner_loop = list(reversed(_circle_loop(center_xy, r1_inner, minang)))
+
+    base_surface, _ = poly2surfaceXY(base_outer_loop, holepolys=[base_inner_loop])
+    base_surface = reversesurface(base_surface)
+    base_surface = translatesurface(base_surface, point(0, 0, base_z))
+
+    top_surface, _ = poly2surfaceXY(top_outer_loop, holepolys=[top_inner_loop])
+    top_surface = translatesurface(top_surface, point(0, 0, base_z + length))
+
+    outer_base = [point(p[0], p[1], base_z, 1.0) for p in base_outer_loop[:-1]]
+    outer_top = [point(p[0], p[1], base_z + length, 1.0) for p in top_outer_loop[:-1]]
+    inner_base = [point(p[0], p[1], base_z, 1.0) for p in base_inner_loop[:-1]]
+    inner_top = [point(p[0], p[1], base_z + length, 1.0) for p in top_inner_loop[:-1]]
+
+    outer_side = _loft_surface(outer_base, outer_top)
+    inner_side = _loft_surface(inner_top, inner_base, invert=True)
+
+    call = ("yapcad.geom3d_util.conic_tube("
+            f"{bottom_outer_diameter}, {top_outer_diameter}, {wall_thickness}, {length}, base_point={base_point})")
+    surfaces = [base_surface, outer_side, top_surface, inner_side]
+    if not include_caps:
+        surfaces = [outer_side, inner_side]
+    return solid(surfaces,
+                 [],
+                 ['procedure', call])
+
+
+def spherical_shell(outer_diameter, wall_thickness,
+                    solid_angle=4 * math.pi, center=point(0, 0, 0),
+                    *, minang=5.0, steps=24):
+    """Create a spherical shell or cap defined by a solid angle."""
+
+    if wall_thickness <= epsilon:
+        raise ValueError('wall thickness must be positive')
+
+    outer_radius = outer_diameter / 2.0
+    inner_radius = outer_radius - wall_thickness
+    if inner_radius <= epsilon:
+        raise ValueError('wall thickness too large for spherical shell')
+
+    solid_angle = max(min(solid_angle, 4 * math.pi), epsilon)
+    cos_theta = 1.0 - solid_angle / (2.0 * math.pi)
+    cos_theta = max(-1.0, min(1.0, cos_theta))
+    theta = math.acos(cos_theta)
+
+    arc_samples = max(12, int(round(360.0 / minang)))
+    lat_steps = max(4, int(math.ceil(theta / math.radians(minang))))
+
+    cz = center[2]
+
+    def _sphere_contour(radius):
+        def contour(z):
+            dz = z - cz
+            dz = max(min(dz, radius), -radius)
+            return math.sqrt(max(radius * radius - dz * dz, 0.0))
+        return contour
+
+    z_start_outer = cz + outer_radius * math.cos(theta)
+    z_start_inner = cz + inner_radius * math.cos(theta)
+    z_end_outer = cz + outer_radius
+    z_end_inner = cz + inner_radius
+
+    outer_surface = makeRevolutionSurface(_sphere_contour(outer_radius),
+                                          z_start_outer, z_end_outer,
+                                          max(steps, lat_steps),
+                                          arcSamples=arc_samples)
+    outer_surface = translatesurface(outer_surface, point(center[0], center[1], 0))
+
+    inner_surface = makeRevolutionSurface(_sphere_contour(inner_radius),
+                                          z_start_inner, z_end_inner,
+                                          max(steps, lat_steps),
+                                          arcSamples=arc_samples)
+    inner_surface = translatesurface(inner_surface, point(center[0], center[1], 0))
+    inner_surface = reversesurface(inner_surface)
+
+    surfaces = [outer_surface, inner_surface]
+
+    if theta < math.pi - epsilon:
+        r_outer_ring = outer_radius * math.sin(theta)
+        r_inner_ring = inner_radius * math.sin(theta)
+
+        base_outer = [point(center[0] + p[0], center[1] + p[1], cz + outer_radius * math.cos(theta), 1.0)
+                      for p in _circle_loop((0, 0), r_outer_ring, minang)[:-1]]
+        base_inner = [point(center[0] + p[0], center[1] + p[1], cz + inner_radius * math.cos(theta), 1.0)
+#                      for p in list(reversed(_circle_loop((0, 0), r_inner_ring, minang)))[:-1]]
+                      for p in _circle_loop((0, 0), r_inner_ring, minang)[:-1]]
+
+        conic_surface = _loft_surface(base_outer, base_inner, invert=False)
+        surfaces.append(conic_surface)
+
+    call = ("yapcad.geom3d_util.spherical_shell("
+            f"{outer_diameter}, {wall_thickness}, {solid_angle}, center={center})")
+    return solid(surfaces,
+                 [],
+                 ['procedure', call])
+
+
+def stack_solids(solids, *, axis='z', start=0.0, gap=0.0, align='center'):
+    """Return translated copies of ``solids`` stacked along an axis."""
+
+    if not solids:
+        return []
+
+    axis = axis.lower()
+    if axis not in ('x', 'y', 'z'):
+        raise ValueError('axis must be one of x, y, or z')
+
+    axis_idx = {'x': 0, 'y': 1, 'z': 2}[axis]
+    other_idx = [i for i in range(3) if i != axis_idx]
+
+    placed = []
+    cursor = start
+    reference = None
+    pending_gap = 0.0
+
+    for entry in solids:
+        if isinstance(entry, str):
+            directive = entry.strip().lower()
+            if directive.startswith('space:'):
+                try:
+                    value = float(directive.split(':', 1)[1])
+                except ValueError as exc:
+                    raise ValueError(f'bad spacing directive {entry}') from exc
+                pending_gap += value
+                continue
+            raise ValueError(f'unsupported directive {entry!r} in stack_solids')
+
+        solid_obj = entry
+        bbox = solidbbox(solid_obj)
+        length = bbox[1][axis_idx] - bbox[0][axis_idx]
+        if length < epsilon:
+            raise ValueError('solid has zero length along stacking axis')
+
+        cursor += pending_gap
+        pending_gap = 0.0
+
+        translation = [0.0, 0.0, 0.0]
+        translation[axis_idx] = cursor - bbox[0][axis_idx]
+
+        if reference is None:
+            if align == 'center':
+                reference = [
+                    (bbox[0][idx] + bbox[1][idx]) / 2.0 for idx in other_idx
+                ]
+            elif align == 'min':
+                reference = [bbox[0][idx] for idx in other_idx]
+            elif align == 'max':
+                reference = [bbox[1][idx] for idx in other_idx]
+            else:
+                raise ValueError('align must be center, min, or max')
+
+        if align == 'center':
+            for ref_val, idx in zip(reference, other_idx):
+                translation[idx] = ref_val - (bbox[0][idx] + bbox[1][idx]) / 2.0
+        elif align == 'min':
+            for ref_val, idx in zip(reference, other_idx):
+                translation[idx] = ref_val - bbox[0][idx]
+        elif align == 'max':
+            for ref_val, idx in zip(reference, other_idx):
+                translation[idx] = ref_val - bbox[1][idx]
+
+        placed.append(translatesolid(solid_obj, vect(translation[0], translation[1], translation[2], 0)))
+        cursor += length + gap
+
+    return placed