o3dvis 0.1.0__tar.gz

o3dvis-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

o3dvis-0.1.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.2
+Name: o3dvis
+Version: 0.1.0
+Summary: open3d visualization toolkit
+Home-page: https://github.com/castle945
+Author: castle945
+Author-email: castle945@njust.edu.cn
+License-File: LICENSE
+Requires-Dist: rpyc
+Requires-Dist: pillow
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary

o3dvis-0.1.0/o3dvis/__init__.py

@@ -0,0 +1,8 @@
+from .draw import (
+    draw,
+    draw_cloud,
+    draw_images,
+    draw_voxel,
+    play,
+)
+from .server import RPCServer

o3dvis-0.1.0/o3dvis/config.py

@@ -0,0 +1 @@
+rpc_server_ip, rpc_server_port = '127.0.0.1', 30570

o3dvis-0.1.0/o3dvis/draw.py

@@ -0,0 +1,222 @@
+# Copyright (c) castle945. All rights reserved.
+import numpy as np
+
+from .utils import (
+    read_image,
+    read_pickle,
+    read_points,
+    rpc_func,
+    transform_points,
+)
+
+
+@rpc_func
+def draw_cloud(
+    points: dict | np.ndarray = None,
+    point_type: str = 'XYZI',
+    point_transform: np.ndarray = None,
+    point_labels: np.ndarray = None,
+    point_colormap: list | np.ndarray = None,
+    bboxes3d: np.ndarray = None,
+    bboxes3d_labels: np.ndarray = None,
+    bboxes3d_colormap: list | np.ndarray = None,
+    vis: dict | object = dict(
+        type='Visualizer',
+        window_name='Cloud Viewer',
+        background_color=np.zeros(3),
+        point_size=1),
+    show: bool = True,
+    **kwargs,
+):
+    import open3d as o3d
+
+    from .utils.open3d_utils import (
+        create_bboxes3d_geometry,
+        create_pointcloud_geometry,
+    )
+    from .visualizer import VISUALIZERS
+
+    if show and isinstance(vis, dict):
+        vis = VISUALIZERS[vis.pop('type')]().create_window(**vis)
+
+    if points is not None:
+        points = read_points(**points) if isinstance(points, dict) else points
+        if point_transform is not None:
+            points[:, :3] = transform_points(points[:, :3], point_transform)
+        cloud_geometry = create_pointcloud_geometry(
+            points, labels=point_labels, colormap=point_colormap, point_type=point_type,
+        )
+        vis.add_geometry(cloud_geometry, name='points')
+
+    if bboxes3d is not None:
+        bboxes3d_geometry = create_bboxes3d_geometry(
+            bboxes3d, labels=bboxes3d_labels, colormap=bboxes3d_colormap, draw_heading=True,
+        )
+        vis.add_geometry(bboxes3d_geometry, name='bboxes3d')
+
+    if show:
+        axis_geometry = o3d.geometry.TriangleMesh.create_coordinate_frame(size=3.0, origin=[0, 0, 0])
+        vis.add_geometry(axis_geometry, name='axis')
+        vis.run()
+        vis.destroy_window()
+
+@rpc_func
+def draw_voxel(
+    voxel_centers: np.ndarray = None,
+    voxel_size: np.ndarray = None,
+    voxel_semantics: np.ndarray = None,
+    voxel_colormap: list | np.ndarray = [[0, 1, 0]],
+    voxel_transform: np.ndarray = None,
+    vis: dict | object = dict(
+        type='Visualizer',
+        window_name='Voxel Viewer',
+        background_color=np.ones(3),
+        point_size=10),
+    show: bool = True,
+    **kwargs,
+):
+    import open3d as o3d
+
+    from .utils.open3d_utils import (
+        create_pointcloud_geometry,
+        create_voxels_geometry,
+    )
+    from .visualizer import VISUALIZERS
+    if show and isinstance(vis, dict):
+        vis = VISUALIZERS[vis.pop('type')]().create_window(**vis)
+
+    if voxel_centers is not None:
+        if voxel_transform is not None:
+            voxel_centers[:, :3] = transform_points(voxel_centers[:, :3], voxel_transform)
+        voxel_centers_geometry = create_pointcloud_geometry(
+            voxel_centers, labels=voxel_semantics, colormap=voxel_colormap,
+        )
+        vis.add_geometry(voxel_centers_geometry, name='voxel_centers')
+
+        voxel_grids_geometry = create_voxels_geometry(
+            voxel_centers=voxel_centers, voxel_size=voxel_size, colormap=[[0, 0, 0]],
+        )
+        vis.add_geometry(voxel_grids_geometry, name='voxels')
+
+    if show:
+        axis_geometry = o3d.geometry.TriangleMesh.create_coordinate_frame(size=3.0, origin=[0, 0, 0])
+        vis.add_geometry(axis_geometry, name='axis')
+        vis.run()
+        vis.destroy_window()
+
+@rpc_func
+def draw_images(
+    images: list[dict | np.ndarray] = None,
+    vis: dict | object = dict(
+        type='MMVisualizer',
+        window_name='Image Viewer',
+        background_color=np.zeros(3),
+        layout=[[-1]]),
+    show: bool = True,
+    image_transform: list[np.ndarray] = None,
+    with_bboxes3d: bool = False,
+    with_points: bool = False,
+    **kwargs,
+):
+    from .visualizer import VISUALIZERS
+    if show and isinstance(vis, dict):
+        vis = VISUALIZERS[vis.pop('type')]().create_window(**vis)
+
+    if images is not None:
+        assert type(vis).__name__ in ['MMVisualizer'], f'{type(vis).__name__} does not support image visualization.'
+        images = (
+            [read_image(img['path']) for img in images]
+            if isinstance(images, list) and isinstance(images[0], dict) else images)
+        for i, image in enumerate(images):
+            vis.update_image(image, widgetId=i+1)
+
+    if show:
+        vis.run()
+        vis.destroy_window()
+
+@rpc_func
+def draw(
+    path: str = None,
+    vis: dict | object = dict(
+        type='MMVisualizer',
+        window_name='Multimodal Viewer',
+        background_color=np.zeros(3),
+        point_size=1,
+        layout=[[-1]]),
+    show: bool = True,
+    **kwargs,
+):
+    import open3d as o3d
+
+    from .visualizer import VISUALIZERS
+
+    if show and isinstance(vis, dict):
+        vis = VISUALIZERS[vis.pop('type')]().create_window(**vis)
+
+    if path is not None:
+        data = read_pickle(path)
+        kwargs.update(data)
+
+    draw_cloud(**kwargs, vis=vis, show=False)
+    draw_voxel(**kwargs, vis=vis, show=False)
+    draw_images(**kwargs, vis=vis, show=False)
+
+    if kwargs.get('points') is not None or kwargs.get('voxel_centers') is not None:
+        axis_geometry = o3d.geometry.TriangleMesh.create_coordinate_frame(size=3.0, origin=[0, 0, 0])
+        vis.add_geometry(axis_geometry, name='axis')
+
+    if show:
+        vis.run()
+        vis.destroy_window()
+
+@rpc_func
+def play(
+    root: str,
+    player: dict = dict(
+        type='StepPlayer',
+        start=0,
+        step=10),
+    vis: dict | object = dict(
+        type='MMVisualizer',
+        window_name='Multimodal Player',
+        background_color=np.zeros(3),
+        point_size=1,
+        layout=[[-1]]),
+):
+    from functools import partial
+    from glob import glob
+
+    from .player import PLAYERS
+    from .visualizer import VISUALIZERS
+
+    paths = sorted(glob(f'{root}/*'))
+    def switch_callback(vis, i):
+        print(f'frame {i}: {paths[i]}')
+
+        vis.save_camera_params()
+        vis.clear_geometries()
+
+        data = read_pickle(paths[i])
+        draw(**data, vis=vis, show=False)
+
+        vis.restore_camera_params()
+
+    vis = VISUALIZERS[vis.pop('type')]().create_window(**vis)
+    player = PLAYERS[player.pop('type')](partial(switch_callback, vis), length=len(paths), **player)
+
+    vis.register_key_callback('W', player.prev_n)
+    vis.register_key_callback('S', player.next_n)
+    vis.register_key_callback('A', player.prev)
+    vis.register_key_callback('D', player.next)
+
+    player.start()
+    vis.run()
+    vis.destroy_window()
+
+DRAW_RPC_FUNCS = {
+    'draw_cloud': draw_cloud,
+    'draw_voxel': draw_voxel,
+    'draw_images': draw_images,
+    'draw': draw,
+    'play': play,
+}

o3dvis-0.1.0/o3dvis/player.py

@@ -0,0 +1,29 @@
+# Copyright (c) castle945. All rights reserved.
+
+class StepPlayer:
+
+    def __init__(self, switch_callback, start, step, length):
+        self.switch_callback = switch_callback
+        self.idx = start
+        self.step = step
+        self.length = length
+
+    def prev(self):
+        self.idx = max(self.idx - 1, 0)
+        self.switch_callback(self.idx)
+    def next(self):
+        self.idx = min(self.idx + 1, self.length - 1)
+        self.switch_callback(self.idx)
+    def prev_n(self):
+        self.idx = max(self.idx - self.step, 0)
+        self.switch_callback(self.idx)
+    def next_n(self):
+        self.idx = min(self.idx + self.step, self.length - 1)
+        self.switch_callback(self.idx)
+
+    def start(self):
+        self.switch_callback(self.idx)
+
+PLAYERS = {
+    'StepPlayer': StepPlayer,
+}

o3dvis-0.1.0/o3dvis/server.py

@@ -0,0 +1,30 @@
+import pickle
+
+import rpyc
+from rpyc.utils.server import ThreadedServer
+
+from .config import rpc_server_port
+from .draw import DRAW_RPC_FUNCS
+
+
+class RPCServer:
+
+    @classmethod
+    def start(cls):
+        class RPCService(rpyc.Service):
+            def __init__(self):
+                super().__init__()
+                self.func_map = dict()
+                self.func_map.update(DRAW_RPC_FUNCS)
+                for name, func in self.func_map.items():
+                    setattr(self.__class__, f'exposed_{name}', self._create_exposed_method(name, func))
+
+            def _create_exposed_method(self, name, func):
+                def exposed_method(self, serialized_args, serialized_kwargs):
+                    args, kwargs = pickle.loads(serialized_args), pickle.loads(serialized_kwargs)
+                    return pickle.dumps(func(*args, **kwargs))
+                exposed_method.__name__ = f'exposed_{name}'
+                return exposed_method
+
+        server = ThreadedServer(RPCService, port=rpc_server_port, auto_register=True)
+        server.start()

o3dvis-0.1.0/o3dvis/visualizer.py

@@ -0,0 +1,202 @@
+import numpy as np
+import open3d as o3d
+from open3d.visualization import gui, rendering
+
+
+def create_grid_layout(grid2d: list[list[int]]):
+    grid2d = np.array(grid2d)
+    assert len(grid2d.shape) == 2
+
+    h, w = grid2d.shape
+    grid_h, grid_w = 1. / h, 1. / w
+    widgetIds = set(np.unique(grid2d[grid2d >= 0]))
+    layout = dict()
+    for widgetId in widgetIds:
+        positions = np.argwhere(grid2d == widgetId)
+        min_y, max_y = positions[:, 0].min(), positions[:, 0].max()
+        min_x, max_x = positions[:, 1].min(), positions[:, 1].max()
+        assert len(positions) == (max_y - min_y + 1) * (max_x - min_x + 1)
+        layout[widgetId] = (min_x * grid_w, min_y * grid_h, (max_x - min_x + 1) * grid_w, (max_y - min_y + 1) * grid_h)
+    return layout
+
+class Visualizer:
+    def __init__(self):
+        self.vis = o3d.visualization.VisualizerWithKeyCallback()
+        self.camera_params = None
+
+    def create_window(
+        self,
+        window_name: str = 'Open3D',
+        width: int = 1920,
+        height: int = 1080,
+        background_color: np.ndarray = np.zeros(3),
+        point_size: int = 1,
+        **kwargs,
+    ):
+        self.vis.create_window(window_name, width, height)
+        self.vis.get_render_option().background_color = background_color
+        self.vis.get_render_option().point_size = point_size
+        return self
+
+    def add_geometry(self, geometry, **kwargs):
+        self.vis.add_geometry(geometry)
+
+    def clear_geometries(self):
+        self.vis.clear_geometries()
+
+    def run(self):
+        self.vis.run()
+
+    def destroy_window(self):
+        self.vis.destroy_window()
+
+    def register_key_callback(self, key: str, callback: callable):
+        self.vis.register_key_callback(ord(key), lambda vis: callback())
+
+    def save_camera_params(self):
+        if self.camera_params is not None:
+            self.camera_params = self.vis.get_view_control().convert_to_pinhole_camera_parameters()
+
+    def restore_camera_params(self):
+        if self.camera_params is None:
+            self.camera_params = self.vis.get_view_control().convert_to_pinhole_camera_parameters()
+        self.vis.get_view_control().convert_from_pinhole_camera_parameters(self.camera_params, allow_arbitrary=True)
+        self.vis.update_renderer()
+
+class MMVisualizer:
+
+    def __init__(self):
+        self.default_material = rendering.MaterialRecord()
+        self.camera_params = None
+        self.key_callbacks = dict()
+
+    def on_layout(self, layout_context):
+        R = self.window.content_rect
+        offx, offy, content_width, content_height = R.x, R.y, R.width, R.height
+        if self.widget3d:
+            relx, rely, relw, relh = self.layout[0]
+            x = int(offx + relx * content_width)
+            y = int(offy + rely * content_height)
+            widget_width = int(relw * content_width)
+            widget_height = int(relh * content_height)
+            self.widget3d.frame = gui.Rect(x, y, widget_width, widget_height)
+
+        for widgetId, widget in self.widgets2d.items():
+            relx, rely, relw, relh = self.layout[widgetId]
+            x = int(offx + relx * content_width)
+            y = int(offy + rely * content_height)
+            widget_width = int(relw * content_width)
+            widget_height = int(relh * content_height)
+            widget.frame = gui.Rect(x, y, widget_width, widget_height)
+
+    def on_key(self, event):
+        if event.type == gui.KeyEvent.Type.DOWN:
+            for key, callback in self.key_callbacks.items():
+                if event.key == key:
+                    callback()
+                    return True
+
+            if self.widget3d and (event.key == gui.KeyName.MINUS or event.key == gui.KeyName.EQUALS):
+                point_size = int(self.default_material.point_size / self.window.scaling)
+                if event.key == gui.KeyName.MINUS:
+                    self.default_material.point_size = max(point_size - 1, 0) * self.window.scaling
+                elif event.key == gui.KeyName.EQUALS:
+                    self.default_material.point_size = (point_size + 1) * self.window.scaling
+                self.widget3d.scene.update_material(self.default_material)
+        return False
+
+    def create_window(
+        self,
+        window_name: str = 'Open3D',
+        width: int = 1920,
+        height: int = 1080,
+        background_color: np.ndarray = np.zeros(4),
+        point_size: int = 1,
+        layout: list = [[-1]],
+        **kwargs,
+    ):
+        self.app = gui.Application.instance
+        self.app.initialize()
+        self.window = self.app.create_window(window_name, width, height)
+
+        self.widget3d = None
+        self.widgets2d = dict()
+        self.layout = create_grid_layout(layout)
+        for widgetId in self.layout.keys():
+            if widgetId == 0:
+                widget3d = gui.SceneWidget()
+                widget3d.scene = rendering.Open3DScene(self.window.renderer)
+                self.window.add_child(widget3d)
+                self.widget3d = widget3d
+            elif widgetId > 0:
+                widget2d = gui.ImageWidget()
+                self.window.add_child(widget2d)
+                self.widgets2d[widgetId] = widget2d
+
+        self.window.set_on_layout(self.on_layout)
+        self.window.set_on_key(self.on_key)
+
+        if self.widget3d:
+            background_color = np.append(background_color, 1.0) if len(background_color) == 3 else background_color
+            self.widget3d.scene.set_background(background_color)
+            self.default_material.point_size = point_size * self.window.scaling
+        return self
+
+    def add_geometry(
+        self,
+        geometry: object,
+        name: str,
+        reset_bounding_box: bool = True,
+    ):
+        self.widget3d.scene.add_geometry(name, geometry, self.default_material)
+
+        if reset_bounding_box:
+            bounds = self.widget3d.scene.bounding_box
+            center_of_rotation = bounds.get_center()
+            extent = bounds.get_extent()
+            distance = max(np.linalg.norm(extent) * 2.5 / np.sqrt(3), 0.001)
+            fov = 60
+            self.widget3d.setup_camera(fov, bounds, center_of_rotation)
+            self.widget3d.look_at(center_of_rotation, center_of_rotation + [0, 0, distance], [0, -1, 0])
+
+    def update_image(self, image: np.ndarray | o3d.geometry.Image, widgetId: int = 1):
+        assert widgetId > 0
+        if isinstance(image, np.ndarray):
+            image = o3d.geometry.Image(image)
+        self.widgets2d[widgetId].update_image(image)
+
+    def clear_geometries(self):
+        if self.widget3d:
+            self.widget3d.scene.clear_geometry()
+
+    def run(self):
+        self.app.run()
+
+    def destroy_window(self):
+        self.window.close()
+
+    def register_key_callback(self, key: str, callback: callable):
+        key = getattr(gui.KeyName, key)
+        self.key_callbacks[key] = callback
+
+    def save_camera_params(self):
+        if self.widget3d:
+            camera = self.widget3d.scene.camera
+            self.camera_params = dict(
+                model_matrix=camera.get_model_matrix(),
+                fov=camera.get_field_of_view(),
+            )
+
+    def restore_camera_params(self):
+        if self.widget3d and self.camera_params:
+            mat = self.camera_params['model_matrix']
+            eye = mat[:3, 3]
+            forward = -mat[:3, 2]
+            up = mat[:3, 1]
+            center = eye + forward
+            self.widget3d.look_at(center, eye, up)
+
+VISUALIZERS = {
+    'Visualizer': Visualizer,
+    'MMVisualizer': MMVisualizer,
+}

o3dvis-0.1.0/o3dvis.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.2
+Name: o3dvis
+Version: 0.1.0
+Summary: open3d visualization toolkit
+Home-page: https://github.com/castle945
+Author: castle945
+Author-email: castle945@njust.edu.cn
+License-File: LICENSE
+Requires-Dist: rpyc
+Requires-Dist: pillow
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary

o3dvis-0.1.0/o3dvis.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+setup.py
+o3dvis/__init__.py
+o3dvis/config.py
+o3dvis/draw.py
+o3dvis/player.py
+o3dvis/server.py
+o3dvis/visualizer.py
+o3dvis.egg-info/PKG-INFO
+o3dvis.egg-info/SOURCES.txt
+o3dvis.egg-info/dependency_links.txt
+o3dvis.egg-info/requires.txt
+o3dvis.egg-info/top_level.txt
+tests/test_draw.py

o3dvis-0.1.0/o3dvis.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

o3dvis-0.1.0/o3dvis.egg-info/requires.txt

@@ -0,0 +1,2 @@
+rpyc
+pillow

o3dvis-0.1.0/o3dvis.egg-info/top_level.txt

@@ -0,0 +1 @@
+o3dvis

o3dvis-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

o3dvis-0.1.0/setup.py

@@ -0,0 +1,29 @@
+# Copyright (c) castle945. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from setuptools import setup
+
+setup(
+    name='o3dvis',
+    version='0.1.0',
+    packages=['o3dvis'],
+    author='castle945',
+    author_email='castle945@njust.edu.cn',
+    url='https://github.com/castle945',
+    description='open3d visualization toolkit',
+    install_requires=[
+        'rpyc',
+        'pillow',
+    ],
+)

o3dvis-0.1.0/tests/test_draw.py

@@ -0,0 +1,219 @@
+import numpy as np
+import pytest
+
+import o3dvis
+
+NUS_ROOT = '/datasets/nuScenes'
+
+def _generate_vis_data():
+    # mini_nuscenes_infos_val.pkl sample_idx=0 token=3e8750f331d7499e9b5123e9eb70f2e2
+    images = [
+        dict(path=f'{NUS_ROOT}/samples/CAM_FRONT/n008-2018-08-01-15-16-36-0400__CAM_FRONT__1533151603512404.jpg'),
+        dict(path=f'{NUS_ROOT}/samples/CAM_FRONT_RIGHT/n008-2018-08-01-15-16-36-0400__CAM_FRONT_RIGHT__1533151603520482.jpg'),
+        dict(path=f'{NUS_ROOT}/samples/CAM_FRONT_LEFT/n008-2018-08-01-15-16-36-0400__CAM_FRONT_LEFT__1533151603504799.jpg'),
+        dict(path=f'{NUS_ROOT}/samples/CAM_BACK/n008-2018-08-01-15-16-36-0400__CAM_BACK__1533151603537558.jpg'),
+        dict(path=f'{NUS_ROOT}/samples/CAM_BACK_LEFT/n008-2018-08-01-15-16-36-0400__CAM_BACK_LEFT__1533151603547405.jpg'),
+        dict(path=f'{NUS_ROOT}/samples/CAM_BACK_RIGHT/n008-2018-08-01-15-16-36-0400__CAM_BACK_RIGHT__1533151603528113.jpg'),
+    ]
+
+    points = dict(
+        path=f'{NUS_ROOT}/samples/LIDAR_TOP/n008-2018-08-01-15-16-36-0400__LIDAR_TOP__1533151603547590.pcd.bin',
+        num_features=5)
+
+    pts_semantic_mask_path = f'{NUS_ROOT}/lidarseg/v1.0-mini/fdddd75ee1d94f14a09991988dab8b3e_lidarseg.bin'
+    label_mapping = dict([
+        (1, 0), (5, 0), (7, 0), (8, 0), (10, 0), (11, 0), (13, 0),
+        (19, 0), (20, 0), (0, 0), (29, 0), (31, 0), (9, 1), (14, 2),
+        (15, 3), (16, 3), (17, 4), (18, 5), (21, 6), (2, 7), (3, 7),
+        (4, 7), (6, 7), (12, 8), (22, 9), (23, 10), (24, 11), (25, 12),
+        (26, 13), (27, 14), (28, 15), (30, 16)])
+    point_colormap = [
+        [0  , 0  , 0  ],  # 0  others               通用障碍     黑色
+        [0  , 0  , 255],  # 1  barrier              围挡障碍     蓝色
+        [174, 112, 0  ],  # 2  bicycle              自行车      棕黄
+        [255, 180, 170],  # 3  bus                  公交车      粉红
+        [255, 128, 0  ],  # 4  car                  汽车        橙色
+        [255, 0  , 0  ],  # 5  construction_vehicle 建筑车辆吊车  红色
+        [163, 217, 0  ],  # 6  motorcycle           摩托车      葱黄
+        [255, 255, 0  ],  # 7  pedestrian           行人        黄色
+        [6  , 82 , 121],  # 8  traffic_cone         交通锥      靛蓝
+        [255, 0  , 150],  # 9  trailer              拖车        洋红
+        [160, 0  , 0  ],  # 10 trunk                卡车        暗红
+        [0  , 255, 255],  # 11 driveable_surface    路面        靛色
+        [100, 100, 100],  # 12 other_flat           道中屏障     深灰
+        [255, 180, 255],  # 13 sidewalk             人行道       浅浅紫
+        [255, 100, 255],  # 14 terrain    地形即人行道外的路面     浅紫
+        [200, 200, 200],  # 15 manmade         人造建筑如墙等     浅灰
+        [0  , 180, 0  ],  # 16 vegetation           植被        绿色
+    ]
+    point_labels = np.fromfile(pts_semantic_mask_path, dtype=np.uint8)
+    point_labels = np.vectorize(label_mapping.__getitem__, otypes=[np.int64])(point_labels)
+
+    # instances = mini_nuscenes_infos_val["data_list"][0]["instances"]
+    # instances = [inst for inst in instances if inst["num_lidar_pts"] > 0]
+    # [inst["bbox_3d"][:7] for inst in instances] [inst["bbox_label_3d"] for inst in instances]
+    first6_bboxes3d = np.array([
+        [ -7.96, 36.90,  0.21, 0.65, 0.62, 1.78, -1.78],
+        [  7.39, 17.46, -0.18, 0.94, 0.69, 1.90, -1.80],
+        [-10.37, 14.92, -0.54, 0.61, 0.58, 1.75, -1.53],
+        [-40.42, 17.11, -1.19, 1.11, 0.91, 2.00, -3.14],
+        [  9.88, 29.82,  0.11, 1.03, 0.75, 1.98, -1.73],
+        [  6.62, 42.97,  0.61, 4.73, 2.00, 1.48,  1.18],])
+    first6_bboxes3d_labels = np.array([7, 7, 7, 7, 7, 0])
+    det24cls_colormap = [
+        [1.0, 0.0, 0.0], # 红
+        [1.0, 0.5, 0.0], # 橙
+        [1.0, 1.0, 0.0], # 黄
+        [0.0, 0.0, 1.0], # 蓝
+        [0.0, 1.0, 1.0], # 靛
+        [1.0, 0.0, 1.0], # 紫
+        [1.0, 1.0, 0.5],
+        [1.0, 0.5, 1.0],
+        [1.0, 0.5, 0.5],
+        [1.0, 0.0, 0.5],
+        [0.5, 1.0, 1.0],
+        [0.5, 1.0, 0.5],
+        [0.5, 1.0, 0.0],
+        [0.5, 0.5, 1.0],
+        [0.5, 0.5, 0.5],
+        [0.5, 0.5, 0.0],
+        [0.5, 0.0, 1.0],
+        [0.5, 0.0, 0.5],
+        [0.5, 0.0, 0.0],
+        [0.0, 1.0, 0.5],
+        [0.0, 0.5, 1.0],
+        [0.0, 0.5, 0.5],
+        [0.0, 0.5, 0.0],
+        [0.0, 0.0, 0.5],
+    ]
+
+    voxel_semantic_mask_path = f'{NUS_ROOT}/surroundocc/samples/n008-2018-08-01-15-16-36-0400__LIDAR_TOP__1533151603547590.pcd.bin.npy'
+    point_cloud_range = np.array([-50.0, -50.0, -5.0, 50.0, 50.0, 3.0])
+    voxel_size = [0.5, 0.5, 0.5]
+    sparse_labels = np.load(voxel_semantic_mask_path)
+    voxel_centers = np.vstack((sparse_labels[:, 0], sparse_labels[:, 1], sparse_labels[:, 2])).T * voxel_size
+    voxel_centers = voxel_centers + point_cloud_range[0:3]
+    voxel_semantics = sparse_labels[:, 3]
+
+    return dict(
+        images=images,
+        points=points,
+        point_type='XYZIR',
+        point_labels=point_labels,
+        point_colormap=point_colormap,
+        bboxes3d=first6_bboxes3d,
+        bboxes3d_labels=first6_bboxes3d_labels,
+        bboxes3d_colormap=det24cls_colormap,
+        voxel_centers=voxel_centers,
+        voxel_size=voxel_size,
+        voxel_semantics=voxel_semantics,
+        voxel_colormap=point_colormap,
+    )
+
+data = _generate_vis_data()
+
+def test_draw_images():
+    o3dvis.draw_images(
+        images=data['images'],
+        vis=dict(
+            type='MMVisualizer',
+            window_name='Image Viewer',
+            background_color=np.zeros(3),
+            layout=[[3, 1, 2], [5, 4, 6]],
+        ),
+    )
+
+def test_draw_cloud():
+    o3dvis.draw_cloud(
+        points=data['points'],
+        point_type=data['point_type'],
+        # point_colormap=[[255, 255, 255]],
+        # rpc=True,
+    )
+
+def test_draw_cloud_seg3d():
+    o3dvis.draw_cloud(
+        points=data['points'],
+        point_type=data['point_type'],
+        point_labels=data['point_labels'],
+        point_colormap=data['point_colormap'],
+    )
+
+def test_draw_cloud_pcdet():
+    o3dvis.draw_cloud(
+        points=data['points'],
+        point_type=data['point_type'],
+        bboxes3d=data['bboxes3d'],
+        bboxes3d_labels=data['bboxes3d_labels'],
+        bboxes3d_colormap=data['bboxes3d_colormap'],
+    )
+
+def test_draw_mvxdet():
+    o3dvis.draw(
+        points=data['points'],
+        point_type=data['point_type'],
+        bboxes3d=data['bboxes3d'],
+        bboxes3d_labels=data['bboxes3d_labels'],
+        bboxes3d_colormap=data['bboxes3d_colormap'],
+        images=data['images'],
+        vis=dict(
+            type='MMVisualizer',
+            window_name='Multimodal 3D Detection Viewer',
+            background_color=np.zeros(4),
+            layout=[[3, 1, 2], [0, 0, 0], [0, 0, 0], [0, 0, 0], [5, 4, 6]],
+        ),
+    )
+
+def test_draw_voxel():
+    o3dvis.draw_voxel(
+        voxel_centers=data['voxel_centers'],
+        voxel_size=data['voxel_size'],
+        voxel_semantics=data['voxel_semantics'],
+        voxel_colormap=data['voxel_colormap'],
+    )
+
+def test_draw_mvocc():
+    o3dvis.draw(
+        voxel_centers=data['voxel_centers'],
+        voxel_size=data['voxel_size'],
+        voxel_semantics=data['voxel_semantics'],
+        voxel_colormap=data['voxel_colormap'],
+        images=data['images'],
+        vis=dict(
+            type='MMVisualizer',
+            window_name='Multimodal 3D Occupancy Viewer',
+            background_color=np.ones(4),
+            point_size=10,
+            layout=[[3, 1, 2], [0, 0, 0], [0, 0, 0], [0, 0, 0], [5, 4, 6]],
+        ),
+    )
+
+@pytest.mark.skip(reason='')
+def test_draw_file():
+    o3dvis.draw(
+        path='/workspace/codevault/Occ3D/OpenOcc3D/work_dirs/test_superocc/test_val/20261110_040635/vis_buffer/000000.pkl',
+        vis=dict(
+            type='MMVisualizer',
+            window_name='Multimodal 3D Occupancy Viewer',
+            background_color=np.ones(4),
+            point_size=10,
+            layout=[[3, 1, 2], [0, 0, 0], [0, 0, 0], [0, 0, 0], [5, 4, 6]],
+        ),
+        # rpc=True,
+    )
+
+@pytest.mark.skip(reason='')
+def test_play_dir():
+    o3dvis.play(
+        root='/workspace/codevault/Occ3D/OpenOcc3D/work_dirs/test_superocc/test_val/20261110_040635/vis_buffer',
+        vis=dict(
+            type='MMVisualizer',
+            window_name='Multimodal 3D Occupancy Viewer',
+            background_color=np.ones(4),
+            point_size=10,
+            layout=[[3, 1, 2], [0, 0, 0], [0, 0, 0], [0, 0, 0], [5, 4, 6]],
+        ),
+    )
+
+if __name__ == '__main__':
+    test_draw_file()