handle all channel formats for 8, 16 and 32 bps output

Author: robertsulej

plotoptix/_load_lib.py

@@ -66,7 +66,7 @@ def _load_optix_win():
     optix.save_image_to_file_32bps.argtypes = [c_wchar_p]
     optix.save_image_to_file_32bps.restype = c_bool
 
-    optix.get_output.argtypes = [c_void_p, c_int, c_int]
+    optix.get_output.argtypes = [c_void_p, c_int, c_int, c_int]
     optix.get_output.restype = c_bool
 
     optix.get_fps.restype = c_float
@@ -565,8 +565,8 @@ def save_image_to_file_16bps(self, fname): return self._optix.save_image_to_file
 
     def save_image_to_file_32bps(self, fname): return self._optix.save_image_to_file_32bps(fname)
 
-    def get_output(self, buf_ptr, buf_size, depth):
-        return self._optix.get_output_ptr(IntPtr.__overloads__[Int64](buf_ptr), buf_size, depth)
+    def get_output(self, buf_ptr, buf_size, depth, channels):
+        return self._optix.get_output_ptr(IntPtr.__overloads__[Int64](buf_ptr), buf_size, depth, channels)
 
 
     def get_fps(self): return self._optix.get_fps()

plotoptix/bin/RnD.SharpOptiX.dll

@@ -329,55 +329,73 @@ def close(self) -> None:
     def is_started(self) -> bool: return self._is_started
     def is_closed(self) -> bool: return self._is_closed
 
-    def get_rt_output(self, bps: Union[ChannelDepth, str] = ChannelDepth.Bps8) -> np.ndarray:
+    def get_rt_output(self,
+                      bps: Union[ChannelDepth, str] = ChannelDepth.Bps8,
+                      channels: Union[ChannelOrder, str] = ChannelOrder.RGBA) -> Optional[np.ndarray]:
         """Return a copy of the output image.
 
         The image data type is specified with the ``bps`` argument. 8 bit per channel data,
         ``numpy.uint8``, is returned by default. Use ``Bps16`` value to read the image in
         16 bit per channel depth, ``numpy.uint16``. Use ``Bps32`` value to read the HDR image
         in 32 bit per channel format, ``numpy.float32``.
 
-        Channels ordering is RGBA, with constant values in the alpha channel (100% opaque,
-        to be used in the future releases).
+        If channels ordering includes alpha channel then it is a constant, 100% opaque value,
+        to be used in the future releases.
         
         Safe to call at any time, from any thread.
 
         Parameters
         ----------
         bps : ChannelDepth enum or string, optional
             Color depth.
+        channels : ChannelOrder enum or string, optional
+            Color channels ordering.
 
         Returns
         -------
         out : ndarray
-            RGBA array of shape (height, width, 4) and type corresponding to ``bps`` argument.
+            RGB(A) array of shape (height, width, 3) or (height, width, 4) and type corresponding
+            to ``bps`` argument. ``None`` in case of errors.
 
         See Also
         --------
-        :class:`plotoptix.enums.ChannelDepth`
+        :class:`plotoptix.enums.ChannelDepth`, :class:`plotoptix.enums.ChannelOrder`
         """
         assert self._is_started, "Raytracing output not running."
 
         if isinstance(bps, str): bps = ChannelDepth[bps]
+        if isinstance(channels, str): channels = ChannelOrder[channels]
 
         a = None
 
         try:
             self._padlock.acquire()
 
-            ok = True
+            if bps == ChannelDepth.Bps8 and channels == ChannelOrder.RGBA:
+                return self._img_rgba.copy()
 
             if bps == ChannelDepth.Bps8:
-                a = self._img_rgba.copy()
+                if channels == ChannelOrder.BGRA:
+                    a = np.ascontiguousarray(np.zeros((self._height, self._width, 4), dtype=np.uint8))
+                elif channels == ChannelOrder.RGB or channels == ChannelOrder.BGR:
+                    a = np.ascontiguousarray(np.zeros((self._height, self._width, 3), dtype=np.uint8))
+
             elif bps == ChannelDepth.Bps16:
-                a = np.ascontiguousarray(np.zeros((self._height, self._width, 4), dtype=np.uint16))
-                ok = self._optix.get_output(a.ctypes.data, a.nbytes, bps.value)
+                if channels == ChannelOrder.RGBA or channels == ChannelOrder.BGRA:
+                    a = np.ascontiguousarray(np.zeros((self._height, self._width, 4), dtype=np.uint16))
+                elif channels == ChannelOrder.RGB or channels == ChannelOrder.BGR:
+                    a = np.ascontiguousarray(np.zeros((self._height, self._width, 3), dtype=np.uint16))
+
             elif bps == ChannelDepth.Bps32:
-                a = np.ascontiguousarray(np.zeros((self._height, self._width, 4), dtype=np.float32))
-                ok = self._optix.get_output(a.ctypes.data, a.nbytes, bps.value)
+                if channels == ChannelOrder.RGBA or channels == ChannelOrder.BGRA:
+                    a = np.ascontiguousarray(np.zeros((self._height, self._width, 4), dtype=np.float32))
+                elif channels == ChannelOrder.RGB or channels == ChannelOrder.BGR:
+                    a = np.ascontiguousarray(np.zeros((self._height, self._width, 3), dtype=np.float32))
 
-            if not ok:
-                msg = "Image not saveed."
+            else: return a
+
+            if not self._optix.get_output(a.ctypes.data, a.nbytes, bps.value, channels.value):
+                msg = "Image not copied."
                 self._logger.error(msg)
                 if self._raise_on_error: raise ValueError(msg)
 
@@ -1740,7 +1758,7 @@ def save_image(self, file_name: str,
                 ok = False
 
             if not ok:
-                msg = "Image not saveed."
+                msg = "Image not saved."
                 self._logger.error(msg)
                 if self._raise_on_error: raise ValueError(msg)