update corpus test and print a summary

Author: mikedh

pyproject.toml

@@ -5,7 +5,7 @@ requires = ["setuptools >= 61.0", "wheel"]
 [project]
 name = "trimesh"
 requires-python = ">=3.8"
-version = "4.9.0"
+version = "4.10.0"
 authors = [{name = "Michael Dawson-Haggerty", email = "[email protected]"}]
 license = {file = "LICENSE.md"}
 description = "Import, export, process, analyze and view triangular meshes."
@@ -168,7 +168,7 @@ flake8-implicit-str-concat = {"allow-multiline" = false}
 # disallow things that have caused problems
 [tool.ruff.lint.flake8-tidy-imports.banned-api]
 "IPython.embed".msg = "you forgot to remove a debug embed ;)"
-# "matplotlib".msg = "you forgot to remove a debug plot"
+"matplotlib".msg = "you forgot to remove a debug plot"
 "numpy.empty".msg = "uninitialized arrays are haunted: try numpy.zeros"
 "numpy.empty_like".msg = "uninitialized arrays are haunted: try numpy.zeros"
 

tests/corpus.py

@@ -6,9 +6,11 @@
 will download more than a gigabyte to your home directory!
 """
 
+import argparse
 import json
 import sys
 import time
+from collections import defaultdict
 from dataclasses import asdict, dataclass
 
 import numpy as np
@@ -28,6 +30,12 @@ class LoadReport:
     # i.e 'glb'
     file_type: str
 
+    # how long did this take
+    duration: float
+
+    # how many bytes was this file?
+    file_size: float
+
     # i.e. 'Scene'
     type_load: Optional[str] = None
 
@@ -53,34 +61,112 @@ class Report:
     # a pyinstrument.renderers.JSONRenderer output
     profile: str
 
-    def compare(self, other: "Report"):
+    def summary(self) -> str:
         """
-        Compare this load report to another.
+        Prints a nice markdown table of load results including both overall
+        and per-format statistics.
         """
-        # what files were loaded by both versions
-        self_type = {o.file_name: o.type_load for o in self.load}
-        other_type = {n.file_name: n.type_load for n in other.load}
+        # Group loads by file type and split success/failure
+        by_type = defaultdict(list)
+        for load in self.load:
+            by_type[load.file_type].append(load)
+
+        # Count exceptions per type
+        exc_counts = defaultdict(lambda: defaultdict(int))
+        for load in self.load:
+            if load.exception:
+                exc_counts[load.file_type][load.exception] += 1
+
+        # Extract successful load metrics for overall stats
+        successful = [load for load in self.load if load.exception is None]
+        duration = np.array([load.duration for load in successful])
+        size = np.array([load.file_size for load in successful])
+
+        lines = []
+
+        # Build exception table if there are any exceptions
+        if exc_counts:
+            lines.append("Exceptions\n=================\n")
+            exc_rows = [
+                (ftype.upper(), count, str(exc)[:70])
+                for ftype in sorted(exc_counts.keys())
+                for exc, count in exc_counts[ftype].items()
+            ]
+            lines.append(markdown_table(("Format", "Count", "Exception"), exc_rows))
+            lines.append("")
+
+        # Build main results table
+        rows = []
+        # Add overall row
+        success = float(len(successful)) / len(self.load) if len(self.load) > 0 else 0.0
+        rows.append(
+            (
+                "Overall",
+                f"{len(successful)}/{len(self.load)} ({success * 100.0:.2f}%)",
+                f"{duration.mean():.3f} ± {duration.std():.3f}",
+                f"{size.mean() / 1e6:.2f} ± {size.std() / 1e6:.2f}",
+            )
+        )
+
+        # Add per-format rows
+        for ftype in sorted(by_type.keys()):
+            loads = by_type[ftype]
+            ok = [load for load in loads if load.exception is None]
+            if ok:
+                dur = np.array([load.duration for load in ok])
+                sz = np.array([load.file_size for load in ok])
+                success = float(len(ok)) / len(loads) if len(loads) > 0 else 0.0
+                rows.append(
+                    (
+                        ftype.upper(),
+                        f"{len(ok)}/{len(loads)} ({success * 100.0:.2f}%)",
+                        f"{dur.mean():.3f} ± {dur.std():.3f}",
+                        f"{sz.mean() / 1e6:.2f} ± {sz.std() / 1e6:.2f}",
+                    )
+                )
 
-        both = set(self_type.keys()).intersection(other_type.keys())
-        matches = np.array([self_type[k] == other_type[k] for k in both])
-        percent = matches.sum() / len(matches)
+        lines.append("\nLoad Results\n=================\n")
+        lines.append(markdown_table(("Format", "Loaded", "Time (s)", "Size (MB)"), rows))
 
-        print(f"Comparing `{self.version}` against `{other.version}`")
-        print(f"Return types matched {percent * 100.0:0.3f}% of the time")
-        print(f"Loaded {len(self.load)} vs Loaded {len(other.load)}")
+        return "\n".join(lines)
 
 
-def from_dict(data: dict) -> Report:
+def markdown_table(headers: tuple[str, ...], rows: list[tuple]) -> str:
     """
-    Parse a `Report` which has been exported using `dataclasses.asdict`
-    into a Report object.
+    Print a markdown-formatted table.
+
+    Parameters
+    ----------
+    headers
+        Column headers as a tuple of strings.
+    rows
+        List of tuples, where each tuple represents a row of data.
+
+    Returns
+    -------
+    table
+        A string containing the markdown-formatted table.
     """
-    return Report(
-        load=[LoadReport(**r) for r in data.get("load", [])],
-        version=data.get("version"),
-        profile=data.get("profile"),
+    # set column widths based on the longest item in each column
+    col_widths = [
+        max(len(h), max(len(str(row[i])) for row in rows)) for i, h in enumerate(headers)
+    ]
+    # start with header row and separator row
+    lines = [
+        "| " + " | ".join(h.ljust(col_widths[i]) for i, h in enumerate(headers)) + " |",
+        "| " + " | ".join("-" * w for w in col_widths) + " |",
+    ]
+
+    # extend with data rows
+    lines.extend(
+        "| "
+        + " | ".join(str(cell).ljust(col_widths[i]) for i, cell in enumerate(row))
+        + " |"
+        for row in rows
     )
 
+    return "\n".join(lines)
+
 
 def on_repo(
     repo: str, commit: str, available: set, root: Optional[str] = None
@@ -123,33 +209,39 @@ def on_repo(
         should_raise = any(b in check for b in broke)
         raised = False
 
+        blob = resolver.get(name)
+
         # start collecting data about the current load attempt
-        current = LoadReport(file_name=name, file_type=trimesh.util.split_extension(name))
+        current = LoadReport(
+            file_name=name,
+            duration=0.0,
+            file_size=len(blob),
+            file_type=trimesh.util.split_extension(name),
+        )
 
         print(f"Attempting: {name}")
 
         try:
-            m = trimesh.load(
+            tic = time.time()
+            m = trimesh.load_scene(
                 file_obj=wrap_as_stream(resolver.get(name)),
                 file_type=name,
                 resolver=resolver,
             )
-
-            # save the load types
-            current.type_load = m.__class__.__name__
-            if isinstance(m, trimesh.Scene):
-                # save geometry types
-                current.type_geometry = tuple(
-                    [g.__class__.__name__ for g in m.geometry.values()]
-                )
+            toc = time.time()
+            # save geometry types
+            current.type_geometry = tuple(
+                {g.__class__.__name__ for g in m.geometry.values()}
+            )
+            current.duration = toc - tic
             # save the <Trimesh ...> repr
             current.repr_load = str(m)
 
             # if our source was a GLTF we should be able to roundtrip without
             # dropping
             if name.lower().split(".")[-1] in ("gltf", "glb") and len(m.geometry) > 0:
                 # try round-tripping the file
-                e = trimesh.load(
+                e = trimesh.load_scene(
                     file_obj=wrap_as_stream(m.export(file_type="glb")),
                     file_type="glb",
                     process=False,
@@ -236,7 +328,7 @@ def equal(a, b):
     return a == b
 
 
-def run(save: bool = False):
+def run(save: bool = False) -> Report:
     """
     Try to load and export every mesh we can get our hands on.
 
@@ -257,14 +349,11 @@ def run(save: bool = False):
         ]
     )
 
-    # TODO : waiting on a release containing pycollada/pycollada/147
-    available.difference_update({"dae"})
-
     with Profiler() as P:
         # check against the small trimesh corpus
         loads = on_repo(
             repo="mikedh/trimesh",
-            commit="2fcb2b2ea8085d253e692ecd4f71b8f450890d51",
+            commit="76b6dd1a2f552673b3b38ffd44ce4342d4e95273",
             available=available,
             root="models",
         )
@@ -273,7 +362,7 @@ def run(save: bool = False):
         loads.extend(
             on_repo(
                 repo="assimp/assimp",
-                commit="1e44036c363f64d57e9f799beb9f06d4d3389a87",
+                commit="ab28db52f022a7268ffff499cd85bbabf84c4271",
                 available=available,
                 root="test",
             )
@@ -312,16 +401,19 @@ def run(save: bool = False):
 
 
 if __name__ == "__main__":
-    trimesh.util.attach_to_log()
-
-    if "-run" in " ".join(sys.argv):
-        run()
+    parser = argparse.ArgumentParser(
+        description="Test trimesh loaders against large corpuses (downloads >1GB to ~/.trimesh-cache)"
+    )
+    parser.add_argument("-run", action="store_true", help="Run the corpus test")
+    parser.add_argument("-save", action="store_true", help="Save JSON report")
 
-    if "-compare" in " ".join(sys.argv):
-        with open("trimesh.4.5.3.1737061410.json") as f:
-            old = from_dict(json.load(f))
+    args = parser.parse_args()
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit(0)
 
-        with open("trimesh.4.6.0.1737060030.json") as f:
-            new = from_dict(json.load(f))
+    trimesh.util.attach_to_log()
 
-        new.compare(old)
+    if args.run:
+        report = run(save=args.save)
+        print(report.summary())

tests/test_color.py

@@ -365,7 +365,7 @@ def test_interpolate():
 
     # now see if we match matplotlib if it's installed
     try:
-        from matplotlib.pyplot import get_cmap
+        from matplotlib.pyplot import get_cmap  # noqa
     except ImportError:
         return
 

trimesh/path/entities.py

@@ -436,7 +436,7 @@ def plot(self, vertices, show=False):
         if vertices.shape[1] != 2:
             raise ValueError("only for 2D points!")
 
-        import matplotlib.pyplot as plt
+        import matplotlib.pyplot as plt  # noqa
 
         # get rotation angle in degrees
         angle = np.degrees(self.angle(vertices))

trimesh/path/path.py

@@ -1437,7 +1437,7 @@ def plot_discrete(self, show=False, annotations=True):
         """
         Plot the closed curves of the path.
         """
-        import matplotlib.pyplot as plt
+        import matplotlib.pyplot as plt  # noqa
 
         axis = plt.gca()
         axis.set_aspect("equal", "datalim")
@@ -1469,7 +1469,7 @@ def plot_entities(self, show=False, annotations=True, color=None):
         color : str
           Override entity colors and make them all this color.
         """
-        import matplotlib.pyplot as plt
+        import matplotlib.pyplot as plt  # noqa
 
         # keep plot axis scaled the same
         axis = plt.gca()

trimesh/path/polygons.py

@@ -294,7 +294,7 @@ def plot(polygon=None, show=True, axes=None, **kwargs):
     **kwargs
       Passed to plt.plot
     """
-    import matplotlib.pyplot as plt
+    import matplotlib.pyplot as plt  # noqa
 
     def plot_single(single):
         axes.plot(*single.exterior.xy, **kwargs)

trimesh/points.py

@@ -374,8 +374,9 @@ def plot_points(points, show=True):
     show : bool
       If False, will not show until plt.show() is called
     """
-    import matplotlib.pyplot as plt
-    from mpl_toolkits.mplot3d import Axes3D  # NOQA
+    # TODO : should this just use SceneViewer?
+    import matplotlib.pyplot as plt  # noqa
+    from mpl_toolkits.mplot3d import Axes3D  # noqa
 
     points = np.asanyarray(points, dtype=float64)
 

trimesh/scene/transforms.py

@@ -414,7 +414,7 @@ def show(self, **kwargs):
         kwargs : dict
           Passed to `networkx.draw_networkx`
         """
-        import matplotlib.pyplot as plt
+        import matplotlib.pyplot as plt  # noqa
         import networkx
 
         # default kwargs will only be set if not