Struct PyLibreDR

pub struct PyLibreDR(/* private fields */);

Python interface for LibreDR client

Implementations

impl PyLibreDR

pub const MISS_NONE: u8 = 0u8

See render::MISS_NONE for details.

pub const MISS_ENVMAP: u8 = 1u8

See render::MISS_ENVMAP for details.

pub const REFLECTION_NORMAL_FACE: u8 = 0u8

See render::REFLECTION_NORMAL_FACE for details.

pub const REFLECTION_NORMAL_VERTEX: u8 = 1u8

See render::REFLECTION_NORMAL_VERTEX for details.

pub const REFLECTION_NORMAL_TEXTURE: u8 = 2u8

See render::REFLECTION_NORMAL_TEXTURE for details.

pub const REFLECTION_DIFFUSE_NONE: u8 = 0u8

See render::REFLECTION_DIFFUSE_NONE for details.

pub const REFLECTION_DIFFUSE_LAMBERTIAN: u8 = 1u8

See render::REFLECTION_DIFFUSE_LAMBERTIAN for details.

pub const REFLECTION_SPECULAR_NONE: u8 = 0u8

See render::REFLECTION_SPECULAR_NONE for details.

pub const REFLECTION_SPECULAR_PHONG: u8 = 1u8

See render::REFLECTION_SPECULAR_PHONG for details.

pub const REFLECTION_SPECULAR_BLINN_PHONG: u8 = 2u8

See render::REFLECTION_SPECULAR_BLINN_PHONG for details.

pub const REFLECTION_SPECULAR_TORRANCE_SPARROW_PHONG: u8 = 3u8

See render::REFLECTION_SPECULAR_TORRANCE_SPARROW_PHONG for details.

pub const REFLECTION_SPECULAR_TORRANCE_SPARROW_BLINN_PHONG: u8 = 4u8

See render::REFLECTION_SPECULAR_TORRANCE_SPARROW_BLINN_PHONG for details.

pub const REFLECTION_SPECULAR_TORRANCE_SPARROW_BECKMANN: u8 = 5u8

See render::REFLECTION_SPECULAR_TORRANCE_SPARROW_BECKMANN for details.

pub fn py_new( py: Python<'_>, connect: String, unix: bool, tls: bool, ) -> Result<Self>

Construct LibreDR by connecting to LibreDR server.

See LibreDR::new for details.

pub fn __getnewargs__(&self) -> (String, bool, bool)

To allow pickle PyLibreDR object by reconnecting to the server.

Unpickled connection has different UUID.

pub fn py_ray_tracing_forward<'py>( &mut self, py: Python<'py>, geometry: &PyGeometry, ray: PyReadonlyArrayDyn<'_, f32>, texture: PyReadonlyArray3<'_, f32>, envmap: PyReadonlyArray4<'_, f32>, sample_per_pixel: Py<PyAny>, max_bounce: Py<PyAny>, switches: (u8, u8, u8, u8), clip_near: Py<PyAny>, camera_space: bool, requires_grad: bool, srand: i32, low_discrepancy: Option<u32>, ) -> Result<Bound<'py, PyArrayDyn<f32>>>

Create a RequestRayTracingForward task and wait for response

Arguments

• ray - ray parameters
  • if camera_space is false 18 * image_shape
    • including ray position 9 * image_shape
    • including ray direction 9 * image_shape
  • if camera_space is true, add another (1 + 14) channels
    • including ray depth 1 * image_shape (if depth <= 0, treat as hit miss)
    • including ray material 14 * image_shape
• texture - (3 + 3 + 3 + 1 + 3 + 1) * texture_resolution * texture_resolution (must be square image)
  • including normal + diffuse + specular + roughness + intensity + window
• envmap - 3 * 6 * envmap_resolution * envmap_resolution
  • (must be box unwrapped 6 square images)
• sample_per_pixel - sample_per_pixel_forward, (sample_per_pixel_backward)
  • sample_per_pixel can be a single integer,
    • (same value for forward and backward)
  • or tuple of 2 integers.
    • (only sample_per_pixel_backward number of rays are stored for backward)
    • (must ensure sample_per_pixel_forward >= sample_per_pixel_backward)
• max_bounce - max_bounce_forward, (max_bounce_backward), (max_bounce_low_discrepancy), (skip_bounce)
  • max_bounce can be a single integer, or tuple of 2-4 integers.
  • The default value for max_bounce_backward is the same as max_bounce_forward.
  • The default value for max_bounce_low_discrepancy is 0.
  • The default value for skip_bounce is 0.
• switches - tuple of 4 switches to determine hit miss and reflection behavior
  • render::MISS_* - determine how to deal with ray hit miss
    • common::render::MISS_NONE
    • common::render::MISS_ENVMAP
  • render::REFLECTION_NORMAL_* - determine how to get surface normal
    • common::render::REFLECTION_NORMAL_FACE
    • common::render::REFLECTION_NORMAL_VERTEX
    • common::render::REFLECTION_NORMAL_TEXTURE
  • render::REFLECTION_DIFFUSE_* - determine diffuse reflection model
    • common::render::REFLECTION_DIFFUSE_NONE
    • common::render::REFLECTION_DIFFUSE_LAMBERTIAN
  • render::REFLECTION_SPECULAR_* - determine specular reflection model
    • common::render::REFLECTION_SPECULAR_NONE
    • common::render::REFLECTION_SPECULAR_PHONG
    • common::render::REFLECTION_SPECULAR_BLINN_PHONG
    • common::render::REFLECTION_SPECULAR_TORRANCE_SPARROW_PHONG
    • common::render::REFLECTION_SPECULAR_TORRANCE_SPARROW_BLINN_PHONG
    • common::render::REFLECTION_SPECULAR_TORRANCE_SPARROW_BECKMANN
• clip_near - clip near distance for camera
  • clip_near can be a single float number (same for all bounces),
  • or tuple of 3 float numbers (first bounce, second bounce, and other bounces)
• camera_space - if true, the first bounce uses the depth and material given by the ray
• requires_grad - if true, worker will save intermediate data, the next task must be ray_tracing_backward
• srand - random seed
  • if srand >= 0, the same random seed is used for every pixel
  • if srand < 0, use different seed for each pixel
• low_discrepancy - (optional) start id of Halton low discrepancy sequence.
  • The default value is the same as sample_per_pixel_forward.
  • if combine multiple rendered images to reduce noise, this value can be set to:
    1 * sample_per_pixel_forward, 2 * sample_per_pixel_forward, 3 * sample_per_pixel_forward, …

Return

Return shape will be,

• if camera_space is true
  • render image 3 * image_shape
• if camera_space is false, add another
  • ray texture coordinate 2 * image_shape
  • ray depth (Euclidean distance) 1 * image_shape
  • ray normal 3 * image_shape

pub fn py_ray_tracing_backward<'py>( &mut self, py: Python<'py>, d_ray: PyReadonlyArrayDyn<'_, f32>, ) -> Result<(Bound<'py, PyArray3<f32>>, Bound<'py, PyArray4<f32>>, Option<Bound<'py, PyArrayDyn<f32>>>)>

Create a RequestRayTracingBackward task and wait for response.

Must be called consecutive to a RequestRayTracingForward task with requires_grad set to true.
To create multiple RequestRayTracingForward tasks and backward together, multiple client connections are required.

Arguments

• d_ray - gradient of image 3 * image_shape (must ensure same image_shape as RequestRayTracingForward)

Return

Return shape will be,

• if camera_space is false for RequestRayTracingForward task
  • 1st return value (3 + 3 + 3 + 1 + 3 + 1) * texture_resolution * texture_resolution
    • (same texture_resolution as RequestRayTracingForward)
    • including d_normal + d_diffuse + d_specular + d_roughness + d_intensity + d_window
  • 2nd return value 3 * 6 * envmap_resolution * envmap_resolution
    • (same envmap_resolution as RequestRayTracingForward)
    • including d_envmap
• if camera_space is true for RequestRayTracingForward task, add another
  • 3rd return value 14 * image_shape (same shape as RequestRayTracingForward)
    • including d_ray_texture

Trait Implementations

impl Debug for PyLibreDR

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for PyLibreDR

fn drop(&mut self)

Executes the destructor for this type.

impl IntoPy<Py<PyAny>> for PyLibreDR

fn into_py(self, py: Python<'_>) -> PyObject

👎Deprecated since 0.23.0: IntoPy is going to be replaced by IntoPyObject. See the migration guide (https://pyo3.rs/v0.23.0/migration) for more information.

Performs the conversion.

impl<'py> IntoPyObject<'py> for PyLibreDR

type Target = PyLibreDR

The Python output type

type Output = Bound<'py, <PyLibreDR as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for PyLibreDR

type Frozen = False

Whether the pyclass is frozen.

impl PyClassBaseType for PyLibreDR

type LayoutAsBase = PyClassObject<PyLibreDR>

type BaseNativeType = <PyLibreDR as PyClassImpl>::BaseNativeType

type Initializer = PyClassInitializer<PyLibreDR>

type PyClassMutability = <PyLibreDR as PyClassImpl>::PyClassMutability

impl PyClassImpl for PyLibreDR

const IS_BASETYPE: bool = true

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<PyLibreDR>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature<PyLibreDR> for PyClassImplCollector<PyLibreDR>

fn new_text_signature(self) -> Option<&'static str>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a PyLibreDR

type Holder = Option<PyRef<'py, PyLibreDR>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a mut PyLibreDR

type Holder = Option<PyRefMut<'py, PyLibreDR>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<PyLibreDR> for PyClassImplCollector<PyLibreDR>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for PyLibreDR

const NAME: &'static str = "LibreDR"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn type_object_bound(py: Python<'_>) -> Bound<'_, PyType>

👎Deprecated since 0.23.0: renamed to PyTypeInfo::type_object

Deprecated name for PyTypeInfo::type_object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_type_of_bound(object: &Bound<'_, PyAny>) -> bool

👎Deprecated since 0.23.0: renamed to PyTypeInfo::is_type_of

Deprecated name for PyTypeInfo::is_type_of.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

fn is_exact_type_of_bound(object: &Bound<'_, PyAny>) -> bool

👎Deprecated since 0.23.0: renamed to PyTypeInfo::is_exact_type_of

Deprecated name for PyTypeInfo::is_exact_type_of.

impl DerefToPyAny for PyLibreDR