Signal 11 in open3d

[MeyerBuaharon]

i am having some issues with running a script i wrote in python.
what it does is build a pcd, and updating the visualizer.

I can't really figure out why I got signal 11 completely random, maybe its my uses of threads..?

The error happens randomly and crashes between 10s-10m after starting the program.

I ran profiler but everything seems to be working fine

this the code that cause the error:

import numpy as np
import open3d as o3d
import open3d.visualization.gui as gui
import open3d.visualization.rendering as rendering
import time
import threading

from open3d.cuda.pybind.core import Tensor


class VideoWindow:

    def __init__(self):
        self.pcdA = o3d.t.geometry.PointCloud()
        self.pcdB = o3d.t.geometry.PointCloud()

        self.window = gui.Application.instance.create_window("Open3D - Video Example", 1000, 500)

        self.widget3d = gui.SceneWidget()
        self.widget3d.scene = rendering.Open3DScene(self.window.renderer)
        self.window.add_child(self.widget3d)

        self.is_done = False
        threading.Thread(target=self._update_thread).start()

    def get_ply_from_shared_mem(self, pcd):
        data_lines = np.random.randint(100, 100000)
        buff_x2 = np.random.randint(-100, 100, size=data_lines)
        buff_y2 = np.random.randint(-100, 100, size=data_lines)
        buff_z2 = np.random.randint(-100, 100, size=data_lines)
        buff_r2 = np.random.randint(-100, 100, size=data_lines)
        buff_g2 = np.random.randint(-100, 100, size=data_lines)
        buff_b2 = np.random.randint(-100, 100, size=data_lines)

        self.load_point_cloud(data_lines, buff_x2, buff_y2, buff_z2, buff_r2, buff_g2, buff_b2, pcd)

    def load_point_cloud(self, data_lines, buff_x_breakdown, buff_y_breakdown, buff_z_breakdown,
                         buff_r_breakdown, buff_g_breakdown, buff_b_breakdown, pcd):

        xyz = np.zeros((data_lines, 3))
        colors = np.zeros((data_lines, 3))

        xyz[:, 0] = buff_x_breakdown
        xyz[:, 1] = buff_y_breakdown
        xyz[:, 2] = buff_z_breakdown

        colors[:, 0] = buff_r_breakdown
        colors[:, 1] = buff_g_breakdown
        colors[:, 2] = buff_b_breakdown

        xyz = Tensor(xyz, dtype=o3d.core.float32)
        colors = Tensor(colors, dtype=o3d.core.float32)

        tempPcd = o3d.t.geometry.PointCloud({
            'positions': xyz,
            'colors': colors,
        })

        if pcd == 'A':
            self.pcdA = tempPcd
        if pcd == 'B':
            self.pcdB = tempPcd

    def get_ply_a(self):
        while True:
            time.sleep(1 / 60)
            if True:
                try:
                    self.get_ply_from_shared_mem('A')
                    self.widget3d.scene.scene.update_geometry('frameA', self.pcdA,
                                                              rendering.Scene.UPDATE_POINTS_FLAG |
                                                              rendering.Scene.UPDATE_COLORS_FLAG)
                except:
                    print('cant get pcd A')

    def get_ply_b(self):
        while True:
            time.sleep(1 / 60)
            if True:
                try:
                    self.get_ply_from_shared_mem('B')
                    self.widget3d.scene.scene.update_geometry('frameB', self.pcdB,
                                                              rendering.Scene.UPDATE_POINTS_FLAG |
                                                              rendering.Scene.UPDATE_COLORS_FLAG)
                except:
                    print('cant get pcd B')
                    pass

    def _update_thread(self):
        pcd_placeholder = o3d.t.geometry.PointCloud(Tensor(np.zeros((1000000, 3), dtype=np.float32)))
        pcd_placeholder.point['colors'] = Tensor(np.zeros((1000000, 3), dtype=np.float32))
        self.widget3d.scene.scene.add_geometry('frameA', pcd_placeholder, rendering.MaterialRecord())
        self.widget3d.scene.scene.add_geometry('frameB', pcd_placeholder, rendering.MaterialRecord())

        threading.Thread(target=self.get_ply_a).start()
        threading.Thread(target=self.get_ply_b).start()

        while not self.is_done:
            time.sleep(1 / 60)
            self.window.post_redraw()


def main():
    gui.Application.instance.initialize()
    win = VideoWindow()
    gui.Application.instance.run()


if __name__ == "__main__":
    main()

would love you guys insight on this problem