Drop support for CameraFrame in ImageProcessor

ctapipe/containers.py

@@ -32,8 +32,6 @@
     "MonitoringCameraContainer",
     "MonitoringContainer",
     "MorphologyContainer",
-    "BaseHillasParametersContainer",
-    "CameraHillasParametersContainer",
     "CameraTimingParametersContainer",
     "ParticleClassificationContainer",
     "PedestalContainer",
@@ -184,45 +182,17 @@ class TelEventIndexContainer(Container):
     tel_id = tel_id_field()
 
 
-class BaseHillasParametersContainer(Container):
-    """
-    Base container for hillas parameters to
-    allow the CameraHillasParametersContainer to
-    be assigned to an ImageParametersContainer as well.
-    """
-
-    intensity = Field(nan, "total intensity (size)")
-    skewness = Field(nan, "measure of the asymmetry")
-    kurtosis = Field(nan, "measure of the tailedness")
-
-
-class CameraHillasParametersContainer(BaseHillasParametersContainer):
-    """
-    Hillas Parameters in the camera frame. The cog position
-    is given in meter from the camera center.
-    """
-
-    default_prefix = "camera_frame_hillas"
-    x = Field(nan * u.m, "centroid x coordinate", unit=u.m)
-    y = Field(nan * u.m, "centroid x coordinate", unit=u.m)
-    r = Field(nan * u.m, "radial coordinate of centroid", unit=u.m)
-    phi = Field(nan * u.deg, "polar coordinate of centroid", unit=u.deg)
-
-    length = Field(nan * u.m, "standard deviation along the major-axis", unit=u.m)
-    length_uncertainty = Field(nan * u.m, "uncertainty of length", unit=u.m)
-    width = Field(nan * u.m, "standard spread along the minor-axis", unit=u.m)
-    width_uncertainty = Field(nan * u.m, "uncertainty of width", unit=u.m)
-    psi = Field(nan * u.deg, "rotation angle of ellipse", unit=u.deg)
-
-
-class HillasParametersContainer(BaseHillasParametersContainer):
+class HillasParametersContainer(Container):
     """
     Hillas Parameters in a spherical system centered on the pointing position
     (TelescopeFrame). The cog position is given as offset in
     longitude and latitude in degree.
     """
 
     default_prefix = "hillas"
+    intensity = Field(nan, "total intensity (size)")
+    skewness = Field(nan, "measure of the asymmetry")
+    kurtosis = Field(nan, "measure of the tailedness")
     fov_lon = Field(
         nan * u.deg,
         "longitude angle in a spherical system centered on the pointing position",
@@ -366,7 +336,7 @@ class ImageParametersContainer(Container):
     hillas = Field(
         default_factory=HillasParametersContainer,
         description="Hillas Parameters",
-        type=BaseHillasParametersContainer,
+        type=HillasParametersContainer,
     )
     timing = Field(
         default_factory=TimingParametersContainer,

ctapipe/image/concentration.py

@@ -1,14 +1,10 @@
-import numpy as np
 import astropy.units as u
+import numpy as np
 
-from ..containers import (
-    ConcentrationContainer,
-    HillasParametersContainer,
-    CameraHillasParametersContainer,
-)
-from .hillas import camera_to_shower_coordinates
+from ..containers import ConcentrationContainer
 from ..instrument import CameraGeometry
 from ..utils.quantities import all_to_value
+from .hillas import camera_to_shower_coordinates
 
 __all__ = ["concentration_parameters"]
 
@@ -24,44 +20,32 @@ def concentration_parameters(geom: CameraGeometry, image, hillas_parameters):
     """
 
     h = hillas_parameters
-    if isinstance(h, CameraHillasParametersContainer):
-        unit = h.x.unit
-        pix_x, pix_y, x, y, length, width, pixel_width = all_to_value(
-            geom.pix_x,
-            geom.pix_y,
-            h.x,
-            h.y,
-            h.length,
-            h.width,
-            geom.pixel_width,
-            unit=unit,
-        )
-    elif isinstance(h, HillasParametersContainer):
-        unit = h.fov_lon.unit
-        pix_x, pix_y, x, y, length, width, pixel_width = all_to_value(
-            geom.pix_x,
-            geom.pix_y,
-            h.fov_lon,
-            h.fov_lat,
-            h.length,
-            h.width,
-            geom.pixel_width,
-            unit=unit,
-        )
+
+    unit = h.fov_lon.unit
+    pix_x, pix_y, x, y, length, width, pixel_width = all_to_value(
+        geom.pix_x,
+        geom.pix_y,
+        h.fov_lon,
+        h.fov_lat,
+        h.length,
+        h.width,
+        geom.pixel_width,
+        unit=unit,
+    )
 
     delta_x = pix_x - x
     delta_y = pix_y - y
 
     # take pixels within one pixel diameter from the cog
-    mask_cog = (delta_x ** 2 + delta_y ** 2) < pixel_width ** 2
+    mask_cog = (delta_x**2 + delta_y**2) < pixel_width**2
     conc_cog = np.sum(image[mask_cog]) / h.intensity
 
     if hillas_parameters.width.value != 0:
         # get all pixels inside the hillas ellipse
         longi, trans = camera_to_shower_coordinates(
             pix_x, pix_y, x, y, h.psi.to_value(u.rad)
         )
-        mask_core = (longi ** 2 / length ** 2) + (trans ** 2 / width ** 2) <= 1.0
+        mask_core = (longi**2 / length**2) + (trans**2 / width**2) <= 1.0
         conc_core = image[mask_core].sum() / h.intensity
     else:
         conc_core = 0.0

ctapipe/image/extractor.py

@@ -30,6 +30,7 @@
 from traitlets import Bool, Int
 
 from ctapipe.containers import DL1CameraContainer
+from ctapipe.coordinates import TelescopeFrame
 from ctapipe.core import TelescopeComponent
 from ctapipe.core.traits import (
     BoolTelescopeParameter,
@@ -1051,7 +1052,9 @@ def _apply_second_pass(
         # Apply correction to 1st pass charges
         charge_1stpass = charge_1stpass_uncorrected * correction[selected_gain_channel]
 
-        camera_geometry = self.subarray.tel[tel_id].camera.geometry
+        camera_geometry = self.subarray.tel[tel_id].camera.geometry.transform_to(
+            TelescopeFrame()
+        )
         if self.invalid_pixel_handler is not None:
             charge_1stpass, pulse_time_1stpass = self.invalid_pixel_handler(
                 tel_id,
@@ -1122,7 +1125,11 @@ def _apply_second_pass(
 
         # get projected distances along main image axis
         longitude, _ = camera_to_shower_coordinates(
-            camera_geometry.pix_x, camera_geometry.pix_y, hillas.x, hillas.y, hillas.psi
+            camera_geometry.pix_x,
+            camera_geometry.pix_y,
+            hillas.fov_lon,
+            hillas.fov_lat,
+            hillas.psi,
         )
 
         # get the predicted times as a linear relation

ctapipe/image/hillas.py

@@ -8,7 +8,7 @@
 import numpy as np
 from astropy.coordinates import Angle
 
-from ..containers import CameraHillasParametersContainer, HillasParametersContainer
+from ..containers import HillasParametersContainer
 
 HILLAS_ATOL = np.finfo(np.float64).eps
 
@@ -73,7 +73,7 @@ def hillas_parameters(geom, image):
 
     Parameters
     ----------
-    geom: ctapipe.instrument.CameraGeometry
+    geom: ctapipe.instrument.CameraGeometry in TelescopeFrame
         Camera geometry, the cleaning mask should be applied to improve performance
     image : array_like
         Charge in each pixel, the cleaning mask should already be applied to
@@ -178,21 +178,6 @@ def hillas_parameters(geom, image):
             np.sum(((((b * A) + (a * B) + (-c * C))) ** 2.0) * image)
         ) / (2 * width)
 
-    if unit.is_equivalent(u.m):
-        return CameraHillasParametersContainer(
-            x=u.Quantity(cog_x, unit),
-            y=u.Quantity(cog_y, unit),
-            r=u.Quantity(cog_r, unit),
-            phi=Angle(cog_phi, unit=u.rad),
-            intensity=size,
-            length=u.Quantity(length, unit),
-            length_uncertainty=u.Quantity(length_uncertainty, unit),
-            width=u.Quantity(width, unit),
-            width_uncertainty=u.Quantity(width_uncertainty, unit),
-            psi=Angle(psi, unit=u.rad),
-            skewness=skewness_long,
-            kurtosis=kurtosis_long,
-        )
     return HillasParametersContainer(
         fov_lon=u.Quantity(cog_x, unit),
         fov_lat=u.Quantity(cog_y, unit),

ctapipe/image/image_processor.py

@@ -1,23 +1,19 @@
 """
 High level image processing  (ImageProcessor Component)
 """
-from copy import deepcopy
-
 import numpy as np
 
 from ctapipe.coordinates import TelescopeFrame
 
 from ..containers import (
     ArrayEventContainer,
-    CameraHillasParametersContainer,
-    CameraTimingParametersContainer,
     ImageParametersContainer,
     IntensityStatisticsContainer,
     PeakTimeStatisticsContainer,
     TimingParametersContainer,
 )
 from ..core import QualityQuery, TelescopeComponent
-from ..core.traits import Bool, BoolTelescopeParameter, ComponentName, List
+from ..core.traits import BoolTelescopeParameter, ComponentName, List
 from ..instrument import SubarrayDescription
 from .cleaning import ImageCleaner
 from .concentration import concentration_parameters
@@ -40,15 +36,9 @@
     kurtosis=np.float64(np.nan),
 )
 DEFAULT_TIMING_PARAMETERS = TimingParametersContainer()
-DEFAULT_TIMING_PARAMETERS_CAMFRAME = CameraTimingParametersContainer()
 DEFAULT_PEAKTIME_STATISTICS = PeakTimeStatisticsContainer()
 
 
-DEFAULT_IMAGE_PARAMETERS_CAMFRAME = deepcopy(DEFAULT_IMAGE_PARAMETERS)
-DEFAULT_IMAGE_PARAMETERS_CAMFRAME.hillas = CameraHillasParametersContainer()
-DEFAULT_IMAGE_PARAMETERS_CAMFRAME.timing = CameraTimingParametersContainer()
-
-
 class ImageQualityQuery(QualityQuery):
     """for configuring image-wise data checks"""
 
@@ -68,11 +58,6 @@ class ImageProcessor(TelescopeComponent):
         ImageCleaner, default_value="TailcutsImageCleaner"
     ).tag(config=True)
 
-    use_telescope_frame = Bool(
-        default_value=True,
-        help="Whether to calculate parameters in the telescope or camera frame",
-    ).tag(config=True)
-
     apply_image_modifier = BoolTelescopeParameter(
         default_value=False, help="If true, apply ImageModifier to dl1 images"
     ).tag(config=True)
@@ -105,16 +90,14 @@ def __init__(
 
         self.check_image = ImageQualityQuery(parent=self)
 
-        self.default_image_container = DEFAULT_IMAGE_PARAMETERS_CAMFRAME
-        if self.use_telescope_frame:
-            self.default_image_container = DEFAULT_IMAGE_PARAMETERS
-            telescope_frame = TelescopeFrame()
-            self.telescope_frame_geometries = {
-                tel_id: self.subarray.tel[tel_id].camera.geometry.transform_to(
-                    telescope_frame
-                )
-                for tel_id in self.subarray.tel
-            }
+        self.default_image_container = DEFAULT_IMAGE_PARAMETERS
+        telescope_frame = TelescopeFrame()
+        self.telescope_frame_geometries = {
+            tel_id: self.subarray.tel[tel_id].camera.geometry.transform_to(
+                telescope_frame
+            )
+            for tel_id in self.subarray.tel
+        }
 
     def __call__(self, event: ArrayEventContainer):
         self._process_telescope_event(event)
@@ -182,10 +165,7 @@ def _parameterize_image(
                     container_class=PeakTimeStatisticsContainer,
                 )
             else:
-                if self.use_telescope_frame:
-                    timing = DEFAULT_TIMING_PARAMETERS
-                else:
-                    timing = DEFAULT_TIMING_PARAMETERS_CAMFRAME
+                timing = DEFAULT_TIMING_PARAMETERS
 
                 peak_time_statistics = DEFAULT_PEAKTIME_STATISTICS
 
@@ -209,11 +189,8 @@ def _process_telescope_event(self, event):
         """
         for tel_id, dl1_camera in event.dl1.tel.items():
 
-            if self.use_telescope_frame:
-                # Use the transformed geometries
-                geometry = self.telescope_frame_geometries[tel_id]
-            else:
-                geometry = self.subarray.tel[tel_id].camera.geometry
+            # Use the transformed geometries
+            geometry = self.telescope_frame_geometries[tel_id]
 
             if self.apply_image_modifier.tel[tel_id]:
                 dl1_camera.image = self.modify(tel_id=tel_id, image=dl1_camera.image)

ctapipe/image/muon/tests/test_ring_fitter.py

@@ -1,6 +1,7 @@
 import astropy.units as u
 import pytest
 
+from ctapipe.coordinates import TelescopeFrame
 from ctapipe.image import tailcuts_clean, toymodel
 from ctapipe.image.muon import MuonRingFitter
 
@@ -15,10 +16,10 @@ def test_MuonRingFitter_has_methods():
 def test_MuonRingFitter(method, prod5_mst_flashcam):
     """test MuonRingFitter"""
     # flashCam example
-    center_xs = 0.3 * u.m
-    center_ys = 0.6 * u.m
-    radius = 0.3 * u.m
-    width = 0.05 * u.m
+    center_xs = 0.3 * u.deg
+    center_ys = 0.6 * u.deg
+    radius = 0.5 * u.deg
+    width = 0.05 * u.deg
 
     muon_model = toymodel.RingGaussian(
         x=center_xs,
@@ -28,7 +29,7 @@ def test_MuonRingFitter(method, prod5_mst_flashcam):
     )
 
     # testing with flashcam
-    geom = prod5_mst_flashcam.camera.geometry
+    geom = prod5_mst_flashcam.camera.geometry.transform_to(TelescopeFrame())
     charge, _, _ = muon_model.generate_image(
         geom,
         intensity=1000,