mesh-to-point 0.1__tar.gz

mesh_to_point-0.1/.github/workflows/python-publish.yml

@@ -0,0 +1,68 @@
+# This workflow will upload a Python Package to PyPI when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  push:
+    tags:        
+      - 'v*'
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+
+      - name: Build release distributions
+        run: |
+          python -m pip install build
+          python -m build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+
+    # Dedicated environments with protections for publishing are strongly recommended.
+    # For more information, see: https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-protection-rules
+    environment:
+      name: pypi
+      # OPTIONAL: uncomment and update to include your PyPI project URL in the deployment status:
+      url: https://pypi.org/p/mesh-to-point
+      #
+      # ALTERNATIVE: if your GitHub Release name is the PyPI project version string
+      # ALTERNATIVE: exactly, uncomment the following line instead:
+      # url: https://pypi.org/project/YOURPROJECT/${{ github.event.release.name }}
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

mesh_to_point-0.1/.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer,
+#  you could uncomment the following to ignore the entire vscode folder
+.vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

mesh_to_point-0.1/.pre-commit-config.yaml

@@ -0,0 +1,12 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.3.0
+    hooks:
+    -   id: check-yaml
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+-   repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 26.5.1
+    hooks:
+    -   id: black
+        language_version: python3.13

mesh_to_point-0.1/.python-version

@@ -0,0 +1 @@
+3.13

mesh_to_point-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Giorgio Mariani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mesh_to_point-0.1/PKG-INFO

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: mesh-to-point
+Version: 0.1
+Summary: RGB point-cloud generation from meshes.
+Project-URL: Homepage, https://github.com/giorgio-mariani/mesh-to-point
+Project-URL: Repository, https://github.com/giorgio-mariani/mesh-to-point
+Project-URL: Issues, https://github.com/giorgio-mariani/mesh-to-point/issues
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: click
+Requires-Dist: bpy
+Requires-Dist: mathutils>=5.1.0
+Requires-Dist: openexr>=3.4.12
+Requires-Dist: pillow>=12.2.0
+Requires-Dist: scikit-learn>=1.9.0
+Requires-Dist: plotly>=6.8.0
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# Mesh‑to‑Point
+
+## Overview
+`mesh-to-point` is a lightweight Python library that converts 3D meshes into dense RGB point clouds.
+
+It is built on top of **NumPy**, and **scikit‑learn** for data handling, and uses **Blender** (via the `bpy` API) for rendering synthetic views.
+
+The project ships a small command‑line interface that can render a mesh from multiple camera viewpoints and generate a point cloud from the rendered RGB-D images.
+
+
+## Installation
+The package is published on PyPI and can be installed with `pip`:
+
+```bash
+pip install mesh-to-point
+```
+
+Note that this will also install a headless version of blender 5.0 to be used for rendering.
+
+**Development install.** If you want to contribute or run the test suite, install the optional development dependencies:
+
+```bash
+pip install .[dev]
+pre-commit install
+```
+
+## Quick start
+### Command Line Interface
+```bash
+# Render a mesh and generate a point cloud with 8192 points
+mesh-to-point --mesh assets/suzanne.glb \
+              --cameras assets/cameras.json \
+              --lights assets/lights.json \
+              --output-dir output \
+              --points 8192 \
+              --html
+```
+
+The command will:
+
+* Render the mesh from the specified camera viewpoints using Blender Cycles.
+* Store the rendered RGB-D images in the chosen output directory.
+* Build a dense RGB point cloud from the rendered images.
+* Write the point cloud as a NumPy ``.npy`` array or (optionally) as a text ``.ply`` file.
+* Optionally generate an interactive Plotly HTML visualization of the point cloud.
+
+**Output directory.** The output directory contains the rendered images, camera transforms, point cloud data, and an optional HTML visualization. Images are stored under ``<output_dir>/images`` as ``<index>_rgb.png`` and ``<index>_depth.exr``. Extrinsic and intrinsic camera parameters are saved in ``transforms.json``. The point cloud is written as ``pointcloud.npy`` (or ``pointcloud.ply`` if ``--as-ply`` is used). If ``--html`` is enabled, an interactive Plotly visualization is generated as ``pointcloud.html``.
+
+Overview of output directory structure:
+
+```
+<output-dir>
+|- images/
+|  |- 0000_depth.exr
+|  |- 0000_rgb.png
+|  |  ...
+|  |- <num-views>_rgb.png
+|
+|- transforms.json  # Camera parameters
+|- pointcloud.npy   # Point cloud data (`pointcloud.ply` if --as-ply is used)
+|- pointcloud.html  # Point cloud visualization script (only if --html is used)
+```
+
+**Configuration files.** Lighting and camera information are provided to the CLI through JSON files; These describe the extrinsic camera poses and the intrinsic camera parameters, together with the amount of point lights in the scene and the background light color and intensity. If these are not provided, `mesh-to-point` will default to [[assets/cameras.json]] and [[assets/lights.json]] for cameras and lights respectively.
+- *Camera configuration.* The file should follow the format used by the `mesh_to_point.read_camera_config` helper. It contains intrinsic parameters (focal length, principal point, image size) and a list of extrinsic pose matrices.
+- *Lights configuration.* It specifies an optional environment color and intensity, together with a list of point lights. Each light has an origin, color, intensity, and a flag for shadows.  The file is parsed by `mesh_to_point.read_light_config`, take a look at the function docstring for a more in-depth description.
+
+> **NOTE ⚠**
+When loaded into the scene, the input geometry mesh is automatically normalized to match the size of a unit cube, and placed at the origin. Camera and light parameters should take this into consideration.
+
+
+Below are two minimal examples; one for a camera configuration file and another for a light configuration file.
+
+*Minimal cameras config file:*
+```json
+{
+    "camera_model": "PINHOLE",  # Only PINHOLE or SIMPLE_PINHOLE are supported
+    "fl_x": 1422.22,
+    "fl_y": 1422.22,
+    "cx": 512,
+    "cy": 512,
+    "h": 1024,
+    "w": 1024,
+    "frames": [
+        {
+            "transform_matrix": [  # Camera-to-world transformation matrix
+                [1, 0, 0, 0],
+                [0, 1, 0, 0],
+                [0, 0, 1, 0],
+                [0, 0, 0, 1]
+            ]
+        }
+    ]
+}
+```
+
+*Minimal lights config file:*
+```json
+lights.json
+{
+    "environment_color": [1, 1, 1, 1],  # RGB-Alpha
+    "environment_intensity": 0.5,       # Between  [0.0, 1.0]
+    "lights": [
+        {
+            "origin": [0, 0, 2],
+            "color": [1, 1, 1],
+            "intensity": 10,            # Between [0.0, +inf)
+            "use_shadows": true
+        }
+    ]
+}
+```
+
+Examples for both configuration file types can found in the `./assets` directory.
+
+### API reference
+The library exposes a small set of public functions that can be used programmatically:
+
+* ``mesh_to_point.render_dataset`` – Render a dataset of RGB-D images from a mesh.
+* ``mesh_to_point.create_pointcloud_from_multiview`` – Build a point cloud from a directory of rendered RGB-D images.
+* ``mesh_to_point.create_pointcloud_figure`` – Create a Plotly figure for visualising a point cloud.
+
+#### Examples
+If necessary, it is possible to directly invoke the python rendering function instead of using the [command-line interface](#command-line-interface). For example, by calling the `render_dataset` function directly:
+```python
+from mesh_to_point import render_dataset, GlobalConfig, read_camera_config, read_light_config
+
+# Load camera and lights configuration
+camera, camera_poses = read_camera_config("path-to-camera-cfg")
+background_light, lights = read_light_config("path-to-light-cfg")
+
+# Setup rendering config
+cfg = GlobalConfig(
+    mesh="path-to-mesh",
+    output_dir="output",
+    lights=lights,
+    background_light=background_light,
+    camera=camera,
+    camera_poses=camera_poses,
+    use_gpu=True,
+    samples=16,
+    depth_pass=True,
+)
+
+# Render views
+render_dataset(cfg)
+```
+Once the multiple views have been rendered, it is possible to construct a point cloud from them by
+using the `create_pointcloud_from_multiview` utility:
+```python
+from mesh_to_point import create_pointcloud_from_multiview
+
+# Path to the folder that contains the rendered images.
+# The folder must follow the CLI output layout:
+#        <output_dir>/images/<idx>_rgb.png
+#        <output_dir>/images/<idx>_depth.exr
+render_dir = "output"
+pointcloud = create_pointcloud_from_multiview(
+    render_dir, num_points=8192,
+)
+
+print(f"Point cloud shape: {pointcloud.shape}")   # (8192, 6)
+
+```
+Finally, it is also possible to produce an HTML/javascript file to visualize the point cloud on a browser of your choice.
+```python
+from mesh_to_point import create_pointcloud_figure
+# Visualise the point cloud with Plotly.
+fig = create_pointcloud_figure(pointcloud)
+fig.write_html("pointcloud.html")   # open in a browser to visualize the point cloud
+```
+
+## License
+MIT – see the [LICENSE](LICENSE) file.

mesh_to_point-0.1/README.md

@@ -0,0 +1,174 @@
+# Mesh‑to‑Point
+
+## Overview
+`mesh-to-point` is a lightweight Python library that converts 3D meshes into dense RGB point clouds.
+
+It is built on top of **NumPy**, and **scikit‑learn** for data handling, and uses **Blender** (via the `bpy` API) for rendering synthetic views.
+
+The project ships a small command‑line interface that can render a mesh from multiple camera viewpoints and generate a point cloud from the rendered RGB-D images.
+
+
+## Installation
+The package is published on PyPI and can be installed with `pip`:
+
+```bash
+pip install mesh-to-point
+```
+
+Note that this will also install a headless version of blender 5.0 to be used for rendering.
+
+**Development install.** If you want to contribute or run the test suite, install the optional development dependencies:
+
+```bash
+pip install .[dev]
+pre-commit install
+```
+
+## Quick start
+### Command Line Interface
+```bash
+# Render a mesh and generate a point cloud with 8192 points
+mesh-to-point --mesh assets/suzanne.glb \
+              --cameras assets/cameras.json \
+              --lights assets/lights.json \
+              --output-dir output \
+              --points 8192 \
+              --html
+```
+
+The command will:
+
+* Render the mesh from the specified camera viewpoints using Blender Cycles.
+* Store the rendered RGB-D images in the chosen output directory.
+* Build a dense RGB point cloud from the rendered images.
+* Write the point cloud as a NumPy ``.npy`` array or (optionally) as a text ``.ply`` file.
+* Optionally generate an interactive Plotly HTML visualization of the point cloud.
+
+**Output directory.** The output directory contains the rendered images, camera transforms, point cloud data, and an optional HTML visualization. Images are stored under ``<output_dir>/images`` as ``<index>_rgb.png`` and ``<index>_depth.exr``. Extrinsic and intrinsic camera parameters are saved in ``transforms.json``. The point cloud is written as ``pointcloud.npy`` (or ``pointcloud.ply`` if ``--as-ply`` is used). If ``--html`` is enabled, an interactive Plotly visualization is generated as ``pointcloud.html``.
+
+Overview of output directory structure:
+
+```
+<output-dir>
+|- images/
+|  |- 0000_depth.exr
+|  |- 0000_rgb.png
+|  |  ...
+|  |- <num-views>_rgb.png
+|
+|- transforms.json  # Camera parameters
+|- pointcloud.npy   # Point cloud data (`pointcloud.ply` if --as-ply is used)
+|- pointcloud.html  # Point cloud visualization script (only if --html is used)
+```
+
+**Configuration files.** Lighting and camera information are provided to the CLI through JSON files; These describe the extrinsic camera poses and the intrinsic camera parameters, together with the amount of point lights in the scene and the background light color and intensity. If these are not provided, `mesh-to-point` will default to [[assets/cameras.json]] and [[assets/lights.json]] for cameras and lights respectively.
+- *Camera configuration.* The file should follow the format used by the `mesh_to_point.read_camera_config` helper. It contains intrinsic parameters (focal length, principal point, image size) and a list of extrinsic pose matrices.
+- *Lights configuration.* It specifies an optional environment color and intensity, together with a list of point lights. Each light has an origin, color, intensity, and a flag for shadows.  The file is parsed by `mesh_to_point.read_light_config`, take a look at the function docstring for a more in-depth description.
+
+> **NOTE ⚠**
+When loaded into the scene, the input geometry mesh is automatically normalized to match the size of a unit cube, and placed at the origin. Camera and light parameters should take this into consideration.
+
+
+Below are two minimal examples; one for a camera configuration file and another for a light configuration file.
+
+*Minimal cameras config file:*
+```json
+{
+    "camera_model": "PINHOLE",  # Only PINHOLE or SIMPLE_PINHOLE are supported
+    "fl_x": 1422.22,
+    "fl_y": 1422.22,
+    "cx": 512,
+    "cy": 512,
+    "h": 1024,
+    "w": 1024,
+    "frames": [
+        {
+            "transform_matrix": [  # Camera-to-world transformation matrix
+                [1, 0, 0, 0],
+                [0, 1, 0, 0],
+                [0, 0, 1, 0],
+                [0, 0, 0, 1]
+            ]
+        }
+    ]
+}
+```
+
+*Minimal lights config file:*
+```json
+lights.json
+{
+    "environment_color": [1, 1, 1, 1],  # RGB-Alpha
+    "environment_intensity": 0.5,       # Between  [0.0, 1.0]
+    "lights": [
+        {
+            "origin": [0, 0, 2],
+            "color": [1, 1, 1],
+            "intensity": 10,            # Between [0.0, +inf)
+            "use_shadows": true
+        }
+    ]
+}
+```
+
+Examples for both configuration file types can found in the `./assets` directory.
+
+### API reference
+The library exposes a small set of public functions that can be used programmatically:
+
+* ``mesh_to_point.render_dataset`` – Render a dataset of RGB-D images from a mesh.
+* ``mesh_to_point.create_pointcloud_from_multiview`` – Build a point cloud from a directory of rendered RGB-D images.
+* ``mesh_to_point.create_pointcloud_figure`` – Create a Plotly figure for visualising a point cloud.
+
+#### Examples
+If necessary, it is possible to directly invoke the python rendering function instead of using the [command-line interface](#command-line-interface). For example, by calling the `render_dataset` function directly:
+```python
+from mesh_to_point import render_dataset, GlobalConfig, read_camera_config, read_light_config
+
+# Load camera and lights configuration
+camera, camera_poses = read_camera_config("path-to-camera-cfg")
+background_light, lights = read_light_config("path-to-light-cfg")
+
+# Setup rendering config
+cfg = GlobalConfig(
+    mesh="path-to-mesh",
+    output_dir="output",
+    lights=lights,
+    background_light=background_light,
+    camera=camera,
+    camera_poses=camera_poses,
+    use_gpu=True,
+    samples=16,
+    depth_pass=True,
+)
+
+# Render views
+render_dataset(cfg)
+```
+Once the multiple views have been rendered, it is possible to construct a point cloud from them by
+using the `create_pointcloud_from_multiview` utility:
+```python
+from mesh_to_point import create_pointcloud_from_multiview
+
+# Path to the folder that contains the rendered images.
+# The folder must follow the CLI output layout:
+#        <output_dir>/images/<idx>_rgb.png
+#        <output_dir>/images/<idx>_depth.exr
+render_dir = "output"
+pointcloud = create_pointcloud_from_multiview(
+    render_dir, num_points=8192,
+)
+
+print(f"Point cloud shape: {pointcloud.shape}")   # (8192, 6)
+
+```
+Finally, it is also possible to produce an HTML/javascript file to visualize the point cloud on a browser of your choice.
+```python
+from mesh_to_point import create_pointcloud_figure
+# Visualise the point cloud with Plotly.
+fig = create_pointcloud_figure(pointcloud)
+fig.write_html("pointcloud.html")   # open in a browser to visualize the point cloud
+```
+
+## License
+MIT – see the [LICENSE](LICENSE) file.