• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• PyOptiX-master
  • examples
    • buffers_of_buffers
      • phong.h
      • optixBuffersOfBuffers.cu
      • common_structs.py
      • sphere_texcoord.cu
      • constantbg.cu
      • buffers_of_buffers.py
      • commonStructs.h
      • helpers.h
      • __init__.py
      • pinhole_camera.cu
      • phong.cu
      • parallelogram.cu
    • sphere
      • normal_shader.cu
      • constantbg.cu
      • sphere.cu
      • helpers.h
      • sphere.py
      • __init__.py
      • pinhole_camera.cu
    • texture_sampler
      • draw_texture.cu
      • texture_sampler.py
      • __init__.py
    • common.py
    • __init__.py
    • hello
      • draw_color.cu
      • __init__.py
      • hello.py
  • LICENSE
  • setup.py
  • driver
    • selector.h
    • texture_sampler.h
    • context.cpp
    • transform.h
    • main.cpp
    • scoped.h
    • material.h
    • texture_sampler.cpp
    • context.h
    • shared_includes.h
    • group.h
    • program.cpp
    • material.cpp
    • transform.cpp
    • group.cpp
    • destroyable.cpp
    • geometry.h
    • program.h
    • scoped.cpp
    • variable.h
    • variable.cpp
    • geometry_instance.cpp
    • geometry.cpp
    • selector.cpp
    • acceleration.cpp
    • buffer.cpp
    • destroyable.h
    • geometry_group.cpp
    • geometry_instance.h
    • geometry_group.h
    • acceleration.h
    • buffer.h
  • pyoptix
    • entry_point.py
    • transform.py
    • geometry.py
    • material.py
    • selector.py
    • texture_sampler.py
    • geometry_instance.py
    • geometry_group.py
    • buffer.py
    • variable.py
    • group.py
    • __init__.py
    • utils.py
    • compiler.py
    • context.py
    • acceleration.py
    • enums.py
    • program.py
    • mixins
      • bindless.py
      • scoped.py
      • parent.py
      • __init__.py
      • destroyable.py
      • hascontext.py
      • graphnode.py
  • README.md
  • requirements.txt
  • Dockerfile
  • .gitignore
  • .dockerignore
  • MANIFEST.in

import numpy
from pyoptix.enums import Format, convert_buffer_type, get_format_from_dtype
from pyoptix.context import current_context
from pyoptix.mixins.bindless import BindlessMixin
from pyoptix.mixins.destroyable import DestroyableObject
from pyoptix.mixins.hascontext import HasContextMixin


class Buffer(HasContextMixin, DestroyableObject, BindlessMixin):
    def __init__(self, buffer_type='io'):
        HasContextMixin.__init__(self, current_context())
        DestroyableObject.__init__(self, self._safe_context._create_buffer(convert_buffer_type(buffer_type)))
        BindlessMixin.__init__(self)

        self._numpy_dtype = None
        self._numpy_shape = None
        self._last_dim_dropped = False

    @property
    def id(self):
        return self.get_id()

    @property
    def numpy_shape(self):
        return self._numpy_shape

    @property
    def shape(self):
        return self._safe_native.get_size()

    @property
    def dtype(self):
        return numpy.dtype(self._numpy_dtype)

    @property
    def size(self):
        return self._safe_native.get_size_in_bytes()

    @property
    def element_size(self):
        return self._safe_native.get_element_size()

    @classmethod
    def empty(cls, shape, dtype=numpy.float32, buffer_type='io', drop_last_dim=False):
        instance = cls(buffer_type=buffer_type)
        instance._reset_buffer(shape, dtype, drop_last_dim)
        return instance

    @classmethod
    def from_array(cls, array, dtype=None, buffer_type='io', drop_last_dim=False):
        if not isinstance(array, numpy.ndarray):
            try:
                array = numpy.array(array, dtype=dtype)
            except Exception as e:
                raise TypeError('array parameter must be a numpy array or castable to numpy array')

        instance = cls(buffer_type=buffer_type)
        instance._restructure_and_copy_from_numpy_array(array, drop_last_dim)
        return instance

    def get_id(self):
        return self._safe_native.get_id()

    def mark_dirty(self):
        self._safe_native.mark_dirty()

    def get_element_size(self):
        return self._safe_native.get_element_size()

    def get_size(self):
        return self._safe_native.get_size()

    def get_size_in_bytes(self):
        return self._safe_native.get_size_in_bytes()

    def set_format(self, format=None, dtype=None, type_size=1):
        _format = None

        if format is not None:
            if isinstance(format, Format):
                _format = format
            else:
                raise ValueError('Invalid buffer format')
        elif dtype is not None:
            try:
                dtype = numpy.dtype(dtype)
                _format = get_format_from_dtype(dtype, type_size)
            except TypeError:
                raise ValueError('Invalid dtype argument')

        self._safe_native.set_format(_format)

    def _reset_buffer(self, numpy_shape, dtype=numpy.float32, drop_last_dim=False):
        self._numpy_dtype = numpy.dtype(dtype)
        self._numpy_shape = numpy_shape

        item_size = self._numpy_dtype.itemsize
        temp_shape = numpy_shape
        type_size = 1

        if drop_last_dim:
            item_size = numpy_shape[-1] * self._numpy_dtype.itemsize
            temp_shape = numpy_shape[0:-1]
            type_size = numpy_shape[-1]
            self._last_dim_dropped = True

        self.set_format(dtype=dtype, type_size=type_size)
        if self._safe_native.get_format() == Format.user:
            self._safe_native.set_element_size(item_size)

        # convert numpy dim to optix dim (inverting shape)
        temp_shape = temp_shape[::-1]
        self._safe_native.set_size(list(temp_shape))

    def _restructure_according_to_numpy_array(self, numpy_array, drop_last_dim=False):
        self._reset_buffer(numpy_shape=numpy_array.shape, dtype=numpy_array.dtype, drop_last_dim=drop_last_dim)

    def _restructure_and_copy_from_numpy_array(self, numpy_array, drop_last_dim=False):
        self._restructure_according_to_numpy_array(numpy_array, drop_last_dim)
        self.copy_from_array(numpy_array)

    def to_array(self):
        numpy_array = numpy.empty(self._numpy_shape, dtype=self.dtype)
        self.copy_to_array(numpy_array)
        return numpy_array

    def copy_to_array(self, numpy_array):
        if numpy_array.nbytes != self._safe_native.get_size_in_bytes():
            raise BufferError("Arrays size must be equal!")

        self._safe_native.copy_into_array(numpy_array)

    def copy_from_array(self, numpy_array):
        if numpy_array.nbytes != self._safe_native.get_size_in_bytes():
            raise BufferError("Arrays size must be equal!")

        self._safe_native.copy_from_array(numpy_array)

    def set_mip_level_count(self, level_count):
        self._safe_native.set_mip_level_count(level_count)

    def get_mip_level_count(self):
        return self._safe_native.get_mip_level_count()

    def get_mip_level_size(self):
        return self._safe_native.get_mip_level_size()

    def get_mip_level_size_in_bytes(self):
        return self._safe_native.get_mip_level_size_in_bytes()

    def copy_level_from_array(self, level, numpy_array):
        if numpy_array.nbytes != self._safe_native.get_mip_level_size_in_bytes(level):
            raise BufferError("Arrays size must be equal!")

        self._safe_native.copy_mip_level_from_array(level, numpy_array)

    def copy_level_from_buffer(self, level, buffer):
        if not isinstance(buffer, Buffer):
            raise TypeError('buffer is not of type Buffer')
        self.copy_level_from_array(self, level, buffer.to_array())

    def validate(self):
        self._safe_native.validate()