@deepblend/dsh-blender-provider-local 0.2.20 → 0.3.1

package/python/deepblend_vessel.py

@@ -0,0 +1,192 @@
+"""Shared-boundary cup geometry. Construction is isolated from runtime actions.
+
+Root strips use quintic endpoint jets. Numeric output checks do not certify
+arbitrary continuous surfaces or artistic quality.
+"""
+import math
+import bpy
+import bmesh
+from mathutils import Vector
+from mathutils.geometry import delaunay_2d_cdt
+from deepblend_vessel_parameters import handled_cup_parameters
+from deepblend_mesh_checks import validate_handled_cup_mesh
+from deepblend_util import ActionError
+from deepblend_vessel_math import CupSurface, add, unit
+
+
+class MeshBuilder:
+
+    def __init__(self):
+        self.vertices = []
+        self.faces = []
+        self.uv = []
+        self.regions = []
+        self.keys = {}
+        self.normals = []
+
+    def vertex(self, p, normal):
+        normal = unit(normal)
+        key = tuple((round(c, 10) for c in p))
+        if key not in self.keys:
+            self.keys[key] = len(self.vertices)
+            self.vertices.append(tuple(p))
+            self.normals.append(normal)
+        else:
+            previous = self.normals[self.keys[key]]
+            if sum((a-b)**2 for a,b in zip(previous, normal)) > 1e-10:
+                raise ActionError('SCENE_SPEC_INVALID', 'handled_cup output: incompatible shared surface normals')
+        return self.keys[key]
+
+    def face(self, ids, uv, region):
+        unique = []
+        coords = []
+        for (i, c) in zip(ids, uv):
+            if i not in unique:
+                unique.append(i)
+                coords.append(c)
+        if len(unique) < 3:
+            return
+        self.faces.append(unique)
+        self.uv.append(coords)
+        self.regions.append(region)
+
+    def finish(self, name):
+        mesh = bpy.data.meshes.new(name)
+        mesh.from_pydata(self.vertices, [], self.faces)
+        mesh.update()
+        uv = mesh.uv_layers.new(name='UVMap')
+        attr = mesh.attributes.new('deepblend_cup_region', 'INT', 'FACE')
+        for (i, (polygon, coords)) in enumerate(zip(mesh.polygons, self.uv)):
+            attr.data[i].value = self.regions[i]
+            for (loop, c) in zip(polygon.loop_indices, coords):
+                uv.data[loop].uv = c
+        bm = bmesh.new()
+        bm.from_mesh(mesh)
+        bmesh.ops.recalc_face_normals(bm, faces=list(bm.faces))
+        bm.to_mesh(mesh)
+        bm.free()
+        obj = bpy.data.objects.new(name, mesh)
+        bpy.context.scene.collection.objects.link(obj)
+        select(obj)
+        bpy.ops.object.shade_smooth_by_angle(angle=math.radians(30))
+        mesh.normals_split_custom_set([self.normals[loop.vertex_index] for loop in mesh.loops])
+        return obj
+
+def select(obj):
+    bpy.ops.object.select_all(action='DESELECT')
+    obj.select_set(True)
+    bpy.context.view_layer.objects.active = obj
+
+def inside(point, polygon):
+    (x, y) = point
+    hit = False
+    for (a, b) in zip(polygon, polygon[1:] + polygon[:1]):
+        if (a[1] > y) != (b[1] > y) and x < (b[0] - a[0]) * (y - a[1]) / (b[1] - a[1]) + a[0]:
+            hit = not hit
+    return hit
+
+class _HandledCupMesh(CupSurface):
+    """Analytic profiles sampled into one mesh; roots share cup/handle vertices.
+
+    R/T/B are cup radius/wall/base, r is the tube radius, A/L are root
+    footprint/length, H is attachment half-gap, N/M are angular resolutions.
+    """
+
+
+
+
+    def add_wall(self, builder, holes):
+        (lower, upper) = (self.C, self.HEIGHT - self.T / 2)
+        p = self.profile()
+        dist = [0]
+        for (a, b) in zip(p, p[1:]):
+            dist.append(dist[-1] + math.dist(a, b))
+        (v0, v1) = (dist[9] / dist[-1], dist[10] / dist[-1])
+        hole_coords = []
+        for z in (self.P['lower'], self.P['upper']):
+            hole_coords.append([(self.R * math.asin(self.A * math.cos(self.TAU * j / self.M) / self.R), z + self.A * math.sin(self.TAU * j / self.M)) for j in range(self.M)])
+        coords = []
+        edges = []
+        for row in range(self.P['wallRows'] + 1):
+            z = lower + (upper - lower) * row / self.P['wallRows']
+            for col in range(self.N + 1):
+                u = -math.pi * self.R + self.TAU * self.R * col / self.N
+                if holes and any((inside((u, z), p) for p in hole_coords)):
+                    continue
+                coords.append((u, z))
+        if holes:
+            for polygon in hole_coords:
+                start = len(coords)
+                coords.extend(polygon)
+                edges.extend(((start + j, start + (j + 1) % self.M) for j in range(self.M)))
+        output = delaunay_2d_cdt([Vector(p) for p in coords], edges, [], 0, 1e-09, True)
+        (points, _, faces, orig, _, _) = output
+        points = [coords[ids[0]] if len(ids) == 1 else tuple(p) for (p, ids) in zip(points, orig)]
+        for face in faces:
+            center = tuple((sum((points[i][axis] for i in face)) / len(face) for axis in range(2)))
+            if holes and any((inside(center, p) for p in hole_coords)):
+                continue
+            ids = [builder.vertex((self.R * math.cos(points[i][0] / self.R), self.R * math.sin(points[i][0] / self.R), points[i][1]),
+                                  (math.cos(points[i][0] / self.R), math.sin(points[i][0] / self.R), 0)) for i in face]
+            builder.face(ids, [(0.25 * (points[i][0] / (self.TAU * self.R) + 0.5), v0 + (v1 - v0) * (points[i][1] - lower) / (upper - lower)) for i in face], 0)
+
+    def add_cup(self, builder, holes):
+        p = self.profile()
+        rings = []
+        dist = [0]
+        for (a, b) in zip(p, p[1:]):
+            dist.append(dist[-1] + math.dist(a, b))
+        vs = [v / dist[-1] for v in dist]
+        for (radius, z), (radial, vertical) in zip(p, self.profile_normals()):
+            rings.append([builder.vertex((radius * math.cos(-math.pi + self.TAU * j / self.N), radius * math.sin(-math.pi + self.TAU * j / self.N), z),
+                                        (radial * math.cos(-math.pi + self.TAU * j / self.N), radial * math.sin(-math.pi + self.TAU * j / self.N), vertical)) for j in range(self.N)])
+        for row in range(len(p) - 1):
+            if row == 9:
+                continue
+            for j in range(self.N):
+                k = (j + 1) % self.N
+                builder.face([rings[row][j], rings[row][k], rings[row + 1][k], rings[row + 1][j]], [(0.25 * j / self.N, vs[row]), (0.25 * (j + 1) / self.N, vs[row]), (0.25 * (j + 1) / self.N, vs[row + 1]), (0.25 * j / self.N, vs[row + 1])], 1)
+        self.add_wall(builder, holes)
+
+    def add_roots(self, builder):
+        for upper in (False, True):
+            rings = []
+            for i in range(self.P['rootSegments'] + 1):
+                rings.append([builder.vertex(self.root_point(i / self.P['rootSegments'], self.TAU * j / self.M, upper),
+                                            self.root_normal(i / self.P['rootSegments'], self.TAU * j / self.M, upper)) for j in range(self.M)])
+            for i in range(self.P['rootSegments']):
+                for j in range(self.M):
+                    k = (j + 1) % self.M
+                    u = 0.3 if upper else 0.45
+                    builder.face([rings[i][j], rings[i][k], rings[i + 1][k], rings[i + 1][j]], [(u + 0.1 * j / self.M, i / self.P['rootSegments']), (u + 0.1 * (j + 1) / self.M, i / self.P['rootSegments']), (u + 0.1 * (j + 1) / self.M, (i + 1) / self.P['rootSegments']), (u + 0.1 * j / self.M, (i + 1) / self.P['rootSegments'])], 2 if upper else 3)
+
+    def add_handle(self, builder):
+        sections = []
+        for i in range(self.P['handleSegments'] + 1):
+            a = math.pi * i / self.P['handleSegments']
+            sections.append(((self.R + self.L + self.H * math.sin(a), 0, self.MID + self.H * math.cos(a)), (math.sin(a), 0, math.cos(a))))
+        rings = []
+        for (center, normal) in sections:
+            rings.append([builder.vertex(add(center, (self.r * math.sin(self.TAU * j / self.M) * normal[0], self.r * math.cos(self.TAU * j / self.M), self.r * math.sin(self.TAU * j / self.M) * normal[2])),
+                                        (math.sin(self.TAU * j / self.M) * normal[0], math.cos(self.TAU * j / self.M), math.sin(self.TAU * j / self.M) * normal[2])) for j in range(self.M)])
+        for i in range(len(rings) - 1):
+            for j in range(self.M):
+                k = (j + 1) % self.M
+                builder.face([rings[i][j], rings[i][k], rings[i + 1][k], rings[i + 1][j]], [(0.6 + 0.4 * j / self.M, i / (len(rings) - 1)), (0.6 + 0.4 * (j + 1) / self.M, i / (len(rings) - 1)), (0.6 + 0.4 * (j + 1) / self.M, (i + 1) / (len(rings) - 1)), (0.6 + 0.4 * j / self.M, (i + 1) / (len(rings) - 1))], 4)
+
+def create_handled_cup(name, spec):
+    parameters=handled_cup_parameters(spec)
+    shape=_HandledCupMesh(parameters)
+    builder=MeshBuilder()
+    shape.add_cup(builder, True)
+    shape.add_roots(builder)
+    shape.add_handle(builder)
+    obj=builder.finish(name)
+    try:
+        validate_handled_cup_mesh(obj.data, parameters)
+    except Exception:
+        mesh=obj.data
+        bpy.data.objects.remove(obj, do_unlink=True)
+        bpy.data.meshes.remove(mesh)
+        raise
+    return obj

package/python/deepblend_vessel_math.py

@@ -0,0 +1,116 @@
+"""Analytic cup surfaces, independent of Blender and mesh tessellation."""
+import math
+
+def unit(vector):
+    size = math.sqrt(sum(value * value for value in vector))
+    if size == 0 or not math.isfinite(size):
+        raise ValueError('invalid surface normal')
+    return tuple(value / size for value in vector)
+
+def add(a, b):
+    return tuple((x + y for (x, y) in zip(a, b)))
+
+def mul(a, s):
+    return tuple((x * s for x in a))
+
+def sub(a, b):
+    return add(a, mul(b, -1))
+
+def bezier(controls, t):
+    n = len(controls) - 1
+    return tuple((sum((math.comb(n, i) * (1 - t) ** (n - i) * t ** i * p[k] for (i, p) in enumerate(controls))) for k in range(3)))
+
+class CupSurface:
+
+    def __init__(self, parameters):
+        self.P = parameters
+        for (key, source) in {'R': 'radius', 'T': 'wall', 'B': 'bottom', 'HEIGHT': 'height', 'C': 'footRound', 'r': 'handleRadius', 'A': 'rootRadius', 'L': 'rootLength', 'N': 'bodySegments', 'M': 'sectionSegments'}.items():
+            setattr(self, key, parameters[source])
+        self.H = (parameters['upper'] - parameters['lower']) / 2
+        self.MID = (parameters['upper'] + parameters['lower']) / 2
+        self.TAU = math.tau
+
+    def root_controls(self, theta, upper):
+        """Quintic Hermite jets from the cylindrical wall and half-torus surface.
+
+        rho decreases at the wall. At the tube end, alpha increases along the
+        outgoing torus (opposite traversal for the lower attachment).
+        Tension scales endpoint speeds; the second jets scale quadratically,
+        keeping the same adjacent-surface tangent and curvature at each join.
+        Missing tension resolves to 1 to retain the original surface.
+        """
+        (ct, st) = (math.cos(theta), math.sin(theta))
+        z = self.P['upper'] if upper else self.P['lower']
+        q0 = (math.sqrt(self.R * self.R - self.A * self.A * ct * ct), self.A * ct, z + self.A * st)
+        speed = (self.A - self.r) * self.P['rootTension']
+        d0 = (self.A * speed * ct * ct / q0[0], -speed * ct, -speed * st)
+        dd0 = (-speed * speed * ct * ct * self.R * self.R / q0[0] ** 3, 0, 0)
+        q1 = (self.R + self.L, self.r * ct, z + self.r * st)
+        sign = 1 if upper else -1
+        alpha_speed = self.L / self.H * self.P['rootTension']
+        d1 = (alpha_speed * (self.H + sign * self.r * st), 0, 0)
+        dd1 = (0, 0, -sign * alpha_speed ** 2 * (self.H + sign * self.r * st))
+        return [q0, add(q0, mul(d0, 0.2)), add(add(q0, mul(d0, 0.4)), mul(dd0, 0.05)), add(sub(q1, mul(d1, 0.4)), mul(dd1, 0.05)), sub(q1, mul(d1, 0.2)), q1]
+
+    def root_point(self, t, theta, upper):
+        return bezier(self.root_controls(theta, upper), t)
+
+    def root_dt(self, t, theta, upper):
+        c = self.root_controls(theta, upper)
+        return bezier([mul(sub(c[i + 1], c[i]), 5) for i in range(5)], t)
+
+    def profile(self):
+        points = [(0, 0), (self.R - self.C, 0)]
+        for k in range(1, 9):
+            a = -math.pi / 2 + k * math.pi / 16
+            points.append((self.R - self.C + self.C * math.cos(a), self.C + self.C * math.sin(a)))
+        points.append((self.R, self.HEIGHT - self.T / 2))
+        for k in range(1, 17):
+            a = k * math.pi / 16
+            points.append((self.R - self.T / 2 + self.T / 2 * math.cos(a), self.HEIGHT - self.T / 2 + self.T / 2 * math.sin(a)))
+        points.append((self.R - self.T, self.B + self.C))
+        for k in range(1, 9):
+            a = k * math.pi / 16
+            points.append((self.R - self.T - self.C + self.C * math.cos(a), self.B + self.C - self.C * math.sin(a)))
+        points.append((0, self.B))
+        return points
+
+    def root_dtheta(self, t, theta, upper):
+        """Exact theta partial of the quintic root, including endpoint jets."""
+        ct, st = math.cos(theta), math.sin(theta)
+        x = math.sqrt(self.R * self.R - self.A * self.A * ct * ct)
+        speed = (self.A - self.r) * self.P['rootTension']
+        q0 = (self.A * self.A * ct * st / x, -self.A * st, self.A * ct)
+        d0 = (-self.A * speed * ct * st * (2 / x + self.A * self.A * ct * ct / x**3),
+              speed * st, -speed * ct)
+        dd0 = (speed * speed * self.R * self.R * ct * st *
+               (2 / x**3 + 3 * self.A * self.A * ct * ct / x**5), 0, 0)
+        q1 = (0, -self.r * st, self.r * ct)
+        sign = 1 if upper else -1
+        alpha_speed = self.L / self.H * self.P['rootTension']
+        d1 = (alpha_speed * sign * self.r * ct, 0, 0)
+        dd1 = (0, 0, -alpha_speed * alpha_speed * self.r * ct)
+        controls = [q0, add(q0, mul(d0, .2)), add(add(q0, mul(d0, .4)), mul(dd0, .05)),
+                    add(sub(q1, mul(d1, .4)), mul(dd1, .05)), sub(q1, mul(d1, .2)), q1]
+        return bezier(controls, t)
+
+    def root_normal(self, t, theta, upper):
+        a, b = self.root_dtheta(t, theta, upper), self.root_dt(t, theta, upper)
+        return unit((a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]))
+
+    def profile_normals(self):
+        """Outward radial/Z normal at each exact profile sample."""
+        result = [(0, -1), (0, -1)]
+        for k in range(1, 9):
+            angle = -math.pi / 2 + k * math.pi / 16
+            result.append((math.cos(angle), math.sin(angle)))
+        result.append((1, 0))
+        for k in range(1, 17):
+            angle = k * math.pi / 16
+            result.append((math.cos(angle), math.sin(angle)))
+        result.append((-1, 0))
+        for k in range(1, 9):
+            angle = k * math.pi / 16
+            result.append((-math.cos(angle), math.sin(angle)))
+        result.append((0, 1))
+        return result

package/python/deepblend_vessel_parameters.py

@@ -0,0 +1,65 @@
+"""Handled-cup inputs, validated before creating Blender data blocks."""
+import math
+from deepblend_util import ActionError
+
+
+def handled_cup_parameters(spec):
+    def invalid(message):
+        raise ActionError('SCENE_SPEC_INVALID', 'handled_cup: '+message)
+    fields=['radius','height','wallThickness','baseThickness','footRound','handleRadius','handleLower','handleUpper',
+            'rootRadius','rootLength','rootTension','segments','sectionSegments','handleSegments','rootSegments','wallRows']
+    for key in fields:
+        if key in spec and (isinstance(spec[key],bool) or not isinstance(spec[key],(int,float))
+                or not math.isfinite(spec[key]) or spec[key]<=0):
+            invalid(key+' must be a finite positive number')
+    radius = spec.get('radius', .04)
+    height = spec.get('height', radius*2.625)
+    wall = spec.get('wallThickness', radius*.075)
+    bottom = spec.get('baseThickness', radius*.125)
+    values = {
+        'radius': radius, 'height': height, 'wall': wall, 'bottom': bottom,
+        'footRound': spec.get('footRound', min(wall, bottom*.8)),
+        'handleRadius': spec.get('handleRadius', radius*.1375),
+        'lower': spec.get('handleLower', height*(4/15)),
+        'upper': spec.get('handleUpper', height*(26/35)),
+        'rootRadius': spec.get('rootRadius', radius*.2625),
+        'rootLength': spec.get('rootLength', radius*.2),
+        'rootTension': spec.get('rootTension', 1),
+        'bodySegments': spec.get('segments', 192),
+        'sectionSegments': spec.get('sectionSegments', 96),
+        'handleSegments': spec.get('handleSegments', 96),
+        'rootSegments': spec.get('rootSegments', 32),
+        'wallRows': spec.get('wallRows', 40),
+    }
+    if any(isinstance(v, bool) or not isinstance(v, (int,float)) or not math.isfinite(v) or v<=0 for v in values.values()):
+        invalid('dimensions and resolutions must be finite positive numbers')
+    def within(v,lo,hi): return lo-1e-12<=v<=hi+1e-12
+    if not 1 <= values['rootTension'] <= 2.5:
+        invalid('rootTension must be within 1–2.5')
+    ratios=[('radius',radius,.02,.08),('height/radius',height/radius,1.8,4),
+        ('wallThickness/radius',wall/radius,.025,.15),('baseThickness/radius',bottom/radius,.05,.25),
+        ('handleRadius/radius',values['handleRadius']/radius,.05,.2),
+        ('rootRadius/radius',values['rootRadius']/radius,.12,.35),
+        ('rootRadius/handleRadius',values['rootRadius']/values['handleRadius'],1.4,3),
+        ('rootLength/rootRadius',values['rootLength']/values['rootRadius'],.4,1.2),
+        ('footRound/radius',values['footRound']/radius,.01,.15)]
+    for name,value,lo,hi in ratios:
+        if not within(value,lo,hi):invalid('%s must be within %s–%s' % (name,lo,hi))
+    gap=(values['upper']-values['lower'])/2
+    if gap<=0 or values['rootLength']/gap>.8+1e-12:
+        invalid('handleUpper must exceed handleLower; rootLength/half-gap must be <=0.8')
+    if gap+radius*1e-12<max(1.1*values['rootRadius'],2*values['handleRadius']):
+        invalid('attachment half-gap must be >=1.1*rootRadius and >=2*handleRadius')
+    if values['lower']-values['rootRadius']+radius*1e-12<values['footRound']+.01*radius:
+        invalid('lower root footprint must clear the rounded foot by 0.01*radius')
+    if values['upper']+values['rootRadius']>height-wall/2-.01*radius+radius*1e-12:
+        invalid('upper root footprint must clear the rounded lip by 0.01*radius')
+    for key,lo,hi,multiple in [('bodySegments',64,256,4),('sectionSegments',32,96,4),
+        ('handleSegments',24,128,4),('rootSegments',8,48,1),('wallRows',16,64,1)]:
+        value=values[key]
+        if value!=int(value) or not lo<=value<=hi or value%multiple:
+            invalid('%s must be an integer within %s–%s, divisible by %s' % (key,lo,hi,multiple))
+        values[key] = int(value)
+    if values['footRound']>min(wall,bottom*.8)+radius*1e-12:
+        invalid('footRound must not exceed wallThickness or 0.8*baseThickness')
+    return values

package/python/deepblend_views.py

@@ -40,6 +40,8 @@ import bpy
 import numpy as np
 
 from deepblend_render import (
+    _camera_facts,
+    _render_config as _actual_render_config,
     apply_render_overrides,
     checkpoint_profile,
     find_camera,
@@ -202,6 +204,11 @@ def _render_one(scene, entry, tracked, parts, object_index, guard, base_percent,
             {"view": view_id, "output": output},
         )
 
+    # Capture the frame and evaluated camera that produced these bytes before
+    # isolation measurements temporarily change the scene's render settings.
+    actual_camera = scene.camera
+    render_config = _render_config(scene)
+    camera_facts = _camera_facts(scene, actual_camera)
     report_progress("measure", base_percent + 5.0, {"view": view_id})
     width, height = png_dimensions(output) or (
         int(scene.render.resolution_x),
@@ -215,16 +222,20 @@ def _render_one(scene, entry, tracked, parts, object_index, guard, base_percent,
         "bytes": os.path.getsize(output),
         "width": width,
         "height": height,
-        "frame": frame,
-        "cameraId": camera.get("deepblend_id") or camera.name,
-        "cameraName": camera.name,
-        "lens": round(float(camera.data.lens), 6),
-        "engine": scene.render.engine,
+        "frame": int(scene.frame_current),
+        "cameraId": actual_camera.get("deepblend_id") or actual_camera.name,
+        "cameraName": actual_camera.name,
+        "lens": round(camera_facts["lens"], 6),
+        "engine": render_config["engine"],
+        "renderConfig": render_config,
+        "cameraFacts": camera_facts,
         "metrics": measure_view(scene, output, tracked, parts, object_index, guard, view_id, scratch),
     }
     return entry_report
 
 
+
+
 def measure_view(scene, image_path, tracked, parts, object_index, guard, view_id, scratch):
     """Compute the deterministic measurements for one rendered frame.
 
@@ -716,21 +727,9 @@ def _load_rgb(path):
 
 
 def _render_config(scene):
-    """The render settings in force for this plan, for the manifest."""
-    samples = None
-    try:
-        if scene.render.engine == "CYCLES":
-            samples = int(scene.cycles.samples)
-    except Exception:
-        samples = None
+    """Actual settings, retaining the plan report's checkpoint profile field."""
     return {
-        "engine": scene.render.engine,
-        "resolution": [int(scene.render.resolution_x), int(scene.render.resolution_y)],
-        "samples": samples,
-        "viewTransform": scene.view_settings.view_transform,
-        "frameStart": int(scene.frame_start),
-        "frameEnd": int(scene.frame_end),
-        "fps": int(scene.render.fps),
+        **_actual_render_config(scene),
         "checkpointProfile": checkpoint_profile(scene),
     }