Add a simple Eigen affine 2D matrix class

This currently is enough to instantiate
`matplotlib.transforms.Affine2D`, and get its matrix, but can't do
anything else.

Author: QuLogic

lib/matplotlib/_eigen.pyi

@@ -0,0 +1,9 @@
+from collections.abc import Sequence
+
+import numpy as np
+
+class Affine2d:
+    def __init__(self, matrix: Sequence[Sequence[float]] | None = ...): ...
+    def get_matrix(self) -> np.ndarray: ...
+    def is_diagonal(self) -> bool: ...
+    def __call__(self, i: int, j: int) -> float: ...

lib/matplotlib/meson.build

@@ -80,6 +80,7 @@ typing_sources = [
   'py.typed',
   # Compiled extension types.
   '_c_internal_utils.pyi',
+  '_eigen.pyi',
   'ft2font.pyi',
   '_image.pyi',
   '_qhull.pyi',

lib/matplotlib/transforms.py

@@ -44,7 +44,7 @@
 import numpy as np
 from numpy.linalg import inv
 
-from matplotlib import _api
+from matplotlib import _api, _eigen
 from matplotlib._path import affine_transform, count_bboxes_overlapping_bbox
 from .path import Path
 
@@ -1918,20 +1918,20 @@ def __init__(self, matrix=None, **kwargs):
         If *matrix* is None, initialize with the identity transform.
         """
         super().__init__(**kwargs)
-        if matrix is None:
-            # A bit faster than np.identity(3).
-            matrix = IdentityTransform._mtx
-        self._mtx = matrix.copy()
+        if matrix is not None:
+            self._mtx = _eigen.Affine2d(matrix)
+        else:
+            self._mtx = _eigen.Affine2d()
         self._invalid = 0
 
     _base_str = _make_str_method("_mtx")
 
     def __str__(self):
         return (self._base_str()
-                if (self._mtx != np.diag(np.diag(self._mtx))).any()
-                else f"Affine2D().scale({self._mtx[0, 0]}, {self._mtx[1, 1]})"
-                if self._mtx[0, 0] != self._mtx[1, 1]
-                else f"Affine2D().scale({self._mtx[0, 0]})")
+                if not self._mtx.is_diagonal
+                else f"Affine2D().scale({self._mtx(0, 0)}, {self._mtx(1, 1)})"
+                if self._mtx(0, 0) != self._mtx(1, 1)
+                else f"Affine2D().scale({self._mtx(0, 0)})")
 
     @staticmethod
     def from_values(a, b, c, d, e, f):
@@ -1944,8 +1944,7 @@ def from_values(a, b, c, d, e, f):
 
         .
         """
-        return Affine2D(
-            np.array([a, c, e, b, d, f, 0.0, 0.0, 1.0], float).reshape((3, 3)))
+        return Affine2D([[a, c, e], [b, d, f], [0.0, 0.0, 1.0]])
 
     def get_matrix(self):
         """
@@ -1960,7 +1959,7 @@ def get_matrix(self):
         if self._invalid:
             self._inverted = None
             self._invalid = 0
-        return self._mtx
+        return self._mtx.get_matrix()
 
     def set_matrix(self, mtx):
         """
@@ -2679,8 +2678,7 @@ def __init__(self, xt, yt, scale_trans, **kwargs):
     def get_matrix(self):
         # docstring inherited
         if self._invalid:
-            # A bit faster than np.identity(3).
-            self._mtx = IdentityTransform._mtx.copy()
+            self._mtx = _eigen.Affine2d()
             self._mtx[:2, 2] = self._scale_trans.transform(self._t)
             self._invalid = 0
             self._inverted = None

meson.build

@@ -39,6 +39,7 @@ py_mod = import('python')
 py3 = py_mod.find_installation(pure: false)
 py3_dep = py3.dependency()
 
+eigen_dep = dependency('eigen3', version: '>=3')
 pybind11_dep = dependency('pybind11', version: '>=2.13.2')
 
 subdir('extern')

src/_eigen.cpp

@@ -0,0 +1,50 @@
+// Matrix operations we need:
+// .copy()
+// check if [0, 0] != [1, 1]
+// re-set a, b, c, d, e, f
+// convert to NumPy matrix
+// reset to identity
+// rotate in place
+// translate in place
+// scale in place
+// skew in place
+// dot two matrices
+
+#include <pybind11/pybind11.h>
+#include <pybind11/eigen.h>
+#include <pybind11/numpy.h>
+#include <pybind11/stl.h>
+#include <Eigen/Geometry>
+
+namespace py = pybind11;
+using namespace pybind11::literals;
+
+PYBIND11_MODULE(_eigen, m) {
+    py::class_<Eigen::Affine2d>(m, "Affine2d")
+        .def(py::init([]() {
+            return Eigen::Affine2d::Identity();
+        }))
+        .def(py::init([](const Eigen::Matrix3d& matrix) {
+            return Eigen::Affine2d(matrix);
+        }),
+        "matrix"_a.none(false))
+
+        .def("get_matrix", [](const Eigen::Affine2d& self) {
+            return self.matrix();
+        })
+        .def_property_readonly("is_diagonal", [](const Eigen::Affine2d& self) {
+            return self.matrix().isDiagonal();
+        })
+        .def("__call__", [](const Eigen::Affine2d& self, py::ssize_t i, py::ssize_t j) {
+            if (i < 0 || i >= 3) {
+                throw std::out_of_range(
+                    "Index i (" + std::to_string(i) + ") out of range");
+            }
+            if (j < 0 || j >= 3) {
+                throw std::out_of_range(
+                    "Index j (" + std::to_string(j) + ") out of range");
+            }
+            return self(i, j);
+        }, "i"_a, "j"_a)
+    ;
+}

src/meson.build

@@ -46,6 +46,13 @@ extension_data = {
     ),
     'dependencies': [pybind11_dep, dl, ole32, shell32, user32],
   },
+  '_eigen': {
+    'subdir': 'matplotlib',
+    'sources': files(
+      '_eigen.cpp',
+    ),
+    'dependencies': [pybind11_dep, eigen_dep],
+  },
   'ft2font': {
     'subdir': 'matplotlib',
     'sources': files(