driftlessmap 1.6.0__tar.gz → 1.6.1__tar.gz

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/CITATION.cff

@@ -4,8 +4,8 @@ message: >-
   HERBS paper listed under references.
 title: DriftlessMap
 type: software
-version: 1.6.0
-date-released: 2026-09-27
+version: 1.6.1
+date-released: 2026-09-28
 authors:
   - name: Mohebi & Associates
     website: https://www.mohebi-associates.org/

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/MANUAL.md

@@ -1,6 +1,6 @@
 # DriftlessMap User Manual
 
-This manual applies to **DriftlessMap 1.6.0**.
+This manual applies to **DriftlessMap 1.6.1**.
 
 DriftlessMap - Histological E-data Registration in Brain Space - is a desktop
 application for aligning rodent histology with a reference atlas, reconstructing
@@ -107,7 +107,7 @@ purposes. See [Saving, loading, and exporting](#18-saving-loading-and-exporting)
 
 ### 2.1 Requirements
 
-DriftlessMap 1.6.0 requires:
+DriftlessMap 1.6.1 requires:
 
 - A 64-bit operating system and 64-bit Python 3.10 or newer.
 - Python 3.10-3.14 for the core application.
@@ -126,7 +126,7 @@ page. The macOS DMG (`-macOS-arm64.dmg`) is built for Apple Silicon; on an Intel
 Mac, use the developer installation below.
 The desktop builds include Python and all runtime dependencies. Windows users
 extract the entire ZIP and run `DriftlessMap.exe`; macOS users open the DMG and
-drag `DriftlessMap.app` to Applications. The 1.6.0 release is unsigned, so the
+drag `DriftlessMap.app` to Applications. The 1.6.1 release is unsigned, so the
 first launch may require Windows SmartScreen confirmation or Control-clicking
 the macOS app and choosing **Open**.
 
@@ -174,7 +174,7 @@ python -m pip --version
 python -c "import driftlessmap; print(driftlessmap.__version__)"
 ```
 
-The final command should print `1.6.0`.
+The final command should print `1.6.1`.
 
 ### 2.5 Launching DriftlessMap
 
@@ -756,10 +756,13 @@ section and fills the Triangulation tool with paired landmarks:
 2. Choose **Atlas > Propose Landmarks**. If landmarks already exist, you are
    asked before they are replaced.
 3. DriftlessMap fits the outlines, then refines the fit on the image
-   intensities where that improves the match. It places about 36 landmarks
-   evenly inside the atlas section, and moves the boundary anchors with the
-   same fit.
-4. The status bar reports the number of pairs and the outline overlap. The
+   intensities where that improves the match. It suggests up to 10 landmarks:
+   up to 5 at the sharpest tips and notches of the outline, snapped onto the
+   section outline, and the rest on strong internal edges that both images
+   show, such as the corpus callosum. It moves the boundary anchors with the
+   same fit. The landmarks are suggestions to confirm and edit.
+4. The status bar reports how many pairs are on the outline and how many are
+   on internal edges, and the outline overlap. The
    Triangulation tool opens so you can check the mesh. Drag any landmark that
    is off, add more where the anatomy needs them, and check mesh quality
    (Section 8.5) before transferring.
@@ -768,6 +771,10 @@ The fit follows the outline and the overall shape well, but internal
 boundaries can still be several voxels off. Treat the proposal as a first
 draft of the manual landmarks, not as a finished registration.
 
+The tutorial [Automatic Section Matching and Landmark Proposal](Tutorial/Registration_Related/automatic_section_and_landmarks.md)
+walks through both steps on a real section, with screenshots, and explains
+how each stage works.
+
 ### 8.3 Place paired landmarks
 
 1. Activate Triangulation.

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: driftlessmap
-Version: 1.6.0
+Version: 1.6.1
 Summary: Interactive histology registration and brain-atlas mapping
 Author: Pearl Saldanha, Jacopo Paglia, Jonathan R. Whitlock, Mohebi & Associates, Ali Mohebi
 Author-email: Jingyi Guo Fuglstad <jingyi.g.fuglstad@gmail.com>
@@ -104,7 +104,7 @@ See [CITATION.cff](CITATION.cff) for machine-readable citation metadata.
 
 ## Installation
 
-DriftlessMap 1.6.0 is available as a desktop application for end users and as
+DriftlessMap 1.6.1 is available as a desktop application for end users and as
 a Python package for developers.
 
 ### Mode 1: desktop application for end users
@@ -112,10 +112,10 @@ a Python package for developers.
 No Python or Conda installation is required. Download the asset for your
 computer from [GitHub Releases](https://github.com/mohebi-n-associates/DriftlessMap/releases):
 
-- **Windows 64-bit:** download `DriftlessMap-1.6.0-Windows-x64.zip`, extract
+- **Windows 64-bit:** download `DriftlessMap-1.6.1-Windows-x64.zip`, extract
   the complete folder, and double-click `DriftlessMap.exe`. Do not move the
   executable out of its extracted folder.
-- **macOS (Apple Silicon):** download `DriftlessMap-1.6.0-macOS-arm64.dmg`,
+- **macOS (Apple Silicon):** download `DriftlessMap-1.6.1-macOS-arm64.dmg`,
   open it, and drag `DriftlessMap.app` to Applications. The application bundle
   includes the DriftlessMap icon and all Python dependencies. Intel Macs are
   not covered by the desktop build; use the Conda/pip installation below.
@@ -139,7 +139,7 @@ malware:
    required only for the first launch.
 
 Only use **Open Anyway** for a copy downloaded from the
-[official DriftlessMap 1.6.0 release](https://github.com/mohebi-n-associates/DriftlessMap/releases/tag/v1.6.0).
+[official DriftlessMap 1.6.1 release](https://github.com/mohebi-n-associates/DriftlessMap/releases/tag/v1.6.1).
 The official macOS DMG has this SHA-256 digest:
 
 ```text

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/README.md

@@ -46,7 +46,7 @@ See [CITATION.cff](CITATION.cff) for machine-readable citation metadata.
 
 ## Installation
 
-DriftlessMap 1.6.0 is available as a desktop application for end users and as
+DriftlessMap 1.6.1 is available as a desktop application for end users and as
 a Python package for developers.
 
 ### Mode 1: desktop application for end users
@@ -54,10 +54,10 @@ a Python package for developers.
 No Python or Conda installation is required. Download the asset for your
 computer from [GitHub Releases](https://github.com/mohebi-n-associates/DriftlessMap/releases):
 
-- **Windows 64-bit:** download `DriftlessMap-1.6.0-Windows-x64.zip`, extract
+- **Windows 64-bit:** download `DriftlessMap-1.6.1-Windows-x64.zip`, extract
   the complete folder, and double-click `DriftlessMap.exe`. Do not move the
   executable out of its extracted folder.
-- **macOS (Apple Silicon):** download `DriftlessMap-1.6.0-macOS-arm64.dmg`,
+- **macOS (Apple Silicon):** download `DriftlessMap-1.6.1-macOS-arm64.dmg`,
   open it, and drag `DriftlessMap.app` to Applications. The application bundle
   includes the DriftlessMap icon and all Python dependencies. Intel Macs are
   not covered by the desktop build; use the Conda/pip installation below.
@@ -81,7 +81,7 @@ malware:
    required only for the first launch.
 
 Only use **Open Anyway** for a copy downloaded from the
-[official DriftlessMap 1.6.0 release](https://github.com/mohebi-n-associates/DriftlessMap/releases/tag/v1.6.0).
+[official DriftlessMap 1.6.1 release](https://github.com/mohebi-n-associates/DriftlessMap/releases/tag/v1.6.1).
 The official macOS DMG has this SHA-256 digest:
 
 ```text

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/UpdateLog.md

@@ -1,5 +1,10 @@
 # Update Log
 
+### 28th September 2026
+##### DriftlessMap 1.6.1
+
+Fixes **Show Boundary**, which drew atlas region boundaries almost black and therefore invisibly. **Propose Landmarks** now suggests up to 10 landmarks on features both images show (outline tips and notches, shared internal edges) instead of about 36. Adds a tutorial for the automatic section and landmark suggestions.
+
 ### 27th September 2026
 ##### DriftlessMap 1.6.0
 

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/WhatsNew.md

@@ -3,6 +3,36 @@
 This cumulative release history is maintained as a single document. New
 releases are added at the top; earlier release notes remain below them.
 
+## DriftlessMap 1.6.1
+
+Release date: 28 September 2026
+
+### Fixed
+
+- **Show Boundary** now draws atlas region boundaries in white. Since the
+  boundary images were stored as one byte per pixel, they had been drawn
+  almost black, so the button appeared to do nothing.
+
+### Changed
+
+- **Propose Landmarks** now suggests up to 10 landmarks instead of about 36,
+  each on a feature you can see and check in both images:
+  - up to 5 at the sharpest tips and notches of the brain outline, snapped
+    onto the section outline;
+  - the rest on strong internal edges that both images show, such as the
+    corpus callosum and the ventricles.
+
+  An edge seen in only one image is never chosen: an atlas region border in
+  uniform-looking tissue, or a dye track in the section. The status bar says
+  how many points are on the outline and how many are internal. Confirm or
+  drag each point, and add more by hand where the anatomy needs them.
+
+### Documentation
+
+- A new tutorial, [Automatic Section Matching and Landmark Proposal](Tutorial/Registration_Related/automatic_section_and_landmarks.md),
+  walks through **Suggest Atlas Section...** and **Propose Landmarks** on a
+  real sagittal section and explains how each stage works.
+
 ## DriftlessMap 1.6.0
 
 Release date: 27 September 2026

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/driftlessmap/app.py

@@ -1944,10 +1944,13 @@ class DriftlessMap(QMainWindow, FORM_Main):
         else:
             self._build_triangulation_registration(strict=False, show_error=False)
         stage = "outline and intensity" if proposal.deformable_used else "outline"
+        on_outline = sum(kind == "outline" for kind in proposal.kinds)
         self.print_message(
-            "Proposed {} landmark pairs from the {} fit (outline overlap {:.2f}). "
-            "Review them and drag any that are off before transferring.".format(
-                len(proposal.atlas_points), stage, proposal.overlap_final
+            "Suggested {} landmark pairs ({} on the outline, {} on internal edges) "
+            "from the {} fit (outline overlap {:.2f}). Confirm or drag each one "
+            "before transferring.".format(
+                len(proposal.atlas_points), on_outline,
+                len(proposal.atlas_points) - on_outline, stage, proposal.overlap_final
             ),
             self.normal_color,
         )

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/driftlessmap/auto_registration.py

@@ -1,9 +1,10 @@
 """Automatic landmark proposal between an atlas slice and a histology section.
 
 The atlas slice is the fixed image, so the fitted SimpleITK transform maps an
-atlas point directly to the matching section point; sampling it at a grid of
-atlas points yields landmark pairs for DriftlessMap's piecewise-affine
-registration, which the user then reviews and edits.
+atlas point directly to the matching section point; sampling it at the tips
+and notches of the outline and at edges that both images show yields landmark
+pairs for DriftlessMap's piecewise-affine registration. They are suggestions
+that the user confirms and edits.
 
 Both images are given physical coordinates in DriftlessMap's convention
 (pixel ``k`` spans ``[k, k + 1)``; its centre is ``k + 0.5``), so points need
@@ -35,6 +36,7 @@ class LandmarkProposal:
     deformable_used: bool
     boundary_points: np.ndarray    # extra atlas points mapped into the section,
                                    # clamped to the section image
+    kinds: tuple = ()              # "outline" or "internal" for each landmark
 
 
 def _as_image(array, scale):
@@ -131,29 +133,149 @@ def _bspline_on_intensities(fixed, moving, fixed_mask, affine, mesh_size):
     return composite, after < before
 
 
-def _grid_points(mask, count):
-    """Roughly ``count`` points on a regular grid inside the eroded mask."""
-    height, width = mask.shape
-    step = max(2, int(np.sqrt(mask.sum() / max(count, 1))))
-    inner = cv2.erode(mask.astype(np.uint8), np.ones((3, 3), np.uint8), iterations=max(1, step // 3)) > 0
-    points = [
-        (x + 0.5, y + 0.5)
-        for y in range(step // 2, height, step)
-        for x in range(step // 2, width, step)
-        if inner[y, x]
-    ]
+OUTLINE_LANDMARKS = 5   # tips and notches of the outline
+EDGE_MARGIN = 8         # atlas pixels; the slice may cut the brain at the image edge
+MIN_AGREEMENT = 0.2     # internal edges must show clearly in both images
+
+
+def _spacing(mask, count):
+    """Typical distance between ``count`` points spread over ``mask``."""
+    return max(2.0, float(np.sqrt(mask.sum() / max(count, 1))))
+
+
+def _outer_contour(mask):
+    contours, _ = cv2.findContours(mask.astype(np.uint8), cv2.RETR_EXTERNAL,
+                                   cv2.CHAIN_APPROX_NONE)
+    if not contours:
+        return np.zeros((0, 2))
+    return max(contours, key=cv2.contourArea)[:, 0, :].astype(float)
+
+
+def _outline_points(atlas_mask, atlas_image, count):
+    """The sharpest tips and notches of the atlas outline, most pronounced first.
+
+    Points where the slice cuts the brain at the image edge are skipped, as
+    are points where the labels extend past the visible template (the
+    template can be dark at the brain surface), because neither is an
+    outline that can be seen in the section.
+    """
+    contour = _outer_contour(atlas_mask)
+    n = len(contour)
+    if n < 20 or count <= 0:
+        return np.zeros((0, 2))
+    def turning(step):
+        before = contour - np.roll(contour, step, axis=0)
+        after = np.roll(contour, -step, axis=0) - contour
+        return np.arctan2(before[:, 0] * after[:, 1] - before[:, 1] * after[:, 0],
+                          (before * after).sum(axis=1))
+
+    # A wide window finds the pronounced tips and notches; a narrow one then
+    # places each at its sharpest point.
+    k = max(4, n // 40)
+    turn = turning(k)
+    turn = np.convolve(np.r_[turn[-3:], turn, turn[:3]], np.ones(7) / 7, "valid")
+    fine = turning(max(2, k // 3))
+
+    def sharpest(index):
+        window = (index + np.arange(-k, k + 1)) % n
+        same_sign = window[np.sign(fine[window]) == np.sign(turn[index])]
+        if not len(same_sign):
+            return index
+        return int(same_sign[np.argmax(np.abs(fine[same_sign]))])
+    height, width = atlas_mask.shape
+    visible = np.percentile(atlas_image[atlas_mask], 5)
+    chosen = []
+    for index in np.argsort(-np.abs(turn)):
+        if len(chosen) == count:
+            break
+        index = sharpest(int(index))
+        x, y = contour[index]
+        if not (EDGE_MARGIN <= x < width - EDGE_MARGIN and EDGE_MARGIN <= y < height - EDGE_MARGIN):
+            continue
+        if atlas_image[int(y) - 1:int(y) + 2, int(x) - 1:int(x) + 2].mean() < visible:
+            continue
+        if all(min(abs(index - j), n - abs(index - j)) > n / 10 for j in chosen):
+            chosen.append(index)
+    return contour[chosen] + 0.5
+
+
+def _edge_magnitude(image):
+    blurred = cv2.GaussianBlur(np.asarray(image, dtype=np.float32), (0, 0), 1.0)
+    return np.hypot(cv2.Sobel(blurred, cv2.CV_32F, 1, 0), cv2.Sobel(blurred, cv2.CV_32F, 0, 1))
+
+
+def _local_correlation(a, b, radius=5):
+    size = (2 * radius + 1, 2 * radius + 1)
+    mean_a, mean_b = cv2.boxFilter(a, -1, size), cv2.boxFilter(b, -1, size)
+    covariance = cv2.boxFilter(a * b, -1, size) - mean_a * mean_b
+    var_a = cv2.boxFilter(a * a, -1, size) - mean_a ** 2
+    var_b = cv2.boxFilter(b * b, -1, size) - mean_b ** 2
+    return covariance / np.sqrt(np.maximum(var_a * var_b, 1e-12))
+
+
+def _shared_edge_score(atlas_image, section_in_atlas, inner):
+    """Strong atlas edges that the registered section shows too, in [0, 1].
+
+    An edge seen in only one image (an atlas region border in uniform
+    tissue, or a dye track in the section) scores near zero.
+    """
+    atlas_edges = _edge_magnitude(atlas_image)
+    section_edges = _edge_magnitude(section_in_atlas)
+    agreement = np.clip(_local_correlation(atlas_edges, section_edges), 0.0, 1.0)
+    top = np.percentile(atlas_edges[inner], 99) if inner.any() else 0.0
+    strength = np.clip(atlas_edges / top, 0.0, 1.0) if top > 0 else np.zeros_like(atlas_edges)
+    return np.where(inner, agreement * strength, 0.0)
+
+
+def _peaks(score, count, radius, taken=()):
+    """Up to ``count`` score maxima above MIN_AGREEMENT, ``radius`` apart."""
+    score = score.copy()
+    for x, y in taken:
+        cv2.circle(score, (int(x), int(y)), int(radius), 0, -1)
+    points = []
+    while len(points) < count:
+        row, col = np.unravel_index(np.argmax(score), score.shape)
+        if score[row, col] < MIN_AGREEMENT:
+            break
+        points.append((col + 0.5, row + 0.5))
+        cv2.circle(score, (int(col), int(row)), int(radius), 0, -1)
     return np.asarray(points, dtype=float).reshape(-1, 2)
 
 
-def propose_landmarks(atlas_intensity, atlas_labels, section, count=36,
+def _section_in_atlas(section_gray, atlas_shape, transform):
+    """The section resampled onto the atlas slice's pixels."""
+    reference = sitk.GetImageFromArray(np.zeros(atlas_shape, np.float32))
+    reference.SetOrigin((0.5, 0.5))
+    moving = sitk.GetImageFromArray(np.ascontiguousarray(section_gray, dtype=np.float32))
+    moving.SetOrigin((0.5, 0.5))
+    return sitk.GetArrayFromImage(sitk.Resample(moving, reference, transform, sitk.sitkLinear, 0.0))
+
+
+def _snap_to_outline(points, contour, limit):
+    """Move each point to the nearest point of ``contour`` if within ``limit``."""
+    if not len(contour):
+        return points
+    snapped = points.copy()
+    for i, point in enumerate(points):
+        distances = np.linalg.norm(contour - point, axis=1)
+        nearest = int(np.argmin(distances))
+        if distances[nearest] <= limit:
+            snapped[i] = contour[nearest] + 0.5
+    return snapped
+
+
+def propose_landmarks(atlas_intensity, atlas_labels, section, count=10,
                       deformable=True, mesh_size=6, boundary_points=None):
     """Propose paired landmarks mapping an atlas slice onto a section.
 
     ``section`` must already be in the atlas orientation (see
-    ``atlas_matching``). ``boundary_points`` are further atlas points (such
-    as the mesh's frame points) to carry through the same transform; they are
-    clamped into the section image so they remain valid landmarks.
-    Returns a :class:`LandmarkProposal`.
+    ``atlas_matching``). Up to ``count`` landmarks are proposed: the sharpest
+    tips and notches of the outline, snapped onto the section outline, then
+    internal points on strong edges that both images show. They are
+    suggestions for the user to confirm and edit. ``boundary_points`` are
+    further atlas points (such as the mesh's frame points) to carry through
+    the same transform; they are clamped into the section image so they
+    remain valid landmarks. Returns a :class:`LandmarkProposal`.
     """
     atlas_mask = np.asarray(atlas_labels) > 0
     if atlas_mask.sum() < 100:
@@ -189,27 +311,38 @@ def propose_landmarks(atlas_intensity, atlas_labels, section, count=36,
         except RuntimeError:
             pass  # optimiser failure: fall back to the affine fit
 
-    atlas_points = _grid_points(atlas_mask, count)
-    mapped = np.array([transform.TransformPoint((float(x), float(y)))
-                       for x, y in atlas_points]).reshape(-1, 2)
+    def to_section(points):
+        return np.array([transform.TransformPoint((float(x), float(y)))
+                         for x, y in points]).reshape(-1, 2)
+
     height, width = section_mask.shape
-    inside = (
-        (mapped[:, 0] >= 0) & (mapped[:, 0] < width)
-        & (mapped[:, 1] >= 0) & (mapped[:, 1] < height)
-    )
-    if inside.any():
-        rows = np.clip(mapped[inside, 1].astype(int), 0, height - 1)
-        cols = np.clip(mapped[inside, 0].astype(int), 0, width - 1)
-        on_tissue = section_mask[rows, cols]
-        keep = np.flatnonzero(inside)[on_tissue]
-    else:
-        keep = np.array([], dtype=int)
+    spacing = _spacing(atlas_mask, count)
+
+    outline_atlas = _outline_points(atlas_mask, atlas_image, min(OUTLINE_LANDMARKS, count))
+    outline_section = _snap_to_outline(to_section(outline_atlas), _outer_contour(section_mask),
+                                       limit=0.05 * np.hypot(height, width))
+
+    inner = cv2.erode(atlas_mask.astype(np.uint8), np.ones((3, 3), np.uint8), iterations=4) > 0
+    score = _shared_edge_score(atlas_image, _section_in_atlas(section_gray / 255.0,
+                                                              atlas_mask.shape, transform), inner)
+    radius = 0.45 * spacing  # keeps internal points about a tenth of the section apart
+    internal_atlas = _peaks(score, count - len(outline_atlas), radius, taken=outline_atlas)
+    internal_section = to_section(internal_atlas)
+    if len(internal_section):
+        rows = np.clip(internal_section[:, 1].astype(int), 0, height - 1)
+        cols = np.clip(internal_section[:, 0].astype(int), 0, width - 1)
+        inside = ((internal_section[:, 0] >= 0) & (internal_section[:, 0] < width)
+                  & (internal_section[:, 1] >= 0) & (internal_section[:, 1] < height))
+        keep = inside & section_mask[rows, cols]
+        internal_atlas, internal_section = internal_atlas[keep], internal_section[keep]
+
     boundary = np.asarray(boundary_points if boundary_points is not None else [],
                           dtype=float).reshape(-1, 2)
-    carried = np.array([transform.TransformPoint((float(x), float(y)))
-                        for x, y in boundary]).reshape(-1, 2)
+    carried = to_section(boundary)
     if len(carried):
         carried[:, 0] = np.clip(carried[:, 0], 0, width - 1)
         carried[:, 1] = np.clip(carried[:, 1], 0, height - 1)
-    return LandmarkProposal(atlas_points[keep], mapped[keep], overlap_affine,
-                            overlap_final, used, carried)
+    kinds = ("outline",) * len(outline_atlas) + ("internal",) * len(internal_atlas)
+    return LandmarkProposal(np.vstack([outline_atlas, internal_atlas]),
+                            np.vstack([outline_section, internal_section]),
+                            overlap_affine, overlap_final, used, carried, kinds)

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/driftlessmap/slice_stacks.py

@@ -202,7 +202,9 @@ class SliceStacks(pg.GraphicsLayoutWidget):
             self.set_boundary_data(contour)
 
     def set_boundary_data(self, contour):
-        self.boundary.setImage(contour, autoLevels=False)
+        # Contours are 0/1; without explicit levels a uint8 image is drawn
+        # on a 0-255 scale and the boundary is invisible.
+        self.boundary.setImage(contour, autoLevels=False, levels=(0, 1))
 
     def add_display_obj_to_view(self, obj_data, obj_color, obj_type):
         if obj_type == 'probe':

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/driftlessmap/version.py

@@ -1,6 +1,6 @@
 """Canonical DriftlessMap version."""
 
-__version__ = "1.6.0"
+__version__ = "1.6.1"
 APPLICATION_DISPLAY_NAME = "DriftlessMap {}".format(__version__)
 APPLICATION_WINDOW_TITLE = (
     "{} - Interactive Histology Registration and Brain-Atlas Mapping".format(

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/driftlessmap.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: driftlessmap
-Version: 1.6.0
+Version: 1.6.1
 Summary: Interactive histology registration and brain-atlas mapping
 Author: Pearl Saldanha, Jacopo Paglia, Jonathan R. Whitlock, Mohebi & Associates, Ali Mohebi
 Author-email: Jingyi Guo Fuglstad <jingyi.g.fuglstad@gmail.com>
@@ -104,7 +104,7 @@ See [CITATION.cff](CITATION.cff) for machine-readable citation metadata.
 
 ## Installation
 
-DriftlessMap 1.6.0 is available as a desktop application for end users and as
+DriftlessMap 1.6.1 is available as a desktop application for end users and as
 a Python package for developers.
 
 ### Mode 1: desktop application for end users
@@ -112,10 +112,10 @@ a Python package for developers.
 No Python or Conda installation is required. Download the asset for your
 computer from [GitHub Releases](https://github.com/mohebi-n-associates/DriftlessMap/releases):
 
-- **Windows 64-bit:** download `DriftlessMap-1.6.0-Windows-x64.zip`, extract
+- **Windows 64-bit:** download `DriftlessMap-1.6.1-Windows-x64.zip`, extract
   the complete folder, and double-click `DriftlessMap.exe`. Do not move the
   executable out of its extracted folder.
-- **macOS (Apple Silicon):** download `DriftlessMap-1.6.0-macOS-arm64.dmg`,
+- **macOS (Apple Silicon):** download `DriftlessMap-1.6.1-macOS-arm64.dmg`,
   open it, and drag `DriftlessMap.app` to Applications. The application bundle
   includes the DriftlessMap icon and all Python dependencies. Intel Macs are
   not covered by the desktop build; use the Conda/pip installation below.
@@ -139,7 +139,7 @@ malware:
    required only for the first launch.
 
 Only use **Open Anyway** for a copy downloaded from the
-[official DriftlessMap 1.6.0 release](https://github.com/mohebi-n-associates/DriftlessMap/releases/tag/v1.6.0).
+[official DriftlessMap 1.6.1 release](https://github.com/mohebi-n-associates/DriftlessMap/releases/tag/v1.6.1).
 The official macOS DMG has this SHA-256 digest:
 
 ```text

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/tests/test_atlas_view.py

@@ -198,6 +198,15 @@ class AtlasViewPerformanceTests(unittest.TestCase):
             view.cimg.boundary.image.shape, view.cimg.label_data.shape
         )
 
+    def test_boundaries_are_drawn_at_full_brightness(self):
+        stack = SliceStacks()
+        contour = np.zeros((20, 20), dtype=np.uint8)
+        contour[5:15, 10] = 1
+        stack.set_boundary_data(contour)
+        stack.boundary.render()
+        self.assertEqual(stack.boundary.qimage.pixelColor(10, 10).getRgb()[:3],
+                         (255, 255, 255))
+
     def test_image_edge_hover_coordinates_are_rejected(self):
         image = np.zeros((3, 4), dtype=np.uint8)
 

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/tests/test_auto_registration.py

@@ -5,7 +5,11 @@ import unittest
 import cv2
 import numpy as np
 
-from driftlessmap.auto_registration import propose_landmarks
+from driftlessmap.atlas_matching import tissue_mask
+from driftlessmap.auto_registration import (
+    EDGE_MARGIN, MIN_AGREEMENT, _outer_contour, _outline_points, _shared_edge_score,
+    propose_landmarks,
+)
 
 
 def synthetic_slice(size=(160, 240)):
@@ -54,14 +58,76 @@ class ProposeLandmarkTests(unittest.TestCase):
     def test_landmarks_follow_a_known_deformation(self):
         intensity, labels = synthetic_slice()
         section = warped_section(intensity, labels)
-        proposal = propose_landmarks(intensity, labels, section, count=30)
-        self.assertGreaterEqual(len(proposal.atlas_points), 15)
-        truth = known_warp(proposal.atlas_points)
-        errors = np.linalg.norm(proposal.histology_points - truth, axis=1)
-        # section pixels are 2.5x atlas pixels: stay within ~1 atlas pixel
-        self.assertLess(np.median(errors), 3.0, errors)
+        # Measure the fit on a fixed interior grid, independent of which
+        # landmarks are selected, by carrying the grid through the transform.
+        ys, xs = np.mgrid[10:160:12, 10:240:12]
+        grid = np.column_stack([xs.ravel(), ys.ravel()]).astype(float) + 0.5
+        inner = cv2.erode((labels > 0).astype(np.uint8), np.ones((9, 9), np.uint8)) > 0
+        grid = grid[inner[grid[:, 1].astype(int), grid[:, 0].astype(int)]]
+        proposal = propose_landmarks(intensity, labels, section, boundary_points=grid)
+        self.assertTrue(3 <= len(proposal.atlas_points) <= 10)
+        self.assertEqual(len(proposal.kinds), len(proposal.atlas_points))
+        errors = np.linalg.norm(proposal.boundary_points - known_warp(grid), axis=1)
+        # section pixels are 2.5x atlas pixels: within ~1.6 atlas pixels,
+        # including grid points close to the outline
+        self.assertLess(np.median(errors), 4.0, errors)
+        internal = np.array([kind == "internal" for kind in proposal.kinds])
+        if internal.any():
+            truth = known_warp(proposal.atlas_points[internal])
+            landmark_errors = np.linalg.norm(proposal.histology_points[internal] - truth, axis=1)
+            self.assertLess(np.median(landmark_errors), 6.0, landmark_errors)
         self.assertGreater(proposal.overlap_final, 0.9)
 
+    def test_outline_points_lie_on_both_outlines(self):
+        intensity, labels = synthetic_slice()
+        section = warped_section(intensity, labels)
+        proposal = propose_landmarks(intensity, labels, section, deformable=False)
+        outline = np.array([kind == "outline" for kind in proposal.kinds])
+        self.assertGreaterEqual(outline.sum(), 2)
+        atlas_contour = _outer_contour(labels > 0) + 0.5
+        section_contour = _outer_contour(tissue_mask(section)) + 0.5
+        for a, h in zip(proposal.atlas_points[outline], proposal.histology_points[outline]):
+            self.assertLess(np.linalg.norm(atlas_contour - a, axis=1).min(), 1.0)
+            self.assertLess(np.linalg.norm(section_contour - h, axis=1).min(), 1.0)
+        # a notch where the two lobes of the synthetic slice meet is found
+        notch = np.array([[35.8, 117.4], [20.0, 84.0]])  # ellipse intersections
+        self.assertLess(min(np.linalg.norm(proposal.atlas_points[outline] - q, axis=1).min()
+                            for q in notch), 12.0)
+
+    def test_internal_points_sit_on_edges_both_images_show(self):
+        intensity, labels = synthetic_slice()
+        section = warped_section(intensity, labels)
+        proposal = propose_landmarks(intensity, labels, section, deformable=False)
+        internal = proposal.atlas_points[[kind == "internal" for kind in proposal.kinds]]
+        self.assertGreaterEqual(len(internal), 1)
+        edges = cv2.Canny((intensity * 255).astype(np.uint8), 20, 60) > 0
+        ys, xs = np.nonzero(edges)
+        edge_points = np.column_stack([xs, ys]) + 0.5
+        for point in internal:
+            self.assertLess(np.linalg.norm(edge_points - point, axis=1).min(), 4.0)
+
+    def test_an_edge_in_only_one_image_scores_nothing(self):
+        atlas = np.full((80, 80), 0.4, np.float32)
+        atlas[:, 40:] = 0.9                       # an edge in both images
+        section = atlas.copy()
+        section[20:60, 15] = 1.0                  # a "dye track" only in the section
+        atlas_only = atlas.copy()
+        atlas_only[40:, 60] = 0.1                 # a border only in the atlas
+        inner = np.ones_like(atlas, bool)
+        score = _shared_edge_score(atlas_only, section, inner)
+        self.assertGreater(score[40, 39:41].max(), MIN_AGREEMENT)
+        self.assertLess(score[40, 12:18].max(), MIN_AGREEMENT)
+        self.assertLess(score[60, 58:62].max(), MIN_AGREEMENT)
+
+    def test_outline_cut_by_the_image_edge_is_skipped(self):
+        intensity, labels = synthetic_slice()
+        cut = labels.copy()
+        cut[:, :40] = 0
+        cut[40:130, :40] = 1                      # brain runs off the left edge
+        image = cv2.normalize(intensity + 0.4 * (cut > 0), None, 0, 1, cv2.NORM_MINMAX)
+        points = _outline_points(cut > 0, image, 5)
+        self.assertTrue(np.all(points[:, 0] >= EDGE_MARGIN), points)
+
     def test_affine_only_mode_and_empty_atlas(self):
         intensity, labels = synthetic_slice()
         section = warped_section(intensity, labels)

{driftlessmap-1.6.0 → driftlessmap-1.6.1}/tests/test_version.py

@@ -22,7 +22,7 @@ class VersionTests(unittest.TestCase):
         cls.app = QApplication.instance() or QApplication([])
 
     def test_public_package_version_uses_the_canonical_value(self):
-        self.assertEqual(__version__, "1.6.0")
+        self.assertEqual(__version__, "1.6.1")
         self.assertEqual(driftlessmap.__version__, __version__)
 
     def test_main_window_display_strings_include_the_version(self):