PyRXMesh 0.2.1rc0__cp311-cp311-win_amd64.whl

pyrxmesh/__init__.py

@@ -0,0 +1,382 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+_dll_handles = []
+
+
+def _add_windows_dll_dir(path: Path) -> None:
+    if os.name != "nt" or not path.exists():
+        return
+    try:
+        handle = os.add_dll_directory(str(path))
+    except (FileNotFoundError, OSError):
+        return
+    _dll_handles.append(handle)
+
+
+def _prepare_dll_search_path() -> None:
+    if os.name != "nt":
+        return
+
+    package_dir = Path(__file__).resolve().parent
+    _add_windows_dll_dir(package_dir)
+    _add_windows_dll_dir(package_dir / "bin")
+    _add_windows_dll_dir(package_dir / "lib")
+
+    for env_name in ("CUDA_PATH", "CUDA_HOME"):
+        cuda_root = os.environ.get(env_name)
+        if cuda_root:
+            _add_windows_dll_dir(Path(cuda_root) / "bin")
+
+    for env_name, cuda_root in os.environ.items():
+        if env_name.startswith("CUDA_PATH_V") and cuda_root:
+            _add_windows_dll_dir(Path(cuda_root) / "bin")
+
+    default_cuda_root = Path("C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA")
+    if default_cuda_root.exists():
+        for cuda_bin in sorted(default_cuda_root.glob("v*/bin"), reverse=True):
+            _add_windows_dll_dir(cuda_bin)
+
+
+_prepare_dll_search_path()
+
+_extension_import_error: ModuleNotFoundError | None = None
+
+try:
+    from ._rxmesh import (
+        Attribute,
+        CGSolver,        
+        CholeskySolver,
+        DEdgeHandle,
+        DType,
+        DenseMatrix,
+        EdgeAttributeFloat32,
+        EdgeAttributeFloat64,
+        EdgeAttributeInt32,
+        EdgeAttributeInt8,
+        EdgeHandle,
+        ElementKind,
+        FaceAttributeFloat32,
+        FaceAttributeFloat64,
+        FaceAttributeInt32,
+        FaceAttributeInt8,
+        FaceHandle,
+        HessianSparseMatrix,
+        JacobianSparseMatrix,
+        Layout,
+        Location,
+        LogLevel,
+        Op,
+        PCGSolver,
+        QRSolver,
+        RXMeshStatic,
+        LUSolver,
+        SparseMatrix,
+        VertexAttributeFloat32,
+        VertexAttributeFloat64,
+        VertexAttributeInt32,
+        VertexAttributeInt8,
+        VertexHandle,
+        abi_version,
+        build_config_tag,
+        create_plane,
+        cuda_stream_synchronize,
+        cuDSSCholeskySolver,
+        has_cudss,
+        init,
+        show,
+    )
+except ModuleNotFoundError as exc:
+    if exc.name != f"{__name__}._rxmesh":
+        raise
+    _extension_import_error = exc
+    __all__ = []
+else:
+    __all__ = [
+        "Attribute",
+        "CGSolver",        
+        "CholeskySolver",
+        "DEdgeHandle",
+        "DType",
+        "DenseMatrix",
+        "EdgeAttributeFloat32",
+        "EdgeAttributeFloat64",
+        "EdgeAttributeInt32",
+        "EdgeAttributeInt8",
+        "EdgeHandle",
+        "ElementKind",
+        "FaceAttributeFloat32",
+        "FaceAttributeFloat64",
+        "FaceAttributeInt32",
+        "FaceAttributeInt8",
+        "FaceHandle",
+        "HessianSparseMatrix",
+        "JacobianSparseMatrix",
+        "Layout",
+        "Location",
+        "LogLevel",
+        "Op",
+        "PCGSolver",
+        "QRSolver",
+        "RXMeshStatic",
+        "LUSolver",
+        "SparseMatrix",
+        "VertexAttributeFloat32",
+        "VertexAttributeFloat64",
+        "VertexAttributeInt32",
+        "VertexAttributeInt8",
+        "VertexHandle",
+        "abi_version",
+        "build_config_tag",
+        "create_plane",
+        "cuda_stream_synchronize",
+        "cuDSSCholeskySolver",
+        "has_cudss",
+        "init",
+        "show",
+    ]
+
+    def _require_torch():
+        try:
+            import torch
+        except ImportError as exc:
+            raise ImportError(
+                "PyTorch is required for PyRXMesh torch interop helpers. "
+                "Install torch or use the DLPack/NumPy APIs directly."
+            ) from exc
+        return torch
+
+    class _DenseMatrixDlpackView:
+        def __init__(self, matrix, location):
+            self._matrix = matrix
+            self._location = location
+            self._is_host = location == Location.HOST
+            self._is_device = location == Location.DEVICE
+
+        def __dlpack__(self, stream=None):
+            return self._matrix.to_dlpack(self._location, stream=stream)
+
+        def __dlpack_device__(self):
+            if self._is_host:
+                return (1, 0)
+            if self._is_device:
+                torch = _require_torch()
+                return (2, torch.cuda.current_device())
+            raise ValueError(
+                "DenseMatrix.to_torch() location must be Location.HOST or "
+                "Location.DEVICE."
+            )
+
+    class _SparseMatrixDlpackView:
+        def __init__(self, matrix, location, component):
+            self._matrix = matrix
+            self._location = location
+            self._component = component
+            self._is_host = location == Location.HOST
+            self._is_device = location == Location.DEVICE
+
+        def __dlpack__(self, stream=None):
+            if self._component == "row_ptr":
+                return self._matrix._row_ptr_dlpack(
+                    self._location,
+                    stream=stream,
+                )
+            if self._component == "col_idx":
+                return self._matrix._col_indices_dlpack(
+                    self._location,
+                    stream=stream,
+                )
+            if self._component == "values":
+                return self._matrix._values_dlpack(
+                    self._location,
+                    stream=stream,
+                )
+            raise ValueError("Unsupported SparseMatrix DLPack component.")
+
+        def __dlpack_device__(self):
+            if self._is_host:
+                return (1, 0)
+            if self._is_device:
+                torch = _require_torch()
+                return (2, torch.cuda.current_device())
+            raise ValueError(
+                "SparseMatrix.to_torch() location must be Location.HOST or "
+                "Location.DEVICE."
+            )
+
+    def _dense_matrix_to_torch(self, location=Location.DEVICE):
+        torch = _require_torch()
+        return torch.utils.dlpack.from_dlpack(
+            _DenseMatrixDlpackView(self, location)
+        )
+
+    def _dense_matrix_from_torch_copy(source):
+        tensor = source.detach() if hasattr(source, "detach") else source
+        return DenseMatrix.from_dlpack_copy(tensor)
+
+    def _sparse_matrix_to_torch(self, location=Location.DEVICE):
+        torch = _require_torch()
+        crow = torch.utils.dlpack.from_dlpack(
+            _SparseMatrixDlpackView(self, location, "row_ptr")
+        )
+        col = torch.utils.dlpack.from_dlpack(
+            _SparseMatrixDlpackView(self, location, "col_idx")
+        )
+        val = torch.utils.dlpack.from_dlpack(
+            _SparseMatrixDlpackView(self, location, "values")
+        )
+        return torch.sparse_csr_tensor(
+            crow,
+            col,
+            val,
+            size=self.shape,
+            device=val.device,
+        )
+
+    def _sparse_matrix_from_torch_values_copy(
+        self,
+        values,
+        target=Location.ALL,
+        stream=None,
+    ):
+        tensor = values.detach() if hasattr(values, "detach") else values
+        self.from_dlpack_values_copy(tensor, target=target, stream=stream)
+        return self
+
+    def _torch_dtype_name(dtype):
+        torch = _require_torch()
+        if dtype == torch.float32:
+            return "float32"
+        if dtype == torch.float64:
+            return "float64"
+        if dtype == torch.int32:
+            return "int32"
+        raise TypeError(f"Unsupported torch dtype for PyRXMesh copy: {dtype}")
+
+    def _sparse_matrix_from_torch_copy(source, dtype=None, stream=None):
+        torch = _require_torch()
+        if source.layout != torch.sparse_csr:
+            raise TypeError(
+                "SparseMatrix.from_torch_copy() expects a torch sparse CSR "
+                "tensor."
+            )
+        value_dtype = dtype or _torch_dtype_name(source.values().dtype)
+        return SparseMatrix.from_dlpack_copy(
+            source.crow_indices().detach(),
+            source.col_indices().detach(),
+            source.values().detach(),
+            tuple(source.shape),
+            dtype=value_dtype,
+            stream=stream,
+        )
+
+    def _attribute_to_torch(self, location=Location.DEVICE):
+        torch = _require_torch()
+        return torch.utils.dlpack.from_dlpack(self.to_dlpack(location))
+
+    def _attribute_from_torch_copy(self, values, target=Location.ALL):
+        tensor = values.detach() if hasattr(values, "detach") else values
+        self.from_dlpack_copy(tensor, target=target)
+        return self
+
+    def _sparse_matrix_to_scipy_csr(self):
+        try:
+            import scipy.sparse as scipy_sparse
+        except ImportError as exc:
+            raise ImportError(
+                "SciPy is required for SparseMatrix.to_scipy_csr(). "
+                "Install scipy or use to_numpy()."
+            ) from exc
+
+        row_ptr, col_idx, values = self.to_numpy(Location.HOST)
+        return scipy_sparse.csr_matrix((values, col_idx, row_ptr), shape=self.shape)
+
+    def _sparse_matrix_to_scipy_csr_copy(self, source=Location.HOST, stream=None):
+        try:
+            import scipy.sparse as scipy_sparse
+        except ImportError as exc:
+            raise ImportError(
+                "SciPy is required for SparseMatrix.to_scipy_csr_copy(). "
+                "Install scipy or use to_numpy_copy()."
+            ) from exc
+
+        row_ptr, col_idx, values = self.to_numpy_copy(source=source, stream=stream)
+        return scipy_sparse.csr_matrix((values, col_idx, row_ptr), shape=self.shape)
+
+    _native_sparse_matrix_multiply_vector = SparseMatrix.multiply_vector
+
+    def _sparse_matrix_multiply_vector(
+        self,
+        vector,
+        stream=None,
+    ):
+        if isinstance(vector, DenseMatrix):
+            return _native_sparse_matrix_multiply_vector(
+                self,
+                vector,
+                stream,
+            )
+
+        import numpy as np
+
+        values = np.asarray(vector)
+        if values.ndim == 1:
+            values = values.reshape(-1, 1)
+        if values.ndim != 2 or values.shape[1] != 1:
+            raise ValueError(
+                "SparseMatrix.multiply_vector() expects a 1D array or a "
+                "DenseMatrix/array with shape (cols, 1)."
+            )
+        if values.shape[0] != self.cols:
+            raise ValueError(
+                "SparseMatrix.multiply_vector() vector length must match matrix.cols."
+            )
+
+        dense = DenseMatrix(
+            self.cols,
+            1,
+            dtype=self.dtype,
+            location=Location.ALL,
+        )
+        dense.from_numpy_copy(values, target=Location.ALL, stream=stream)
+        return _native_sparse_matrix_multiply_vector(self, dense, stream)
+
+    DenseMatrix.to_torch = _dense_matrix_to_torch
+    DenseMatrix.from_torch_copy = staticmethod(_dense_matrix_from_torch_copy)
+    SparseMatrix.to_torch = _sparse_matrix_to_torch
+    SparseMatrix.from_torch_copy = staticmethod(_sparse_matrix_from_torch_copy)
+    SparseMatrix.from_torch_values_copy = _sparse_matrix_from_torch_values_copy
+    SparseMatrix.to_scipy_csr = _sparse_matrix_to_scipy_csr
+    SparseMatrix.to_scipy_csr_copy = _sparse_matrix_to_scipy_csr_copy
+    SparseMatrix.multiply_vector = _sparse_matrix_multiply_vector
+    _attribute_types = (
+        Attribute,
+        VertexAttributeFloat32,
+        VertexAttributeFloat64,
+        VertexAttributeInt32,
+        VertexAttributeInt8,
+        EdgeAttributeFloat32,
+        EdgeAttributeFloat64,
+        EdgeAttributeInt32,
+        EdgeAttributeInt8,
+        FaceAttributeFloat32,
+        FaceAttributeFloat64,
+        FaceAttributeInt32,
+        FaceAttributeInt8,
+    )
+    for _attribute_type in _attribute_types:
+        _attribute_type.to_torch = _attribute_to_torch
+        _attribute_type.from_torch_copy = _attribute_from_torch_copy
+    del _attribute_type, _attribute_types
+
+
+def __getattr__(name: str):
+    if _extension_import_error is not None:
+        raise ModuleNotFoundError(
+            "pyrxmesh._rxmesh is not installed yet. Build/install PyRXMesh "
+            "before using runtime mesh bindings."
+        ) from _extension_import_error
+    raise AttributeError(name)

pyrxmesh/build_config.json

@@ -0,0 +1,13 @@
+{
+  "abi_version": "2",
+  "pyrxmesh_version": "0.2.1rc0",
+  "build_config_tag": "abi=2,pyrxmesh=0.2.1rc0,rxmesh_repo=https://github.com/owensgroup/RXMesh.git,rxmesh_tag=main,rxmesh_source=,polyscope=ON,double=OFF,cudss=OFF,suitesparse=OFF,cuda_arch=89",
+  "rxmesh_git_repository": "https://github.com/owensgroup/RXMesh.git",
+  "rxmesh_git_tag": "main",
+  "rxmesh_source_dir": "",
+  "use_polyscope": "ON",
+  "use_double": "OFF",
+  "use_cudss": "OFF",
+  "use_suitesparse": "OFF",
+  "cuda_architectures": "89"
+}

pyrxmesh/cmake_dir.py

@@ -0,0 +1,17 @@
+"""Print the installed PyRXMesh CMake package directory."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def get_cmake_dir() -> Path:
+    return Path(__file__).resolve().parent / "cmake"
+
+
+def main() -> None:
+    print(get_cmake_dir())
+
+
+if __name__ == "__main__":
+    main()

pyrxmesh/diff.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from . import HessianSparseMatrix, JacobianSparseMatrix
+
+__all__ = [    
+    "HessianSparseMatrix",
+    "JacobianSparseMatrix",
+]

pyrxmesh/geometry.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from . import create_plane
+
+__all__ = ["create_plane"]

pyrxmesh/plugin.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+import argparse
+import re
+from pathlib import Path
+
+
+_MODULE_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+def _write(path: Path, content: str, force: bool) -> None:
+    if path.exists() and not force:
+        raise FileExistsError(f"{path} already exists; pass --force to overwrite it")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8", newline="\n")
+
+
+def _pyproject(module: str) -> str:
+    dist_name = module.replace("_", "-")
+    return f"""[build-system]
+requires = [
+    "scikit-build-core>=0.12",
+    "pybind11>=2.13",
+]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "{dist_name}"
+version = "0.1.0"
+description = "Custom PyRXMesh CUDA kernels"
+requires-python = ">=3.10"
+dependencies = [
+    "PyRXMesh",
+]
+
+[tool.scikit-build]
+minimum-version = "0.12"
+cmake.version = ">=3.24,<4"
+cmake.build-type = "Release"
+build-dir = "build/{{wheel_tag}}"
+wheel.packages = ["src/{module}"]
+build.targets = ["_{module}"]
+install.components = ["python"]
+"""
+
+
+def _cmake(module: str) -> str:
+    return f"""cmake_minimum_required(VERSION 3.24 FATAL_ERROR)
+
+if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES)
+    set(CMAKE_CUDA_ARCHITECTURES native)
+endif()
+
+project({module} LANGUAGES C CXX CUDA)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CUDA_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+set(CMAKE_CUDA_STANDARD_REQUIRED TRUE)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+find_package(Python3 REQUIRED COMPONENTS Interpreter Development.Module)
+
+execute_process(
+    COMMAND "${{Python3_EXECUTABLE}}" -m pyrxmesh.cmake_dir
+    OUTPUT_VARIABLE pyrxmesh_DIR
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    COMMAND_ERROR_IS_FATAL ANY
+)
+
+find_package(pyrxmesh CONFIG REQUIRED PATHS "${{pyrxmesh_DIR}}" NO_DEFAULT_PATH)
+
+pyrxmesh_add_plugin(_{module} src/{module}.cu)
+
+install(TARGETS _{module}
+    LIBRARY DESTINATION {module} COMPONENT python
+    RUNTIME DESTINATION {module} COMPONENT python
+)
+"""
+
+
+def _source(module: str) -> str:
+    return f"""#include <pybind11/pybind11.h>
+
+#include "pyrxmesh/plugin_api.h"
+
+namespace py = pybind11;
+using namespace rxmesh;
+
+void compute_edge_lengths(py::object mesh_obj,
+                          py::object coords_obj,
+                          py::object out_obj)
+{{
+    auto coords = pyrxmesh::vertex_attribute<float>(coords_obj);
+    auto out    = pyrxmesh::edge_attribute<float>(out_obj);
+
+    if (coords.get_num_attributes() < 3) {{
+        throw std::runtime_error("coords must have at least 3 values per vertex.");
+    }}
+    if (out.get_num_attributes() != 1) {{
+        throw std::runtime_error("out must have exactly 1 value per edge.");
+    }}
+
+    pyrxmesh::for_each<Op::EV, 256>(
+        mesh_obj,
+        [coords, out] __device__(const EdgeHandle& eh,
+                                 const VertexIterator& iter) mutable {{
+            const Eigen::Vector3f a = coords.to_eigen<3>(iter[0]);
+            const Eigen::Vector3f b = coords.to_eigen<3>(iter[1]);
+            out(eh) = (a - b).norm();
+        }});
+}}
+
+PYBIND11_MODULE(_{module}, m)
+{{
+    pyrxmesh::require_compatible_runtime(m);
+
+    m.def("compute_edge_lengths",
+          &compute_edge_lengths,
+          py::arg("mesh"),
+          py::arg("coords"),
+          py::arg("out"));
+}}
+"""
+
+
+def _init(module: str) -> str:
+    return f"""from __future__ import annotations
+
+from ._{module} import compute_edge_lengths
+
+__all__ = ["compute_edge_lengths"]
+"""
+
+
+def _readme(module: str) -> str:
+    return f"""# {module}
+
+Custom CUDA kernels for PyRXMesh.
+
+## Layout
+
+```text
+{module}/
+  pyproject.toml
+  CMakeLists.txt
+  src/
+    {module}.cu             # CUDA source for the plugin
+    {module}/__init__.py    # Python package source
+  my_script.py              # your own scripts can live here
+```
+
+Python sources live under `src/`, so the plugin root never shadows the
+installed package. Run scripts can sit at the plugin root and `import {module}`
+directly with no `sys.path` setup.
+
+## Build
+
+Build inside the same conda environment where `pyrxmesh` is installed:
+
+```bash
+python -m pip install -v --no-build-isolation .
+```
+
+After installation, `{module}` is available from any directory in the env,
+just like `pyrxmesh`.
+
+## Use from Python
+
+```python
+import pyrxmesh as rx
+import {module}
+
+mesh = rx.RXMeshStatic("mesh.obj")
+coords = mesh.input_vertex_coordinates()
+edge_lengths = mesh.add_edge_attribute("edge_lengths", dtype="float32", dim=1)
+
+{module}.compute_edge_lengths(mesh, coords, edge_lengths)
+print(edge_lengths.to_numpy_copy(source=rx.Location.DEVICE))
+```
+"""
+
+
+def init_plugin(module: str, output_dir: Path, force: bool = False) -> Path:
+    if not _MODULE_RE.match(module):
+        raise ValueError(
+            "Plugin module name must be a valid Python identifier, for example "
+            "'my_kernels'."
+        )
+
+    root = output_dir / module
+    root.mkdir(parents=True, exist_ok=True)
+
+    _write(root / "pyproject.toml", _pyproject(module), force)
+    _write(root / "CMakeLists.txt", _cmake(module), force)
+    _write(root / "README.md", _readme(module), force)
+    _write(root / "src" / f"{module}.cu", _source(module), force)
+    _write(root / "src" / module / "__init__.py", _init(module), force)
+
+    return root
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    init = subparsers.add_parser("init", help="Create a custom kernel plugin")
+    init.add_argument("module", help="Python module name, for example my_kernels")
+    init.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path.cwd(),
+        help="Directory where the plugin package directory will be created",
+    )
+    init.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite existing scaffold files",
+    )
+
+    args = parser.parse_args(argv)
+
+    if args.command == "init":
+        root = init_plugin(args.module, args.output_dir, args.force)
+        print(root)
+
+
+if __name__ == "__main__":
+    main()

pyrxmesh-0.2.1rc0.dist-info/METADATA

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: PyRXMesh
+Version: 0.2.1rc0
+Summary: Python bindings for RXMesh, a CUDA/C++ library for mesh processing on the GPU.
+Author: Ahmed Mahmoud
+License-Expression: BSD-2-Clause
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Project-URL: RXMesh, https://github.com/owensgroup/RXMesh
+Project-URL: Documentation, https://ahdhn.github.io/RXMeshDocs/
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.26
+Description-Content-Type: text/markdown
+
+# PyRXMesh
+
+Python bindings for [RXMesh](https://github.com/owensgroup/RXMesh), a CUDA/C++ library for GPU mesh processing.
+
+PyRXMesh allows you to keep mesh workflows in Python while using RXMesh data structures and GPU kernels underneath. It supports exchanging arrays and attributes with NumPy and PyTorch, building sparse matrices, and solving linear systems. We use a Python plugin to allow CUDA kernels to be written, compiled, and used directly in Python. Check out [CUSTOM_CUDA_PLUGINS.md](CUSTOM_CUDA_PLUGINS.md) for more details.
+
+
+## Installation
+
+Install PyRXMesh with:
+
+```bash
+python -m pip install PyRXMesh
+```
+
+PyRXMesh is a CUDA package. You need an NVIDIA driver compatible with the CUDA version used by the wheel. For source builds and development setup, see [DEVELOPING.md](DEVELOPING.md).
+
+## Simple Example
+
+```python
+import pyrxmesh as rx
+
+#Use GPU 0 
+rx.init(0) 
+
+mesh = rx.RXMeshStatic("mesh.obj")
+print(mesh.num_vertices, mesh.num_edges, mesh.num_faces)
+
+rx.show()
+```
+
+The repository includes a small viewer example:
+
+```bash
+python examples/load_and_show.py --input mesh.obj
+```
+
+## Mesh Attributes
+
+Attributes are data attached to vertices, edges, or faces
+
+```python
+import pyrxmesh as rx
+
+mesh = rx.RXMeshStatic("mesh.obj")
+
+coords = mesh.input_vertex_coordinates()
+velocity = mesh.add_vertex_attribute("velocity", dtype="float32",
+                                     dim=3, location=rx.Location.ALL)
+
+velocity.reset(0.0, rx.Location.DEVICE)
+
+host_coords = coords.to_numpy_copy(source=rx.Location.HOST)
+print(host_coords.shape)
+```
+
+## NumPy And Torch Interop
+
+Unsuffixed `to_*` methods return zero-copy views when possible. Methods ending
+in `_copy` make an explicit copy.
+
+```python
+import pyrxmesh as rx
+
+mesh = rx.RXMeshStatic("mesh.obj")
+attr = mesh.add_vertex_attribute("temperature", dtype="float32",
+                                 dim=1, location=rx.Location.ALL)
+
+attr.reset(1.0, rx.Location.ALL)
+
+view = attr.to_numpy(rx.Location.HOST)
+view[0, 0] = 42.0
+
+owned = attr.to_numpy_copy(source=rx.Location.HOST)
+print(owned[0, 0])
+```
+
+Torch views use DLPack:
+
+```python
+tensor = attr.to_torch(rx.Location.DEVICE)
+tensor += 2.0
+```
+
+## Dense And Sparse Matrices
+
+PyRXMesh exposes RXMesh dense matrices and CSR sparse matrices.
+
+```python
+import numpy as np
+import pyrxmesh as rx
+
+matrix = rx.DenseMatrix(4, 3, dtype="float32", location=rx.Location.ALL)
+values = np.arange(12, dtype=np.float32).reshape(4, 3)
+
+matrix.from_numpy_copy(values, target=rx.Location.ALL)
+print(matrix.norm2())
+```
+
+Sparse matrices are CSR-only:
+
+```python
+mesh = rx.RXMeshStatic("mesh.obj")
+laplace_like = mesh.sparse_matrix(rx.Op.VV, dtype="float32")
+
+row_ptr, col_idx, values = laplace_like.to_numpy_copy()
+print(laplace_like.shape, laplace_like.nnz)
+```
+
+You can multiply sparse matrices by dense vectors:
+
+```python
+x = np.ones((laplace_like.cols, 1), dtype=np.float32)
+y = laplace_like.multiply_vector(x)
+print(y.to_numpy_copy(source=rx.Location.HOST))
+```
+
+## Solvers
+
+RXMesh solver bindings work with `SparseMatrix` and `DenseMatrix` objects:
+
+```python
+import numpy as np
+import pyrxmesh as rx
+
+row_ptr = np.array([0, 2, 5, 7], dtype=np.int32)
+col_idx = np.array([0, 1, 0, 1, 2, 1, 2], dtype=np.int32)
+values = np.array([4, 1, 1, 3, 1, 1, 2], dtype=np.float32)
+
+A = rx.SparseMatrix.from_numpy_copy(row_ptr, col_idx, values,
+                                    shape=(3, 3), dtype="float32")
+
+b = rx.DenseMatrix(3, 1, dtype="float32", location=rx.Location.ALL)
+b.from_numpy_copy(np.array([[1], [2], [3]], dtype=np.float32))
+
+solver = rx.CGSolver(A, unknown_dim=1)
+x = solver.solve(b)
+
+print(x.to_numpy_copy(source=rx.Location.HOST))
+```
+
+## Documentation
+- [RXMeshDocs](https://ahdhn.github.io/RXMeshDocs/): RXMesh CUDA/C++ documentation website 
+- [DEVELOPING.md](DEVELOPING.md): build PyRXMesh from source and work against RXMesh forks, tags, or local checkouts.
+- [CUSTOM_CUDA_PLUGINS.md](CUSTOM_CUDA_PLUGINS.md): write small compiled CUDA plugins that operate on PyRXMesh meshes and attributes.

pyrxmesh-0.2.1rc0.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyrxmesh/__init__.py,sha256=5dZNYxEZ4cv80RpOhX6tC8GnWmu06wthtYabQZ3VMu4,12658
+pyrxmesh/_rxmesh.cp311-win_amd64.pyd,sha256=pGNLpMtM2LxxLa60_mVfL_k-9otBUc0hsMbgV9yMfcY,67914752
+pyrxmesh/build_config.json,sha256=Ym6uhIZbalIT0GaNbbMHcchhn-LBIMKPrrO2xk7_yB4,522
+pyrxmesh/cmake_dir.py,sha256=ylPlG-hpZA2VJ-GlnicP2K7dGmxl_1ur-3zeaZVnTaY,312
+pyrxmesh/diff.py,sha256=CbMedL95HUA7q8Lz-er2WqwH4D3SLdYbMHBwb_jTKGg,174
+pyrxmesh/geometry.py,sha256=eX4y8mieixPWohWK3rFkG8DaY1ej46XmJmSf-KLihc8,96
+pyrxmesh/plugin.py,sha256=CbDeNnAKGSeB12VmEdeHy48cgpEpymXYrge3RbGnXGg,6298
+pyrxmesh-0.2.1rc0.dist-info/METADATA,sha256=e4aDfe1h3z18JsN-dfQP5-sumLPwDD-BjHCi-vvypiw,4587
+pyrxmesh-0.2.1rc0.dist-info/WHEEL,sha256=NHmw5Qi_104FW4Xq2pbA3Gs3F6EqwqCa-xRmRnEiDI8,106
+pyrxmesh-0.2.1rc0.dist-info/entry_points.txt,sha256=ZM8Ckpy6TpMGdTRL05cC3l2Vs9FmBu2_jZ6u9DwDujc,58
+pyrxmesh-0.2.1rc0.dist-info/licenses/LICENSE,sha256=Mq7J1MpxYoaE1t_I7XkUNyOJqwslkMSXkMtnt8gtGkk,1372
+pyrxmesh-0.2.1rc0.dist-info/RECORD,,

pyrxmesh-0.2.1rc0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.12.2
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+

pyrxmesh-0.2.1rc0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pyrxmesh-plugin = pyrxmesh.plugin:main
+

pyrxmesh-0.2.1rc0.dist-info/licenses/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, Ahmed Mahmoud and PyRXMesh contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.