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

include/momentum/math/fwd.h

@@ -0,0 +1,132 @@
+/*
+ * 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.
+ */
+
+// This file is @generated by gen_fwd.py
+// Do not edit this file directly, instead update gen_fwd_input.toml and run:
+// buck run @arvr/mode/platform010/opt //arvr/libraries/momentum:gen_fwd
+
+#pragma once
+
+#include <memory>
+
+namespace momentum {
+
+template <typename T>
+struct MeshT;
+using Mesh = MeshT<float>;
+using Meshd = MeshT<double>;
+
+using Mesh_p = ::std::shared_ptr<Mesh>;
+using Mesh_u = ::std::unique_ptr<Mesh>;
+using Mesh_w = ::std::weak_ptr<Mesh>;
+using Mesh_const_p = ::std::shared_ptr<const Mesh>;
+using Mesh_const_u = ::std::unique_ptr<const Mesh>;
+using Mesh_const_w = ::std::weak_ptr<const Mesh>;
+
+using Meshd_p = ::std::shared_ptr<Meshd>;
+using Meshd_u = ::std::unique_ptr<Meshd>;
+using Meshd_w = ::std::weak_ptr<Meshd>;
+using Meshd_const_p = ::std::shared_ptr<const Meshd>;
+using Meshd_const_u = ::std::unique_ptr<const Meshd>;
+using Meshd_const_w = ::std::weak_ptr<const Meshd>;
+
+template <typename T>
+struct MppcaT;
+using Mppca = MppcaT<float>;
+using Mppcad = MppcaT<double>;
+
+using Mppca_p = ::std::shared_ptr<Mppca>;
+using Mppca_u = ::std::unique_ptr<Mppca>;
+using Mppca_w = ::std::weak_ptr<Mppca>;
+using Mppca_const_p = ::std::shared_ptr<const Mppca>;
+using Mppca_const_u = ::std::unique_ptr<const Mppca>;
+using Mppca_const_w = ::std::weak_ptr<const Mppca>;
+
+using Mppcad_p = ::std::shared_ptr<Mppcad>;
+using Mppcad_u = ::std::unique_ptr<Mppcad>;
+using Mppcad_w = ::std::weak_ptr<Mppcad>;
+using Mppcad_const_p = ::std::shared_ptr<const Mppcad>;
+using Mppcad_const_u = ::std::unique_ptr<const Mppcad>;
+using Mppcad_const_w = ::std::weak_ptr<const Mppcad>;
+
+template <typename T>
+struct TransformT;
+using Transform = TransformT<float>;
+using Transformd = TransformT<double>;
+
+using Transform_p = ::std::shared_ptr<Transform>;
+using Transform_u = ::std::unique_ptr<Transform>;
+using Transform_w = ::std::weak_ptr<Transform>;
+using Transform_const_p = ::std::shared_ptr<const Transform>;
+using Transform_const_u = ::std::unique_ptr<const Transform>;
+using Transform_const_w = ::std::weak_ptr<const Transform>;
+
+using Transformd_p = ::std::shared_ptr<Transformd>;
+using Transformd_u = ::std::unique_ptr<Transformd>;
+using Transformd_w = ::std::weak_ptr<Transformd>;
+using Transformd_const_p = ::std::shared_ptr<const Transformd>;
+using Transformd_const_u = ::std::unique_ptr<const Transformd>;
+using Transformd_const_w = ::std::weak_ptr<const Transformd>;
+
+template <typename T>
+class LowRankCovarianceMatrixT;
+using LowRankCovarianceMatrix = LowRankCovarianceMatrixT<float>;
+using LowRankCovarianceMatrixd = LowRankCovarianceMatrixT<double>;
+
+using LowRankCovarianceMatrix_p = ::std::shared_ptr<LowRankCovarianceMatrix>;
+using LowRankCovarianceMatrix_u = ::std::unique_ptr<LowRankCovarianceMatrix>;
+using LowRankCovarianceMatrix_w = ::std::weak_ptr<LowRankCovarianceMatrix>;
+using LowRankCovarianceMatrix_const_p = ::std::shared_ptr<const LowRankCovarianceMatrix>;
+using LowRankCovarianceMatrix_const_u = ::std::unique_ptr<const LowRankCovarianceMatrix>;
+using LowRankCovarianceMatrix_const_w = ::std::weak_ptr<const LowRankCovarianceMatrix>;
+
+using LowRankCovarianceMatrixd_p = ::std::shared_ptr<LowRankCovarianceMatrixd>;
+using LowRankCovarianceMatrixd_u = ::std::unique_ptr<LowRankCovarianceMatrixd>;
+using LowRankCovarianceMatrixd_w = ::std::weak_ptr<LowRankCovarianceMatrixd>;
+using LowRankCovarianceMatrixd_const_p = ::std::shared_ptr<const LowRankCovarianceMatrixd>;
+using LowRankCovarianceMatrixd_const_u = ::std::unique_ptr<const LowRankCovarianceMatrixd>;
+using LowRankCovarianceMatrixd_const_w = ::std::weak_ptr<const LowRankCovarianceMatrixd>;
+
+template <typename T>
+class GeneralizedLossT;
+using GeneralizedLoss = GeneralizedLossT<float>;
+using GeneralizedLossd = GeneralizedLossT<double>;
+
+using GeneralizedLoss_p = ::std::shared_ptr<GeneralizedLoss>;
+using GeneralizedLoss_u = ::std::unique_ptr<GeneralizedLoss>;
+using GeneralizedLoss_w = ::std::weak_ptr<GeneralizedLoss>;
+using GeneralizedLoss_const_p = ::std::shared_ptr<const GeneralizedLoss>;
+using GeneralizedLoss_const_u = ::std::unique_ptr<const GeneralizedLoss>;
+using GeneralizedLoss_const_w = ::std::weak_ptr<const GeneralizedLoss>;
+
+using GeneralizedLossd_p = ::std::shared_ptr<GeneralizedLossd>;
+using GeneralizedLossd_u = ::std::unique_ptr<GeneralizedLossd>;
+using GeneralizedLossd_w = ::std::weak_ptr<GeneralizedLossd>;
+using GeneralizedLossd_const_p = ::std::shared_ptr<const GeneralizedLossd>;
+using GeneralizedLossd_const_u = ::std::unique_ptr<const GeneralizedLossd>;
+using GeneralizedLossd_const_w = ::std::weak_ptr<const GeneralizedLossd>;
+
+template <typename T>
+class SimdGeneralizedLossT;
+using SimdGeneralizedLoss = SimdGeneralizedLossT<float>;
+using SimdGeneralizedLossd = SimdGeneralizedLossT<double>;
+
+using SimdGeneralizedLoss_p = ::std::shared_ptr<SimdGeneralizedLoss>;
+using SimdGeneralizedLoss_u = ::std::unique_ptr<SimdGeneralizedLoss>;
+using SimdGeneralizedLoss_w = ::std::weak_ptr<SimdGeneralizedLoss>;
+using SimdGeneralizedLoss_const_p = ::std::shared_ptr<const SimdGeneralizedLoss>;
+using SimdGeneralizedLoss_const_u = ::std::unique_ptr<const SimdGeneralizedLoss>;
+using SimdGeneralizedLoss_const_w = ::std::weak_ptr<const SimdGeneralizedLoss>;
+
+using SimdGeneralizedLossd_p = ::std::shared_ptr<SimdGeneralizedLossd>;
+using SimdGeneralizedLossd_u = ::std::unique_ptr<SimdGeneralizedLossd>;
+using SimdGeneralizedLossd_w = ::std::weak_ptr<SimdGeneralizedLossd>;
+using SimdGeneralizedLossd_const_p = ::std::shared_ptr<const SimdGeneralizedLossd>;
+using SimdGeneralizedLossd_const_u = ::std::unique_ptr<const SimdGeneralizedLossd>;
+using SimdGeneralizedLossd_const_w = ::std::weak_ptr<const SimdGeneralizedLossd>;
+
+} // namespace momentum

include/momentum/math/generalized_loss.h

@@ -0,0 +1,61 @@
+/*
+ * 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
+
+namespace momentum {
+
+/// Implementation of "A General and Adaptive Robust Loss Function"
+/// (https://arxiv.org/abs/1701.03077).
+/// This loss transforms a squared error value with parameters alpha and c.
+/// Alpha can be approximately thought of as the norm: alpha=2 is the squared L2 norm loss; alpha=1
+/// is a soft L1 norm or the L2-L1/pseudo-Huber loss. Alpha controls the effect of "outliers" (ie.
+/// "robust"). Smaller alpha reduces the contribution of large errors so they don't affect the
+/// result as much. c scales the gradient with respect to the squared error term inversely.
+/// This does not implement solving for alpha. It assumes alpha and c are given as input.
+template <typename T>
+class GeneralizedLossT {
+ public:
+  // Special case alpha values that are either at singularity or would simplify computation
+  static constexpr T kL2 = T(2);
+  static constexpr T kL1 = T(1);
+  static constexpr T kCauchy = T(0);
+  static constexpr T kWelsch = -1e-9; // any number smaller is considered -inf
+
+  // Alpha can be [-inf, inf] in theory, but it will be numerically unstable if
+  // alpha is too large, eg. >100 (large alpha not needed in practice).
+  // Similarly, c scales the gradient inversely and quadratically. So too small a value for c will
+  // lead to instability.
+  // Calculations with log and exp usually require double precision.
+  GeneralizedLossT(const T& a = kL2, const T& c = T(1));
+
+  [[nodiscard]] T value(const T& sqrError) const;
+
+  /// Derivative of the loss with respective to the input squared error.
+  /// This effectively scales the gradient of what's being squared.
+  [[nodiscard]] T deriv(const T& sqrError) const;
+
+ protected:
+  enum class LossType {
+    L1,
+    L2,
+    Cauchy,
+    Welsch,
+    General,
+  };
+
+  // A small threshold for special values
+  static constexpr T kEps = 1e-9;
+
+  const T alpha_;
+
+  // store 1/c^2 instead of c as a small optimization
+  const T invC2_;
+
+  LossType lossType_;
+};
+} // namespace momentum

include/momentum/math/intersection.h

@@ -0,0 +1,32 @@
+/*
+ * 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/fwd.h>
+#include <momentum/math/types.h>
+
+namespace momentum {
+
+/// test whether two given faces of a mesh intersect with each other
+template <typename T>
+bool intersectFace(
+    const MeshT<T>& mesh,
+    const std::vector<Vector3<T>>& faceNormals,
+    int32_t face0,
+    int32_t face1);
+
+/// test if the mesh self intersects anywhere and return all intersecting face pairs using brute
+/// force
+template <typename T>
+std::vector<std::pair<int32_t, int32_t>> intersectMeshBruteForce(const MeshT<T>& mesh);
+/// test if the mesh self intersects anywhere and return all intersecting face pairs using a bvh
+/// tree
+template <typename T>
+std::vector<std::pair<int32_t, int32_t>> intersectMesh(const MeshT<T>& mesh);
+
+} // namespace momentum

include/momentum/math/mesh.h

@@ -0,0 +1,84 @@
+/*
+ * 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/fwd.h>
+#include <momentum/math/types.h>
+
+namespace momentum {
+
+/// A generic mesh representation with support for vertices, faces, lines, and texture coordinates.
+///
+/// @tparam T The scalar type used for vertex coordinates and confidence values (typically float or
+/// double)
+template <typename T>
+struct MeshT {
+  /// List of mesh vertices in 3D space
+  std::vector<Eigen::Vector3<T>> vertices;
+
+  /// List of vertex normals (same size as vertices when computed)
+  std::vector<Eigen::Vector3<T>> normals;
+
+  /// List of triangular faces defined by vertex indices
+  std::vector<Eigen::Vector3i> faces;
+
+  /// List of polylines defined by vertex indices
+  /// Each inner vector represents a single polyline
+  std::vector<std::vector<int32_t>> lines;
+
+  /// List of per-vertex RGB colors (0-255 for each channel)
+  std::vector<Eigen::Vector3b> colors;
+
+  /// List of per-vertex confidence values
+  /// Higher values typically indicate higher confidence in the vertex position
+  std::vector<T> confidence;
+
+  /// List of texture coordinates (UV coordinates).
+  ///
+  /// The texture coordinates are format-agnostic, and it's the user's responsibility to ensure
+  /// their consistent use.
+  ///
+  /// For GLTF, Momentum stores and saves the texture coordinates as they are represented by the
+  /// underlying GLTF parser. When dealing with FBX, the Y-axis is flipped. This distinction is
+  /// crucial to understand when working with different formats.
+  std::vector<Eigen::Vector2f> texcoords;
+
+  /// List of texture coordinate indices per face
+  /// Maps each face to its corresponding texture coordinates
+  std::vector<Eigen::Vector3i> texcoord_faces;
+
+  /// List of texture coordinate indices per line
+  /// Maps each line to its corresponding texture coordinates
+  std::vector<std::vector<int32_t>> texcoord_lines;
+
+  /// Compute vertex normals by averaging connected face normals.
+  ///
+  /// This method calculates normals for each vertex by averaging the normals of all
+  /// connected faces. The resulting normals are normalized to unit length.
+  /// If a vertex is part of a degenerate face (e.g., colinear vertices), that face
+  /// will not contribute to the vertex normal.
+  void updateNormals();
+
+  /// Cast the mesh to a different scalar type.
+  ///
+  /// This method creates a new mesh with all numeric data converted to the target type.
+  /// Vertex positions, normals, and confidence values are cast to the new type.
+  /// Non-numeric data like faces and lines remain unchanged.
+  ///
+  /// @tparam T2 The target scalar type
+  /// @return A new mesh with the target scalar type
+  template <typename T2>
+  [[nodiscard]] MeshT<T2> cast() const;
+
+  /// Reset the mesh by clearing all data.
+  ///
+  /// This method clears all vectors, effectively resetting the mesh to an empty state.
+  void reset();
+};
+
+} // namespace momentum

include/momentum/math/mppca.h

@@ -0,0 +1,67 @@
+/*
+ * 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/utility.h>
+
+namespace momentum {
+
+/// Mixture of Probabilistic Principal Component Analysis (MPPCA)
+/// Based on: http://www.miketipping.com/papers/met-mppca.pdf
+///
+/// @tparam T Scalar type (float or double)
+template <typename T>
+struct MppcaT {
+  /// Dimension of data space
+  size_t d = 0;
+
+  /// Number of mixture components
+  size_t p = 0;
+
+  /// Parameter names (should match dimension d)
+  std::vector<std::string> names;
+
+  /// Mean vectors (p×d matrix)
+  Eigen::MatrixX<T> mu;
+
+  /// Inverse covariance matrices
+  std::vector<Eigen::MatrixX<T>> Cinv;
+
+  /// Matrices for efficient computation
+  std::vector<Eigen::MatrixX<T>> L;
+
+  /// Precomputed responsibility terms
+  Eigen::VectorX<T> Rpre;
+
+  /// Sets model parameters and precomputes matrices
+  ///
+  /// @param[in] pi Mixture weights
+  /// @param[in] mmu Mean vectors
+  /// @param[in] W Principal axes matrices
+  /// @param[in] sigma2 Noise variances
+  void set(
+      const VectorX<T>& pi,
+      const MatrixX<T>& mmu,
+      gsl::span<const MatrixX<T>> W,
+      const VectorX<T>& sigma2);
+
+  /// Converts to a different scalar type
+  ///
+  /// @tparam T2 Target scalar type
+  /// @return Converted MPPCA model
+  template <typename T2>
+  [[nodiscard]] MppcaT<T2> cast() const;
+
+  /// Checks approximate equality with another model
+  ///
+  /// @param[in] mppcaT Model to compare with
+  /// @return true if approximately equal
+  [[nodiscard]] bool isApprox(const MppcaT<T>& mppcaT) const;
+};
+
+} // namespace momentum