Datasources coords

pytools/app_rel.py

@@ -9,21 +9,28 @@
 telemetry_dir_name = 'telemetry'
 
 mon = Monitor(monitor_bus_name=mon_bus_name, argv=sys.argv)
+zero = DataSourceConst('zero', value=0)
 
 rp = EwRelativePosition([
+    DataSourceConst("boat", value="airplane-white"),
     DataSourceSinus('plane_phi', mult=360),
     DataSourceConst('plane_r', value=60),
+    DataSourceConst('zero', value=20),  # alt
     DataSourceSinus('plane_course', iphase=0.0, mult=360),
 
+    DataSourceConst("boat", value="aim-yellow"),
     DataSourceSinus('base_phi', iphase=0.5, mult=360),
     DataSourceConst('base_r', value=120),
+    zero,  # alt
+    zero,  # course
 
+    DataSourceConst("boat", value="boat-white"),  # icon
     DataSourceSinus('target_phi', iphase=-0.5, mult=360),
     DataSourceConst('target_r', value=160),
+    zero,  # alt
+    zero,  # course
 ])
 
-
-
 mon.add_widget(EwGroup([rp]))
 
 mon.app_window.resize(800, 800)

pytools/ds/common.py

@@ -0,0 +1,39 @@
+from typing import Union
+
+from mymath import to_cartesian, to_polar
+from .datasources import DataSourceBasic, NoDataStub
+
+
+class DataSourceCoordsCartesian(DataSourceBasic):
+    def __init__(self, name, phi, r, scale=1.0, decimals=3, **kwargs):
+        super().__init__(name, **kwargs)
+        self._phi = phi
+        self._r = r
+        self._scale = scale
+        self._decimals = decimals
+
+    def connect(self):
+        pass
+
+    def read(self) -> Union[float, int, str, NoDataStub]:
+        return to_cartesian(phi=self._phi,
+                            r=self._r,
+                            scale=self._scale,
+                            decimals=self._decimals)
+
+
+class DataSourceCoordsPolar(DataSourceBasic):
+    def __init__(self, name, x, y, scale=1.0, decimals=3, **kwargs):
+        super().__init__(name, **kwargs)
+        self._x = x
+        self._y = y
+        self._scale = scale
+        self._decimals = decimals
+
+    def connect(self):
+        pass
+
+    def read(self) -> Union[float, int, str, NoDataStub]:
+        return to_polar(x=self._x, y=self._y,
+                        scale=self._scale,
+                        decimals=self._decimals)

pytools/ds/datasources.py

@@ -1,9 +1,7 @@
+import math
+import time
 from abc import abstractmethod
 from typing import List, Union
-import time
-import math
-
-from PyQt5.QtWidgets import QLineEdit
 
 
 class NoDataStub:
@@ -107,6 +105,7 @@ def read(self) -> Union[float, int, str, NoDataStub]:
         self.time += self.delta_time
         return self.time
 
+
 class DataSourceSinus(DataSourceBasic):
     def __init__(self, name, *, omega=1.0, iphase=0.0, bias=0.0, **kwargs):
         super().__init__(name, **kwargs)

pytools/ds/tests/test_coords_cartesian.py

@@ -0,0 +1,38 @@
+import mymath
+from unittest import TestCase
+
+from ds.common import DataSourceCoordsCartesian
+
+
+# Sample coords:
+#
+#      •4    |     •1
+#            |
+#  ----------+-----------
+#            |
+#      •3    |     •2
+
+class TestDataSourceCartesian(TestCase):
+    def test_pt1(self):
+        ds = DataSourceCoordsCartesian("cartesian", phi=45, r=mymath.hypot(10, 10), decimals=2)
+        [x, y] = ds.read()
+        self.assertEqual(10.0, x)
+        self.assertEqual(10.0, y)
+
+    def test_pt2(self):
+        ds = DataSourceCoordsCartesian("cartesian", phi=45+90, r=mymath.hypot(10, 10), decimals=2)
+        [x, y] = ds.read()
+        self.assertEqual(10.0, x)
+        self.assertEqual(-10.0, y)
+
+    def test_pt3(self):
+        ds = DataSourceCoordsCartesian("cartesian", phi=45 + 180, r=mymath.hypot(10, 10), decimals=2)
+        [x, y] = ds.read()
+        self.assertEqual(-10.0, x)
+        self.assertEqual(-10.0, y)
+
+    def test_pt4(self):
+        ds = DataSourceCoordsCartesian("cartesian", phi=45 + 270, r=mymath.hypot(10, 10), decimals=2)
+        [x, y] = ds.read()
+        self.assertEqual(-10.0, x)
+        self.assertEqual(10.0, y)

pytools/ds/tests/test_coords_polar.py

@@ -0,0 +1,42 @@
+import mymath
+from unittest import TestCase
+
+from ds.common import DataSourceCoordsPolar
+
+
+# Sample coords:
+#
+#      •4    |     •1
+#            |
+#  ----------+-----------
+#            |
+#      •3    |     •2
+
+class TestDataSourcePolar(TestCase):
+    def test_pt1(self):
+        decimals = 3
+        polar_ds = DataSourceCoordsPolar("to_polar", 10, 10, decimals=decimals)
+        [phi, r] = polar_ds.read()
+        self.assertEqual(45.0, phi)
+        self.assertEqual(round(mymath.hypot(10, 10), decimals), r)
+
+    def test_pt2(self):
+        decimals = 3
+        polar_ds = DataSourceCoordsPolar("to_polar", x=10, y=-10, decimals=decimals)
+        [phi, r] = polar_ds.read()
+        self.assertEqual(phi, 45.0 + 90.0)
+        self.assertEqual(round(mymath.hypot(10, 10), decimals), r)
+
+    def test_pt3(self):
+        decimals = 3
+        polar_ds = DataSourceCoordsPolar("to_polar", x=-10, y=-10, decimals=decimals)
+        [phi, r] = polar_ds.read()
+        self.assertEqual(phi, 45.0 + 180.0)
+        self.assertEqual(r, round(mymath.hypot(10, 10), decimals))
+
+    def test_pt4(self):
+        decimals = 3
+        polar_ds = DataSourceCoordsPolar("to_polar", x=-10, y=10, decimals=decimals)
+        [phi, r] = polar_ds.read()
+        self.assertEqual(phi, 45.0 + 270.0)
+        self.assertEqual(round(mymath.hypot(10, 10), decimals), r)

pytools/ew/relative_position.py

@@ -1,11 +1,12 @@
-import math
 from typing import List, Union, Dict
 
 from PyQt5 import QtGui
 from PyQt5.QtCore import Qt, QPointF, pyqtSignal
 from PyQt5.QtGui import QPainter, QPen, QPixmap, QBrush, QFont
 
+from mymath import to_polar, to_cartesian, translate_point, rev_translate_point
 from ds import DataSourceBasic, NoDataStub
+
 from .common import MyQtWidget, rel_path
 from .widgets import EwBasic
 
@@ -15,31 +16,6 @@
 ds_tuple_size = 5
 
 
-def to_polar(x, y, scale=1.0):
-    pt = QPointF(x, y)
-    r = math.sqrt(pt.x() * pt.x() + pt.y() * pt.y()) / scale
-    degrees = math.degrees(math.atan2(-y, x)) + 90
-    phi = (degrees + 360) % 360
-    return [round(phi, 2), round(r, 3)]
-
-
-def to_cartesian(r, phi, scale=1.0):
-    _phi_rad = math.radians(phi)
-    _x = scale * r * math.sin(_phi_rad)
-    _y = -(scale * r * math.cos(_phi_rad))
-    return [_x, _y]
-
-
-def rtranslate_point(width, height, pt: QPointF, zero_offset_x=0.0, zero_offset_y=0.0):
-    dx, dy = width / 2 + zero_offset_x, height / 2 + zero_offset_y
-    return QPointF(pt.x() - dx, - (pt.y() - dy))
-
-
-def translate_point(width, height, pt: QPointF, zero_offset_x=0.0, zero_offset_y=0.0):
-    dx, dy = width / 2 + zero_offset_x, height / 2 + zero_offset_y
-    return QPointF(pt.x() + dx, pt.y() + dy)
-
-
 class EwRelativePosition(MyQtWidget, EwBasic):
     target_changed = pyqtSignal(float, float, name='targetChanged')
     scale_changed = pyqtSignal(float, name='zoomChanged')
@@ -55,16 +31,18 @@ def __init__(self, icon='aim-yellow'):
             self.azimuth = 0.0
 
         def draw(self, canvas, center, scale):
-            [_x, _y] = to_cartesian(self.r, self.phi, scale)
+            [_x, _y] = to_cartesian(r=self.r, phi=self.phi, scale=scale)
             self.svg_icon.setX(_x + center[0])
-            self.svg_icon.setY(_y + center[1])
+            self.svg_icon.setY(-_y + center[1])
             self.svg_icon.setRotation(self.azimuth)
             canvas.setPen(QPen(Qt.darkGray, 1, Qt.DotLine, Qt.RoundCap))
-            canvas.drawLine(translate_point(canvas.device().width(), canvas.device().height(),
+            canvas.drawLine(translate_point(canvas.device().width(),
+                                            canvas.device().height(),
                                             QPointF(0, 0),
                                             center[0], center[1]),
-                            translate_point(canvas.device().width(), canvas.device().height(),
-                                            QPointF(_x, _y),
+                            translate_point(canvas.device().width(),
+                                            canvas.device().height(),
+                                            QPointF(_x, -_y),
                                             center[0], center[1]))
 
     def __init__(self, data_sources: List[DataSourceBasic], fixed_size=None, **kwargs):
@@ -117,7 +95,8 @@ def wheelEvent(self, event: QtGui.QWheelEvent) -> None:
             self.zoom_out()
 
     def _emit_target_chg(self, x, y):
-        pt = rtranslate_point(self.rect().width(), self.rect().height(), QPointF(x, y), self.center[0], self.center[1])
+        pt = rev_translate_point(self.rect().width(), self.rect().height(), QPointF(x, y), self.center[0],
+                                 self.center[1])
         [phi, r] = to_polar(pt.x(), pt.y(), scale=self.scale_m)
         # noinspection PyUnresolvedReferences
         self.target_changed.emit(phi, r)
@@ -175,6 +154,7 @@ def paintEvent(self, event):
 
     def radraw_handler(self, vals: List[Union[float, int, str, NoDataStub]], vals_map: Dict):
         count = len(vals) // ds_tuple_size
+
         def check_stub(d):
             return d if not isinstance(d, NoDataStub) else 0.0
 

pytools/ew/widgets.py

@@ -1,4 +1,4 @@
-import math
+import mymath
 from abc import abstractmethod
 from typing import List, Union, Dict, Tuple
 
@@ -456,11 +456,11 @@ def paintEvent(self, event):
         _scaleX = _width / _originalWidth
         _scaleY = _height / _originalHeight
 
-        roll_rad = math.pi * self._roll / 180.0
+        roll_rad = mymath.pi * self._roll / 180.0
         delta = 1.7 * self._pitch
 
-        _faceDeltaX_new = _scaleX * delta * math.sin(roll_rad)
-        _faceDeltaY_new = _scaleY * delta * math.cos(roll_rad)
+        _faceDeltaX_new = _scaleX * delta * mymath.sin(roll_rad)
+        _faceDeltaY_new = _scaleY * delta * mymath.cos(roll_rad)
 
         offs_x = _faceDeltaX_new - self._faceDeltaX_old
         offs_y = _faceDeltaY_new - self._faceDeltaY_old

pytools/monitor.py

@@ -1,9 +1,8 @@
 import sys
-import time
 from typing import List
 
 from PyQt5 import QtWidgets, QtCore
-from PyQt5.QtCore import QThread, QObject, pyqtSignal, QThreadPool, QRunnable, pyqtSlot
+from PyQt5.QtCore import QObject, pyqtSignal, QThreadPool, QRunnable, pyqtSlot
 from PyQt5.QtWidgets import QPushButton, QApplication
 
 
@@ -90,7 +89,8 @@ def run(self):
         Your code goes in this function
         """
         print("Thread start")
-        self.job(self.process_events)
+        self.job()
+        self.process_events()
         print("Thread finished")