pyribbit 0.1.46__tar.gz

pyribbit-0.1.46/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Matthew Matl
+
+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.

pyribbit-0.1.46/MANIFEST.in

@@ -0,0 +1,5 @@
+# Include the license
+include LICENSE
+include README.rst
+include pyribbit/fonts/*
+include pyribbit/shaders/*

pyribbit-0.1.46/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: pyribbit
+Version: 0.1.46
+Summary: Easy-to-use Python renderer for 3D visualization
+Home-page: https://github.com/fishbotics/pyribbit
+Author: Adam Fishman
+Author-email: hello@fishbotics.com
+License: MIT License
+Keywords: rendering graphics opengl 3d visualization pbr gltf
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Natural Language :: English
+Classifier: Topic :: Scientific/Engineering
+Provides-Extra: dev
+Provides-Extra: docs
+License-File: LICENSE
+
+A simple implementation of Physically-Based Rendering (PBR) in Python. Compliant with the glTF 2.0 standard.

pyribbit-0.1.46/README.md

@@ -0,0 +1,92 @@
+# Pyribbit
+
+[![Build Status](https://travis-ci.org/mmatl/pyribbit.svg?branch=master)](https://travis-ci.org/mmatl/pyribbit)
+[![Documentation Status](https://readthedocs.org/projects/pyribbit/badge/?version=latest)](https://pyribbit.readthedocs.io/en/latest/?badge=latest)
+[![Coverage Status](https://coveralls.io/repos/github/mmatl/pyribbit/badge.svg?branch=master)](https://coveralls.io/github/mmatl/pyribbit?branch=master)
+[![PyPI version](https://badge.fury.io/py/pyribbit.svg)](https://badge.fury.io/py/pyribbit)
+[![Downloads](https://pepy.tech/badge/pyribbit)](https://pepy.tech/project/pyribbit)
+
+Pyribbit is a pure Python (2.7, 3.4, 3.5, 3.6) library for physically-based
+rendering and visualization.
+It is designed to meet the [glTF 2.0 specification from Khronos](https://www.khronos.org/gltf/).
+
+Pyribbit is lightweight, easy to install, and simple to use.
+It comes packaged with both an intuitive scene viewer and a headache-free
+offscreen renderer with support for GPU-accelerated rendering on headless
+servers, which makes it perfect for machine learning applications.
+
+Extensive documentation, including a quickstart guide, is provided [here](https://pyribbit.readthedocs.io/en/latest/).
+
+For a minimal working example of GPU-accelerated offscreen rendering using EGL,
+check out the [EGL Google CoLab Notebook](https://colab.research.google.com/drive/1pcndwqeY8vker3bLKQNJKr3B-7-SYenE?usp=sharing).
+
+
+<p align="center">
+  <img width="48%" src="https://github.com/mmatl/pyribbit/blob/master/docs/source/_static/rotation.gif?raw=true" alt="GIF of Viewer"/>
+  <img width="48%" src="https://github.com/mmatl/pyribbit/blob/master/docs/source/_static/damaged_helmet.png?raw=true" alt="Damaged Helmet"/>
+</p>
+
+## Installation
+You can install pyribbit directly from pip.
+
+```bash
+pip install pyribbit
+```
+
+## Features
+
+Despite being lightweight, pyribbit has lots of features, including:
+
+* Simple interoperation with the amazing [trimesh](https://github.com/mikedh/trimesh) project,
+which enables out-of-the-box support for dozens of mesh types, including OBJ,
+STL, DAE, OFF, PLY, and GLB.
+* An easy-to-use scene viewer with support for animation, showing face and vertex
+normals, toggling lighting conditions, and saving images and GIFs.
+* An offscreen rendering module that supports OSMesa and EGL backends.
+* Shadow mapping for directional and spot lights.
+* Metallic-roughness materials for physically-based rendering, including several
+types of texture and normal mapping.
+* Transparency.
+* Depth and color image generation.
+
+## Sample Usage
+
+For sample usage, check out the [quickstart
+guide](https://pyribbit.readthedocs.io/en/latest/examples/index.html) or one of
+the Google CoLab Notebooks:
+
+* [EGL Google CoLab Notebook](https://colab.research.google.com/drive/1pcndwqeY8vker3bLKQNJKr3B-7-SYenE?usp=sharing)
+
+## Viewer Keyboard and Mouse Controls
+
+When using the viewer, the basic controls for moving about the scene are as follows:
+
+* To rotate the camera about the center of the scene, hold the left mouse button and drag the cursor.
+* To rotate the camera about its viewing axis, hold `CTRL` left mouse button and drag the cursor.
+* To pan the camera, do one of the following:
+    * Hold `SHIFT`, then hold the left mouse button and drag the cursor.
+    * Hold the middle mouse button and drag the cursor.
+* To zoom the camera in or out, do one of the following:
+    * Scroll the mouse wheel.
+    * Hold the right mouse button and drag the cursor.
+
+The available keyboard commands are as follows:
+
+* `a`: Toggles rotational animation mode.
+* `c`: Toggles backface culling.
+* `f`: Toggles fullscreen mode.
+* `h`: Toggles shadow rendering.
+* `i`: Toggles axis display mode (no axes, world axis, mesh axes, all axes).
+* `l`: Toggles lighting mode (scene lighting, Raymond lighting, or direct lighting).
+* `m`: Toggles face normal visualization.
+* `n`: Toggles vertex normal visualization.
+* `o`: Toggles orthographic camera mode.
+* `q`: Quits the viewer.
+* `r`: Starts recording a GIF, and pressing again stops recording and opens a file dialog.
+* `s`: Opens a file dialog to save the current view as an image.
+* `w`: Toggles wireframe mode (scene default, flip wireframes, all wireframe, or all solid).
+* `z`: Resets the camera to the default view.
+
+As a note, displaying shadows significantly slows down rendering, so if you're
+experiencing low framerates, just kill shadows or reduce the number of lights in
+your scene.

pyribbit-0.1.46/pyribbit/__init__.py

@@ -0,0 +1,24 @@
+from .camera import (Camera, PerspectiveCamera, OrthographicCamera,
+                     IntrinsicsCamera)
+from .light import Light, PointLight, DirectionalLight, SpotLight
+from .sampler import Sampler
+from .texture import Texture
+from .material import Material, MetallicRoughnessMaterial
+from .primitive import Primitive
+from .mesh import Mesh
+from .node import Node
+from .scene import Scene
+from .renderer import Renderer
+from .viewer import Viewer
+from .offscreen import OffscreenRenderer
+from .version import __version__
+from .constants import RenderFlags, TextAlign, GLTF
+
+__all__ = [
+    'Camera', 'PerspectiveCamera', 'OrthographicCamera', 'IntrinsicsCamera',
+    'Light', 'PointLight', 'DirectionalLight', 'SpotLight',
+    'Sampler', 'Texture', 'Material', 'MetallicRoughnessMaterial',
+    'Primitive', 'Mesh', 'Node', 'Scene', 'Renderer', 'Viewer',
+    'OffscreenRenderer', '__version__', 'RenderFlags', 'TextAlign',
+    'GLTF'
+]

pyribbit-0.1.46/pyribbit/camera.py

@@ -0,0 +1,437 @@
+"""Virtual cameras compliant with the glTF 2.0 specification as described at
+https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-camera
+
+Author: Matthew Matl
+"""
+import abc
+import numpy as np
+import six
+import sys
+
+from .constants import DEFAULT_Z_NEAR, DEFAULT_Z_FAR
+
+
+@six.add_metaclass(abc.ABCMeta)
+class Camera(object):
+    """Abstract base class for all cameras.
+
+    Note
+    ----
+    Camera poses are specified in the OpenGL format,
+    where the z axis points away from the view direction and the
+    x and y axes point to the right and up in the image plane, respectively.
+
+    Parameters
+    ----------
+    znear : float
+        The floating-point distance to the near clipping plane.
+    zfar : float
+        The floating-point distance to the far clipping plane.
+        ``zfar`` must be greater than ``znear``.
+    name : str, optional
+        The user-defined name of this object.
+    """
+
+    def __init__(self,
+                 znear=DEFAULT_Z_NEAR,
+                 zfar=DEFAULT_Z_FAR,
+                 name=None):
+        self.name = name
+        self.znear = znear
+        self.zfar = zfar
+
+    @property
+    def name(self):
+        """str : The user-defined name of this object.
+        """
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        if value is not None:
+            value = str(value)
+        self._name = value
+
+    @property
+    def znear(self):
+        """float : The distance to the near clipping plane.
+        """
+        return self._znear
+
+    @znear.setter
+    def znear(self, value):
+        value = float(value)
+        if value < 0:
+            raise ValueError('z-near must be >= 0.0')
+        self._znear = value
+
+    @property
+    def zfar(self):
+        """float : The distance to the far clipping plane.
+        """
+        return self._zfar
+
+    @zfar.setter
+    def zfar(self, value):
+        value = float(value)
+        if value <= 0 or value <= self.znear:
+            raise ValueError('zfar must be >0 and >znear')
+        self._zfar = value
+
+    @abc.abstractmethod
+    def get_projection_matrix(self, width=None, height=None):
+        """Return the OpenGL projection matrix for this camera.
+
+        Parameters
+        ----------
+        width : int
+            Width of the current viewport, in pixels.
+        height : int
+            Height of the current viewport, in pixels.
+        """
+        pass
+
+
+class PerspectiveCamera(Camera):
+
+    """A perspective camera for perspective projection.
+
+    Parameters
+    ----------
+    yfov : float
+        The floating-point vertical field of view in radians.
+    znear : float
+        The floating-point distance to the near clipping plane.
+        If not specified, defaults to 0.05.
+    zfar : float, optional
+        The floating-point distance to the far clipping plane.
+        ``zfar`` must be greater than ``znear``.
+        If None, the camera uses an infinite projection matrix.
+    aspectRatio : float, optional
+        The floating-point aspect ratio of the field of view.
+        If not specified, the camera uses the viewport's aspect ratio.
+    name : str, optional
+        The user-defined name of this object.
+    """
+
+    def __init__(self,
+                 yfov,
+                 znear=DEFAULT_Z_NEAR,
+                 zfar=None,
+                 aspectRatio=None,
+                 name=None):
+        super(PerspectiveCamera, self).__init__(
+            znear=znear,
+            zfar=zfar,
+            name=name,
+        )
+
+        self.yfov = yfov
+        self.aspectRatio = aspectRatio
+
+    @property
+    def yfov(self):
+        """float : The vertical field of view in radians.
+        """
+        return self._yfov
+
+    @yfov.setter
+    def yfov(self, value):
+        value = float(value)
+        if value <= 0.0:
+            raise ValueError('Field of view must be positive')
+        self._yfov = value
+
+    @property
+    def zfar(self):
+        """float : The distance to the far clipping plane.
+        """
+        return self._zfar
+
+    @zfar.setter
+    def zfar(self, value):
+        if value is not None:
+            value = float(value)
+            if value <= 0 or value <= self.znear:
+                raise ValueError('zfar must be >0 and >znear')
+        self._zfar = value
+
+    @property
+    def aspectRatio(self):
+        """float : The ratio of the width to the height of the field of view.
+        """
+        return self._aspectRatio
+
+    @aspectRatio.setter
+    def aspectRatio(self, value):
+        if value is not None:
+            value = float(value)
+            if value <= 0.0:
+                raise ValueError('Aspect ratio must be positive')
+        self._aspectRatio = value
+
+    def get_projection_matrix(self, width=None, height=None):
+        """Return the OpenGL projection matrix for this camera.
+
+        Parameters
+        ----------
+        width : int
+            Width of the current viewport, in pixels.
+        height : int
+            Height of the current viewport, in pixels.
+        """
+        aspect_ratio = self.aspectRatio
+        if aspect_ratio is None:
+            if width is None or height is None:
+                raise ValueError('Aspect ratio of camera must be defined')
+            aspect_ratio = float(width) / float(height)
+
+        a = aspect_ratio
+        t = np.tan(self.yfov / 2.0)
+        n = self.znear
+        f = self.zfar
+
+        P = np.zeros((4,4))
+        P[0][0] = 1.0 / (a * t)
+        P[1][1] = 1.0 / t
+        P[3][2] = -1.0
+
+        if f is None:
+            P[2][2] = -1.0
+            P[2][3] = -2.0 * n
+        else:
+            P[2][2] = (f + n) / (n - f)
+            P[2][3] = (2 * f * n) / (n - f)
+
+        return P
+
+
+class OrthographicCamera(Camera):
+    """An orthographic camera for orthographic projection.
+
+    Parameters
+    ----------
+    xmag : float
+        The floating-point horizontal magnification of the view.
+    ymag : float
+        The floating-point vertical magnification of the view.
+    znear : float
+        The floating-point distance to the near clipping plane.
+        If not specified, defaults to 0.05.
+    zfar : float
+        The floating-point distance to the far clipping plane.
+        ``zfar`` must be greater than ``znear``.
+        If not specified, defaults to 100.0.
+    name : str, optional
+        The user-defined name of this object.
+    """
+
+    def __init__(self,
+                 xmag,
+                 ymag,
+                 znear=DEFAULT_Z_NEAR,
+                 zfar=DEFAULT_Z_FAR,
+                 name=None):
+        super(OrthographicCamera, self).__init__(
+            znear=znear,
+            zfar=zfar,
+            name=name,
+        )
+
+        self.xmag = xmag
+        self.ymag = ymag
+
+    @property
+    def xmag(self):
+        """float : The horizontal magnification of the view.
+        """
+        return self._xmag
+
+    @xmag.setter
+    def xmag(self, value):
+        value = float(value)
+        if value <= 0.0:
+            raise ValueError('X magnification must be positive')
+        self._xmag = value
+
+    @property
+    def ymag(self):
+        """float : The vertical magnification of the view.
+        """
+        return self._ymag
+
+    @ymag.setter
+    def ymag(self, value):
+        value = float(value)
+        if value <= 0.0:
+            raise ValueError('Y magnification must be positive')
+        self._ymag = value
+
+    @property
+    def znear(self):
+        """float : The distance to the near clipping plane.
+        """
+        return self._znear
+
+    @znear.setter
+    def znear(self, value):
+        value = float(value)
+        if value <= 0:
+            raise ValueError('z-near must be > 0.0')
+        self._znear = value
+
+    def get_projection_matrix(self, width=None, height=None):
+        """Return the OpenGL projection matrix for this camera.
+
+        Parameters
+        ----------
+        width : int
+            Width of the current viewport, in pixels.
+            Unused in this function.
+        height : int
+            Height of the current viewport, in pixels.
+            Unused in this function.
+        """
+        xmag = self.xmag
+        ymag = self.ymag
+
+        # If screen width/height defined, rescale xmag
+        if width is not None and height is not None:
+            xmag = width / height * ymag
+
+        n = self.znear
+        f = self.zfar
+        P = np.zeros((4,4))
+        P[0][0] = 1.0 / xmag
+        P[1][1] = 1.0 / ymag
+        P[2][2] = 2.0 / (n - f)
+        P[2][3] = (f + n) / (n - f)
+        P[3][3] = 1.0
+        return P
+
+
+class IntrinsicsCamera(Camera):
+    """A perspective camera with custom intrinsics.
+
+    Parameters
+    ----------
+    fx : float
+        X-axis focal length in pixels.
+    fy : float
+        Y-axis focal length in pixels.
+    cx : float
+        X-axis optical center in pixels.
+    cy : float
+        Y-axis optical center in pixels.
+    znear : float
+        The floating-point distance to the near clipping plane.
+        If not specified, defaults to 0.05.
+    zfar : float
+        The floating-point distance to the far clipping plane.
+        ``zfar`` must be greater than ``znear``.
+        If not specified, defaults to 100.0.
+    name : str, optional
+        The user-defined name of this object.
+    """
+
+    def __init__(self,
+                 fx,
+                 fy,
+                 cx,
+                 cy,
+                 znear=DEFAULT_Z_NEAR,
+                 zfar=DEFAULT_Z_FAR,
+                 name=None):
+        super(IntrinsicsCamera, self).__init__(
+            znear=znear,
+            zfar=zfar,
+            name=name,
+        )
+
+        self.fx = fx
+        self.fy = fy
+        self.cx = cx
+        self.cy = cy
+
+    @property
+    def fx(self):
+        """float : X-axis focal length in meters.
+        """
+        return self._fx
+
+    @fx.setter
+    def fx(self, value):
+        self._fx = float(value)
+
+    @property
+    def fy(self):
+        """float : Y-axis focal length in meters.
+        """
+        return self._fy
+
+    @fy.setter
+    def fy(self, value):
+        self._fy = float(value)
+
+    @property
+    def cx(self):
+        """float : X-axis optical center in pixels.
+        """
+        return self._cx
+
+    @cx.setter
+    def cx(self, value):
+        self._cx = float(value)
+
+    @property
+    def cy(self):
+        """float : Y-axis optical center in pixels.
+        """
+        return self._cy
+
+    @cy.setter
+    def cy(self, value):
+        self._cy = float(value)
+
+    def get_projection_matrix(self, width, height):
+        """Return the OpenGL projection matrix for this camera.
+
+        Parameters
+        ----------
+        width : int
+            Width of the current viewport, in pixels.
+        height : int
+            Height of the current viewport, in pixels.
+        """
+        width = float(width)
+        height = float(height)
+
+        cx, cy = self.cx, self.cy
+        fx, fy = self.fx, self.fy
+        if sys.platform == 'darwin':
+            cx = self.cx * 2.0
+            cy = self.cy * 2.0
+            fx = self.fx * 2.0
+            fy = self.fy * 2.0
+
+        P = np.zeros((4,4))
+        P[0][0] = 2.0 * fx / width
+        P[1][1] = 2.0 * fy / height
+        P[0][2] = 1.0 - 2.0 * cx / width
+        P[1][2] = 2.0 * cy / height - 1.0
+        P[3][2] = -1.0
+
+        n = self.znear
+        f = self.zfar
+        if f is None:
+            P[2][2] = -1.0
+            P[2][3] = -2.0 * n
+        else:
+            P[2][2] = (f + n) / (n - f)
+            P[2][3] = (2 * f * n) / (n - f)
+
+        return P
+
+
+__all__ = ['Camera', 'PerspectiveCamera', 'OrthographicCamera',
+           'IntrinsicsCamera']