TwoPy 0.2.1__tar.gz → 0.3.0__tar.gz

{twopy-0.2.1 → twopy-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: twopy
-Version: 0.2.1
+Version: 0.3.0
 Summary: Two-photon imaging analysis tool with a napari interface.
 Author-email: Gustavo Madeira Santana <fromweb1@gumadeiras.com>
 License-Expression: MIT

{twopy-0.2.1 → twopy-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "twopy"
-version = "0.2.1"
+version = "0.3.0"
 description = "Two-photon imaging analysis tool with a napari interface."
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{twopy-0.2.1 → twopy-0.3.0}/src/twopy/analysis/persistence.py

@@ -48,6 +48,10 @@ from twopy.hdf5_utils import (
     write_string_dataset as _write_string_dataset,
 )
 from twopy.roi import RoiSet, TraceStatistic, make_roi_set
+from twopy.spatial_orientation import (
+    require_twopy_spatial_orientation,
+    write_twopy_spatial_orientation,
+)
 from twopy.typing_guards import (
     require_bool_array,
     require_float64_array,
@@ -238,7 +242,9 @@ def load_analysis_outputs(path: Path) -> LoadedAnalysisOutputs:
         return LoadedAnalysisOutputs(
             path=input_path,
             roi_set=(
-                _read_roi_set(h5_file["roi_set"]) if "roi_set" in h5_file else None
+                _read_roi_set(h5_file["roi_set"], path=input_path)
+                if "roi_set" in h5_file
+                else None
             ),
             traces=(
                 _read_background_traces(h5_file["traces"])
@@ -347,19 +353,28 @@ def _write_roi_set(group: h5py.Group, roi_set: RoiSet) -> None:
     Returns:
         None.
     """
-    group.create_dataset("masks", data=roi_set.masks, compression="gzip")
+    write_twopy_spatial_orientation(group)
+    masks = group.create_dataset("masks", data=roi_set.masks, compression="gzip")
+    write_twopy_spatial_orientation(masks)
     _write_string_dataset(group, "labels", roi_set.labels)
 
 
-def _read_roi_set(group: h5py.Group) -> RoiSet:
+def _read_roi_set(group: h5py.Group, *, path: Path) -> RoiSet:
     """Read a persisted ROI set.
 
     Args:
         group: HDF5 ``roi_set`` group.
+        path: Analysis output path used in validation errors.
 
     Returns:
         ``RoiSet`` with validated masks and labels.
     """
+    require_twopy_spatial_orientation(group, path=path, label="roi_set")
+    require_twopy_spatial_orientation(
+        group["masks"],
+        path=path,
+        label="roi_set/masks",
+    )
     return make_roi_set(
         require_bool_array(group["masks"][()], name="roi_set/masks", ndim=3),
         labels=_read_string_dataset(group, "labels"),

{twopy-0.2.1 → twopy-0.3.0}/src/twopy/analysis/response_maps.py

@@ -43,6 +43,10 @@ from twopy.analysis.timing import resolve_recording_timing
 from twopy.analysis.trials import EpochFrameWindow, is_baseline_epoch_name
 from twopy.converted import RecordingData, recording_frame_rate_hz
 from twopy.spatial import SpatialCrop
+from twopy.spatial_orientation import (
+    require_twopy_spatial_orientation,
+    write_twopy_spatial_orientation,
+)
 
 __all__ = [
     "EpochResponseMap",
@@ -247,29 +251,33 @@ def save_response_map_data(path: Path, map_data: ResponseMapData) -> None:
     recording-level movie products. Values are stored as normalized signed maps
     with the original dF/F scale in ``response_scale`` for audit.
     """
+    _require_response_map_shapes(map_data)
     output_path = path.expanduser()
     output_path.parent.mkdir(parents=True, exist_ok=True)
     with h5py.File(output_path, "w") as h5_file:
         h5_file.attrs["twopy_format"] = RESPONSE_MAP_FILE_FORMAT
         h5_file.attrs["response_scale"] = map_data.response_scale
+        write_twopy_spatial_orientation(h5_file)
         _write_response_map_options(h5_file.create_group("options"), map_data.options)
         _write_spatial_crop(h5_file.create_group("spatial_crop"), map_data.spatial_crop)
-        h5_file.create_dataset(
+        mean_image = h5_file.create_dataset(
             "mean_image",
             data=map_data.mean_image,
             compression="gzip",
         )
+        write_twopy_spatial_orientation(mean_image)
         epochs_group = h5_file.create_group("epochs")
         for index, epoch in enumerate(map_data.epochs):
             epoch_group = epochs_group.create_group(f"{index:04d}")
             epoch_group.attrs["epoch_name"] = epoch.epoch_name
             epoch_group.attrs["epoch_number"] = epoch.epoch_number
             epoch_group.attrs["trial_count"] = epoch.trial_count
-            epoch_group.create_dataset(
+            response_values = epoch_group.create_dataset(
                 "response_values",
                 data=epoch.response_values,
                 compression="gzip",
             )
+            write_twopy_spatial_orientation(response_values)
 
 
 def load_response_map_data(path: Path) -> ResponseMapData:
@@ -287,21 +295,34 @@ def load_response_map_data(path: Path) -> ResponseMapData:
     input_path = path.expanduser()
     with h5py.File(input_path, "r") as h5_file:
         _require_response_map_format(h5_file, input_path)
+        require_twopy_spatial_orientation(
+            h5_file,
+            path=input_path,
+            label="response heatmap file",
+        )
         options = _read_response_map_options(h5_file["options"])
         spatial_crop = _read_spatial_crop(h5_file["spatial_crop"])
-        mean_image = np.asarray(h5_file["mean_image"], dtype=np.float64)
+        mean_image_dataset = h5_file["mean_image"]
+        require_twopy_spatial_orientation(
+            mean_image_dataset,
+            path=input_path,
+            label="mean_image",
+        )
+        mean_image = np.asarray(mean_image_dataset, dtype=np.float64)
         epochs_group = h5_file["epochs"]
         epochs = tuple(
-            _read_epoch_response_map(epochs_group[name])
+            _read_epoch_response_map(epochs_group[name], path=input_path)
             for name in sorted(epochs_group.keys())
         )
-        return ResponseMapData(
+        map_data = ResponseMapData(
             mean_image=mean_image,
             epochs=epochs,
             options=options,
             spatial_crop=spatial_crop,
             response_scale=float(h5_file.attrs["response_scale"]),
         )
+        _require_response_map_shapes(map_data)
+        return map_data
 
 
 def _write_response_map_options(
@@ -357,16 +378,45 @@ def _read_spatial_crop(group: h5py.Group) -> SpatialCrop:
     )
 
 
-def _read_epoch_response_map(group: h5py.Group) -> EpochResponseMap:
+def _read_epoch_response_map(group: h5py.Group, *, path: Path) -> EpochResponseMap:
     """Read one persisted epoch response map."""
+    response_values = group["response_values"]
+    require_twopy_spatial_orientation(
+        response_values,
+        path=path,
+        label=f"{group.name}/response_values",
+    )
     return EpochResponseMap(
         epoch_name=_string_attr(group, "epoch_name"),
         epoch_number=int(group.attrs["epoch_number"]),
-        response_values=np.asarray(group["response_values"], dtype=np.float64),
+        response_values=np.asarray(response_values, dtype=np.float64),
         trial_count=int(group.attrs["trial_count"]),
     )
 
 
+def _require_response_map_shapes(map_data: ResponseMapData) -> None:
+    """Require heatmap spatial arrays to match their recorded crop."""
+    if map_data.mean_image.ndim != 2:
+        msg = (
+            f"response heatmap mean_image must be 2-D; got {map_data.mean_image.shape}"
+        )
+        raise ValueError(msg)
+    if map_data.mean_image.shape != map_data.spatial_crop.shape:
+        msg = (
+            "response heatmap mean_image shape must match spatial_crop shape; "
+            f"got {map_data.mean_image.shape} and {map_data.spatial_crop.shape}"
+        )
+        raise ValueError(msg)
+    for epoch in map_data.epochs:
+        if epoch.response_values.shape != map_data.mean_image.shape:
+            msg = (
+                "response heatmap response_values shape must match mean_image "
+                f"shape; got {epoch.response_values.shape} for "
+                f"{epoch.epoch_name!r} and {map_data.mean_image.shape}"
+            )
+            raise ValueError(msg)
+
+
 def _require_response_map_format(h5_file: h5py.File, path: Path) -> None:
     """Raise when an HDF5 file is not a twopy response heatmap file."""
     actual = _string_attr(h5_file, "twopy_format")

{twopy-0.2.1 → twopy-0.3.0}/src/twopy/analysis_cache.py

@@ -4,10 +4,10 @@ Inputs: configured recording roots, local cache folders, and saved analysis file
 Outputs: cache refreshes and publish-sync plans for twopy-owned outputs.
 
 The cache keeps interactive reads and writes on local storage. The publish sync
-copies only user-visible analysis outputs back to the configured output folder;
-converted movies remain derived local working files by default. Exported figure
-files are removed from the local cache after they copy successfully because the
-publish destination is their durable location.
+copies twopy-owned converted files and user-visible analysis outputs back to the
+configured output folder. Exported figure files are removed from the local cache
+after they copy successfully because the publish destination is their durable
+location.
 """
 
 import os
@@ -25,7 +25,9 @@ from twopy.config import (
 )
 from twopy.converted import RecordingData
 from twopy.filenames import (
+    ALIGNED_MOVIE_FILENAME,
     ANALYSIS_OUTPUT_FILENAME,
+    RECORDING_DATA_FILENAME,
     RESPONSE_HEATMAPS_FILENAME,
     ROI_FILENAME,
 )
@@ -36,11 +38,14 @@ __all__ = [
     "build_analysis_sync_plan",
     "copy_file_atomically",
     "copy_analysis_sync_plan",
+    "copy_converted_files_to_publish",
     "refresh_cached_analysis_outputs",
     "start_analysis_sync",
 ]
 
 _CACHE_REFRESH_FILENAMES = (
+    RECORDING_DATA_FILENAME,
+    ALIGNED_MOVIE_FILENAME,
     ROI_FILENAME,
     ANALYSIS_OUTPUT_FILENAME,
     RESPONSE_HEATMAPS_FILENAME,
@@ -91,8 +96,8 @@ def refresh_cached_analysis_outputs(
         Local paths refreshed from published outputs.
 
     Missing config or disabled caching means there is no cache refresh to do.
-    Only the HDF5 files needed by the GUI reload path are pulled down; CSV and
-    image exports are regenerated from saved analysis when needed.
+    HDF5 files needed by the GUI are pulled down; CSV and image exports are
+    regenerated from saved analysis when needed.
     """
     try:
         config = load_config(config_path)
@@ -137,21 +142,60 @@ def build_analysis_sync_plan(
         config_path: YAML config file with cache and publish settings.
 
     Returns:
-        A sync plan, or ``None`` when caching is disabled, config is missing,
-        the publish root is the local root, or no syncable files were written.
+        A sync plan, or ``None`` when config is missing, the publish root is the
+        local root, or no syncable files were written.
     """
     try:
         config = load_config(config_path)
     except FileNotFoundError:
         return None
     try:
-        return _build_analysis_sync_plan_from_config(
-            recording=recording,
-            local_paths=local_paths,
+        plan = _build_sync_plan_from_config(
+            source_session_dir=recording.source_session_dir,
+            local_root=recording.path.expanduser().parent,
+            local_paths=(*_converted_recording_paths(recording), *local_paths),
             config=config,
         )
     except ValueError:
         return None
+    if len(plan.local_paths) == 0:
+        return None
+    return plan
+
+
+def copy_converted_files_to_publish(
+    *,
+    recording_data_path: Path,
+    movie_path: Path,
+    source_session_dir: Path,
+    config_path: Path = DEFAULT_CONFIG_PATH,
+) -> AnalysisSyncResult | None:
+    """Copy converted recording files to the configured publish folder.
+
+    Args:
+        recording_data_path: Local ``recording_data.h5`` file.
+        movie_path: Local ``aligned_movie.h5`` file.
+        source_session_dir: Source microscope recording folder that defines the
+            configured publish location.
+        config_path: YAML config file with cache and publish settings.
+
+    Returns:
+        Sync result, or ``None`` when config is missing, the publish root is the
+        local root, or publish routing does not apply.
+    """
+    try:
+        config = load_config(config_path)
+        plan = _build_sync_plan_from_config(
+            source_session_dir=source_session_dir,
+            local_root=recording_data_path.expanduser().parent,
+            local_paths=(recording_data_path, movie_path),
+            config=config,
+        )
+    except (FileNotFoundError, ValueError):
+        return None
+    if len(plan.local_paths) == 0:
+        return None
+    return copy_analysis_sync_plan(plan)
 
 
 def start_analysis_sync(
@@ -194,6 +238,8 @@ def copy_analysis_sync_plan(plan: AnalysisSyncPlan) -> AnalysisSyncResult:
         publish_path = plan.publish_root / relative
         if _same_path(local_path, publish_path):
             continue
+        if _copy_is_current(local_path, publish_path):
+            continue
         copy_file_atomically(local_path, publish_path)
         copied.append(publish_path)
         if _should_remove_after_sync(local_path):
@@ -206,20 +252,21 @@ def copy_analysis_sync_plan(plan: AnalysisSyncPlan) -> AnalysisSyncResult:
     )
 
 
-def _build_analysis_sync_plan_from_config(
+def _build_sync_plan_from_config(
     *,
-    recording: RecordingData,
+    source_session_dir: Path,
+    local_root: Path,
     local_paths: tuple[Path | None, ...],
     config: TwopyConfig,
-) -> AnalysisSyncPlan | None:
+) -> AnalysisSyncPlan:
     """Return a sync plan from an already-loaded config."""
-    if not config.analysis_caching:
-        return None
-
-    local_root = recording.path.expanduser().parent
-    publish_root = resolve_analysis_output_dir(config, recording.source_session_dir)
+    publish_root = resolve_analysis_output_dir(config, source_session_dir)
     if _same_path(local_root, publish_root):
-        return None
+        return AnalysisSyncPlan(
+            local_root=local_root,
+            publish_root=publish_root,
+            local_paths=(),
+        )
 
     syncable: list[Path] = []
     seen: set[Path] = set()
@@ -236,8 +283,6 @@ def _build_analysis_sync_plan_from_config(
         seen.add(local_path)
         syncable.append(local_path)
 
-    if len(syncable) == 0:
-        return None
     return AnalysisSyncPlan(
         local_root=local_root,
         publish_root=publish_root,
@@ -287,6 +332,23 @@ def _same_path(left: Path, right: Path) -> bool:
     )
 
 
+def _copy_is_current(source: Path, target: Path) -> bool:
+    """Return whether the published file already matches this source version."""
+    if not target.is_file():
+        return False
+    source_stat = source.stat()
+    target_stat = target.stat()
+    return (
+        target_stat.st_size == source_stat.st_size
+        and target_stat.st_mtime_ns >= source_stat.st_mtime_ns
+    )
+
+
+def _converted_recording_paths(recording: RecordingData) -> tuple[Path, Path]:
+    """Return the converted HDF5 files that travel with every publish sync."""
+    return (recording.path, recording.movie.path)
+
+
 def _should_remove_after_sync(path: Path) -> bool:
     """Return whether a local cache file is disposable after publish sync."""
     return path.suffix.lower() in _REMOVE_AFTER_SYNC_SUFFIXES

{twopy-0.2.1 → twopy-0.3.0}/src/twopy/conversion/alignment_crop.py

@@ -10,6 +10,7 @@ from pathlib import Path
 import numpy as np
 import numpy.typing as npt
 
+from twopy.conversion.orientation import twopy_spatial_shape_from_source_spatial_shape
 from twopy.conversion.types import (
     AcquisitionMetadata,
     AlignedMovieSource,
@@ -69,9 +70,13 @@ def load_alignment_valid_crop(
 
     alignment_window = alignment[frame_start:frame_stop, :]
     line_scan = _is_line_scan(acquisition)
+    source_spatial_shape = _source_movie_spatial_shape(aligned_movie)
+    twopy_spatial_shape = twopy_spatial_shape_from_source_spatial_shape(
+        source_spatial_shape,
+    )
     motion_threshold_pixels = _motion_threshold_pixels(
         acquisition=acquisition,
-        spatial_shape=_movie_spatial_shape(aligned_movie),
+        source_x_pixel_count=source_spatial_shape[0],
         line_scan=line_scan,
     )
     alignment_shift_pixels = _alignment_shift_pixels(
@@ -86,7 +91,7 @@ def load_alignment_valid_crop(
     )
     crop, x_cutoff, y_cutoff = _alignment_crop_from_offsets(
         kept_alignment,
-        spatial_shape=_movie_spatial_shape(aligned_movie),
+        spatial_shape=twopy_spatial_shape,
         line_scan=line_scan,
     )
 
@@ -132,14 +137,14 @@ def _stimulus_alignment_frame_range(
 def _motion_threshold_pixels(
     *,
     acquisition: AcquisitionMetadata,
-    spatial_shape: tuple[int, int],
+    source_x_pixel_count: int,
     line_scan: bool,
 ) -> float:
     """Convert the motion rejection threshold from microns to pixels.
 
     Args:
         acquisition: Acquisition metadata with zoom.
-        spatial_shape: Full movie spatial shape in twopy array axes.
+        source_x_pixel_count: Number of source pixels along the physical x axis.
         line_scan: Whether this recording is a line scan.
 
     Returns:
@@ -151,7 +156,7 @@ def _motion_threshold_pixels(
         else DEFAULT_PLANE_MOTION_LIMIT_MICRONS
     )
     zoom = _required_float_field(acquisition, "acq.zoomFactor")
-    x_axis_conversion = 256.0 / float(spatial_shape[0])
+    x_axis_conversion = 256.0 / float(source_x_pixel_count)
     return micron_limit * ONE_X_PIXELS_PER_MICRON_AT_256_X * zoom * x_axis_conversion
 
 
@@ -223,19 +228,19 @@ def _alignment_crop_from_offsets(
     Returns:
         Spatial crop plus x/y cutoff values.
 
-    Source alignment columns are x/y motion offsets. twopy arrays store x along
-    spatial axis 0 and y along spatial axis 1, so the crop is mapped directly to
-    those axes.
+    Source alignment columns are x/y motion offsets. Converted twopy arrays use
+    Python image axis order matching MATLAB display of the source data: spatial
+    axis 0 is displayed y/rows, and spatial axis 1 is displayed x/columns.
     """
     x_cutoff = _ceil_abs_offset(alignment[:, 0])
     y_cutoff = 1 if line_scan else _ceil_abs_offset(alignment[:, 1])
     axis0_start, axis0_stop = _crop_bounds_from_cutoff(
         length=spatial_shape[0],
-        cutoff=x_cutoff,
+        cutoff=y_cutoff,
     )
     axis1_start, axis1_stop = _crop_bounds_from_cutoff(
         length=spatial_shape[1],
-        cutoff=y_cutoff,
+        cutoff=x_cutoff,
     )
     return (
         SpatialCrop(
@@ -283,14 +288,14 @@ def _crop_bounds_from_cutoff(*, length: int, cutoff: int) -> tuple[int, int]:
     return start, stop
 
 
-def _movie_spatial_shape(aligned_movie: AlignedMovieSource) -> tuple[int, int]:
-    """Return the two spatial dimensions of the aligned source movie.
+def _source_movie_spatial_shape(aligned_movie: AlignedMovieSource) -> tuple[int, int]:
+    """Return the source spatial dimensions of the aligned source movie.
 
     Args:
         aligned_movie: Source movie metadata.
 
     Returns:
-        ``(axis0, axis1)`` spatial shape.
+        ``(source_x, source_y)`` spatial shape.
     """
     if len(aligned_movie.shape) != 3:
         msg = f"Aligned movie must be 3D; got {aligned_movie.shape}"

{twopy-0.2.1 → twopy-0.3.0}/src/twopy/conversion/api.py

@@ -20,6 +20,10 @@ from twopy.conversion.hdf5_writing import (
     write_aligned_movie_file,
     write_recording_data_file,
 )
+from twopy.conversion.orientation import (
+    orient_source_array_to_twopy,
+    twopy_shape_from_source_movie_shape,
+)
 from twopy.conversion.source_loading import load_source_conversion_inputs
 from twopy.conversion.types import (
     ConvertedRecording,
@@ -71,9 +75,11 @@ def convert_recording_to_twopy(
         stop_frame=mean_stop_frame,
         context="frame range for mean image",
     )
-    mean_image = inputs.aligned_movie.mean_image(
-        start_frame=start_frame,
-        stop_frame=stop_frame,
+    mean_image = orient_source_array_to_twopy(
+        inputs.aligned_movie.mean_image(
+            start_frame=start_frame,
+            stop_frame=stop_frame,
+        ),
     )
 
     destination_dir = _resolve_conversion_output_dir(
@@ -94,14 +100,24 @@ def convert_recording_to_twopy(
         mean_stop_frame=stop_frame,
     )
 
-    return ConvertedRecording(
+    converted = ConvertedRecording(
         path=recording_data_path,
         movie_path=movie_path,
         source_session_dir=inputs.session_files.session_dir,
-        movie_shape=inputs.aligned_movie.shape,
+        movie_shape=twopy_shape_from_source_movie_shape(inputs.aligned_movie.shape),
         mean_image_start_frame=start_frame,
         mean_image_stop_frame=stop_frame,
     )
+    if output_dir is None:
+        from twopy.analysis_cache import copy_converted_files_to_publish
+
+        copy_converted_files_to_publish(
+            recording_data_path=converted.path,
+            movie_path=converted.movie_path,
+            source_session_dir=converted.source_session_dir,
+            config_path=config_path,
+        )
+    return converted
 
 
 def _resolve_conversion_output_dir(

{twopy-0.2.1 → twopy-0.3.0}/src/twopy/conversion/hdf5_writing.py

@@ -15,6 +15,10 @@ import numpy as np
 import numpy.typing as npt
 
 from twopy.conversion.matlab_values import json_ready
+from twopy.conversion.orientation import (
+    orient_source_array_to_twopy,
+    twopy_shape_from_source_movie_shape,
+)
 from twopy.conversion.types import (
     AlignedMovieSource,
     AlignmentCropAudit,
@@ -26,6 +30,10 @@ from twopy.conversion.types import (
 )
 from twopy.filenames import ALIGNED_MOVIE_FILENAME
 from twopy.hdf5_utils import write_string_dataset
+from twopy.spatial_orientation import (
+    SOURCE_SPATIAL_ORIENTATION,
+    write_twopy_spatial_orientation,
+)
 
 __all__ = [
     "ALIGNED_MOVIE_DATASET",
@@ -146,13 +154,18 @@ def _write_movie_reference_group(
     movie_group = h5_file.create_group("movie")
     movie_group.attrs["aligned_movie_file"] = ALIGNED_MOVIE_FILENAME
     movie_group.attrs["aligned_movie_dataset"] = ALIGNED_MOVIE_DATASET
-    movie_group.attrs["aligned_movie_shape"] = movie.shape
+    movie_group.attrs["aligned_movie_shape"] = twopy_shape_from_source_movie_shape(
+        movie.shape,
+    )
     movie_group.attrs["aligned_movie_dtype"] = movie.dtype
+    write_twopy_spatial_orientation(movie_group)
+    movie_group.attrs["source_spatial_orientation"] = SOURCE_SPATIAL_ORIENTATION
 
     mean_dataset = movie_group.create_dataset(
         "mean_image",
         data=mean_image,
     )
+    write_twopy_spatial_orientation(mean_dataset)
     mean_dataset.attrs["start_frame"] = mean_start_frame
     mean_dataset.attrs["stop_frame"] = mean_stop_frame
     _write_alignment_crop_group(movie_group, alignment_crop)
@@ -326,21 +339,31 @@ def _copy_aligned_movie(source: AlignedMovieSource, movie_group: h5py.Group) ->
         None. The function writes ``movie/aligned``.
     """
     chunk_frames = source.chunks[0] if source.chunks is not None else 64
+    destination_shape = twopy_shape_from_source_movie_shape(source.shape)
+    destination_chunks = (
+        (source.chunks[0], source.chunks[2], source.chunks[1])
+        if source.chunks is not None
+        else None
+    )
     with h5py.File(source.path, "r") as source_file:
         source_dataset = source_file[source.dataset_name]
         aligned = movie_group.create_dataset(
             "aligned",
-            shape=source.shape,
+            shape=destination_shape,
             dtype=source_dataset.dtype,
-            chunks=source.chunks,
+            chunks=destination_chunks,
             compression="gzip",
         )
         aligned.attrs["source_path"] = str(source.path)
         aligned.attrs["source_dataset"] = source.dataset_name
+        write_twopy_spatial_orientation(aligned)
+        aligned.attrs["source_spatial_orientation"] = SOURCE_SPATIAL_ORIENTATION
 
         for start in range(0, source.shape[0], chunk_frames):
             stop = min(start + chunk_frames, source.shape[0])
-            aligned[start:stop, :, :] = source_dataset[start:stop, :, :]
+            aligned[start:stop, :, :] = orient_source_array_to_twopy(
+                source_dataset[start:stop, :, :],
+            )
 
 
 def _write_attrs(group: h5py.Group, values: dict[str, object]) -> None: