zeroing now handled internally with positive values

Author: Jammy2211

autoarray/inversion/inversion/abstract.py

@@ -379,6 +379,60 @@ def curvature_reg_matrix_reduced(self) -> Optional[np.ndarray]:
         # Zero rows and columns in the matrix we want to ignore
         return self.curvature_reg_matrix[ids_to_keep][:, ids_to_keep]
 
+    @cached_property
+    def zeroed_ids_to_keep(self):
+        """
+        Return the **positive global indices** of linear objects to keep in the inversion,
+        given **mesh-local positive pixel indices** to zero.
+
+        Assumes the full linear system parameter vector is laid out as:
+
+            [ non-pixel linear objects ][ pixel block ]
+
+        where:
+          - the pixel block occupies the final `mesh.pixels` entries of the full vector
+          - `mesh.zeroed_pixels` contains **positive** indices in the pixel block's own
+            indexing (0 is top-left for rectangular meshes, increasing row-major)
+          - all non-pixel linear objects are always kept
+
+        This implementation is backend-friendly (NumPy / JAX via `self._xp`) and returns
+        indices suitable for advanced indexing of `data_vector` and curvature matrices.
+
+        Returns
+        -------
+        array-like
+            1D array of **positive** indices to keep, sorted ascending.
+        """
+        xp = self._xp
+
+        mapper_list = self.cls_list_from(cls=Mapper)
+        mesh = mapper_list[0].mesh
+
+        n_total = int(self.total_params)
+        n_pixels = int(mesh.pixels)
+
+        # Pixel block starts at this global index
+        pixel_start = n_total - n_pixels
+
+        # Mesh-local positive pixel indices to zero (e.g. [0, 1, 2, ...] for edges)
+        zeros_local = xp.asarray(mesh.zeroed_pixels)
+
+        # Convert to global positive indices
+        zeros_global = pixel_start + zeros_local
+
+        # Keep mask over full parameter vector
+        keep = xp.ones((n_total,), dtype=bool)
+
+        if hasattr(keep, "at"):
+            keep = keep.at[zeros_global].set(False)
+            keep_ids = xp.nonzero(keep, size=n_total)[0]
+            keep_ids = keep_ids[: keep.sum()]
+        else:
+            keep[zeros_global] = False
+            keep_ids = xp.nonzero(keep)[0]
+
+        return keep_ids
+
     @cached_property
     def reconstruction(self) -> np.ndarray:
         """
@@ -400,16 +454,11 @@ def reconstruction(self) -> np.ndarray:
 
             if self.settings.use_edge_zeroed_pixels and self.has(cls=Mapper):
 
-                mapper_list = self.cls_list_from(cls=Mapper)
-
-                # ids of values which are not zeroed and therefore kept in soluiton, which is computed in preloads.
-                ids_to_keep = mapper_list[0].mesh.zeroed_pixels_to_keep
-
                 # Use advanced indexing to select rows/columns
-                data_vector = self.data_vector[ids_to_keep]
-                curvature_reg_matrix = self.curvature_reg_matrix[ids_to_keep][
-                    :, ids_to_keep
-                ]
+                data_vector = self.data_vector[self.zeroed_ids_to_keep]
+                curvature_reg_matrix = self.curvature_reg_matrix[
+                    self.zeroed_ids_to_keep
+                ][:, self.zeroed_ids_to_keep]
 
                 # Perform reconstruction via fnnls
                 reconstruction_partial = (
@@ -426,11 +475,11 @@ def reconstruction(self) -> np.ndarray:
 
                 # Scatter the partial solution back to the full shape
                 if self._xp.__name__.startswith("jax"):
-                    reconstruction = reconstruction.at[ids_to_keep].set(
+                    reconstruction = reconstruction.at[self.zeroed_ids_to_keep].set(
                         reconstruction_partial
                     )
                 else:
-                    reconstruction[ids_to_keep] = reconstruction_partial
+                    reconstruction[self.zeroed_ids_to_keep] = reconstruction_partial
 
                 return reconstruction
 

autoarray/inversion/mesh/mesh/abstract.py

@@ -52,39 +52,6 @@ def relocated_grid_from(
             xp=xp,
         )
 
-    @property
-    def zeroed_pixels_to_keep(self):
-        """
-        Return the positive indices of pixels that should be kept (solved for),
-        accounting for zeroed pixels specified using Python-style negative indexing.
-
-        This property assumes that `self.zeroed_pixels` contains **negative indices**
-        referring to entries counted from the right-hand side of the parameter array
-        (e.g. -1 is the last entry, -2 the second-to-last, etc.).
-
-        These negative indices are converted to their corresponding positive indices
-        before constructing a boolean mask over the full set of mapper indices.
-
-        Returns
-        -------
-        np.ndarray
-            A 1D array of positive indices corresponding to pixels that are *not*
-            zeroed and should therefore be included in the solve.
-        """
-        # Negative indices from the right (e.g. [-1, -2, ...])
-        ids_zeros_neg = np.array(self.zeroed_pixels, dtype=int)
-
-        # Total number of values being solved for
-        n_values = self.pixels
-
-        # Convert negative indices to positive
-        ids_zeros_pos = n_values + ids_zeros_neg
-
-        values_to_solve = np.ones(n_values, dtype=bool)
-        values_to_solve[ids_zeros_pos] = False
-
-        return np.where(values_to_solve)[0]
-
     def relocated_mesh_grid_from(
         self,
         border_relocator: Optional[BorderRelocator],

autoarray/inversion/mesh/mesh/delaunay.py

@@ -38,14 +38,30 @@ def __init__(
         pixels = int(pixels) + zeroed_pixels
 
         super().__init__()
+        self.pixels = pixels
         self.areas_factor = areas_factor
-        self.zeroed_pixels = zeroed_pixels
+        self._zeroed_pixels = zeroed_pixels
 
+    @property
     def zeroed_pixels(self):
-        if not self.zeroed_pixels:
-            return []
+        """
+        Return the **positive** mesh-local pixel indices to zero for a Delaunay mesh.
+
+        For Delaunay meshes, `self.zeroed_pixels` is interpreted as a *count* of pixels
+        to be zeroed at the end of the pixel block. For example:
+            self.pixels = 780, self.zeroed_pixels = 30
+        returns indices 750..779.
+
+        Returns
+        -------
+        np.ndarray
+            1D array of positive pixel indices to zero.
+        """
+        if self._zeroed_pixels <= 0:
+            return np.array([], dtype=int)
 
-        return -np.arange(1, self.zeroed_pixels + 1).tolist()
+        start = self.pixels - self._zeroed_pixels
+        return np.arange(start, self.pixels, dtype=int)
 
     @property
     def skip_areas(self):

autoarray/inversion/mesh/mesh/rectangular_adapt_density.py

@@ -102,16 +102,29 @@ def __init__(self, shape: Tuple[int, int] = (3, 3)):
 
     @property
     def zeroed_pixels(self):
+        """
+        Return the **positive** 1D pixel indices of the edge pixels in a rectangular mesh.
+
+        Indices are in row-major (C-order) flattened form for the rectangular pixel grid:
+            - 0 corresponds to the top-left pixel (row=0, col=0)
+            - indices increase across rows
+
+        These indices are defined purely within the rectangular mesh's pixel indexing
+        scheme (size = rows * cols) and are intended to be shifted / mapped to the full
+        inversion indexing inside the inversion logic.
 
+        Returns
+        -------
+        np.ndarray
+            A 1D array of positive indices corresponding to edge pixels.
+        """
         from autoarray.inversion.mesh.mesh_geometry.rectangular import (
             rectangular_edge_pixel_list_from,
         )
 
-        edge_pixe_list = rectangular_edge_pixel_list_from(
-            shape_native=self.shape,
-        )
+        edge_pixel_list = rectangular_edge_pixel_list_from(shape_native=self.shape)
 
-        return -(np.array(edge_pixe_list) + 1)
+        return np.array(edge_pixel_list, dtype=int)
 
     @property
     def interpolator_cls(self):