From 9fe84e83551670df429fce8c9d03d2f4c1c0e27f Mon Sep 17 00:00:00 2001
From: David Waterman <dgwaterman@gmail.com>
Date: Thu, 13 Feb 2025 14:54:17 +0000
Subject: [PATCH 1/6] =?UTF-8?q?Add=20FormatROD=5FArc=20for=20the=20HyPix-A?=
 =?UTF-8?q?rc=20100=C2=B0=20and=20HyPix-Arc=20150=C2=B0=20detectors?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/dxtbx/format/FormatROD.py | 152 ++++++++++++++++++++++++++++++++++
 1 file changed, 152 insertions(+)

diff --git a/src/dxtbx/format/FormatROD.py b/src/dxtbx/format/FormatROD.py
index 4bf951fd0..da448056f 100644
--- a/src/dxtbx/format/FormatROD.py
+++ b/src/dxtbx/format/FormatROD.py
@@ -20,12 +20,14 @@
 
 import numpy as np
 
+from scitbx import matrix
 from scitbx.array_family import flex
 from scitbx.math import r3_rotation_axis_and_angle_as_matrix
 
 from dxtbx.ext import uncompress_rod_TY6
 from dxtbx.format.Format import Format
 from dxtbx.model.beam import Probe
+from dxtbx.model.detector import Detector
 
 
 class FormatROD(Format):
@@ -482,6 +484,156 @@ def decode_TY6_oneline(self, linedata, w):
         return ret
 
 
+class FormatROD_Arc(FormatROD):
+    @staticmethod
+    def understand(image_file):
+        offset = 256
+        general_nbytes = 512
+        with FormatROD_Arc.open_file(image_file, "rb") as f:
+            f.seek(offset + general_nbytes + 548)
+            detector_type = struct.unpack("<l", f.read(4))[0]
+            if detector_type in [12, 14]:
+                return True
+        return False
+
+    def _detector(self):
+        """2 or 3 panel detector, each rotated 38° from its neighbour."""
+
+        theta_rad = self._gonio_start_angles[1] / 180 * np.pi
+        detector_rotns_rad = np.array(self._bin_header["detector_rotns"]) / 180 * np.pi
+        rot_e1 = np.array(
+            r3_rotation_axis_and_angle_as_matrix([0, 0, 1], detector_rotns_rad[0])
+        ).reshape(3, 3)  # clockwise along e1 = Z
+        rot_e2 = np.array(
+            r3_rotation_axis_and_angle_as_matrix([-1, 0, 0], detector_rotns_rad[1])
+        ).reshape(3, 3)  # ANTI-clockwise along e2 = X
+        rot_theta = np.array(
+            r3_rotation_axis_and_angle_as_matrix([0, -1, 0], theta_rad)
+        ).reshape(3, 3)  # ANTI-clockwise along e3 = Y
+        detector_axes = rot_theta.dot(rot_e2.dot(rot_e1))
+
+        pixel_size_x = self._bin_header["real_px_size_x"]
+        pixel_size_y = self._bin_header["real_px_size_y"]
+        origin_at_zero = np.array(
+            [
+                -self._bin_header["origin_px_x"] * pixel_size_x,
+                -self._bin_header["origin_px_y"] * pixel_size_y,
+                -self._bin_header["distance_mm"],
+            ]
+        )
+        # Get origin for the first panel, not rotated
+        origin = detector_axes.dot(origin_at_zero)
+
+        d = Detector()
+
+        root = d.hierarchy()
+        root.set_local_frame(detector_axes[:, 0], detector_axes[:, 1], origin)
+
+        self.coords = {}
+        panel_idx = 0
+
+        pnl_data = []
+        gap_px = 30
+        pnl_data.append({"xmin": 0, "ymin": 0, "xmax": 385, "ymax": 775, "xmin_mm": 0})
+        pnl_data.append(
+            {
+                "xmin": (385 + gap_px),
+                "ymin": 0,
+                "xmax": 800,
+                "ymax": 775,
+                "xmin_mm": (385 + gap_px) * pixel_size_x,
+            }
+        )
+        if self._bin_header["detector_type"] == 12:
+            pnl_data.append(
+                {
+                    "xmin": (385 + gap_px) * 2,
+                    "ymin": 0,
+                    "xmax": 1215,
+                    "ymax": 775,
+                    "xmin_mm": (385 + gap_px) * 2 * pixel_size_x,
+                }
+            )
+
+        # redefine fast, slow for the local frame
+        fast = matrix.col((1.0, 0.0, 0.0))
+        slow = matrix.col((0.0, 1.0, 0.0))
+
+        for ipanel, pd in enumerate(pnl_data):
+            xmin = pd["xmin"]
+            xmax = pd["xmax"]
+            ymin = pd["ymin"]
+            ymax = pd["ymax"]
+            xmin_mm = pd["xmin_mm"]
+
+            origin_panel = fast * xmin_mm
+
+            panel_name = "Panel%d" % panel_idx
+            panel_idx += 1
+
+            p = d.add_panel()
+            p.set_type("SENSOR_PAD")
+            p.set_name(panel_name)
+            p.set_raw_image_offset((xmin, ymin))
+            p.set_image_size((xmax - xmin, ymax - ymin))
+            p.set_trusted_range((0, self._bin_header["overflow_threshold"]))
+            p.set_pixel_size((pixel_size_x, pixel_size_y))
+            p.set_local_frame(fast.elems, slow.elems, origin_panel.elems)
+            self.coords[panel_name] = (xmin, ymin, xmax, ymax)
+
+        # Now rotate the external panels. For the time being do the rotation around
+        # and axis along the centre of the gap between the panels.
+        if len(pnl_data) == 2:
+            angle = 19.0
+        elif len(pnl_data) == 3:
+            angle = 38.0
+        else:
+            raise ValueError("Unexpected number of panels")
+
+        left_panel = d[0]
+        right_panel = d[len(d) - 1]
+
+        # Point to rotate the left panel around, from the local origin
+        pnl_fast = matrix.col(left_panel.get_local_fast_axis())
+        pnl_slow = matrix.col(left_panel.get_local_slow_axis())
+        pt = pnl_fast * (
+            left_panel.get_image_size_mm()[0] + (gap_px / 2) * pixel_size_x
+        )
+
+        rotated = (-1.0 * pt).rotate_around_origin(pnl_slow, angle, deg=True)
+        new_origin = pt + rotated
+        new_fast = pnl_fast.rotate_around_origin(pnl_slow, angle, deg=True)
+        left_panel.set_local_frame(new_fast.elems, pnl_slow.elems, new_origin.elems)
+
+        # Point to rotate the right panel around, from the panel's origin
+        pnl_fast = matrix.col(right_panel.get_local_fast_axis())
+        pnl_slow = matrix.col(right_panel.get_local_slow_axis())
+        pnl_origin = matrix.col(right_panel.get_local_origin())
+        pt = -pnl_fast * (gap_px / 2) * pixel_size_x
+
+        rotated = (-1.0 * pt).rotate_around_origin(pnl_slow, -angle, deg=True)
+        new_origin = pnl_origin + pt + rotated
+        new_fast = pnl_fast.rotate_around_origin(pnl_slow, -angle, deg=True)
+        right_panel.set_local_frame(new_fast.elems, pnl_slow.elems, new_origin.elems)
+
+        return d
+
+    def get_raw_data(self):
+        """Get the pixel intensities (i.e. read the image and return as a
+        flex array of integers.)"""
+
+        raw_data = super().get_raw_data()
+
+        # split into separate panels
+        self._raw_data = []
+        d = self.get_detector()
+        for panel in d:
+            xmin, ymin, xmax, ymax = self.coords[panel.get_name()]
+            self._raw_data.append(raw_data[ymin:ymax, xmin:xmax])
+
+        return tuple(self._raw_data)
+
+
 if __name__ == "__main__":
     import sys
 

From d0d02161c5ca33f34102a860c76f0898ddcdcea1 Mon Sep 17 00:00:00 2001
From: David Waterman <dgwaterman@gmail.com>
Date: Thu, 13 Feb 2025 14:55:19 +0000
Subject: [PATCH 2/6] Fix warnings from multiplying arrays where some elements
 are Inf

---
 src/dxtbx/format/FormatROD.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/dxtbx/format/FormatROD.py b/src/dxtbx/format/FormatROD.py
index da448056f..bbf7e5148 100644
--- a/src/dxtbx/format/FormatROD.py
+++ b/src/dxtbx/format/FormatROD.py
@@ -203,13 +203,13 @@ def _start(self):
 
         self._gonio_start_angles = (
             np.array(self._bin_header["start_angles_steps"])
-            * np.array(self._bin_header["step_to_rad"])
+            * np.nan_to_num(np.array(self._bin_header["step_to_rad"]))
             / np.pi
             * 180
         )
         self._gonio_end_angles = (
             np.array(self._bin_header["end_angles_steps"])
-            * np.array(self._bin_header["step_to_rad"])
+            * np.nan_to_num(np.array(self._bin_header["step_to_rad"]))
             / np.pi
             * 180
         )

From a6f4e518895d9a1aac012ff605b6c6e4d172a6df Mon Sep 17 00:00:00 2001
From: David Waterman <dgwaterman@gmail.com>
Date: Thu, 13 Feb 2025 14:59:22 +0000
Subject: [PATCH 3/6] news

---
 newsfragments/xxx.feature | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 newsfragments/xxx.feature

diff --git a/newsfragments/xxx.feature b/newsfragments/xxx.feature
new file mode 100644
index 000000000..243de412e
--- /dev/null
+++ b/newsfragments/xxx.feature
@@ -0,0 +1 @@
+``FormatROD_Arc``: Support for Rigaku HyPix-Arc 100° and 150° curved detectors

From 9d9b4523366060b72e3cf05357c4ad976fd54f68 Mon Sep 17 00:00:00 2001
From: David Waterman <dgwaterman@gmail.com>
Date: Fri, 14 Feb 2025 09:54:49 +0000
Subject: [PATCH 4/6] Add a 2D projection for correct display in the image
 viewer

---
 src/dxtbx/format/FormatROD.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/dxtbx/format/FormatROD.py b/src/dxtbx/format/FormatROD.py
index bbf7e5148..5725694e4 100644
--- a/src/dxtbx/format/FormatROD.py
+++ b/src/dxtbx/format/FormatROD.py
@@ -579,6 +579,7 @@ def _detector(self):
             p.set_trusted_range((0, self._bin_header["overflow_threshold"]))
             p.set_pixel_size((pixel_size_x, pixel_size_y))
             p.set_local_frame(fast.elems, slow.elems, origin_panel.elems)
+            p.set_projection_2d((-1, 0, 0, -1), (0, pd["xmin"]))
             self.coords[panel_name] = (xmin, ymin, xmax, ymax)
 
         # Now rotate the external panels. For the time being do the rotation around

From 16dd7d406a8ed90e8a4c5978808ebd11c22e40eb Mon Sep 17 00:00:00 2001
From: DiamondLightSource-build-server
 <DiamondLightSource-build-server@users.noreply.github.com>
Date: Fri, 14 Feb 2025 10:03:53 +0000
Subject: [PATCH 5/6] Rename newsfragments/xxx.feature to
 newsfragments/787.feature

---
 newsfragments/{xxx.feature => 787.feature} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename newsfragments/{xxx.feature => 787.feature} (100%)

diff --git a/newsfragments/xxx.feature b/newsfragments/787.feature
similarity index 100%
rename from newsfragments/xxx.feature
rename to newsfragments/787.feature

From 2de24bf76a27735a805d4a671f1811ec0df82eac Mon Sep 17 00:00:00 2001
From: David Waterman <dgwaterman@gmail.com>
Date: Wed, 19 Feb 2025 15:57:43 +0000
Subject: [PATCH 6/6] Have found the place in the ver 4 header where these
 camera constants are stored, so read from the header instead of hardcoding

---
 src/dxtbx/format/FormatROD.py | 61 +++++++++++++++++++++++++++++------
 1 file changed, 51 insertions(+), 10 deletions(-)

diff --git a/src/dxtbx/format/FormatROD.py b/src/dxtbx/format/FormatROD.py
index 5725694e4..7b5a6e8af 100644
--- a/src/dxtbx/format/FormatROD.py
+++ b/src/dxtbx/format/FormatROD.py
@@ -496,6 +496,45 @@ def understand(image_file):
                 return True
         return False
 
+    @staticmethod
+    def _read_binary_header(
+        image_file,
+        offset=256,
+        nbytes=5120,
+        general_nbytes=512,
+        special_nbytes=768,
+        km4gonio_nbytes=1024,
+        statistics_nbytes=512,
+        history_nbytes=2048,
+    ):
+        bh = FormatROD._read_binary_header(
+            image_file,
+            offset,
+            nbytes,
+            general_nbytes,
+            special_nbytes,
+            km4gonio_nbytes,
+            statistics_nbytes,
+            history_nbytes,
+        )
+
+        # Seek to the end of the standard version 3 header and into the
+        # extra camera parameters section
+        with FormatROD_Arc.open_file(image_file, "rb") as f:
+            f.seek(nbytes + 268)
+            ix, iy, nx, ny, gapx, gapy = struct.unpack("<hhhhhh", f.read(12))
+        assert ix in (2, 3)
+        assert iy == 1
+        assert nx == 385
+        assert ny == 775
+        assert gapx == 30
+        assert gapy == 0
+        bh["nx"] = nx
+        bh["ny"] = ny
+        bh["gap_px"] = gapx
+
+        return bh
+
     def _detector(self):
         """2 or 3 panel detector, each rotated 38° from its neighbour."""
 
@@ -533,25 +572,27 @@ def _detector(self):
         panel_idx = 0
 
         pnl_data = []
-        gap_px = 30
-        pnl_data.append({"xmin": 0, "ymin": 0, "xmax": 385, "ymax": 775, "xmin_mm": 0})
+        nx = self._bin_header["nx"]
+        ny = self._bin_header["ny"]
+        gap_px = self._bin_header["gap_px"]
+        pnl_data.append({"xmin": 0, "ymin": 0, "xmax": nx, "ymax": ny, "xmin_mm": 0})
         pnl_data.append(
             {
-                "xmin": (385 + gap_px),
+                "xmin": (nx + gap_px),
                 "ymin": 0,
-                "xmax": 800,
-                "ymax": 775,
-                "xmin_mm": (385 + gap_px) * pixel_size_x,
+                "xmax": 2 * nx + gap_px,
+                "ymax": ny,
+                "xmin_mm": (nx + gap_px) * pixel_size_x,
             }
         )
         if self._bin_header["detector_type"] == 12:
             pnl_data.append(
                 {
-                    "xmin": (385 + gap_px) * 2,
+                    "xmin": (nx + gap_px) * 2,
                     "ymin": 0,
-                    "xmax": 1215,
-                    "ymax": 775,
-                    "xmin_mm": (385 + gap_px) * 2 * pixel_size_x,
+                    "xmax": 3 * nx + 2 * gap_px,
+                    "ymax": ny,
+                    "xmin_mm": (nx + gap_px) * 2 * pixel_size_x,
                 }
             )