Add code to register metadata

Author: stephen-riggs

pyproject.toml

@@ -127,6 +127,7 @@ TomographyMetadataContext = "murfey.client.contexts.tomo_metadata:TomographyMeta
 "spa.flush_spa_preprocess" = "murfey.workflows.spa.flush_spa_preprocess:flush_spa_preprocess"
 "spa.motion_corrected" = "murfey.workflows.spa.motion_correction:motion_corrected"
 "sxt.process_tilt_series" = "murfey.workflows.sxt.process_sxt_tilt_series:run"
+"sxt.register_roi" = "murfey.workflows.sxt.sxt_metadata:run"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

src/murfey/client/contexts/sxt.py

@@ -303,11 +303,10 @@ def post_transfer(
                         function_name="register_sxt_roi",
                         token=self._token,
                         instrument_name=environment.instrument_name,
-                        visit_name=environment.visit,
                         session_id=environment.murfey_session,
+                        roi_name=transferred_file.stem,
                         data={
                             "tag": dcg_tag,
-                            "name": transferred_file.stem,
                             "x_stage_position": metadata.get("x_position", None),
                             "y_stage_position": metadata.get("y_position", None),
                             "pixel_size": round(metadata.get("pixel_size", 0), 2),

src/murfey/server/api/workflow_sxt.py

@@ -10,6 +10,7 @@
     validate_instrument_token,
 )
 from murfey.server.murfey_db import murfey_db
+from murfey.util.models import SearchMapParameters
 from murfey.workflows.sxt.process_sxt_tilt_series import SXTTiltSeriesInfo
 
 logger = getLogger("murfey.server.api.workflow_sxt")
@@ -62,23 +63,22 @@ def convert_xrm_to_tiff(xrm_file: XrmFile, db=murfey_db):
         )
 
 
-class SxtRoiInfo(BaseModel):
-    tag: str
-    name: str
-    x_stage_position: float
-    y_stage_position: float
-    pixel_size: float
-    height: int
-    width: int
-    image: Path
-
-
-@router.post("/visits/{visit_name}/sessions/{session_id}/register_sxt_roi")
+@router.post("/sessions/{session_id}/sxt_roi/{roi_name}")
 def register_sxt_roi(
-    visit_name: str,
     session_id: MurfeySessionID,
-    tilt_series_info: SXTTiltSeriesInfo,
+    roi_name: str,
+    roi_info: SearchMapParameters,
     db=murfey_db,
 ):
-    # TODO
-    return
+    if _transport_object:
+        logger.info(f"Registering SXT region {roi_info.name}")
+        _transport_object.send(
+            _transport_object.feedback_queue,
+            {
+                "register": "sxt.register_roi",
+                "session_id": session_id,
+                "roi_name": roi_name,
+                "roi_info": roi_info.model_dump(mode="json"),
+            },
+            new_connection=True,
+        )

src/murfey/util/route_manifest.yaml

@@ -1460,10 +1460,10 @@ murfey.server.api.workflow_sxt.router:
     path_params: []
     methods:
       - POST
-  - path: /workflow/sxt/visits/{visit_name}/sessions/{session_id}/register_sxt_roi
+  - path: /workflow/sxt/sessions/{session_id}/sxt_roi/{roi_name}
     function: register_sxt_roi
     path_params:
-      - name: visit_name
+      - name: roi_name
         type: str
       - name: session_id
         type: int

src/murfey/workflows/sxt/sxt_metadata.py

@@ -0,0 +1,124 @@
+import logging
+
+from sqlmodel.orm.session import Session as SQLModelSession, select
+
+from murfey.server import _transport_object
+from murfey.util import sanitise
+from murfey.util.db import (
+    DataCollectionGroup,
+    SxtRoi,
+)
+from murfey.util.models import SearchMapParameters
+
+logger = logging.getLogger("murfey.workflows.sxt.sxt_metadata")
+
+
+def register_sxt_roi(
+    session_id: int,
+    roi_name: str,
+    roi_parameters: SearchMapParameters,
+    murfey_db: SQLModelSession,
+) -> dict[str, bool]:
+    dcg = murfey_db.exec(
+        select(DataCollectionGroup)
+        .where(DataCollectionGroup.session_id == session_id)
+        .where(DataCollectionGroup.tag == roi_parameters.tag)
+    ).one()
+    roi_query = murfey_db.exec(
+        select(SxtRoi)
+        .where(SxtRoi.name == roi_name)
+        .where(SxtRoi.tag == roi_parameters.tag)
+        .where(SxtRoi.session_id == SxtRoi)
+    ).all()
+    if roi_query:
+        # See if there is already a search map with this name and update if so
+        roi = roi_query[0]
+        roi.x_stage_position = roi_parameters.x_stage_position or roi.x_stage_position
+        roi.y_stage_position = roi_parameters.y_stage_position or roi.y_stage_position
+        roi.height = roi_parameters.height or roi.height
+        roi.width = roi_parameters.width or roi.width
+        roi.pixel_size = roi_parameters.pixel_size or roi.pixel_size
+        roi.image = roi_parameters.image or roi.image
+        if _transport_object:
+            _transport_object.do_update_sxt_roi(roi.id, roi_parameters)
+    else:
+        logger.info(f"Registering new sxt roi {sanitise(roi_name)}")
+        if _transport_object:
+            roi_ispyb_response = _transport_object.do_insert_sxt_roi(
+                dcg.atlas_id, roi_parameters
+            )
+        else:
+            # mock up response so that below still works
+            roi_ispyb_response = {"success": False, "return_value": None}
+        # Register new search map
+        roi = SxtRoi(
+            id=(
+                roi_ispyb_response["return_value"]
+                if roi_ispyb_response["success"]
+                else None
+            ),
+            name=roi_name,
+            session_id=session_id,
+            tag=roi_parameters.tag,
+            x_stage_position=roi_parameters.x_stage_position,
+            y_stage_position=roi_parameters.y_stage_position,
+            pixel_size=roi_parameters.pixel_size,
+            width=roi_parameters.width,
+            height=roi_parameters.height,
+            thumbnail_size_x=1024,
+            thumbnail_size_y=1024,
+            image=roi_parameters.image or "",
+        )
+
+    if all(
+        [
+            roi.x_stage_position,
+            roi.y_stage_position,
+            roi.pixel_size,
+            dcg.atlas_pixel_size,
+            dcg.atlas_stage_x,
+            dcg.atlas_height,
+        ]
+    ):
+        # Convert from stage position to pixel locations
+        roi.x_location = (
+            roi.x_stage_position - dcg.atlas_stage_x
+        ) / dcg.atlas_pixel_size
+        roi.y_location = (
+            roi.y_stage_position - dcg.atlas_stage_y
+        ) / dcg.atlas_pixel_size
+
+        # Scaling from different pixel size of atlas and roi, and atlas thumbnailing
+        roi_parameters.x_location = roi.x_location
+        roi_parameters.y_location = roi.y_location
+        roi_parameters.height_on_atlas = (
+            roi.height
+            * (roi.pixel_size / dcg.atlas_pixel_size)
+            * (1024 / dcg.atlas_height)
+        )
+        roi_parameters.width_on_atlas = (
+            roi.width
+            * (roi.pixel_size / dcg.atlas_pixel_size)
+            * (1024 / dcg.atlas_width)
+        )
+        if _transport_object:
+            _transport_object.do_update_sxt_roi(roi.id, roi_parameters)
+    else:
+        logger.info(
+            f"Unable to register roi {sanitise(roi.name)} position yet: "
+            f"roi pixel size {sanitise(str(roi.pixel_size))}, "
+            f"atlas pixel size {sanitise(str(dcg.atlas_pixel_size))}"
+        )
+    murfey_db.add(roi)
+    murfey_db.commit()
+    murfey_db.close()
+    return {"success": True}
+
+
+def run(message: dict, murfey_db: SQLModelSession) -> dict[str, bool]:
+    return register_sxt_roi(
+        message["session_id"],
+        message["roi_name"],
+        SearchMapParameters(**message["roi_info"]),
+        murfey_db,
+    )