pymomentum-cpu 0.1.93.post0__cp312-cp312-macosx_14_0_arm64.whl

include/momentum/rasterizer/camera.h

@@ -0,0 +1,453 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <drjit/array.h>
+#include <drjit/fwd.h>
+#include <drjit/matrix.h>
+
+#include <momentum/rasterizer/fwd.h>
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+#include <memory>
+
+namespace momentum::rasterizer {
+
+/// Base class for camera intrinsics models.
+/// This abstract class defines the interface for different camera models
+/// such as pinhole and OpenCV distortion models.
+template <typename T>
+class IntrinsicsModelT {
+ public:
+  /// Constructor for intrinsics model.
+  /// @param imageWidth Width of the image in pixels
+  /// @param imageHeight Height of the image in pixels
+  IntrinsicsModelT(int32_t imageWidth, int32_t imageHeight)
+      : imageWidth_(imageWidth), imageHeight_(imageHeight) {}
+  virtual ~IntrinsicsModelT() = default;
+
+  /// Get the focal length in the x direction.
+  /// @return Focal length fx in pixels
+  [[nodiscard]] virtual T fx() const = 0;
+
+  /// Get the focal length in the y direction.
+  /// @return Focal length fy in pixels
+  [[nodiscard]] virtual T fy() const = 0;
+
+  /// Project 3D points to 2D image coordinates.
+  /// @param point 3D points in camera coordinate space
+  /// @return Pair of projected 2D points and validity mask
+  [[nodiscard]] virtual std::pair<Vector3xP<T>, typename PacketType_t<T>::MaskType> project(
+      const Vector3xP<T>& point) const = 0;
+
+  /// Project a single 3D point to 2D image coordinates (Eigen version).
+  /// @param point 3D point in camera coordinate space
+  /// @return Pair of projected 2D point and validity flag
+  [[nodiscard]] virtual std::pair<Eigen::Vector3<T>, bool> project(
+      const Eigen::Vector3<T>& point) const = 0;
+
+  /// Compute the Jacobian of the projection function with respect to 3D camera coordinates.
+  /// @param point 3D point in camera coordinate space
+  /// @return Tuple of (projected point, Jacobian matrix, valid flag)
+  /// The Jacobian is a 3x3 matrix where:
+  /// - Row 0: [du/dx, du/dy, du/dz]
+  /// - Row 1: [dv/dx, dv/dy, dv/dz]
+  /// - Row 2: [0, 0, 1] (for homogeneous coordinates)
+  [[nodiscard]] virtual std::tuple<Eigen::Vector3<T>, Eigen::Matrix<T, 3, 3>, bool> projectJacobian(
+      const Eigen::Vector3<T>& point) const = 0;
+
+  /// Unproject 3D image points to 3D camera points using Newton's method.
+  /// @param imagePoint 3D point in image coordinates (u, v, z) where z is the desired depth
+  /// @param maxIterations Maximum number of Newton iterations (default: 10)
+  /// @param tolerance Convergence tolerance for the residual (default: 1e-6)
+  /// @return Pair of 3D point in camera coordinates and validity flag
+  [[nodiscard]] virtual std::pair<Eigen::Vector3<T>, bool> unproject(
+      const Eigen::Vector3<T>& imagePoint,
+      int maxIterations = 10,
+      T tolerance = T(1e-6)) const = 0;
+
+  /// Resample the intrinsics by a given factor.
+  /// @param factor Resampling factor (>1 for upsampling, <1 for downsampling)
+  /// @return New intrinsics model with resampled parameters
+  [[nodiscard]] std::shared_ptr<const IntrinsicsModelT<T>> resample(T factor) const;
+
+  /// Downsample the intrinsics by a given factor.
+  /// @param factor Downsampling factor (e.g., 2.0 halves the resolution)
+  /// @return New intrinsics model with downsampled parameters
+  [[nodiscard]] std::shared_ptr<const IntrinsicsModelT<T>> downsample(T factor) const;
+
+  /// Upsample the intrinsics by a given factor.
+  /// @param factor Upsampling factor (e.g., 2.0 doubles the resolution)
+  /// @return New intrinsics model with upsampled parameters
+  [[nodiscard]] std::shared_ptr<const IntrinsicsModelT<T>> upsample(T factor) const;
+
+  /// Resize the intrinsics to new image dimensions.
+  /// @param imageWidth New image width in pixels
+  /// @param imageHeight New image height in pixels
+  /// @return New intrinsics model with resized parameters
+  [[nodiscard]] virtual std::shared_ptr<const IntrinsicsModelT<T>> resize(
+      int32_t imageWidth,
+      int32_t imageHeight) const = 0;
+
+  /// Crop the intrinsics to a sub-region of the image.
+  /// @param top Top offset in pixels
+  /// @param left Left offset in pixels
+  /// @param newWidth New width in pixels after cropping
+  /// @param newHeight New height in pixels after cropping
+  /// @return New intrinsics model with cropped parameters
+  [[nodiscard]] virtual std::shared_ptr<const IntrinsicsModelT<T>>
+  crop(int32_t top, int32_t left, int32_t newWidth, int32_t newHeight) const = 0;
+
+  /// Get the image width.
+  /// @return Image width in pixels
+  [[nodiscard]] int32_t imageWidth() const {
+    return imageWidth_;
+  }
+
+  /// Get the image height.
+  /// @return Image height in pixels
+  [[nodiscard]] int32_t imageHeight() const {
+    return imageHeight_;
+  }
+
+ private:
+  int32_t imageWidth_ = 640;
+  int32_t imageHeight_ = 480;
+};
+
+/// Camera class that combines intrinsics and extrinsics for 3D rendering.
+/// This class encapsulates both the camera's intrinsic parameters (focal length,
+/// principal point, image dimensions) and extrinsic parameters (position and orientation).
+template <typename T>
+class CameraT {
+ public:
+  /// Default constructor creates a camera with identity transform.
+  CameraT();
+
+  /// Constructor with intrinsics model and optional transform.
+  /// @param intrinsicsModel Shared pointer to the camera's intrinsics model
+  /// @param eyeFromWorld Transform from world space to camera/eye space (defaults to identity)
+  explicit CameraT(
+      std::shared_ptr<const IntrinsicsModelT<T>> intrinsicsModel,
+      const Eigen::Transform<T, 3, Eigen::Affine>& eyeFromWorld =
+          Eigen::Transform<T, 3, Eigen::Affine>::Identity());
+
+  /// Get the image width from the intrinsics model.
+  /// @return Image width in pixels
+  [[nodiscard]] auto imageWidth() const {
+    return intrinsicsModel_->imageWidth();
+  }
+
+  /// Get the image height from the intrinsics model.
+  /// @return Image height in pixels
+  [[nodiscard]] auto imageHeight() const {
+    return intrinsicsModel_->imageHeight();
+  }
+
+  /// Get the focal length in x direction from the intrinsics model.
+  /// @return Focal length fx in pixels
+  [[nodiscard]] auto fx() const {
+    return intrinsicsModel_->fx();
+  }
+
+  /// Get the focal length in y direction from the intrinsics model.
+  /// @return Focal length fy in pixels
+  [[nodiscard]] auto fy() const {
+    return intrinsicsModel_->fy();
+  }
+
+  /// Get the intrinsics model.
+  /// @return Shared pointer to the intrinsics model
+  [[nodiscard]] std::shared_ptr<const IntrinsicsModelT<T>> intrinsicsModel() const {
+    return intrinsicsModel_;
+  }
+
+  /// Get the eye-from-world transformation matrix.
+  /// @return Reference to the transformation from world space to camera space
+  [[nodiscard]] const Eigen::Transform<T, 3, Eigen::Affine>& eyeFromWorld() const {
+    return eyeFromWorld_;
+  }
+
+  /// Get the world-from-eye transformation matrix.
+  /// @return Transformation from camera space to world space
+  [[nodiscard]] Eigen::Transform<T, 3, Eigen::Affine> worldFromEye() const {
+    return eyeFromWorld_.inverse();
+  }
+
+  /// Set the eye-from-world transformation matrix.
+  /// @param eyeFromWorld New transformation from world space to camera space
+  void setEyeFromWorld(const Eigen::Transform<T, 3, Eigen::Affine>& eyeFromWorld) {
+    eyeFromWorld_ = eyeFromWorld;
+  }
+
+  /// Position the camera to look at a specific target point.
+  ///
+  /// @param position The position of the camera in world space
+  /// @param target The target point to look at in world space
+  /// @param up The up vector in world space (default is Y-up)
+  /// @return A new camera with the updated transform
+  [[nodiscard]] CameraT<T> lookAt(
+      const Eigen::Vector3<T>& position,
+      const Eigen::Vector3<T>& target = Eigen::Vector3<T>::Zero(),
+      const Eigen::Vector3<T>& up = Eigen::Vector3<T>::UnitY()) const;
+
+  /// Adjust the camera position to ensure all specified points are in view.
+  /// This preserves the camera's orientation but adjusts its position.
+  ///
+  /// @param points The 3D points in world space that should be in view
+  /// @param minZ The minimum Z distance from the camera
+  /// @param edgePadding Padding from the edge of the frame (0.0-1.0)
+  /// @return A new camera with the updated transform
+  [[nodiscard]] CameraT<T> framePoints(
+      const std::vector<Eigen::Vector3<T>>& points,
+      T minZ = T(0.1),
+      T edgePadding = T(0.05)) const;
+
+  /// Project 3D world points to 2D image coordinates.
+  /// @param worldPoints 3D points in world coordinate space (wide vector)
+  /// @return Pair of projected 2D points and validity mask
+  [[nodiscard]] std::pair<Vector3xP<T>, typename PacketType_t<T>::MaskType> project(
+      const Vector3xP<T>& worldPoints) const;
+
+  /// Project a single 3D world point to 2D image coordinates (Eigen version).
+  /// @param worldPoint 3D point in world coordinate space
+  /// @return Pair of projected 2D point and validity flag
+  [[nodiscard]] std::pair<Eigen::Vector3<T>, bool> project(
+      const Eigen::Vector3<T>& worldPoint) const;
+
+  /// Compute the Jacobian of the projection function with respect to 3D world coordinates.
+  /// @param worldPoint 3D point in world coordinate space
+  /// @return Tuple of (projected point, Jacobian matrix, valid flag)
+  /// The Jacobian is a 2x3 matrix where:
+  /// - Row 0: [du/dX_world, du/dY_world, du/dZ_world]
+  /// - Row 1: [dv/dX_world, dv/dY_world, dv/dZ_world]
+  [[nodiscard]] std::tuple<Eigen::Vector3<T>, Eigen::Matrix<T, 2, 3>, bool> projectJacobian(
+      const Eigen::Vector3<T>& worldPoint) const;
+
+  /// Unproject 3D image points to 3D world points using Newton's method.
+  /// @param imagePoints 3D points in image coordinates (u, v, z) where z is the desired depth (wide
+  /// vector)
+  /// @param maxIterations Maximum number of Newton iterations (default: 10)
+  /// @param tolerance Convergence tolerance for the residual (default: 1e-6)
+  /// @return Pair of 3D points in world coordinates and validity mask
+  [[nodiscard]] std::pair<Vector3xP<T>, typename PacketType_t<T>::MaskType>
+  unproject(const Vector3xP<T>& imagePoints, int maxIterations = 10, T tolerance = T(1e-6)) const;
+
+  /// Unproject 3D image point to 3D world point using Newton's method (Eigen version).
+  /// @param imagePoint 3D point in image coordinates (u, v, z) where z is the desired depth
+  /// @param maxIterations Maximum number of Newton iterations (default: 10)
+  /// @param tolerance Convergence tolerance for the residual (default: 1e-6)
+  /// @return Pair of 3D point in world coordinates and validity flag
+  [[nodiscard]] std::pair<Eigen::Vector3<T>, bool> unproject(
+      const Eigen::Vector3<T>& imagePoint,
+      int maxIterations = 10,
+      T tolerance = T(1e-6)) const;
+
+  /// Create a cropped camera with a sub-region of the original image.
+  /// @param top Top offset in pixels
+  /// @param left Left offset in pixels
+  /// @param newWidth New width in pixels after cropping
+  /// @param newHeight New height in pixels after cropping
+  /// @return New camera with cropped intrinsics and same pose
+  [[nodiscard]] CameraT<T> crop(int32_t top, int32_t left, int32_t newWidth, int32_t newHeight)
+      const {
+    return CameraT<T>(intrinsicsModel_->crop(top, left, newWidth, newHeight), eyeFromWorld_);
+  }
+
+  /// Create a resized camera with new image dimensions.
+  /// @param imageWidth New image width in pixels
+  /// @param imageHeight New image height in pixels
+  /// @return New camera with resized intrinsics and same pose
+  [[nodiscard]] CameraT<T> resize(int32_t imageWidth, int32_t imageHeight) const {
+    return CameraT<T>(intrinsicsModel_->resize(imageWidth, imageHeight), eyeFromWorld_);
+  }
+
+  [[nodiscard]] const IntrinsicsModelT<T>& getIntrinsicsModel() const {
+    return *intrinsicsModel_;
+  }
+
+ private:
+  /// Transform world points to camera/eye space using SIMD operations.
+  /// @param worldPoints 3D points in world coordinate space (wide vector)
+  /// @return 3D points in camera/eye coordinate space (wide vector)
+  [[nodiscard]] Vector3xP<T> transformWorldToEye(const Vector3xP<T>& worldPoints) const;
+
+  /// Transform a single world point to camera/eye space.
+  /// @param worldPoint 3D point in world coordinate space
+  /// @return 3D point in camera/eye coordinate space
+  [[nodiscard]] Eigen::Vector3<T> transformWorldToEye(const Eigen::Vector3<T>& worldPoint) const;
+
+  Eigen::Transform<T, 3, Eigen::Affine> eyeFromWorld_ =
+      Eigen::Transform<T, 3, Eigen::Affine>::Identity();
+
+  std::shared_ptr<const IntrinsicsModelT<T>> intrinsicsModel_;
+};
+
+/// OpenCV distortion parameters for camera lens distortion correction.
+/// These parameters follow the OpenCV camera calibration model and include
+/// both radial and tangential distortion coefficients.
+template <typename T>
+struct OpenCVDistortionParametersT {
+  T k1 = T(0); ///< First radial distortion coefficient
+  T k2 = T(0); ///< Second radial distortion coefficient
+  T k3 = T(0); ///< Third radial distortion coefficient
+  T k4 = T(0); ///< Fourth radial distortion coefficient (for fisheye model)
+  T k5 = T(0); ///< Fifth radial distortion coefficient (for fisheye model)
+  T k6 = T(0); ///< Sixth radial distortion coefficient (for fisheye model)
+
+  T p1 = T(0); ///< First tangential distortion coefficient
+  T p2 = T(0); ///< Second tangential distortion coefficient
+  T p3 = T(0); ///< Third tangential distortion coefficient (for thin prism)
+  T p4 = T(0); ///< Fourth tangential distortion coefficient (for thin prism)
+};
+
+/// PinholeIntrinsicsModel implements a basic pinhole camera model.
+/// This model uses the following projection formula:
+/// x = fx * X/Z + cx
+/// y = fy * Y/Z + cy
+///
+/// Where:
+/// - (X, Y, Z) is the 3D point in camera coordinates
+/// - (x, y) is the projected 2D point in image coordinates
+/// - (fx, fy) are the focal lengths
+/// - (cx, cy) is the principal point
+///
+/// Unlike the OpenCVIntrinsicsModel, this model does not include any distortion.
+template <typename T>
+class PinholeIntrinsicsModelT : public IntrinsicsModelT<T> {
+ public:
+  PinholeIntrinsicsModelT(int32_t imageWidth, int32_t imageHeight, T fx, T fy, T cx, T cy);
+  PinholeIntrinsicsModelT(int32_t imageWidth, int32_t imageHeight, T fx, T fy);
+
+  [[nodiscard]] T fx() const final {
+    return fx_;
+  }
+
+  [[nodiscard]] T fy() const final {
+    return fy_;
+  }
+
+  [[nodiscard]] T cx() const {
+    return cx_;
+  }
+
+  [[nodiscard]] T cy() const {
+    return cy_;
+  }
+
+  [[nodiscard]] std::pair<Vector3xP<T>, typename PacketType_t<T>::MaskType> project(
+      const Vector3xP<T>& point) const final;
+
+  [[nodiscard]] std::pair<Eigen::Vector3<T>, bool> project(
+      const Eigen::Vector3<T>& point) const final;
+
+  [[nodiscard]] std::tuple<Eigen::Vector3<T>, Eigen::Matrix<T, 3, 3>, bool> projectJacobian(
+      const Eigen::Vector3<T>& point) const final;
+
+  [[nodiscard]] std::pair<Eigen::Vector3<T>, bool> unproject(
+      const Eigen::Vector3<T>& imagePoint,
+      int maxIterations = 10,
+      T tolerance = T(1e-6)) const final;
+
+  [[nodiscard]] std::shared_ptr<const IntrinsicsModelT<T>> resize(
+      int32_t imageWidth,
+      int32_t imageHeight) const final;
+
+  [[nodiscard]] std::shared_ptr<const IntrinsicsModelT<T>>
+  crop(int32_t top, int32_t left, int32_t newWidth, int32_t newHeight) const final;
+
+ private:
+  T fx_;
+  T fy_;
+  T cx_;
+  T cy_;
+};
+
+/// OpenCVIntrinsicsModel implements the standard OpenCV camera model.
+/// This model uses the following projection formula:
+/// x = fx * X/Z + cx
+/// y = fy * Y/Z + cy
+///
+/// Where:
+/// - (X, Y, Z) is the 3D point in camera coordinates
+/// - (x, y) is the projected 2D point in image coordinates
+/// - (fx, fy) are the focal lengths
+/// - (cx, cy) is the principal point
+template <typename T>
+class OpenCVIntrinsicsModelT : public IntrinsicsModelT<T> {
+ public:
+  OpenCVIntrinsicsModelT(
+      int32_t imageWidth,
+      int32_t imageHeight,
+      T fx,
+      T fy,
+      T cx,
+      T cy,
+      const OpenCVDistortionParametersT<T>& params = OpenCVDistortionParametersT<T>{});
+
+  [[nodiscard]] T fx() const final {
+    return fx_;
+  }
+  [[nodiscard]] T fy() const final {
+    return fy_;
+  }
+  [[nodiscard]] T cx() const {
+    return cx_;
+  }
+  [[nodiscard]] T cy() const {
+    return cy_;
+  }
+
+  /// Get the distortion parameters.
+  /// @return Reference to the OpenCV distortion parameters
+  [[nodiscard]] const OpenCVDistortionParametersT<T>& distortionParameters() const {
+    return distortionParams_;
+  }
+
+  [[nodiscard]] std::pair<Vector3xP<T>, typename PacketType_t<T>::MaskType> project(
+      const Vector3xP<T>& point) const final;
+
+  [[nodiscard]] std::pair<Eigen::Vector3<T>, bool> project(
+      const Eigen::Vector3<T>& point) const final;
+
+  [[nodiscard]] std::tuple<Eigen::Vector3<T>, Eigen::Matrix<T, 3, 3>, bool> projectJacobian(
+      const Eigen::Vector3<T>& point) const final;
+
+  [[nodiscard]] std::pair<Eigen::Vector3<T>, bool> unproject(
+      const Eigen::Vector3<T>& imagePoint,
+      int maxIterations = 10,
+      T tolerance = T(1e-6)) const final;
+
+  [[nodiscard]] std::shared_ptr<const IntrinsicsModelT<T>> resize(
+      int32_t imageWidth,
+      int32_t imageHeight) const final;
+
+  [[nodiscard]] std::shared_ptr<const IntrinsicsModelT<T>>
+  crop(int32_t top, int32_t left, int32_t newWidth, int32_t newHeight) const final;
+
+ private:
+  T fx_;
+  T fy_;
+  T cx_;
+  T cy_;
+  const OpenCVDistortionParametersT<T> distortionParams_;
+};
+
+// Type aliases for common instantiations
+using IntrinsicsModel = IntrinsicsModelT<float>;
+using IntrinsicsModeld = IntrinsicsModelT<double>;
+using Camera = CameraT<float>;
+using Camerad = CameraT<double>;
+using PinholeIntrinsicsModel = PinholeIntrinsicsModelT<float>;
+using PinholeIntrinsicsModeld = PinholeIntrinsicsModelT<double>;
+using OpenCVIntrinsicsModel = OpenCVIntrinsicsModelT<float>;
+using OpenCVIntrinsicsModeld = OpenCVIntrinsicsModelT<double>;
+using OpenCVDistortionParameters = OpenCVDistortionParametersT<float>;
+using OpenCVDistortionParametersd = OpenCVDistortionParametersT<double>;
+
+} // namespace momentum::rasterizer

include/momentum/rasterizer/fwd.h

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <drjit/fwd.h>
+
+namespace momentum::rasterizer {
+
+template <typename T>
+class CameraT;
+
+template <typename T>
+class IntrinsicsModelT;
+
+using Camera = CameraT<float>;
+using IntrinsicsModel = IntrinsicsModelT<float>;
+
+constexpr size_t kSimdPacketSize = drjit::DefaultSize;
+constexpr size_t kSimdAlignment = 4 * kSimdPacketSize;
+
+using IntP = drjit::Packet<int32_t, kSimdPacketSize>;
+using UintP = drjit::Packet<uint32_t, kSimdPacketSize>;
+using Uint8P = drjit::Packet<uint8_t, kSimdPacketSize>;
+
+using FloatP = drjit::Packet<float, kSimdPacketSize>;
+using DoubleP = drjit::Packet<double, kSimdPacketSize>;
+using ByteP = drjit::Packet<uint8_t, kSimdPacketSize>;
+using Vector3f = drjit::Array<float, 3>;
+using Vector3d = drjit::Array<double, 3>;
+using Vector3b = drjit::Array<uint8_t, 3>;
+using Vector2f = drjit::Array<float, 2>;
+using Vector2d = drjit::Array<double, 2>;
+using Matrix3f = drjit::Matrix<float, 3>;
+using Matrix3d = drjit::Matrix<double, 3>;
+using Matrix4f = drjit::Matrix<float, 4>;
+using Matrix4d = drjit::Matrix<double, 4>;
+using Vector2fP = drjit::Array<FloatP, 2>;
+using Vector2dP = drjit::Array<DoubleP, 2>;
+using Vector2iP = drjit::Array<IntP, 2>;
+using Vector3fP = drjit::Array<FloatP, 3>;
+using Vector3dP = drjit::Array<DoubleP, 3>;
+using Vector3bP = drjit::Array<ByteP, 3>;
+using Vector3iP = drjit::Array<IntP, 3>;
+using Vector4fP = drjit::Array<FloatP, 4>;
+using Vector4dP = drjit::Array<DoubleP, 4>;
+using Matrix3fP = drjit::Matrix<FloatP, 3>;
+using Matrix3dP = drjit::Matrix<DoubleP, 3>;
+
+// Template metafunction to map scalar types to their packet equivalents
+template <typename T>
+struct PacketType;
+
+template <>
+struct PacketType<float> {
+  using type = FloatP;
+};
+
+template <>
+struct PacketType<double> {
+  using type = DoubleP;
+};
+
+template <>
+struct PacketType<int32_t> {
+  using type = IntP;
+};
+
+template <>
+struct PacketType<uint32_t> {
+  using type = UintP;
+};
+
+template <>
+struct PacketType<uint8_t> {
+  using type = ByteP;
+};
+
+template <typename T>
+using PacketType_t = typename PacketType<T>::type;
+
+// Templatized vector and matrix definitions
+template <typename T>
+using Vector2xP = drjit::Array<PacketType_t<T>, 2>;
+
+template <typename T>
+using Vector3xP = drjit::Array<PacketType_t<T>, 3>;
+
+template <typename T>
+using Vector4xP = drjit::Array<PacketType_t<T>, 4>;
+
+template <typename T>
+using Matrix3xP = drjit::Matrix<PacketType_t<T>, 3>;
+
+template <typename T>
+using Matrix4xP = drjit::Matrix<PacketType_t<T>, 4>;
+
+} // namespace momentum::rasterizer

include/momentum/rasterizer/geometry.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <momentum/math/mesh.h>
+#include <momentum/rasterizer/camera.h>
+#include <Eigen/Core>
+#include <utility>
+
+namespace momentum::rasterizer {
+
+using RowMatrixXf = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+using RowMatrixXi = Eigen::Matrix<int, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+
+/// Use the momentum Mesh class as the rasterizer Mesh type
+using Mesh = momentum::MeshT<float>;
+
+// Utility functions for creating primitives.
+Mesh makeSphere(int subdivisionLevel);
+Mesh makeCylinder(int numCircleSubdivisions, int numLengthSubdivisions);
+std::array<Mesh, 2> makeCheckerboard(float width, int numChecks, int subdivisions);
+
+Mesh makeCapsule(
+    int numCircleSubdivisions,
+    int numLengthSubdivisions,
+    float startRadius = 1.0,
+    float endRadius = 1.0,
+    float length = 1.0);
+
+Mesh makeArrow(
+    int numCircleSubdivisions,
+    int numLengthSubdivisions,
+    float innerRadius,
+    float outerRadius,
+    float tipLength,
+    float cylinderLength);
+
+Mesh makeArrowhead(
+    int numCircleSubdivisions,
+    float innerRadius,
+    float outerRadius,
+    float length,
+    float translation);
+
+// Creates an octahedron which is basically two pyramids stuck together.
+// "radius" is the width around the middle (where the two pyramid bases meet).
+// "midFraction" is the ratio of the two pyramid heights.
+std::tuple<Mesh, std::vector<Eigen::Vector3f>> makeOctahedron(
+    float radius = 0.5,
+    float midFraction = 0.5);
+
+Eigen::Matrix4f
+makeCylinderTransform(const Eigen::Vector3f& startPos, const Eigen::Vector3f& endPos, float radius);
+
+Eigen::Matrix4f makeSphereTransform(const Eigen::Vector3f& center, float radius);
+
+// Subdivides the lines until the longest segment is no longer than maxLength, except that it won't
+// generate more than maxSubdivisions segments for each line (to prevent infinite recursion).
+std::vector<Eigen::Vector3f> subdivideLines(
+    const std::vector<Eigen::Vector3f>& lines,
+    float maxLength,
+    size_t maxSubdivisions = 100);
+
+std::tuple<RowMatrixXf, RowMatrixXf, RowMatrixXi, RowMatrixXf, RowMatrixXi>
+subdivideMeshNoSmoothing(
+    Eigen::Ref<const RowMatrixXf> vertices_orig,
+    Eigen::Ref<const RowMatrixXf> normals_orig,
+    Eigen::Ref<const RowMatrixXi> triangles_orig,
+    Eigen::Ref<const RowMatrixXf> textureCoords_orig,
+    Eigen::Ref<const RowMatrixXi> textureTriangles_orig,
+    float max_edge_length);
+
+Mesh subdivideMeshNoSmoothing(const Mesh& mesh, float max_edge_length, size_t max_depth = 3);
+
+std::vector<Eigen::Vector3f>
+makeCameraFrustumLines(const Camera& camera, float distance, size_t nSamples = 20);
+
+} // namespace momentum::rasterizer

include/momentum/rasterizer/image.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <momentum/rasterizer/fwd.h>
+#include <momentum/rasterizer/rasterizer.h>
+
+namespace momentum::rasterizer {
+
+template <typename T>
+void alphaMatte(Span2f zBuffer, Span3f rgbBuffer, const Span<T, 3>& tgtImage, float alpha = 1.0f);
+
+} // namespace momentum::rasterizer