cgmath 3.0.2__tar.gz → 3.0.3__tar.gz

{cgmath-3.0.2/cgmath.egg-info → cgmath-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgmath
-Version: 3.0.2
+Version: 3.0.3
 Summary: A DCC-agnostic CG math library: batched matrix, quaternion and euler math, mesh topology, deformers, resampling, skeletal hierarchies, SDFs, a software raytracer and asset IO, all numpy-native.
 Author-email: Eric Vignola <eric.vignola@gmail.com>
 License: ## License

{cgmath-3.0.2 → cgmath-3.0.3}/__init__.py

@@ -4,4 +4,4 @@ The underlying matrix, quaternion, euler and vector math lives in
 :mod:`cgmath.transforms`.
 """
 
-__version__ = "3.0.2"
+__version__ = "3.0.3"

{cgmath-3.0.2 → cgmath-3.0.3}/_tests/test_fbx_export.py

@@ -38,6 +38,117 @@ def _joint(name, parent=None, **kwargs):
     )
 
 
+def _node(name, parent=None, node_type="transform", **kwargs):
+    """Returns a TransformData of ``node_type`` with a uuid, parented by uuid."""
+    return TransformData(
+        name        = name,
+        node_type   = node_type,
+        uuid        = str(uuid.uuid4()).upper(),
+        parent_uuid = parent.uuid if parent is not None else None,
+        **kwargs,
+    )
+
+
+def scaled_rig():
+    """probe_save.py's scaled rig: a group scaled (1, 3, 0.5) turned 30 over
+    a turned group with a locator under it, a joint and a turned
+    space_transform, and beside them a group, a locator and a joint with
+    segment_scale_compensate on"""
+    top = _node("sc", rotate=(0.0, 0.0, 30.0), scale=(1.0, 3.0, 0.5))
+    kid = _node("sc_kid", top, rotate=(40.0, 10.0, -20.0), translate=(1.0, 1.0, 0.0))
+    return HierarchyData([
+        top,
+        kid,
+        _node("sc_loc", kid, "locator", translate=(0.0, 2.0, 1.0)),
+        _node("sc_jnt", top, "joint", rotate=(40.0, 10.0, -20.0), translate=(-1.0, 1.0, 0.0)),
+        _node("sc_spc", top, "space_transform", rotate=(40.0, 10.0, -20.0), translate=(-1.0, -1.0, 0.0)),
+        _node("sc_grp", top, rotate=(10.0, 20.0, 30.0), translate=(1.0, 0.0, 1.0), scale=(1.0, 1.5, 0.75),
+              segment_scale_compensate=True),
+        _node("sc_lcf", top, "locator", translate=(0.5, 1.0, -2.0), segment_scale_compensate=True),
+        _node("sc_cmp", top, "joint", translate=(0.0, 1.0, 1.0), segment_scale_compensate=True),
+    ])
+
+
+# the parents a group with segment_scale_compensate on is saved under:
+# (label, P's scale, P's rotate, G's scale or None for no G); the first three
+# are not mirrored, the last three are
+FLAGGED_CASES = (
+    ("(1, 2, 3)", (1.0, 2.0, 3.0), (0.0, 30.0, 0.0), None),
+    ("(2, 2, 2)", (2.0, 2.0, 2.0), (0.0, 30.0, 0.0), None),
+    ("(2, 1, 0.5) under (1, 2, 3)", (2.0, 1.0, 0.5), (0.0, 30.0, 15.0), (1.0, 2.0, 3.0)),
+    ("(-1, 2, 3)", (-1.0, 2.0, 3.0), (0.0, 30.0, 0.0), None),
+    ("(-2, -2, -2)", (-2.0, -2.0, -2.0), (0.0, 30.0, 0.0), None),
+    ("(-1, 1, 1) under (1, 2, 3)", (-1.0, 1.0, 1.0), (0.0, 30.0, 0.0), (1.0, 2.0, 3.0)),
+)
+
+
+# the parents a group with segment_scale_compensate on and its own scale
+# mirrored is saved under: (label, P's scale or None for no P); the sdk places
+# it under each, Maya's importer under the last two alone, which mirror too
+MIRRORED_CASES = (
+    ("no parent", None),
+    ("(1, 1, 1)", (1.0, 1.0, 1.0)),
+    ("(2, 2, 2)", (2.0, 2.0, 2.0)),
+    ("(1, 2, 3)", (1.0, 2.0, 3.0)),
+    ("(-1, 2, 3)", (-1.0, 2.0, 3.0)),
+    ("(-2, -2, -2)", (-2.0, -2.0, -2.0)),
+)
+
+
+def flagged_rig(scale, rotate, grand=None, own=(1.0, 1.5, 0.75)):
+    """a group gRrs and a locator xRrs with segment_scale_compensate on under
+    a group P at (0, 1, 0) turned ``rotate`` and scaled ``scale``, when given,
+    itself under a group G at (0, 0.5, 0) turned (10, 0, 20) and scaled
+    ``grand`` when given: gRrs at (2, 0.5, -0.5) turned (20, 40, 60) and
+    scaled ``own``, over a locator lRrs, a turned group cRrs over a locator
+    dRrs, and a joint jRrs over a joint kRrs, both compensating their
+    parent's scale (flag_mirror.py's rig); xRrs scaled the signs of ``own``"""
+    nodes = []
+    top   = None
+    if grand is not None:
+        top = _node("G", translate=(0.0, 0.5, 0.0), rotate=(10.0, 0.0, 20.0), scale=grand)
+        nodes.append(top)
+    P = top
+    if scale is not None:
+        P = _node("P", top, translate=(0.0, 1.0, 0.0), rotate=rotate, scale=scale)
+        nodes.append(P)
+    g = _node("gRrs", P, translate=(2.0, 0.5, -0.5), rotate=(20.0, 40.0, 60.0), scale=own,
+              segment_scale_compensate=True)
+    c = _node("cRrs", g, translate=(1.0, 0.0, 0.0), rotate=(10.0, 20.0, 30.0))
+    j = _node("jRrs", g, "joint", translate=(0.0, 0.0, 1.0), segment_scale_compensate=True)
+    nodes += [
+        g,
+        _node("lRrs", g, "locator", translate=(0.5, 1.0, -2.0)),
+        c,
+        _node("dRrs", c, "locator", translate=(0.0, 1.0, 0.0)),
+        j,
+        _node("kRrs", j, "joint", translate=(0.0, 1.0, 0.0), segment_scale_compensate=True),
+        _node("xRrs", P, "locator", translate=(-1.0, 0.5, 0.5), rotate=(0.0, 0.0, 45.0), scale=np.sign(own),
+              segment_scale_compensate=True),
+    ]
+    return HierarchyData(nodes)
+
+
+def tiny_rig():
+    """probe_l1b.py's rig, and -2e-12 beside its scales: for each value v a
+    group K<i> scaled (1.32, 1.8, v) over a joint KJ<i> and a locator KL<i>"""
+    nodes = []
+    for i, v in enumerate((0.0, 1e-13, -1e-13, -2e-12)):
+        top = _node(f"K{i}", translate=(0.67 + 3 * i, 2.84, 3.5), rotate=(27.5, 5.9, 85.6), scale=(1.32, 1.8, v))
+        nodes += [
+            top,
+            _node(f"KJ{i}", top, "joint", translate=(0.3, 0.4, 0.2), rotate=(10.0, 0.0, 30.0)),
+            _node(f"KL{i}", top, "locator", translate=(0.3, 1.0, 0.25), rotate=(20.0, 0.0, 0.0)),
+        ]
+    return HierarchyData(nodes)
+
+
+def gaps(got, want):
+    """(3x3, position) largest gaps between two world matrices"""
+    got, want = np.asarray(got), np.asarray(want)
+    return float(np.abs(got[:3, :3] - want[:3, :3]).max()), float(np.abs(got[3, :3] - want[3, :3]).max())
+
+
 @contextlib.contextmanager
 def _no_fbx_warnings(test):
     """
@@ -174,6 +285,16 @@ class TestFbxExportSkeleton(unittest.TestCase):
 
         return self._walk(_attribute)
 
+    def _placed(self):
+        """Returns {node name: (inherit type name, sdk world matrix)}."""
+
+        def _place(node):
+            world  = node.EvaluateGlobalTransform()
+            matrix = np.array([[world.Get(r, c) for c in range(4)] for r in range(4)])
+            return node.GetTransformationInheritType().name, matrix
+
+        return {path.rsplit("|", 1)[-1]: placed for path, placed in self._walk(_place).items()}
+
     def test_duplicate_names_keep_their_parent(self):
         root  = _joint("root")
         nodes = [root]
@@ -335,6 +456,135 @@ class TestFbxExportSkeleton(unittest.TestCase):
             self.assertTrue(np.allclose(loaded[name].world_matrix, want, rtol=0.0, atol=1e-9), name)
             self.assertEqual(loaded[name].rotate_order, rig[name].rotate_order, name)
 
+    def test_every_node_is_written_with_its_inherit_type(self):
+        """eInheritRrs on a node that compensates its parent's scale,
+        eInheritRSrs on any other, a group or a locator too, as Maya's
+        exporter writes a group and a locator. Written with the sdk's
+        default, eInheritRrSs, which scales a node along its own axes by its
+        parent's world scale, a turned group under a group scaled (1, 3, 0.5)
+        sat 1.58 off the rig in its 3x3 in the sdk, and a locator under it
+        3.17 in position (probe_save.py); the sdk now puts every node where
+        the rig has it"""
+        rig = scaled_rig()
+        self._export(rig)
+        placed = self._placed()
+        for node in rig:
+            with self.subTest(node.name):
+                inherit, world = placed[node.name]
+                axes, position = gaps(world, node.world_matrix)
+                self.assertLessEqual(axes, 1e-9)
+                # the largest measured on this file
+                self.assertLessEqual(position, 8.881784197001252e-16)
+                self.assertEqual(inherit, "eInheritRrs" if node.segment_scale_compensate else "eInheritRSrs")
+
+    def test_a_mirrored_group_compensating_its_parents_scale_is_written_eInheritRrs(self):
+        """a group or locator with segment_scale_compensate on and its own
+        scale mirrored is written eInheritRrs and the sdk puts it and every
+        node under it where the rig has it, with no parent, under a mirrored
+        parent and under one that is not (TransformList.save_fbx says where
+        Maya's importer does not). Written eInheritRrSs, its axes sat off
+        under any parent scaled other than 1"""
+        # the largest position gap measured on each file
+        bounds = {
+            "no parent":    6.661338147750939e-16,
+            "(1, 1, 1)":    4.440892098500626e-16,
+            "(2, 2, 2)":    4.440892098500626e-16,
+            "(1, 2, 3)":    4.440892098500626e-16,
+            "(-1, 2, 3)":   4.440892098500626e-16,
+            "(-2, -2, -2)": 4.440892098500626e-16,
+        }
+        for label, scale in MIRRORED_CASES:
+            with self.subTest(label):
+                rig = flagged_rig(scale, (0.0, 30.0, 0.0), own=(-1.0, 1.5, 0.75))
+                self._export(rig)
+                placed = self._placed()
+                for node in rig:
+                    axes, position = gaps(placed[node.name][1], node.world_matrix)
+                    self.assertLessEqual(axes, 1e-9, node.name)
+                    self.assertLessEqual(position, bounds[label], node.name)
+                    inherit = "eInheritRrs" if node.segment_scale_compensate else "eInheritRSrs"
+                    self.assertEqual(placed[node.name][0], inherit, node.name)
+
+    def test_a_group_compensating_its_parents_scale_is_written_eInheritRrs(self):
+        """a group or locator with segment_scale_compensate on, which a rig
+        built or edited by hand can hold, is written eInheritRrs, as a joint
+        is, so the sdk puts it and every node under it where the rig has it,
+        under mirrored and sheared parents too; written eInheritRrSs, a
+        group's axes sat 1.32 off under a parent scaled (1, 2, 3). Read back
+        its flag is off, as this release reads every node that is no joint,
+        its channels the ones saved"""
+        # the largest position gap measured on each file
+        bounds = {
+            "(1, 2, 3)": 4.440892098500626e-16,
+            "(2, 2, 2)": 4.440892098500626e-16,
+            "(2, 1, 0.5) under (1, 2, 3)": 3.552713678800501e-15,
+            "(-1, 2, 3)": 4.440892098500626e-16,
+            "(-2, -2, -2)": 8.881784197001252e-16,
+            "(-1, 1, 1) under (1, 2, 3)": 1.7763568394002505e-15,
+        }
+        for label, scale, rotate, grand in FLAGGED_CASES:
+            with self.subTest(label):
+                rig = flagged_rig(scale, rotate, grand)
+                self._export(rig)
+                placed = self._placed()
+                for node in rig:
+                    axes, position = gaps(placed[node.name][1], node.world_matrix)
+                    self.assertLessEqual(axes, 1e-9, node.name)
+                    self.assertLessEqual(position, bounds[label], node.name)
+                for node in rig:
+                    inherit = "eInheritRrs" if node.segment_scale_compensate else "eInheritRSrs"
+                    self.assertEqual(placed[node.name][0], inherit, node.name)
+
+                back = HierarchyData.load_fbx(self.path)
+                for node in rig:
+                    read = back[node.name]
+                    flag = node.segment_scale_compensate and node.node_type == "joint"
+                    self.assertEqual(read.segment_scale_compensate, flag, node.name)
+                    for channel in ("translate", "rotate", "scale"):
+                        np.testing.assert_allclose(
+                            getattr(read, channel), getattr(node, channel), rtol=0.0, atol=1e-12, err_msg=node.name
+                        )
+
+    def test_a_scale_under_1e_12_is_written_as_maya_writes_it(self):
+        """a scale under 1e-12 in size, 0 and -0 among them, is written as
+        1e-12, positive, as Maya 2025's FBXExport writes a static one; one of
+        1e-12 or more in size as it is (probe_l1.py)"""
+        values = (0.0, -0.0, 1e-13, -1e-13, 5e-13, 1e-12, -1e-12, 2e-12)
+        rig    = HierarchyData([_node(f"k{i}", scale=(1.32, 1.8, v)) for i, v in enumerate(values)])
+        rig.append(_node("joint", node_type="joint", scale=(0.0, 1.0, -1e-13)))
+        rig.append(_node("locator", node_type="locator", scale=(1e-13, -0.0, 3.0)))
+        self._export(rig)
+
+        written  = {name: tuple(scale) for name, scale in self._walk(lambda node: node.LclScaling.Get()).items()}
+        expected = (1e-12, 1e-12, 1e-12, 1e-12, 1e-12, 1e-12, -1e-12, 2e-12)
+        for i, z in enumerate(expected):
+            self.assertEqual(repr(written[f"|k{i}"]), repr((1.32, 1.8, z)), values[i])
+        self.assertEqual(repr(written["|joint"]), repr((1e-12, 1.0, 1e-12)))
+        self.assertEqual(repr(written["|locator"]), repr((1e-12, 1e-12, 3.0)))
+
+    def test_a_scale_under_1e_12_reads_back_as_1e_12(self):
+        """probe_l1b.py's rig, a group scaled (1.32, 1.8, v) over a joint and
+        a locator, v 0, 1e-13 and -1e-13, and -2e-12 beside them, read back
+        from its save: v as 1e-12, -2e-12 as it is, every world equal to the
+        rig's with 1e-12 in place of each v, and within 1e-12, the size of
+        the clamp, of the rig's own (l1c.py). Written as given, the read gave
+        v back"""
+        rig = tiny_rig()
+        self._export(rig)
+        back = HierarchyData.load_fbx(self.path)
+
+        clamped = tiny_rig()
+        for i, z in enumerate((1e-12, 1e-12, 1e-12, -2e-12)):
+            self.assertEqual(back[f"K{i}"].scale.tolist(), [1.32, 1.8, z])
+            clamped[f"K{i}"].scale = (1.32, 1.8, z)
+        for node in rig:
+            read = back[node.name].world_matrix
+            axes, position = gaps(read, clamped[node.name].world_matrix)
+            self.assertLessEqual(axes, 1e-9, node.name)
+            # the largest measured on this file
+            self.assertLessEqual(position, 0.0, node.name)
+            self.assertLessEqual(max(gaps(read, node.world_matrix)), 1e-12, node.name)
+
     def test_unsupported_node_types_are_skipped(self):
         # a constraint can't be exported, it is skipped along with what is under it
         weight = {"w0": {"attributeType": "double", "value": 1.0, "keyable": True}}

{cgmath-3.0.2 → cgmath-3.0.3}/_tests/test_fbx_labels.py

@@ -1191,12 +1191,47 @@ def _maya():
     return cmds, mel
 
 
+def _stored(path, inherit) -> str:
+    """load_fbx's rig, written with the sdk: a group P at (0, 1, 0) turned
+    (0, 30, 0) and scaled (1, 2, 3) over a group g at (2, 0.5, -0.5) turned
+    (20, 40, 60), scaled (1, 1.5, 0.75) and stored ``inherit``, over a locator
+    l at (0.5, 1, -2)"""
+    manager = FBX.FbxManager.Create()
+    manager.SetIOSettings(FBX.FbxIOSettings.Create(manager, FBX.IOSROOT))
+    scene = FBX.FbxScene.Create(manager, "scene")
+    scene.GetGlobalSettings().SetAxisSystem(FBX.FbxAxisSystem.MayaYUp)
+
+    def node(name, parent, translate, rotate=(0, 0, 0), scale=(1, 1, 1), stored=None, look="eNone"):
+        made = FBX.FbxNode.Create(scene, name)
+        attr = FBX.FbxNull.Create(scene, name)
+        attr.Look.Set(getattr(FBX.FbxNull.ELook, look).value)
+        made.SetNodeAttribute(attr)
+        made.LclTranslation.Set(FBX.FbxDouble3(*translate))
+        made.LclRotation.Set(FBX.FbxDouble3(*rotate))
+        made.LclScaling.Set(FBX.FbxDouble3(*scale))
+        made.SetRotationActive(True)
+        made.SetTransformationInheritType(stored or FBX.FbxTransform.EInheritType.eInheritRSrs)
+        parent.AddChild(made)
+        return made
+
+    top = node("P", scene.GetRootNode(), (0, 1, 0), (0, 30, 0), (1, 2, 3))
+    grp = node("g", top, (2, 0.5, -0.5), (20, 40, 60), (1, 1.5, 0.75), inherit)
+    node("l", grp, (0.5, 1, -2), look="eCross")
+    exporter = FBX.FbxExporter.Create(manager, "")
+    exporter.Initialize(path, -1, manager.GetIOSettings())
+    exporter.Export(scene)
+    exporter.Destroy()
+    manager.Destroy()
+    return path
+
+
 @unittest.skipIf(FBX is None, "the Autodesk FBX SDK is required")
 class TestSaveFbxInMaya(unittest.TestCase):
     """Maya's FBXImport of a save puts every node where it puts the file the
     values were read from, and a mesh, placed under the group its node is
-    saved as, where Maya puts the file's mesh. Needs mayapy with the fbxmaya
-    plug-in"""
+    saved as, where Maya puts the file's mesh, but for a node that is no joint
+    the read puts off the file, which it puts where the read has it. Needs
+    mayapy with the fbxmaya plug-in"""
 
     @classmethod
     def setUpClass(cls):
@@ -1279,6 +1314,161 @@ class TestSaveFbxInMaya(unittest.TestCase):
         self.assertTrue(np.allclose(self.cmds.getAttr("hip.jointOrient")[0], (0.0, 0.0, 90.0)))
         self.assertLess(float(np.abs(worlds["hip"] - np.asarray(rig["hip"].world_matrix)).max()), 1e-9)
 
+    def test_groups_and_locators_import_where_the_rig_has_them(self):
+        """every node written with its inherit type, eInheritRSrs on a group
+        or a locator as Maya's exporter writes them: written eInheritRrSs, a
+        turned group under a group scaled (1, 3, 0.5) imported 1.58 off the
+        rig in its 3x3, and a locator under it 3.17 in position
+        (probe_save.py)"""
+        from cgmath._tests.test_fbx_export import gaps, scaled_rig
+
+        rig = scaled_rig()
+        out = os.path.join(self.out, "scaled.fbx")
+        rig.save_fbx(out)
+        worlds, _ = self.imported(out)
+        for node in rig:
+            axes, position = gaps(worlds[node.name], node.world_matrix)
+            self.assertLessEqual(axes, 1e-9, node.name)
+            # the largest measured on this file
+            self.assertLessEqual(position, 8.881784197001252e-16, node.name)
+
+    def test_a_node_the_read_puts_off_its_file_imports_where_the_read_has_it(self):
+        """load_fbx reads a node that is no joint as eInheritRSrs whatever the
+        file stores and save_fbx writes that, so a load then a save of a file
+        storing one eInheritRrSs or eInheritRrs puts it, in the sdk and in
+        Maya, where the read has it, not where the file does: on load_fbx's
+        rig 1.11 off the file in the 3x3, a locator 2.34 or 1.75 in position.
+        An earlier save_fbx wrote it eInheritRrSs: one stored so imported
+        where the file does, 1.11 off the read (TransformList.save_fbx)"""
+        from cgmath._tests.test_fbx_export import gaps
+
+        # how far the locator's position lands off the file's
+        for inherit, moved in (("eInheritRrSs", 2.34), ("eInheritRrs", 1.75)):
+            with self.subTest(inherit):
+                stored = getattr(FBX.FbxTransform.EInheritType, inherit)
+                path   = _stored(os.path.join(self.out, f"{inherit}.fbx"), stored)
+                rig    = HierarchyData.load_fbx(path)
+                out    = os.path.join(self.out, f"{inherit}_saved.fbx")
+                rig.save_fbx(out)
+                sdk = _sdk_worlds(out)
+                worlds, _ = self.imported(out)
+                file, _ = self.imported(path)
+                for node in rig:
+                    for placed in (sdk, worlds):
+                        axes, position = gaps(placed[node.name], node.world_matrix)
+                        self.assertLessEqual(axes, 1e-9, node.name)
+                        # the largest measured on these two files
+                        self.assertLessEqual(position, 8.881784197001252e-16, node.name)
+                axes, position = gaps(worlds["l"], file["l"])
+                self.assertAlmostEqual(axes, 1.11, places=2)
+                self.assertAlmostEqual(position, moved, places=2)
+
+    def test_a_mirrored_group_under_a_mirrored_parent_imports_where_the_rig_has_it(self):
+        """a group or locator with segment_scale_compensate on whose own scale
+        and its parent's both mirror: Maya's FBXImport puts it and the groups
+        and locators under it where the rig has them (written eInheritRrSs,
+        off under either parent); it parts from the sdk and the rig where one
+        of the two mirrors alone (TransformList.save_fbx). Not the
+        compensating joints directly under it (flag_mirror.py)"""
+        from cgmath._tests.test_fbx_export import MIRRORED_CASES, flagged_rig, gaps
+
+        # the largest position gap measured on each file
+        bounds = {
+            "(-1, 2, 3)":   8.881784197001252e-16,
+            "(-2, -2, -2)": 8.881784197001252e-16,
+        }
+        for label, scale in MIRRORED_CASES[-2:]:
+            with self.subTest(label):
+                rig = flagged_rig(scale, (0.0, 30.0, 0.0), own=(-1.0, 1.5, 0.75))
+                out = os.path.join(self.out, "mirrored.fbx")
+                rig.save_fbx(out)
+                worlds, _ = self.imported(out)
+                for node in rig:
+                    if node.name in ("jRrs", "kRrs"):
+                        continue
+                    axes, position = gaps(worlds[node.name], node.world_matrix)
+                    self.assertLessEqual(axes, 1e-9, node.name)
+                    self.assertLessEqual(position, bounds[label], node.name)
+
+    def test_a_group_compensating_its_parents_scale_imports_where_the_rig_has_it(self):
+        """a group or locator with segment_scale_compensate on, written
+        eInheritRrs, under a parent whose own scale is not mirrored: Maya's
+        FBXImport puts it and the groups and locators under it where the rig
+        has them (written eInheritRrSs, the group's axes 1.32 off under a
+        parent scaled (1, 2, 3)). Not the compensating joints directly under
+        it, which Maya's import puts elsewhere than the sdk and the rig, nor
+        any node of its branch under a mirrored parent (flag_mirror.py)"""
+        from cgmath._tests.test_fbx_export import FLAGGED_CASES, flagged_rig, gaps
+
+        # the largest position gap measured on each file
+        bounds = {
+            "(1, 2, 3)": 4.440892098500626e-16,
+            "(2, 2, 2)": 4.440892098500626e-16,
+            "(2, 1, 0.5) under (1, 2, 3)": 2.6645352591003757e-15,
+        }
+        for label, scale, rotate, grand in FLAGGED_CASES[:3]:
+            with self.subTest(label):
+                rig = flagged_rig(scale, rotate, grand)
+                out = os.path.join(self.out, "flagged.fbx")
+                rig.save_fbx(out)
+                worlds, _ = self.imported(out)
+                for node in rig:
+                    if node.name in ("jRrs", "kRrs"):
+                        continue
+                    axes, position = gaps(worlds[node.name], node.world_matrix)
+                    self.assertLessEqual(axes, 1e-9, node.name)
+                    self.assertLessEqual(position, bounds[label], node.name)
+
+    def test_a_joint_under_a_compensating_group_imports_where_the_rig_has_it(self):
+        """a joint compensating its scale directly under a group with
+        segment_scale_compensate on, and the joint under it, import where the
+        rig has them when the group's scale is positive and it has no parent,
+        or its parent's scale is 1, or 1 in size with two negative axes
+        (TransformList.save_fbx's second case). Written eInheritRrSs, cRrs
+        imported 0.230 off in its 3x3 with no parent, and under (-1, 1, -1)
+        gRrs 1.74, jRrs 1.76 and lRrs 4.06 in position (flag_mirror.py's rig)"""
+        from cgmath._tests.test_fbx_export import flagged_rig, gaps
+
+        # P's scale, or None for no parent; the largest position gap measured
+        # on each file
+        cases = {
+            "no parent":   (None, 6.661338147750939e-16),
+            "(1, 1, 1)":   ((1.0, 1.0, 1.0), 4.440892098500626e-16),
+            "(-1, 1, -1)": ((-1.0, 1.0, -1.0), 4.440892098500626e-16),
+            "(1, -1, -1)": ((1.0, -1.0, -1.0), 4.440892098500626e-16),
+            "(-1, -1, 1)": ((-1.0, -1.0, 1.0), 4.440892098500626e-16),
+        }
+        for label, (scale, bound) in cases.items():
+            with self.subTest(label):
+                rig = flagged_rig(scale, (0.0, 30.0, 0.0))
+                out = os.path.join(self.out, "joints.fbx")
+                rig.save_fbx(out)
+                worlds, _ = self.imported(out)
+                for node in rig:
+                    axes, position = gaps(worlds[node.name], node.world_matrix)
+                    self.assertLessEqual(axes, 1e-9, node.name)
+                    self.assertLessEqual(position, bound, node.name)
+
+    def test_a_scale_under_1e_12_imports_where_the_read_puts_it(self):
+        """probe_l1b.py's rig, a group scaled (1.32, 1.8, v) over a joint and
+        a locator, v 0, 1e-13 and -1e-13, and -2e-12 beside them: written
+        1e-12 in place of each v, as Maya's FBXExport writes such a scale,
+        Maya's FBXImport puts every node where load_fbx reads the save.
+        Written as given, the read held 0 or 1e-13 where Maya holds 1e-12,
+        2.43e-13 off Maya in a locator's position and 9.71e-13 in the 3x3
+        (probe_l1b.py)"""
+        from cgmath._tests.test_fbx_export import gaps, tiny_rig
+
+        out = os.path.join(self.out, "tiny.fbx")
+        tiny_rig().save_fbx(out)
+        worlds, _ = self.imported(out)
+        for node in HierarchyData.load_fbx(out):
+            self.assertTrue(np.isfinite(worlds[node.name]).all(), node.name)
+            axes, position = gaps(worlds[node.name], node.world_matrix)
+            self.assertLessEqual(axes, 1e-9, node.name)
+            # the largest measured on this file
+            self.assertLessEqual(position, 4.440892098500626e-16, node.name)
+
 
 if __name__ == "__main__":
     unittest.main()

{cgmath-3.0.2 → cgmath-3.0.3/cgmath.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgmath
-Version: 3.0.2
+Version: 3.0.3
 Summary: A DCC-agnostic CG math library: batched matrix, quaternion and euler math, mesh topology, deformers, resampling, skeletal hierarchies, SDFs, a software raytracer and asset IO, all numpy-native.
 Author-email: Eric Vignola <eric.vignola@gmail.com>
 License: ## License

{cgmath-3.0.2 → cgmath-3.0.3}/formats/fbx.py

@@ -915,7 +915,11 @@ class LayerData(BaseData):
 
         Supports both Maya and FBX naming conventions:
         - Maya transforms: "translateX" -> "Lcl TranslationX"
-        - Maya blendshapes: node="face_mesh", property="smile" -> "face_mesh.smile.DeformPercent"
+        - Maya blend shapes: node="face_blend.smile", property="DeformPercent"
+          (the blend shape's name, not its mesh's) -> the DeformPercent of
+          blend shape face_blend's channel smile; node="face_blend",
+          property="smile" works only where the file names the channel
+          "face_blend.smile", as Maya's FBX export does
         - FBX naming: Direct usage of FBX property names
 
         Args:
@@ -2827,10 +2831,22 @@ class FbxExporter:
         importer brings a root skeleton node (``eRoot``) with no child in as
         a plain transform, without its joint orient.
 
+        Every node takes the inherit type its ``segment_scale_compensate``
+        says, ``eInheritRrs`` when on and ``eInheritRSrs`` when off, a group
+        and a locator too, as Maya's own exporter writes a group or a
+        locator: the sdk's default, ``eInheritRrSs``, which an earlier
+        version left on them, scales a node along its own axes by its
+        parent's world scale, so the sdk and Maya's importer put a group
+        under an unevenly scaled parent, and the nodes under it, elsewhere
+        than the component has them.
+
         The scene is labelled with the axis system and unit the component's
         values are in, as it records them (``HierarchyData.axis_system`` and
         ``unit``; a view's are its rig's, a list's of nodes their rig's): the
-        values are written as they are, under that label.
+        values are written as they are, under that label, but for a scale
+        under 1e-12 in size, 0 and -0 among them, written as 1e-12,
+        positive, as Maya's own exporter writes a static one and as Maya's
+        evaluation holds it.
 
         Raises ValueError, before anything is added, when a user defined string
         attr is not plain ASCII, the only text the FBX SDK takes, or a node's user
@@ -2854,7 +2870,7 @@ class FbxExporter:
         # never writes them as scene nodes.
         # imported here, cgmath.hierarchy imports this module.
         from cgmath.hierarchy import SUPPORTED_NODE_TYPES
-        from cgmath.hierarchy.hierarchy import TransformList
+        from cgmath.hierarchy.hierarchy import TransformList, _fbx_maya_scale
 
         skipped_nodes = {}
         dropped       = set()
@@ -2901,7 +2917,11 @@ class FbxExporter:
 
             node.LclTranslation.Set(fbx.FbxDouble3(*item.translate))
             node.LclRotation.Set(fbx.FbxDouble3(*item.rotate))
-            node.LclScaling.Set(fbx.FbxDouble3(*item.scale))
+            # a scale under 1e-12 in size as 1e-12, positive, as Maya's
+            # exporter writes a static one: Maya's evaluation holds such a
+            # scale as 1e-12, so load_fbx and Maya's import of the file then
+            # place the nodes under it alike
+            node.LclScaling.Set(fbx.FbxDouble3(*_fbx_maya_scale(item.scale)))
 
             node.SetRotationOrder(
                 fbx.FbxNode.EPivotSet.eSourcePivot,
@@ -2912,6 +2932,17 @@ class FbxExporter:
             # ignores the rotate order of a node without it, turning it in xyz
             node.SetRotationActive(True)
 
+            # the inherit type on every node, a group and a locator too: the
+            # sdk's default, eInheritRrSs, scales a node along its own axes by
+            # its parent's world scale, which no node does in cgmath or in
+            # Maya, whose exporter writes eInheritRSrs on a group or locator
+            inherit_type = (
+                fbx.FbxTransform.EInheritType.eInheritRrs
+                if item.segment_scale_compensate
+                else fbx.FbxTransform.EInheritType.eInheritRSrs
+            )
+            node.SetTransformationInheritType(inherit_type)
+
             # a parent the export leaves out -- outside the view exported, or
             # a parent_uuid no node carries -- makes the node a root, as a
             # view's copy() does: never a node found by its name
@@ -2929,12 +2960,6 @@ class FbxExporter:
                 # an eRoot with no child as a transform, its orient dropped
                 node_attr = fbx.FbxSkeleton.Create(self.manager, "")
                 node_attr.SetSkeletonType(fbx.FbxSkeleton.EType.eLimbNode)
-                inherit_type = (
-                    fbx.FbxTransform.EInheritType.eInheritRrs
-                    if item.segment_scale_compensate
-                    else fbx.FbxTransform.EInheritType.eInheritRSrs
-                )
-                node.SetTransformationInheritType(inherit_type)
                 # pre and post rotation, which fbx reads with rotation active
                 node.SetPreRotation(
                     fbx.FbxNode.EPivotSet.eSourcePivot,