Applying Patch on multiple shapes (orthomosaic patching by script)¶

patch = Metashape.Orthomosaic.Patch()
patch.image_keys = [camera.key]
chunk.orthomosaic.patches[shape] = patch
chunk.orthomosaic.update()

"""Auto-patch each polygonal shape with the camera whose image
centre projects closest to the shape's centroid."""
import Metashape

doc = Metashape.app.document
chunk = doc.chunk
ortho = chunk.orthomosaic

if ortho is None:
    raise SystemExit("No orthomosaic — build one before patching.")

# Filter to polygonal shapes only (polygons enclose patch areas).
polygons = [
    s for s in chunk.shapes
    if isinstance(s.geometry, Metashape.Geometry.Polygon)
]

# Map each polygonal shape to the best aligned camera.
def shape_centroid_xy(shape):
    """Centroid of the polygon's exterior ring in chunk-local XY."""
    # `polygon.coordinates` is `list[list[Vector]]` — outer list
    # is rings (exterior + holes), inner list is the ring's points.
    # Use the exterior ring (index 0).
    rings = shape.geometry.coordinates
    if not rings:
        return None
    pts = rings[0]    # exterior ring: list[Vector]
    if not pts:
        return None
    cx = sum(p.x for p in pts) / len(pts)
    cy = sum(p.y for p in pts) / len(pts)
    return Metashape.Vector([cx, cy])

def project_image_centre(camera, target_z=0.0):
    """Project the image-centre ray onto z = target_z and return XY."""
    if camera.transform is None:
        return None
    # Camera centre in chunk-local frame.
    centre_local = camera.center
    # Image-centre direction in chunk-local frame.
    sensor = camera.sensor
    cx_pix = sensor.width / 2.0
    cy_pix = sensor.height / 2.0
    direction_cam = sensor.calibration.unproject(
        Metashape.Vector([cx_pix, cy_pix])
    )
    direction_world = camera.transform.mulv(direction_cam)
    # Solve for t such that centre_local.z + t * direction_world.z = target_z.
    if abs(direction_world.z) < 1e-9:
        return None
    t = (target_z - centre_local.z) / direction_world.z
    if t <= 0:
        return None    # camera is below the surface
    hit = centre_local + t * direction_world
    return Metashape.Vector([hit.x, hit.y])

aligned_cameras = [c for c in chunk.cameras if c.transform is not None]

for shape in polygons:
    sc = shape_centroid_xy(shape)
    if sc is None:
        continue

    # Find the camera whose image-centre projection is closest to
    # the shape centroid (XY only).
    best_camera = None
    best_dist = float("inf")
    for cam in aligned_cameras:
        ic = project_image_centre(cam)
        if ic is None:
            continue
        dist = (ic - sc).norm()
        if dist < best_dist:
            best_dist = dist
            best_camera = cam

    if best_camera is None:
        print(f"no candidate for shape {shape.label!r}, skipping")
        continue

    patch = Metashape.Orthomosaic.Patch()
    patch.image_keys = [best_camera.key]
    ortho.patches[shape] = patch
    print(f"shape {shape.label!r:>20} → {best_camera.label}  (d={best_dist:.2f})")

ortho.update()
print("orthomosaic patched and updated.")

"""Auto-patch from shape.attributes['Patch'] (camera label).

Pre-condition: each polygon's `Patch` attribute is set to the
desired camera's label. The shape is in a group named
'Patches' (case-insensitive)."""
import Metashape

doc = Metashape.app.document
chunk = doc.chunk

if chunk is None or chunk.orthomosaic is None or not chunk.shapes:
    raise SystemExit("Need active chunk with orthomosaic and shapes.")

ortho = chunk.orthomosaic

# Filter: polygonal shapes in the 'Patches' group.
patches_list = [
    s for s in chunk.shapes
    if isinstance(s.geometry, Metashape.Geometry.Polygon)
    and s.group is not None
    and s.group.label.upper() == "PATCHES"
]

# Build label → Camera lookup (only aligned cameras).
camera_by_label = {
    c.label: c for c in chunk.cameras if c.transform is not None
}

assigned = 0
for shape in patches_list:
    # `shape.attributes` is a `Metashape.MetaData` object, which
    # supports `__getitem__`, `__setitem__`, `__contains__`,
    # `keys()`, `values()`, `items()` — but NOT `.get()`. Use
    # the `in` form instead.
    if "Patch" not in shape.attributes:
        continue    # no Patch attribute on this shape
    label_attr = shape.attributes["Patch"]
    if not label_attr:
        continue
    cam = camera_by_label.get(label_attr)
    if cam is None:
        # Try case-insensitive.
        cam = next(
            (c for c in chunk.cameras
             if c.transform is not None
             and c.label.upper() == label_attr.upper()),
            None,
        )
    if cam is None:
        print(f"no camera matching {label_attr!r} for shape {shape.label!r}, skipping")
        continue

    patch = Metashape.Orthomosaic.Patch()
    patch.image_keys = [cam.key]
    ortho.patches[shape] = patch
    assigned += 1

ortho.update()
print(f"applied {assigned} patches; orthomosaic updated.")

"""Reverse direction: encode existing patches into shape attributes
so they can be replayed on a re-built orthomosaic."""
import Metashape

doc = Metashape.app.document
chunk = doc.chunk
ortho = chunk.orthomosaic

if ortho is None or not ortho.patches:
    raise SystemExit("No patches to extract.")

# Build key → Camera lookup once.
camera_by_key = {c.key: c for c in chunk.cameras}

# Optional: collect all extracted shapes into a 'Patches' group
# so Recipe 2 can re-apply them.
patches_group = None
for g in chunk.shapes.groups:
    if g.label.upper() == "PATCHES":
        patches_group = g
        break
if patches_group is None:
    patches_group = chunk.shapes.addGroup()
    patches_group.label = "Patches"

extracted = 0
for shape, patch in ortho.patches.items():
    if not patch.image_keys:
        continue
    cam = camera_by_key.get(patch.image_keys[0])
    if cam is None:
        continue
    shape.attributes["Patch"] = cam.label
    if shape.label == "" or shape.label is None:
        shape.label = cam.label    # also use camera label as shape label
    shape.group = patches_group
    extracted += 1

print(f"extracted {extracted} patch assignments into shape attributes.")

"""Apply Recipe 1 to a synthetic polygon over the orthomosaic
centre. Verifies that:
  - Orthomosaic.Patch construction works
  - chunk.orthomosaic.patches[shape] = patch persists the assignment
  - chunk.orthomosaic.update() re-renders without errors
"""
import Metashape

doc = Metashape.app.document
chunk = doc.chunk

if chunk.orthomosaic is None:
    raise SystemExit("Build an orthomosaic before running this demo.")

ortho = chunk.orthomosaic

# Synthetic polygon: small square at the orthomosaic centre.
cx = (ortho.left + ortho.right) / 2
cy = (ortho.bottom + ortho.top) / 2
half = min(ortho.right - ortho.left, ortho.top - ortho.bottom) * 0.05

poly_pts = [
    Metashape.Vector([cx - half, cy - half, 0.0]),
    Metashape.Vector([cx + half, cy - half, 0.0]),
    Metashape.Vector([cx + half, cy + half, 0.0]),
    Metashape.Vector([cx - half, cy + half, 0.0]),
    Metashape.Vector([cx - half, cy - half, 0.0]),    # closing point
]

shape = chunk.shapes.addShape()
shape.geometry = Metashape.Geometry.Polygon(poly_pts)
shape.label = "demo_patch"

# Pick the camera nearest to the chunk centroid (Recipe 1
# simplified — single shape).
best_cam = None
best_dist = float("inf")
target = Metashape.Vector([cx, cy])
for cam in chunk.cameras:
    if cam.transform is None:
        continue
    img_xy = Metashape.Vector([cam.center.x, cam.center.y])
    d = (img_xy - target).norm()
    if d < best_dist:
        best_dist = d
        best_cam = cam

if best_cam is None:
    raise SystemExit("No aligned camera found.")

print(f"assigning patch from camera {best_cam.label}  (d={best_dist:.2f})")

patch = Metashape.Orthomosaic.Patch()
patch.image_keys = [best_cam.key]
ortho.patches[shape] = patch

print(f"patches dict size: {len(ortho.patches)}")
print(f"image_keys for demo_patch: {ortho.patches[shape].image_keys}")

ortho.update()
print("orthomosaic updated.")