cleanup names

lumicks/pylake/kymo.py

@@ -334,7 +334,7 @@ def duration(self):
     def pixelsize(self):
         """Returns a `List` of axes dimensions in calibrated units. The length of the
         list corresponds to the number of scan axes."""
-        return [self._calibration.value]
+        return [self._calibration.pixelsize]
 
     def plot(
         self,
@@ -386,7 +386,7 @@ def plot(
 
         image = self._get_plot_data(channel, adjustment)
 
-        size_calibrated = self._calibration.value * self._num_pixels[0]
+        size_calibrated = self._calibration.pixelsize * self._num_pixels[0]
 
         default_kwargs = dict(
             # With origin set to upper (default) bounds should be given as (0, n, n, 0)
@@ -1122,7 +1122,7 @@ def label(self):
 @dataclass(frozen=True)
 class PositionCalibration:
     unit: PositionUnit = PositionUnit.pixel
-    _value: float = 1.0
+    factor: float = 1.0
     origin: float = 0.0
 
     def __post_init__(self):
@@ -1131,15 +1131,15 @@ def __post_init__(self):
 
     def from_pixels(self, pixels):
         """Convert coordinates from pixel values to calibrated values"""
-        return self._value * (np.array(pixels) - self.origin)
+        return self.factor * (np.array(pixels) - self.origin)
 
     def to_pixels(self, calibrated):
         """Convert coordinates from calibrated values to pixel values"""
-        return np.array(calibrated) / self._value + self.origin
+        return np.array(calibrated) / self.factor + self.origin
 
     @property
-    def value(self):
-        return np.abs(self._value)
+    def pixelsize(self):
+        return np.abs(self.factor)
 
     @property
     def unit_label(self):
@@ -1149,7 +1149,7 @@ def downsample(self, factor):
         return (
             self
             if self.unit == PositionUnit.pixel
-            else PositionCalibration(self.unit, self._value * factor)
+            else PositionCalibration(self.unit, self.factor * factor)
         )
 
 

lumicks/pylake/kymotracker/tests/test_greedy_algorithm.py

@@ -187,8 +187,8 @@ def test_track_calibrated_flipped(tether_len, start, end):
         ([5, 15], [6, 15], [7, 14], [8, 15], [9, 16]),
     ]
     for coords in ref_tracks:
-        for c in coords:
-            image[*c[::-1]] = 10
+        for t, p in coords:
+            image[p, t] = 10
 
     kymo = _kymo_from_array(image, "g", line_time_seconds=0.1, pixel_size_um=0.050)
     kymo_flipped = kymo.flip()
@@ -203,9 +203,9 @@ def test_track_calibrated_flipped(tether_len, start, end):
     kymo_flipped = kymo_flipped.calibrate_to_kbp(tether_len, start=start_flipped, end=end_flipped)
 
     params = dict(pixel_threshold=5, window=3)
-    tracks = track_greedy(kymo, "green", track_width=3 * kymo._calibration.value, **params)
+    tracks = track_greedy(kymo, "green", track_width=3 * kymo._calibration.pixelsize, **params)
     tracks_flipped = track_greedy(
-        kymo_flipped, "green", track_width=3 * kymo_flipped._calibration.value, **params
+        kymo_flipped, "green", track_width=3 * kymo_flipped._calibration.pixelsize, **params
     )
 
     for track, track_flipped in zip(tracks, tracks_flipped):

lumicks/pylake/tests/test_imaging_confocal/test_kymo_transforms.py

@@ -13,27 +13,27 @@ def test_calibrate_to_kbp(test_kymo):
 
     # test that default calibration is in microns
     assert kymo._calibration.unit == PositionUnit.um
-    assert kymo._calibration.value == 0.1
+    assert kymo._calibration.pixelsize == 0.1
 
     # test that calibration is stored as kilobase-pairs
     assert kymo_bp._calibration.unit == PositionUnit.kbp
-    np.testing.assert_allclose(kymo_bp._calibration.value, length_kbp / n_pixels)
+    np.testing.assert_allclose(kymo_bp._calibration.pixelsize, length_kbp / n_pixels)
 
     # test conversion from microns to calibration units
     np.testing.assert_allclose(
-        kymo._calibration.value * n_pixels,
+        kymo._calibration.pixelsize * n_pixels,
         ref.metadata.pixelsize_um[0] * n_pixels,
     )
     np.testing.assert_allclose(kymo.pixelsize, ref.metadata.pixelsize_um[0])
-    np.testing.assert_allclose(kymo_bp._calibration.value * n_pixels, length_kbp)
+    np.testing.assert_allclose(kymo_bp._calibration.pixelsize * n_pixels, length_kbp)
     np.testing.assert_allclose(kymo_bp.pixelsize, length_kbp / n_pixels)
 
     start = 0.12
     end = 0.33
     n_pixels_tether = (end - start) / ref.metadata.pixelsize_um[0]
 
     kymo_bp = kymo.calibrate_to_kbp(length_kbp, start=start, end=end)
-    np.testing.assert_allclose(kymo_bp._calibration.value * n_pixels_tether, length_kbp)
+    np.testing.assert_allclose(kymo_bp._calibration.pixelsize * n_pixels_tether, length_kbp)
     np.testing.assert_allclose(kymo_bp.pixelsize, length_kbp / n_pixels_tether)
 
     with pytest.raises(RuntimeError, match="kymo is already calibrated in base pairs."):
@@ -84,8 +84,8 @@ def test_calibrate_sliced_cropped(test_kymo):
     np.testing.assert_allclose(kymo_bp.pixelsize[0], cropped_kymo_bp.pixelsize[0])
     # but will change total length
     np.testing.assert_allclose(
-        kymo_bp._calibration.value * n_cropped_pixels,
-        cropped_kymo_bp._calibration.value * cropped_kymo_bp._num_pixels[0],
+        kymo_bp._calibration.pixelsize * n_cropped_pixels,
+        cropped_kymo_bp._calibration.pixelsize * cropped_kymo_bp._num_pixels[0],
     )
 
 
@@ -140,32 +140,31 @@ def test_position_unit():
 
 def test_enum_in_calibration():
     with pytest.raises(TypeError, match="`unit` must be a PositionUnit instance"):
-        PositionCalibration("kbp", value=0.42)
+        PositionCalibration("kbp", factor=0.42)
 
-    c = PositionCalibration(PositionUnit.um, value=0.42)
+    c = PositionCalibration(PositionUnit.um, factor=0.42)
     assert c.unit_label == PositionUnit.um.label
 
 
 def test_coordinate_transforms():
     px_coord = [0, 1.2, 3.14, 85]
 
-    c = PositionCalibration(PositionUnit.kbp, value=0.42)
+    c = PositionCalibration(PositionUnit.kbp, factor=0.42)
     kbp_coord = [0, 0.504, 1.3188, 35.7]
     transformed = c.from_pixels(px_coord)
     np.testing.assert_allclose(kbp_coord, transformed)
     np.testing.assert_allclose(px_coord, c.to_pixels(transformed))
 
-    c = PositionCalibration(PositionUnit.kbp, value=0.42, origin=2.0)
-    kbp_coord = [-0.84, -0.336, 0.4788, 34.86]
+    c = PositionCalibration(PositionUnit.kbp, factor=0.42, origin=2.0)
+    kbp_coord = np.array([-0.84, -0.336, 0.4788, 34.86])
     transformed = c.from_pixels(px_coord)
     np.testing.assert_allclose(kbp_coord, transformed)
     np.testing.assert_allclose(px_coord, c.to_pixels(transformed))
 
-    c_flipped = PositionCalibration("kbp", -0.42, origin=2.0)
-    kbp_coord = -kbp_coord
+    c_flipped = PositionCalibration(PositionUnit.kbp, factor=-0.42, origin=2.0)
     transformed = c_flipped.from_pixels(px_coord)
-    np.testing.assert_allclose(kbp_coord, transformed)
+    np.testing.assert_allclose(-kbp_coord, transformed)
     np.testing.assert_allclose(px_coord, c_flipped.to_pixels(transformed))
 
-    assert c._value == -c_flipped._value
-    assert c.value == c_flipped.value
+    assert c.factor == -c_flipped.factor
+    assert c.pixelsize == c_flipped.pixelsize