Added actual tensor displaying. Added more tests. Added select channels.

tests/require_graphics/test_pub_cam.py

@@ -13,7 +13,7 @@ class TestFrameHandler(ut.TestCase):
                 print(frame.shape)
             self.i += 1
 
-        w.VideoHandlerThread(
+        w.FrameUpdater(
             0,
             [test_frame_handler],
             request_size=(1280, 720),

tests/require_graphics/test_sub_win.py

@@ -21,21 +21,21 @@ class TestSubWin(ut.TestCase):
         def print_key_thread(key_chr):
             print("key pressed: " + str(key_chr))
 
-        w.VideoHandlerThread().display()
+        w.FrameUpdater().display()
 
     def test_sub(self):
-        w.VideoHandlerThread().display()
+        w.FrameUpdater().display()
 
     def test_image(self):
         img = np.random.uniform(0, 1, (300, 300, 3))
-        w.VideoHandlerThread(video_source=img).display()
+        w.FrameUpdater(video_source=img).display()
 
     def test_image_args(self):
         img = np.random.uniform(0, 1, (30, 30, 3))
-        w.VideoHandlerThread(video_source=img, request_size=(300, -1)).display()
+        w.FrameUpdater(video_source=img, request_size=(300, -1)).display()
 
     def test_sub_with_args(self):
-        video_thread = w.VideoHandlerThread(
+        video_thread = w.FrameUpdater(
             video_source=0, request_size=(800, 600), high_speed=False, fps_limit=8
         )
 
@@ -46,7 +46,7 @@ class TestSubWin(ut.TestCase):
             frame[:, :, 0] = 0
             frame[:, :, 2] = 0
 
-        w.VideoHandlerThread(callbacks=redden_frame_print_spam).display()
+        w.FrameUpdater(callbacks=redden_frame_print_spam).display()
 
     def test_sub_with_callback_exception(self):
         def redden_frame_print_spam(frame):
@@ -54,7 +54,7 @@ class TestSubWin(ut.TestCase):
             frame[:, :, 2] = 1 / 0
 
         with self.assertRaises(ZeroDivisionError) as e:
-            v = w.VideoHandlerThread(callbacks=redden_frame_print_spam)
+            v = w.FrameUpdater(callbacks=redden_frame_print_spam)
             v.display()
             self.assertEqual(v.exception_raised, e)
 
@@ -76,7 +76,7 @@ class TestSubWin(ut.TestCase):
             frame = np.asarray([[[[[[frame + 1 / 0]]]]], [[[[[frame]]], [[[frame]]]]]])
             return frame
 
-        v = w.VideoHandlerThread(callbacks=[nest_frame])
+        v = w.FrameUpdater(callbacks=[nest_frame])
         v.start()
 
         with self.assertRaises(ZeroDivisionError) as e:
@@ -88,7 +88,7 @@ class TestSubWin(ut.TestCase):
         v.join()
 
     def test_conway_life(self):
-        from displayarray.frame import VideoHandlerThread
+        from displayarray.frame import FrameUpdater
         from displayarray.callbacks import function_display_callback
         import numpy as np
         import cv2
@@ -131,15 +131,15 @@ class TestSubWin(ut.TestCase):
                     :,
                     ] = 1.0
 
-        VideoHandlerThread(
+        FrameUpdater(
             video_source=img, callbacks=function_display_callback(conway)
         ).display()
 
     def test_double_win(self):
         vid1 = np.ones((100, 100))
         vid2 = np.zeros((100, 100))
-        t1 = w.VideoHandlerThread(vid1)
-        t2 = w.VideoHandlerThread(vid2)
+        t1 = w.FrameUpdater(vid1)
+        t2 = w.FrameUpdater(vid2)
         t1.start()
         t2.start()
         SubscriberWindows(

tests/unit/frame/test_frame_publishing.py

@@ -1,5 +1,120 @@
 from displayarray.frame.frame_publishing import pub_cam_loop, pub_cam_thread
+import displayarray
+import mock
+import pytest
+import cv2
+from displayarray.frame.np_to_opencv import NpCam
+import numpy as np
+import displayarray.frame.subscriber_dictionary as subd
+import displayarray.frame.frame_publishing as fpub
 
 
-def test_pub_cam_loop():
-   pub_cam_loop()
+def test_pub_cam_loop_exit():
+    not_a_camera = mock.MagicMock()
+    with pytest.raises(TypeError):
+        pub_cam_loop(not_a_camera)
+
+
+def test_pub_cam_int():
+    img = np.zeros((30, 40))
+    with mock.patch.object(cv2, "VideoCapture", new_callable=mock.MagicMock) as mock_cv_capture:
+        cap = NpCam(img)
+        mock_cv_capture.return_value = cap
+        reg_cam = displayarray.frame.frame_publishing.subscriber_dictionary.register_cam = mock.MagicMock()
+        cam_cmd_sub = displayarray.frame.frame_publishing.subscriber_dictionary.cam_cmd_sub = mock.MagicMock()
+        mock_sub = cam_cmd_sub.return_value = mock.MagicMock()
+        mock_sub.get = mock.MagicMock()
+        mock_sub.get.side_effect = ["", "", "", "quit"]
+        mock_sub.release = mock.MagicMock()
+        cap.set = mock.MagicMock()
+        cap.get = mock.MagicMock()
+        cap.get.return_value = 2
+        cap.release = mock.MagicMock()
+
+        cam_0 = subd.CV_CAMS_DICT['0'] = subd.Cam('0')
+        cam_pub = cam_0.frame_pub.publish = mock.MagicMock()
+
+        pub_cam_loop(0, high_speed=False)
+
+        cam_pub.assert_has_calls(
+            [mock.call(img)] * 4
+        )
+
+        reg_cam.assert_called_once_with('0')
+        cam_cmd_sub.assert_called_once_with('0')
+
+        cap.set.assert_has_calls(
+            [mock.call(cv2.CAP_PROP_FRAME_WIDTH, 1280),
+             mock.call(cv2.CAP_PROP_FRAME_HEIGHT, 720)]
+        )
+        cap.get.assert_has_calls(
+            [mock.call(cv2.CAP_PROP_FRAME_COUNT)] * 8
+        )
+        mock_sub.get.assert_has_calls([mock.call(), mock.call(), mock.call(), mock.call()])
+        mock_sub.release.assert_called_once()
+        cap.release.assert_called_once()
+
+
+def test_pub_cam_fail():
+    img = np.zeros((30, 40))
+    with mock.patch.object(cv2, "VideoCapture", new_callable=mock.MagicMock) as mock_cv_capture:
+        cap = NpCam(img)
+        mock_cv_capture.side_effect = [cap]
+
+        cap.isOpened = mock.MagicMock()
+        cap.isOpened.return_value = False
+        subd.register_cam = mock.MagicMock()
+        subd.CV_CAMS_DICT['0'] = subd.Cam('0')
+
+        mock_fail_pub = \
+            subd.CV_CAMS_DICT['0'].status_pub.publish = \
+            mock.MagicMock()
+
+        pub_cam_loop(0, high_speed=False)
+
+        mock_fail_pub.assert_called_once_with("failed")
+
+
+def test_pub_cam_high_speed():
+    img = np.zeros((30, 40))
+    with mock.patch.object(cv2, "VideoCapture", new_callable=mock.MagicMock) as mock_cv_capture:
+        cap = NpCam(img)
+        mock_cv_capture.side_effect = [cap]
+
+        cap.isOpened = mock.MagicMock()
+        cap.isOpened.return_value = False
+        cap.set = mock.MagicMock()
+
+        pub_cam_loop(0, request_size=(640, 480), high_speed=True)
+
+        cap.set.assert_has_calls(
+            [mock.call(cv2.CAP_PROP_FOURCC, cv2.CAP_OPENCV_MJPEG),
+             mock.call(cv2.CAP_PROP_FRAME_WIDTH, 640),
+             mock.call(cv2.CAP_PROP_FRAME_HEIGHT, 480)]
+        )
+
+
+def test_pub_cam_numpy():
+    with mock.patch("displayarray.frame.frame_publishing.uid_for_source", new_callable=mock.MagicMock) as mock_uidfs:
+        img = np.zeros((30, 40))
+        NpCam.read = mock.MagicMock()
+        NpCam.read.side_effect = [(True, img), (True, img), (True, img), (False, None)]
+        subd.register_cam = mock.MagicMock()
+        mock_uidfs.return_value = '0'
+        cam_0 = subd.CV_CAMS_DICT['0'] = subd.Cam('0')
+        cam_pub = cam_0.frame_pub.publish = mock.MagicMock()
+
+        pub_cam_loop(img)
+        cam_pub.assert_has_calls(
+            [mock.call(img)] * 3
+        )
+
+
+def test_pub_cam_thread():
+    with mock.patch("displayarray.frame.frame_publishing.threading.Thread", new_callable=mock.MagicMock) as mock_thread:
+        thread_instance = mock_thread.return_value = mock.MagicMock()
+
+        pub_cam_thread(5)
+
+        mock_thread.assert_called_once_with(target=fpub.pub_cam_loop, args=(5, (1280, 720), True, 240))
+        thread_instance.start.assert_called_once()

tests/unit/frame/test_frame_updater.py

@@ -0,0 +1,123 @@
+import displayarray.frame.frame_updater as fup
+import numpy as np
+import mock
+import pytest
+import itertools
+from displayarray.effects.select_channels import SelectChannels
+
+
+def test_init_defaults():
+    ud = fup.FrameUpdater()
+
+    assert ud.video_source == 0
+    assert ud.cam_id == "0"
+    assert ud.callbacks == []
+    assert ud.request_size == (-1, -1)
+    assert ud.high_speed == True
+    assert ud.fps_limit == 240
+
+
+def test_init():
+    cb = lambda x: np.zeros((1, 1))
+    ud = fup.FrameUpdater("test", cb, (2, 2), False, 30)
+
+    assert ud.video_source == "test"
+    assert ud.cam_id == "test"
+    assert ud.callbacks == [cb]
+    assert ud.request_size == (2, 2)
+    assert ud.high_speed == False
+    assert ud.fps_limit == 30
+
+
+def test_loop():
+    with mock.patch("displayarray.frame.frame_updater.pub_cam_thread") as mock_pubcam_thread, \
+            mock.patch("displayarray.frame.frame_updater.subscriber_dictionary.CV_CAMS_DICT") as mock_cam_dict, \
+            mock.patch("displayarray.frame.frame_updater.subscriber_dictionary.cam_frame_sub") as mock_frame_sub, \
+            mock.patch("displayarray.frame.frame_updater.subscriber_dictionary.handler_cmd_sub") as handler_cmd_sub, \
+            mock.patch("displayarray.frame.frame_updater.global_cv_display_callback") as mock_global_cb:
+        mock_cbs = [mock.MagicMock(), mock.MagicMock()]
+        ud = fup.FrameUpdater(0, callbacks=mock_cbs)
+
+        pub_t = mock_pubcam_thread.return_value = mock.MagicMock()
+        mock_cam_dict.__contains__.side_effect = itertools.cycle([False, False, True])
+        sub_cam = mock_frame_sub.return_value = mock.MagicMock()
+        sub_cam.get = mock.MagicMock()
+        frame = sub_cam.get.return_value = mock.MagicMock()
+        transformed_frame = mock.MagicMock()
+        mock_cbs[0].return_value = transformed_frame
+        mock_cbs[1].return_value = transformed_frame
+        transformed_frame.shape = [1, 2, 3]
+        mock_sub_owner = handler_cmd_sub.return_value = mock.MagicMock()
+        mock_sub_owner.get.side_effect = ["", "", "", "quit"]
+
+        ud.loop()
+
+        mock_pubcam_thread.assert_called_once_with(0, (-1, -1), True, 240)
+        mock_frame_sub.assert_called_once_with("0")
+        handler_cmd_sub.assert_called_once_with("0")
+        sub_cam.get.assert_has_calls([mock.call(blocking=True, timeout=1.0)] * 3)
+        mock_cbs[0].assert_has_calls([mock.call(frame)] * 4)
+        mock_cbs[1].assert_has_calls([mock.call(transformed_frame)] * 4)
+        mock_global_cb.assert_has_calls([mock.call(transformed_frame, '0')] * 4)
+        mock_sub_owner.release.assert_called_once()
+        sub_cam.release.assert_called_once()
+        pub_t.join.assert_called_once()
+
+
+def test_callback_exception():
+    def redden_frame_print_spam(frame):
+        frame[:, :, 0] = 0
+        frame[:, :, 2] = 1 / 0
+
+    with pytest.raises(ZeroDivisionError) as e:
+        v = fup.FrameUpdater(np.zeros((1, 1, 3)), callbacks=redden_frame_print_spam)
+        v.loop()
+    assert e.errisinstance(ZeroDivisionError)
+
+
+def test_display():
+    with mock.patch("displayarray.window.SubscriberWindows", new_callable=mock.MagicMock) as mock_sub_win:
+        f = fup.FrameUpdater()
+        f.start = mock.MagicMock()
+        f.join = mock.MagicMock()
+        mock_sub_win_instance = mock_sub_win.return_value = mock.MagicMock()
+
+        f.display()
+
+        mock_sub_win.assert_called_once_with(video_sources=["0"], callbacks=[])
+        mock_sub_win_instance.loop.assert_called_once()
+        f.start.assert_called_once()
+        f.join.assert_called_once()
+
+
+def test_display_exception():
+    with mock.patch("displayarray.window.SubscriberWindows", new_callable=mock.MagicMock) as mock_sub_win:
+        def redden_frame_print_spam(frame):
+            frame[:, :, 0] = 0
+            frame[:, :, 2] = 1 / 0
+
+        with pytest.raises(ZeroDivisionError) as e:
+            v = fup.FrameUpdater(np.zeros((1, 1, 3)), callbacks=redden_frame_print_spam)
+            v.display()
+        assert e.errisinstance(ZeroDivisionError)
+
+
+from displayarray.window.window_commands import win_cmd_pub
+
+
+def test_display_many_channels():
+    with mock.patch("displayarray.frame.frame_updater.pub_cam_thread"), \
+         mock.patch("displayarray.frame.frame_updater.subscriber_dictionary.CV_CAMS_DICT") as mock_cam_dict, \
+            mock.patch("displayarray.frame.frame_updater.subscriber_dictionary.handler_cmd_sub") as handler_cmd_sub:
+        mock_cam_dict.__contains__.side_effect = itertools.cycle([False, False, True])
+        mock_sub_owner = handler_cmd_sub.return_value = mock.MagicMock()
+        mock_sub_owner.get.side_effect = ["", "", "", "quit"]
+
+        arr = np.ones((20, 20, 20))
+
+        f = fup.FrameUpdater(arr)
+
+        f.loop()
+
+        assert isinstance(f.callbacks[0], SelectChannels)
+        win_cmd_pub.publish("quit")

tests/unit/frame/test_get_frame_ids.py

@@ -0,0 +1,14 @@
+import displayarray.frame.get_frame_ids as gfi
+import mock
+import cv2
+
+
+def test_get_cam_ids():
+    with mock.patch.object(cv2, "VideoCapture", new_callable=mock.MagicMock) as mock_cv_capture:
+        cap = mock.MagicMock()
+        cap.isOpened.return_value = True
+        cap_end = mock.MagicMock()
+        cap_end.isOpened.return_value = False
+        mock_cv_capture.side_effect = [cap, cap, cap, cap_end]
+        ids = gfi.get_cam_ids()
+        assert ids == [0, 1, 2]