fix: improvements to the plot view

rotary_controller_python/components/home/home_page.kv

@@ -1,39 +1,11 @@
 #: import HomeToolbar components.home.home_toolbar
-#: import CoordBar components.coordbar
-#: import ServoBar components.servobar
-#: import StatusBar components.statusbar
 
 <HomePage>:
   orientation: "horizontal"
-  scale_x: scale_x
-  scale_y: scale_y
-  scale_z: scale_z
-  scale_a: scale_a
-  servo: servo
-  status_bar: status_bar
+  bars_container: bars_container
 
   HomeToolbar:
     id: toolbar
   BoxLayout:
-    orientation: "vertical"
-    StatusBar:
-      id: status_bar
-    CoordBar:
-      id: scale_x
-      inputIndex: 0
-      device: root.device
-    CoordBar:
-      id: scale_y
-      inputIndex: 1
-      device: root.device
-    CoordBar:
-      id: scale_z
-      inputIndex: 2
-      device: root.device
-    CoordBar:
-      id: scale_a
-      inputIndex: 3
-      device: root.device
-    ServoBar:
-      id: servo
-      device: root.device
+    id: bars_container
+    orientation: "vertical"

rotary_controller_python/components/home/home_page.py

@@ -7,10 +7,15 @@
 from kivy.lang import Builder
 from kivy.logger import Logger
 from kivy.properties import (
+    ListProperty,
     ObjectProperty,
 )
 from kivy.uix.boxlayout import BoxLayout
 
+from rotary_controller_python.components.coordbar import CoordBar
+from rotary_controller_python.components.servobar import ServoBar
+from rotary_controller_python.components.statusbar import StatusBar
+
 log = Logger.getChild(__name__)
 
 current_app = App.get_running_app()
@@ -23,14 +28,26 @@
 class HomePage(BoxLayout):
     device = ObjectProperty()
     status_bar = ObjectProperty()
-    scale_x = ObjectProperty()
-    scale_y = ObjectProperty()
-    scale_z = ObjectProperty()
-    scale_a = ObjectProperty()
+    bars_container = ObjectProperty()
+    coord_bars = ListProperty([])
     servo = ObjectProperty()
 
-    def __init__(self, **kv):
+    def __init__(self, device, **kv):
         super().__init__(**kv)
+        self.device = device
+
+        self.status_bar = StatusBar()
+        self.bars_container.add_widget(self.status_bar)
+        coord_bars = []
+        for i in range(4):
+            bar = CoordBar(inputIndex=i, device=self.device)
+            coord_bars.append(bar)
+            self.bars_container.add_widget(bar)
+
+        self.coord_bars = coord_bars
+        self.servo = ServoBar(device=self.device)
+        self.bars_container.add_widget(self.servo)
+
         self._keyboard = Window._system_keyboard
         self._keyboard.bind(on_key_down=self._on_keyboard_down)
         self.exit_stack = ExitStack()

rotary_controller_python/components/plot/coords_overlay.kv

@@ -18,23 +18,23 @@
         valign: "middle"
         font_name: "fonts/iosevka-regular.ttf"
         text_size: self.size
-        text: "Pointer"
+        text: "Selected"
     Label:
         size_hint_y: None
         height: 24
         halign: "left"
         valign: "middle"
         font_name: "fonts/iosevka-regular.ttf"
         text_size: self.size
-        text: 'X: {:0.3f}'.format(root.mouse_position[0])
+        text: 'X: {:0.3f}'.format(root.selected_x)
     Label:
         size_hint_y: None
         height: 24
         halign: "left"
         valign: "middle"
         font_name: "fonts/iosevka-regular.ttf"
         text_size: self.size
-        text: 'Y: {:0.3f}'.format(root.mouse_position[1])
+        text: 'Y: {:0.3f}'.format(root.selected_y)
     Label:
         size_hint_y: None
         height: 24
@@ -59,5 +59,29 @@
         font_name: "fonts/iosevka-regular.ttf"
         text_size: self.size
         text: 'Y: {:0.3f}'.format(root.tool_y)
+    Label:
+        size_hint_y: None
+        height: 24
+        halign: "left"
+        valign: "middle"
+        font_name: "fonts/iosevka-regular.ttf"
+        text_size: self.size
+        text: "Distance"
+    Label:
+        size_hint_y: None
+        height: 24
+        halign: "left"
+        valign: "middle"
+        font_name: "fonts/iosevka-regular.ttf"
+        text_size: self.size
+        text: 'X: {:0.3f}'.format(root.selected_x - root.tool_x)
+    Label:
+        size_hint_y: None
+        height: 24
+        halign: "left"
+        valign: "middle"
+        font_name: "fonts/iosevka-regular.ttf"
+        text_size: self.size
+        text: 'Y: {:0.3f}'.format(root.selected_y - root.tool_y)
     Widget:
         size_hint_y: 1

rotary_controller_python/components/plot/coords_overlay.py

@@ -17,3 +17,5 @@ class CoordsOverlay(BoxLayout):
     zoom = NumericProperty(0.0)
     tool_x = NumericProperty(0.0)
     tool_y = NumericProperty(0.0)
+    selected_x = NumericProperty(0.0)
+    selected_y = NumericProperty(0.0)

rotary_controller_python/components/plot/float_view.kv

@@ -18,13 +18,15 @@
                     id: scene_canvas
                     zoom: root.zoom
                     points: root.circle_pattern.points
-                    tool_x: app.home.scale_x.position
-                    tool_y: app.home.scale_y.position
+                    tool_x: app.tool_x
+                    tool_y: app.tool_y
 
     CoordsOverlay:
         pos: root.pos
         size: root.size
         mouse_position: root.mouse_position
         zoom: root.zoom
-        tool_x: app.home.scale_x.position
-        tool_y: app.home.scale_y.position
+        tool_x: app.tool_x
+        tool_y: app.tool_y
+        selected_x: root.circle_pattern.points[root.scene_canvas.selected_point][0]
+        selected_y: root.circle_pattern.points[root.scene_canvas.selected_point][1]

rotary_controller_python/components/plot/float_view.py

@@ -24,7 +24,7 @@ class FloatView(FloatLayout):
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        Window.bind(mouse_pos=self.window_mouse_pos)
+        # Window.bind(mouse_pos=self.window_mouse_pos)
         Window.bind(on_motion=self.on_motion)
         self.circle_pattern.recalculate()
 
@@ -36,10 +36,3 @@ def on_motion(self, window, etype, event):
                     self.zoom = self.zoom / 1.1
                 if event.button == 'scrolldown':
                     self.zoom = self.zoom * 1.1
-
-    def window_mouse_pos(self, instance, value):
-        global_pos = self.scene_canvas.to_widget(value[0], value[1])
-        delta_x = global_pos[0] - 5000
-        delta_y = global_pos[1] - 5000
-        degrees = math.degrees(math.atan2(delta_y, delta_x))
-        self.mouse_position = [delta_x / self.zoom, delta_y / self.zoom, degrees]

rotary_controller_python/components/plot/plot_toolbar.kv

@@ -42,22 +42,6 @@
     text: "REC"
 #    on_release: root.float_view.connect_rect()
 
-  ToolbarButton:
-    # Radius
-    size_hint: None, None
-    width: root.height
-    height: self.width
-    text: "<"
-    #on_release: Factory.Keypad().show(app, 'tool')
-
-  ToolbarButton:
-    # Load DXF
-    size_hint: None, None
-    width: root.height
-    height: self.width
-    width: root.height
-    text: ">"
-    #on_release: Factory.Keypad().show(app, 'tool')
 
   Widget:
     size_hint_x: 1

rotary_controller_python/components/plot/scene.py

@@ -19,7 +19,7 @@
 class Scene(FloatLayout, StencilView):
     zoom = NumericProperty(1.0)
     points = ListProperty([])
-    point_widgets = ListProperty([])
+    scaled_points = ListProperty([])
     selected_point = NumericProperty(0)
     dot_size = NumericProperty(20)
     tool_x = NumericProperty(0.0)
@@ -35,6 +35,13 @@ def __init__(self, **kwargs):
         self.bind(tool_y=self.update_points)
 
     def update_points(self, *args):
+        self.scaled_points = [
+            [
+                item[0] * self.zoom,
+                item[1] * self.zoom,
+            ] for item in self.points
+        ]
+
         self.canvas.clear()
         with self.canvas:
             Color(0, 1, 0, 1)
@@ -44,22 +51,23 @@ def update_points(self, *args):
             Line(points=[self.width/2, 0, self.width/2, self.height], width=1)
             Line(points=[0, self.height/2, self.width,  self.height/2], width=1)
 
-            for i, p in enumerate(self.points):
+            for i, p in enumerate(self.scaled_points):
                 if i == self.selected_point:
                     Color(0.8, 1, 0.8, 1)
                 else:
                     Color(0.8, 1, 0.8, 0.2)
 
                 Ellipse(
                     pos=(
-                        p[0] * self.zoom + self.width / 2 - self.dot_size/2,
-                        p[1] * self.zoom + self.height / 2 - self.dot_size/2
+                        p[0] + self.width / 2 - self.dot_size/2,
+                        p[1] + self.height / 2 - self.dot_size/2
                     ),
                     size=(self.dot_size, self.dot_size),
                     angle_start=0,
                     angle_end=360
                 )
 
+            Color(0.5, 1, 0.5, 1)
             Ellipse(
                 pos=(
                     self.tool_x * self.zoom + self.width / 2 - self.dot_size / 2,
@@ -68,14 +76,13 @@ def update_points(self, *args):
                 size=(self.dot_size, self.dot_size),
                 angle_start=0,
                 angle_end=360
-
             )
 
     def on_touch_up(self, touch):
         touch_x = touch.x - self.width/2
         touch_y = touch.y - self.height/2
 
-        for i, p in enumerate(self.points):
+        for i, p in enumerate(self.scaled_points):
             if p[0] - self.dot_size < touch_x < p[0] + self.dot_size and p[1] - self.dot_size < touch_y < p[1] + self.dot_size:
                 self.selected_point = i
                 break

rotary_controller_python/main.py

@@ -64,8 +64,9 @@ class MainApp(App):
     device = ObjectProperty()
     home = ObjectProperty()
     task_update = None
-    task_update_slow = None
-    task_counter = 0
+
+    tool_x = NumericProperty(0)
+    tool_y = NumericProperty(0)
 
     def __init__(self, **kv):
         self.fast_data_values = dict()
@@ -131,29 +132,23 @@ def update(self, *args):
             self.connected = self.connection_manager.connected
 
         if self.connection_manager.connected:
-            self.home.scale_x.position = self.fast_data_values['scaleCurrent'][self.home.scale_x.inputIndex] / 1000
-            self.home.scale_y.position = self.fast_data_values['scaleCurrent'][self.home.scale_y.inputIndex] / 1000
-            self.home.scale_z.position = self.fast_data_values['scaleCurrent'][self.home.scale_z.inputIndex] / 1000
-            self.home.scale_a.position = self.fast_data_values['scaleCurrent'][self.home.scale_a.inputIndex] / 1000
-            # for bar in self.home.coord_bars:
-            #     bar.position = self.fast_data_values['scaleCurrent'][bar.inputIndex] / 1000
+            for bar in self.home.coord_bars:
+                bar.position = self.fast_data_values['scaleCurrent'][bar.inputIndex] / 1000
             self.home.servo.currentPosition = self.fast_data_values['servoCurrent']
             self.home.servo.desiredPosition = self.fast_data_values['servoDesired']
             self.home.servo.servoEnable = self.fast_data_values['servoEnable']
-            # self.home.status_bar.cycles = self.fast_data_values['cycles']
-            # self.home.status_bar.interval = self.fast_data_values['executionInterval']
             self.home.status_bar.speed = abs(self.fast_data_values['servoSpeed'])
+
+            # TODO: Find a better way to configure x and y axy for the plot view
+            self.tool_x = self.fast_data_values['scaleCurrent'][0]
+            self.tool_y = self.fast_data_values['scaleCurrent'][1]
+
         self.connected = self.connection_manager.connected
 
     def upload(self):
         self.home.servo.upload()
-        self.home.scale_x.upload()
-        self.home.scale_y.upload()
-        self.home.scale_z.upload()
-        self.home.scale_a.upload()
-        self.home.servo.upload()
-        # for scale in self.home.coord_bars:
-        #     scale.upload()
+        for scale in self.home.coord_bars:
+            scale.upload()
 
     def blinker(self, *args):
         self.home.status_bar.fps = Clock.get_fps()
@@ -162,7 +157,6 @@ def blinker(self, *args):
     def build(self):
         self.home = HomePage(device=self.device)
         self.task_update = Clock.schedule_interval(self.update, 1.0 / 30)
-        # self.task_update_slow = Clock.schedule_interval(self.update_slow, 1.0 / 10)
         Clock.schedule_interval(self.blinker, 1.0 / 4)
         return self.home