memory view optimization

docs/examples/viz_streaming_interaction.py

@@ -10,12 +10,16 @@
 # note, if python version is equal or higher than 3.8
 # uses shared memory approach
 if __name__ == '__main__':
+    # se estiver usando python 3.8 e quiser testar o 
+    # raw_array sete use_raw_array=False. 
+    # se estiver usando pytho n3.8 por default escolhe shared memory
+    use_raw_array = None
     use_high_res = False
     if use_high_res:
         window_size = (1280, 720)
         max_window_size = (1920, 1080)
     else:
-        window_size = (500, 400)
+        window_size = (720, 500)
         max_window_size = (600, 600)
     # 0 ms_stream means that the frame will be sent to the server
     # right after the rendering
@@ -72,7 +76,8 @@
     showm.initialize()
 
     stream = FuryStreamClient(
-        showm, window_size, max_window_size=max_window_size)
+        showm, window_size, max_window_size=max_window_size,
+        use_raw_array=use_raw_array)
     stream_interaction = FuryStreamInteraction(
         showm, max_queue_size=max_queue_size, fury_client=stream)
     # linux

fury/stream/client.py

@@ -20,10 +20,10 @@ def __init__(
             self, showm,
             window_size=(200, 200),
             max_window_size=None,
+            use_raw_array=None,
             buffer_count=2,
             image_buffers=None,
-            info_buffer=None,
-            use_raw_array=None):
+            info_buffer=None):
 
         '''
 
@@ -70,12 +70,16 @@ def __init__(
         if use_raw_array:
             self.image_buffer_names = None
             if image_buffers is None:
+                self.image_memory_views = []
                 for _ in range(self.buffer_count):
-                    self.image_buffers.append(multiprocessing.RawArray(
+                    buffer = multiprocessing.RawArray(
                         'B', np.random.randint(
                             0, 255,
                             size=max_window_size[0]*max_window_size[1]*3)
-                        .astype('uint8')))
+                        .astype('uint8'))
+                    self.image_buffers.append(buffer)
+                    self.image_memory_views.append(
+                        np.ctypeslib.as_array(buffer))
             else:
                 self.info_buffer = info_buffer
                 self.image_buffers = image_buffers
@@ -116,19 +120,20 @@ def callback(caller, timerevent):
                 self.window2image_filter.Modified()
                 vtk_image = window2image_filter.GetOutput()
                 vtk_array = vtk_image.GetPointData().GetScalars()
-                num_components = vtk_array.GetNumberOfComponents()
+                # num_components = vtk_array.GetNumberOfComponents()
                 if self.use_raw_array:
                     h, w, _ = vtk_image.GetDimensions()
-                    np_arr = vtk_to_numpy(vtk_array).astype('uint8')
-                    np_arr = np_arr.flatten()
+                    #np_arr = vtk_to_numpy(vtk_array).astype('uint8')
+                    np_arr = np.frombuffer(vtk_array, dtype='uint8')
+                    #np_arr = np_arr.flatten()
                 else:
                     w, h, _ = vtk_image.GetDimensions()
                     np_arr = np.frombuffer(vtk_array, dtype=np.uint8)
 
                 if self.image_buffers is not None:
                     buffer_size = int(h*w)
 
-                    self.info_buffer[0] = num_components
+                    # self.info_buffer[0] = num_components
 
                     # N-Buffering
                     next_buffer_index = (self.info_buffer[1]+1) \
@@ -137,13 +142,20 @@ def callback(caller, timerevent):
                     # 2, 4, 6
                     if buffer_size == self.max_size:
                         if self.use_raw_array:
-                            self.image_buffers[next_buffer_index][:] = np_arr
+                            # throws a type error due uint8
+                            # memoryview(
+                            #     self.image_buffers[next_buffer_index]
+                            # )[:] = np_arr
+                            self.image_memory_views[
+                                next_buffer_index][:] = np_arr
                         else:
                             self.image_reprs[next_buffer_index][:] = np_arr
                     elif buffer_size < self.max_size:
                         if self.use_raw_array:
-                            self.image_buffers[
-                                next_buffer_index][0:buffer_size*3] = np_arr
+                            self.image_memory_views[
+                               next_buffer_index][0:buffer_size*3] = np_arr
+                            # memoryview(self.image_buffers[
+                            #     next_buffer_index])[0:buffer_size*3] = np_arr
                         else:
                             self.image_reprs[
                                 next_buffer_index][0:buffer_size*3] = np_arr
@@ -152,7 +164,7 @@ def callback(caller, timerevent):
                             0, 255, size=self.max_size*3,
                             dtype='uint8')
                         if self.use_raw_array:
-                            self.image_buffers[
+                            self.image_memory_views[
                                 next_buffer_index][:] = rand_img
                         else:
                             self.image_reprs[

fury/stream/tools.py

@@ -16,6 +16,9 @@ def __init__(self, max_size=None, dimension=None, buffers_list=None):
             max_size = np.frombuffer(buffers_list[0], 'float64').shape[0]
 
         self._buffers = buffers_list
+        self._memory_views = [
+            np.ctypeslib.as_array(buffer)
+            for buffer in buffers_list]
         self.dimension = dimension
         self.max_size = max_size
 
@@ -25,7 +28,7 @@ def buffers(self):
 
     @buffers.setter
     def buffers(self, data):
-        self._buffers[:] = data
+        self._memory_views[:] = data
 
     def __getitem__(self, idx):
         return [
@@ -35,7 +38,7 @@ def __getitem__(self, idx):
 
     def __setitem__(self, idx, data):
         for i in range(self.dimension):
-            self._buffers[i][idx] = data[i]
+            self._memory_views[i][idx] = data[i]
 
 
 class CircularQueue:
@@ -52,6 +55,8 @@ def __init__(
 
         self.dimension = buffers.dimension
         self.head_tail_buffer = head_tail_buffer
+        self.head_tail_memview = np.ctypeslib.as_array(self.head_tail_buffer)
+
         self.max_size = buffers.max_size
         self.buffers = buffers
 
@@ -61,15 +66,15 @@ def head(self):
 
     @head.setter
     def head(self, value):
-        self.head_tail_buffer[0] = value
+        self.head_tail_memview[0] = value
 
     @property
     def tail(self):
         return np.frombuffer(self.head_tail_buffer, 'int32')[1]
 
     @tail.setter
     def tail(self, value):
-        self.head_tail_buffer[1] = value
+        self.head_tail_memview[1] = value
 
     @property
     def queue(self):