Merge pull request #112 from AllenNeuralDynamics/wip/pytest

Wip/pytest

Author: jsiegle

Diff for: parallax/__init__.py

@@ -4,7 +4,7 @@
 
 import os
 
-__version__ = "1.1.2"
+__version__ = "1.1.3"
 
 # allow multiple OpenMP instances
 os.environ["KMP_DUPLICATE_LIB_OK"] = "True"

Diff for: tests/test_curr_bg_cmp_processor.py

@@ -1,5 +1,4 @@
 import pytest
-import numpy as np
 import cv2
 import os
 from parallax.curr_bg_cmp_processor import CurrBgCmpProcessor
@@ -21,7 +20,7 @@ def load_images_from_folder(folder):
             images.append(img)
     return images
 
-@pytest.fixture(scope="session")
+@pytest.fixture(scope="function")
 def sample_images():
     """Fixture to provide a way to process images into `curr_img`, `mask`."""
     def process_image(org_img, mask_generator):
@@ -109,7 +108,6 @@ def test_update_cmp(setup_curr_bg_cmp_processor, sample_images):
         # Simulate the next frame (using the same or next image in the sequence)
         ret, precise_tip = processor.update_cmp(curr_img, mask, org_img)
 
-        print(f"Frame {i}: Precise tip found: {precise_tip}, tip: {tip}")
         if precise_tip:
             tip = processor.ProbeDetector.probe_tip
             print(f"Frame {i}: Precise tip found: {precise_tip}, tip: {tip}")

Diff for: tests/test_curr_prev_cmp_processor.py

@@ -0,0 +1,125 @@
+import pytest
+import cv2
+import os
+from parallax.curr_prev_cmp_processor import CurrPrevCmpProcessor
+from parallax.mask_generator import MaskGenerator
+from parallax.probe_detector import ProbeDetector
+
+# Define the folder containing your test images
+IMG_SIZE = (1000, 750)
+IMG_SIZE_ORIGINAL = (4000, 3000)
+
+# Helper function to load images from a folder
+def load_images_from_folder(folder):
+    """Load and sort images from a specified folder."""
+    images = []
+    for filename in sorted(os.listdir(folder)):
+        img_path = os.path.join(folder, filename)
+        img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
+        if img is not None:
+            images.append(img)
+    return images
+
+@pytest.fixture
+def setup_curr_prev_cmp_processor():
+    """Fixture to set up an instance of CurrBgCmpProcessor."""
+    cam_name = "MockCam"
+    probeDetector = ProbeDetector(cam_name, (1000, 750))
+
+    processor = CurrPrevCmpProcessor(
+        cam_name=cam_name,
+        ProbeDetector=probeDetector,
+        original_size=IMG_SIZE_ORIGINAL,
+        resized_size=IMG_SIZE,
+    )
+    return processor
+
+@pytest.fixture(scope="function")
+def sample_images():
+    """Fixture to provide a way to process images into `curr_img`, `mask`."""
+    def process_image(org_img, mask_generator):
+        """Resize, blur, and generate mask for a given original image."""
+        resized_img = cv2.resize(org_img, IMG_SIZE)
+        curr_img = cv2.GaussianBlur(resized_img, (9, 9), 0)
+        mask = mask_generator.process(resized_img)
+        return curr_img, mask
+
+    return process_image
+    
+# Tests
+def test_first_cmp(setup_curr_prev_cmp_processor, sample_images):
+    """Test the first_cmp method with multiple images."""
+    processor = setup_curr_prev_cmp_processor
+
+    # Initialize the mask generator
+    mask_generator = MaskGenerator()  # Replace with appropriate constructor
+
+    # Load test images from the folder
+    base_dir = "tests/test_data/probe_detect_manager"
+    images = load_images_from_folder(base_dir)
+
+    ret, precise_tip, tip, prev_img  = False, False, None, None
+    # Iterate over each frame and process it
+    for i, org_img in enumerate(images):
+        # Generate `curr_img` and `mask` for each frame using the `sample_images` fixture
+        curr_img, mask = sample_images(org_img, mask_generator)
+        if prev_img is None:
+            prev_img = curr_img
+            continue
+
+        # Call the method to test for each frame
+        ret, precise_tip = processor.first_cmp(curr_img, prev_img, mask, org_img)
+
+        if precise_tip:
+            tip = processor.ProbeDetector.probe_tip
+            print(f"Frame {i}: Precise tip found: {precise_tip}, tip: {tip}")
+            break
+
+    # Perform assertions
+    assert ret is not False, f"Return value of ret should not be None."
+    assert precise_tip is not False, f"Precise_tip should be detected."
+    assert isinstance(tip, tuple), "The tip should be a tuple."
+    assert len(tip) == 2, "The tip should contain two elements (x, y)."
+   
+
+def test_update_cmp(setup_curr_prev_cmp_processor, sample_images):
+    """Test the update_cmp method with multiple images."""
+    processor = setup_curr_prev_cmp_processor
+
+    # Initialize the mask generator
+    mask_generator = MaskGenerator()  # Replace with appropriate constructor
+
+    # Load test images from the folder
+    base_dir = "tests/test_data/probe_detect_manager"
+    images = load_images_from_folder(base_dir)
+
+    is_first_detect = True
+    ret, precise_tip, tip, prev_img = False, False, None, None
+    # Iterate over each frame and process it
+    for i, org_img in enumerate(images):
+        # Generate `curr_img` and `mask` for each frame using the `sample_images` fixture
+        curr_img, mask = sample_images(org_img, mask_generator)
+        if prev_img is None:
+            prev_img = curr_img
+            continue
+
+        # Call the first_cmp method to set the initial state
+        if is_first_detect: 
+            ret_, _ = processor.first_cmp(curr_img, prev_img, mask, org_img)
+            if ret_:
+                is_first_detect = False
+                continue
+        
+        # Simulate the next frame (using the same or next image in the sequence)
+        ret, precise_tip = processor.update_cmp(curr_img, prev_img, mask, org_img)
+        
+        if precise_tip:
+            tip = processor.ProbeDetector.probe_tip
+            print(f"Frame {i}: Precise tip found: {precise_tip}, tip: {tip}")
+            break
+
+    # Perform assertions
+    assert ret is not False, f"Return value of ret should not be None."
+    assert precise_tip is not False, f"Precise_tip should be detected."
+    assert isinstance(tip, tuple), "The tip should be a tuple."
+    assert len(tip) == 2, "The tip should contain two elements (x, y)."

Diff for: tests/test_data/probe_fine_tip_detector/tip.jpg

@@ -0,0 +1,95 @@
+import pytest
+import os
+import numpy as np
+from PyQt5.QtWidgets import QApplication
+from parallax.point_mesh import PointMesh
+from parallax.model import Model  # Replace with the actual class that represents the model
+
+@pytest.fixture(scope="session")
+def qapp():
+    """
+    Fixture to create a QApplication instance.
+    """
+    app = QApplication([])
+    yield app
+    app.quit()
+
+@pytest.fixture
+def transformation_data():
+    """
+    Fixture for providing transformation matrix data.
+    """
+    transM = np.array([
+        [0.922764124, 0.151342504, 0.354403467, -619.603148],
+        [0.039239136, 0.877976151, -0.477093459, 32.53554828],
+        [-0.383362311, 0.454151213, 0.804226345, 15143.53139],
+        [0, 0, 0, 1]
+    ])
+    scale = np.array([0.990795167, -0.978485802, -1.004634464])
+    return transM, scale
+
+@pytest.fixture
+def sample_csv_file():
+    """
+    Fixture to provide the path to the existing CSV file.
+    """
+    csv_path = os.path.join("tests", "test_data", "point_mesh", "points.csv")
+    return csv_path
+
+@pytest.fixture
+def point_mesh_widget(qapp, transformation_data, sample_csv_file):
+    """
+    Fixture to create a PointMesh widget with sample data.
+    """
+    model = Model()  # Replace with actual model initialization
+    transM, scale = transformation_data
+    widget = PointMesh(model, sample_csv_file, "SN46115", transM, scale)
+    return widget
+
+def test_parse_csv(point_mesh_widget):
+    """
+    Test that the CSV file is parsed correctly and points are loaded.
+    """
+    point_mesh_widget._parse_csv()
+    
+    # Verify that local points are parsed and transformed to global coordinates
+    assert len(point_mesh_widget.local_pts) > 0, "Local points should be loaded"
+    assert len(point_mesh_widget.global_pts) > 0, "Global points should be loaded"
+
+    # Iterate over all rows in the local and global points and test them
+    for i, (local_point, global_point) in enumerate(zip(point_mesh_widget.local_pts, point_mesh_widget.global_pts)):
+        print(f"Row {i}: local_transform: {local_point}, global: {global_point}")
+
+        # Use np.testing.assert_allclose with an absolute tolerance of 50
+        np.testing.assert_allclose(
+            local_point, global_point, atol=50,
+            err_msg=f"Row {i}: The transformed local point does not match the expected global point within a tolerance of 50"
+        )
+
+def test_draw_specific_points(point_mesh_widget):
+    """
+    Test that specific points are drawn correctly.
+    """
+    point_mesh_widget._parse_csv()
+    point_mesh_widget._draw_specific_points("local_pts")
+    
+    # Check if the local points trace is added
+    assert "local_pts" in point_mesh_widget.traces, "Trace for local points should be added"
+    
+    # Verify that the trace contains data points
+    trace = point_mesh_widget.traces["local_pts"]
+    assert len(trace.x) > 0, "Trace should contain X values"
+    assert len(trace.y) > 0, "Trace should contain Y values"
+    assert len(trace.z) > 0, "Trace should contain Z values"
+
+    # Draw global points
+    point_mesh_widget._draw_specific_points("global_pts")
+    
+    # Check if the global points trace is added
+    assert "global_pts" in point_mesh_widget.traces, "Trace for global points should be added"
+    
+    # Verify that the trace contains data points for global points
+    global_trace = point_mesh_widget.traces["global_pts"]
+    assert len(global_trace.x) > 0, "Global trace should contain X values"
+    assert len(global_trace.y) > 0, "Global trace should contain Y values"
+    assert len(global_trace.z) > 0, "Global trace should contain Z values"

Diff for: tests/test_point_mesh.py

@@ -0,0 +1,82 @@
+import pytest
+import os
+import pandas as pd
+import numpy as np
+from PyQt5.QtCore import QObject, pyqtSignal
+from parallax.probe_calibration import ProbeCalibration
+from parallax.model import Model  # Replace with the actual class that represents the model
+
+
+@pytest.fixture
+def sample_csv_file():
+    """
+    Fixture to provide the path to the existing CSV file.
+    """
+    # Path to the points.csv file in the test_data directory
+    csv_path = os.path.join("tests", "test_data", "probe_calibration", "points.csv")
+    return csv_path
+
+@pytest.fixture
+def model():
+    """
+    Fixture for creating a model object.
+    """
+    return Model()
+
+@pytest.fixture
+def stage_listener():
+    """
+    Fixture for creating a mock stage listener.
+    """
+    class MockStageListener(QObject):
+        probeCalibRequest = pyqtSignal()
+        
+    return MockStageListener()
+
+@pytest.fixture
+def probe_calibration(model, stage_listener):
+    """
+    Fixture for creating a ProbeCalibration instance.
+    """
+    return ProbeCalibration(model, stage_listener)
+
+def test_probe_calibration_update(probe_calibration, sample_csv_file):
+    """
+    Test the update method of ProbeCalibration with each row from the CSV file.
+    """
+    # Load the CSV data
+    df = pd.read_csv(sample_csv_file)
+
+    # Iterate over each row in the CSV file
+    for idx, row in df.iterrows():
+        # Create a mock stage object with values from the CSV row
+        class MockStage:
+            def __init__(self, row):
+                self.sn = row["sn"]
+                self.stage_x = row["local_x"]
+                self.stage_y = row["local_y"]
+                self.stage_z = row["local_z"]
+                self.stage_x_global = row["global_x"]
+                self.stage_y_global = row["global_y"]
+                self.stage_z_global = row["global_z"]
+
+        stage = MockStage(row)
+        
+        probe_calibration.update(stage)
+
+        if probe_calibration._is_enough_points():
+            break
+
+    # Perform assertions to ensure that the calibration is being updated correctly.
+    assert probe_calibration.transM_LR is not None, f"Transformation matrix should be set for stage {stage.sn}"
+    assert probe_calibration.scale is not None, f"Scale should be set for stage {stage.sn}"
+    
+    # Print out the transformation matrix and scale for verification
+    print(f"Test row {idx}: SN = {stage.sn}")
+    print(f"Transformation matrix:\n{probe_calibration.transM_LR}")
+    print(f"Scale: {probe_calibration.scale}")
+    print(f"Average Error: {probe_calibration.avg_err}")
+
+    assert probe_calibration._is_criteria_avg_error_threshold(), \
+        f"Average error should meet threshold for row {idx}, SN = {stage.sn}"
+

Diff for: tests/test_probe_calibration.py

@@ -2,7 +2,6 @@
 import cv2
 import os
 import time
-from PyQt5.QtCore import QCoreApplication, QEventLoop
 from parallax.probe_detect_manager import ProbeDetectManager
 
 # Define the folder containing your test images