Gimbal prototype

scripts/v120_gimbal.py

@@ -0,0 +1,16 @@
+from compas_view2 import app
+from compas.geometry import Box
+from compas.geometry import Frame
+
+viewer = app.App()
+
+f = Frame([0, 0, 0], [1, 0, 0], [0, 1, 0])
+box = Box(f, 1, 1, 1)
+
+obj1 = viewer.add(box)
+# obj1.translation = [2, 0, 0]
+
+obj2 = viewer.add(box)
+obj2.translation = [0, 2, 0]
+
+viewer.show()

src/compas_view2/app/app.py

@@ -326,6 +326,12 @@ def add(self, data: Data,
             obj.init()
             if self.dock_slots['sceneform']:
                 self.dock_slots['sceneform'].update()
+
+        def attach_gimbal(_self, event):
+            if self.view.gimbal.enabled:
+                self.view.gimbal.attach(_self)
+        obj.add_event_listener('mousedown', attach_gimbal)
+
         return obj
 
     def add_reference(self, obj: Object, **kwargs) -> Object:
@@ -687,6 +693,10 @@ def _init_statusbar(self):
         self.statusFps = QtWidgets.QLabel('fps: ')
         self.statusbar.addWidget(self.statusFps)
 
+        @self.checkbox("Gimbal", checked=False, parent=self.statusbar)
+        def gimbal(checked):
+            self.view.gimbal.toggle()
+
     def _init_menubar(self, items: List[Dict]):
         if not items:
             return

src/compas_view2/app/selector.py

@@ -50,6 +50,9 @@ class Selector:
 
     def __init__(self, app):
         self.app = app
+        self.gimbal = app.view.gimbal
+        self.mouse = app.view.mouse
+
         # Selector options
         self.mode = "single"
         self.overwrite_mode = None
@@ -66,6 +69,11 @@ def __init__(self, app):
         self.instance_map = None
         self.box_select_coords = np.zeros((4,), np.int)
         self.location_on_plane = None
+
+        if self.gimbal:
+            for component in self.gimbal.components:
+                self.add(component)
+
         self.start_monitor_instance_map()
 
     # -------------------------------------------------------------------------
@@ -111,24 +119,30 @@ def start_monitor_instance_map(self):
         """
         def select():
             if self.instance_map is not None:
-                instance_map = self.instance_map
-                if self.select_from == "pixel":
-                    # Pick an object from mouse pixel
-                    x = self.app.view.mouse.last_pos.x()
-                    y = self.app.view.mouse.last_pos.y()
-                    self.select_one_from_instance_map(x, y, instance_map)
-                if self.select_from == "box":
-                    # Pick objects from box selection
-                    self.select_all_from_instance_map(instance_map)
-                    self.select_from = "pixel"
-                self.app.view.update()
-                self.instance_map = None
+                if self.enabled:
+                    instance_map = self.instance_map
+                    if self.select_from == "pixel":
+                        # Pick an object from mouse pixel
+                        x = self.app.view.mouse.last_pos.x()
+                        y = self.app.view.mouse.last_pos.y()
+                        self.select_one_from_instance_map(x, y, instance_map)
+                    if self.select_from == "box":
+                        # Pick objects from box selection
+                        self.select_all_from_instance_map(instance_map)
+                        self.select_from = "pixel"
+                    self.app.view.update()
+                    # self.instance_map = None
+                    self.enabled = False
 
                 if self.app.dock_slots["propertyform"] is not None and self.selected:
                     self.app.dock_slots["propertyform"].set_object(self.selected[0])
                 if self.app.dock_slots["sceneform"] is not None:
                     self.app.dock_slots["sceneform"].select(self.selected)
 
+                x = self.app.view.mouse.pos.x()
+                y = self.app.view.mouse.pos.y()
+                self.highlight_one_from_instance_map(x, y, self.instance_map)
+
         # Start monitor loop in a separate worker thread
         ticker = Ticker(interval=0.02)
         ticker.signals.tick.connect(select)
@@ -177,12 +191,45 @@ def select_one_from_instance_map(self, x, y, instance_map):
         -------
         None
         """
+        x = min(max(x, 0), instance_map.shape[1] - 1)
+        y = min(max(y, 0), instance_map.shape[0] - 1)
         rgb_key = tuple(instance_map[y][x])
         obj = None
         if rgb_key in self.instances:
             obj = self.instances[rgb_key]
         self.select(obj)
 
+    def highlight_one_from_instance_map(self, x, y, instance_map):
+        """Highlight one object at given pixel location of the instance map
+
+        Parameters
+        ----------
+        x : int
+            x coordinate of the pixel
+        y : int
+            y coordinate of the pixel
+        instance_map: np.array
+            instance map of the current camera view
+
+        Returns
+        -------
+        None
+        """
+        if self.mouse.pressed_on:
+            return
+
+        x = min(max(x, 0), instance_map.shape[1] - 1)
+        y = min(max(y, 0), instance_map.shape[0] - 1)
+        rgb_key = tuple(instance_map[y][x])
+        for key, obj in self.instances.items():
+            if key == rgb_key:
+                obj._is_highlighted = True
+                if self.mouse.is_pressed():
+                    self.mouse.pressed_on = obj
+                    obj.dispatch_event("mousedown", {'x': x, 'y': y})
+            else:
+                obj._is_highlighted = False
+
     def select_all_from_instance_map(self, instance_map):
         """Select all the objects that appear in the instance map
 
@@ -225,16 +272,16 @@ def select(self, obj=None, mode=None, types=None, update=False):
         if mode == 'single':
             if obj:
                 self.deselect()
-                obj.is_selected = True
+                obj.is_selected = obj.is_selectable
         elif mode == 'multi':
             if not obj:
                 return
             if types:
                 for _type in types:
                     if isinstance(obj._data, _type):
-                        obj.is_selected = True
+                        obj.is_selected = obj.is_selectable
             else:
-                obj.is_selected = True
+                obj.is_selected = obj.is_selectable
         elif mode == 'deselect':
             self.deselect(obj)
         else:

src/compas_view2/objects/__init__.py

@@ -24,6 +24,7 @@
 from compas_view2.shapes import Text
 from compas_view2.collections import Collection
 
+
 from .object import Object
 from .bufferobject import BufferObject  # noqa : F401
 
@@ -57,8 +58,10 @@
 from .robotobject import RobotObject
 
 from .object import DATA_OBJECT  # noqa : F401
+from .gimbalobject import GimbalObject  # noqa: F401
 
 Object.register(Point, PointObject)
+
 Object.register(Vector, VectorObject)
 Object.register(Plane, PlaneObject)
 Object.register(Frame, FrameObject)

src/compas_view2/objects/bufferobject.py

@@ -122,6 +122,7 @@ def draw(self, shader, wireframe=False, is_lighted=False):
         shader.enable_attribute('position')
         shader.enable_attribute('color')
         shader.uniform1i('is_selected', self.is_selected)
+        shader.uniform1i('is_highlighted', self._is_highlighted)
         if self._matrix_buffer is not None:
             shader.uniform4x4('transform', self._matrix_buffer)
         shader.uniform1i('is_lighted', is_lighted)
@@ -170,15 +171,15 @@ def draw_instance(self, shader, wireframe=False):
             shader.uniform4x4('transform', self._matrix_buffer)
         if hasattr(self, "_points_buffer") and self.show_points:
             shader.bind_attribute('position', self._points_buffer['positions'])
-            shader.draw_points(size=self.pointsize, elements=self._points_buffer['elements'], n=self._points_buffer['n'])
+            shader.draw_points(size=self.pointsize, elements=self._points_buffer['elements'], n=self._points_buffer['n'], background=self.background)
         if hasattr(self, "_lines_buffer") and (self.show_lines or wireframe):
             shader.bind_attribute('position', self._lines_buffer['positions'])
-            shader.draw_lines(width=self.linewidth, elements=self._lines_buffer['elements'], n=self._lines_buffer['n'])
+            shader.draw_lines(width=self.linewidth, elements=self._lines_buffer['elements'], n=self._lines_buffer['n'], background=self.background)
         if hasattr(self, "_frontfaces_buffer") and self.show_faces and not wireframe:
             shader.bind_attribute('position', self._frontfaces_buffer['positions'])
-            shader.draw_triangles(elements=self._frontfaces_buffer['elements'], n=self._frontfaces_buffer['n'])
+            shader.draw_triangles(elements=self._frontfaces_buffer['elements'], n=self._frontfaces_buffer['n'], background=self.background)
             shader.bind_attribute('position', self._backfaces_buffer['positions'])
-            shader.draw_triangles(elements=self._backfaces_buffer['elements'], n=self._backfaces_buffer['n'])
+            shader.draw_triangles(elements=self._backfaces_buffer['elements'], n=self._backfaces_buffer['n'], background=self.background)
         if self._matrix_buffer is not None:
             shader.uniform4x4('transform', np.identity(4).flatten())
         shader.uniform3f('instance_color', [0, 0, 0])