hull_3d_tests.py

# hull_2d/test_wrapping3d.py
from __future__ import annotations

import os
import random
from typing import List, Tuple, Dict

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
from matplotlib import animation

from hull_3d.geometry import Point3
from hull_3d.gift_wrapping import convex_hull_3d_wrapping


def generate_random_points_3d_unique(n: int, lo: int = 0, hi: int = 1000) -> List[Point3]:
    """Unique integer 3D points."""
    pts = set()
    while len(pts) < n:
        pts.add((random.randint(lo, hi), random.randint(lo, hi), random.randint(lo, hi)))
    return list(pts)


def set_axes_equal(ax) -> None:
    """
    Make 3D axes have equal scale so the hull isn't visually distorted.
    Matplotlib doesn't do this by default for 3D.
    """
    x_limits = ax.get_xlim3d()
    y_limits = ax.get_ylim3d()
    z_limits = ax.get_zlim3d()

    x_range = abs(x_limits[1] - x_limits[0])
    y_range = abs(y_limits[1] - y_limits[0])
    z_range = abs(z_limits[1] - z_limits[0])

    x_middle = (x_limits[0] + x_limits[1]) / 2
    y_middle = (y_limits[0] + y_limits[1]) / 2
    z_middle = (z_limits[0] + z_limits[1]) / 2

    plot_radius = 0.5 * max([x_range, y_range, z_range])

    ax.set_xlim3d([x_middle - plot_radius, x_middle + plot_radius])
    ax.set_ylim3d([y_middle - plot_radius, y_middle + plot_radius])
    ax.set_zlim3d([z_middle - plot_radius, z_middle + plot_radius])


def build_poly_collection(points: List[Point3], faces: List[Tuple[int, int, int]]) -> Poly3DCollection:
    """
    Convert face index triples into a Poly3DCollection for plotting.
    """
    polys = []
    for (i, j, k) in faces:
        polys.append([points[i], points[j], points[k]])

    poly = Poly3DCollection(polys, alpha=0.25, edgecolor="k", linewidths=0.3)
    return poly


def save_static_plot(points: List[Point3], faces: List[Tuple[int, int, int]], out_png: str) -> None:
    fig = plt.figure()
    ax = fig.add_subplot(111, projection="3d")

    xs = [p[0] for p in points]
    ys = [p[1] for p in points]
    zs = [p[2] for p in points]
    ax.scatter(xs, ys, zs, s=6)

    poly = build_poly_collection(points, faces)
    ax.add_collection3d(poly)

    ax.set_title("3D Convex Hull (Facet Wrapping)")
    ax.set_xlabel("x")
    ax.set_ylabel("y")
    ax.set_zlabel("z")

    # reasonable initial view
    ax.view_init(elev=20, azim=35)
    set_axes_equal(ax)

    plt.savefig(out_png, dpi=150, bbox_inches="tight")
    plt.close(fig)


def save_rotation(points: List[Point3], faces: List[Tuple[int, int, int]], out_gif: str, out_mp4: str) -> None:
    fig = plt.figure()
    ax = fig.add_subplot(111, projection="3d")

    xs = [p[0] for p in points]
    ys = [p[1] for p in points]
    zs = [p[2] for p in points]
    ax.scatter(xs, ys, zs, s=6)

    poly = build_poly_collection(points, faces)
    ax.add_collection3d(poly)

    ax.set_title("3D Convex Hull (Rotating)")
    ax.set_xlabel("x")
    ax.set_ylabel("y")
    ax.set_zlabel("z")
    set_axes_equal(ax)

    # Animation update: rotate azimuth
    def update(frame: int):
        ax.view_init(elev=20, azim=frame)
        return (poly,)

    frames = list(range(0, 360, 4))  # 0..356 degrees
    anim = animation.FuncAnimation(fig, update, frames=frames, interval=50, blit=False)

    # Try GIF first (Pillow), otherwise MP4 (ffmpeg)
    saved = False
    try:
        writer = animation.PillowWriter(fps=20)
        anim.save(out_gif, writer=writer)
        saved = True
    except Exception as e:
        print("Could not save GIF (Pillow missing?). Reason:", e)

    if not saved:
        try:
            writer = animation.FFMpegWriter(fps=20)
            anim.save(out_mp4, writer=writer)
            saved = True
        except Exception as e:
            print("Could not save MP4 (ffmpeg missing?). Reason:", e)

    plt.close(fig)


if __name__ == "__main__":
    random.seed(42)
    os.makedirs("plots/3d_plots", exist_ok=True)

    n = 180 
    points = generate_random_points_3d_unique(n, 0, 1000)

    faces = convex_hull_3d_wrapping(points, return_adjacency=False)

    print("Total points:", len(points))
    print("Hull faces:", len(faces))

    out_png = os.path.join("plots/3d_plots", "hull_static.png")
    save_static_plot(points, faces, out_png)
    print("Saved:", out_png)

    out_gif = os.path.join("plots/3d_plots", "hull_rotate.gif")
    out_mp4 = os.path.join("plots/3d_plots", "hull_rotate.mp4")
    save_rotation(points, faces, out_gif, out_mp4)

    if os.path.exists(out_gif):
        print("Saved:", out_gif)
    if os.path.exists(out_mp4):
        print("Saved:", out_mp4)