def convolved_array_from_array_and_mask(self, array, mask): """ Convolve an array with this Kernel2D Parameters ---------- image : np.ndarray An array representing the image the Kernel2D is convolved with. Returns ------- convolved_image : np.ndarray An array representing the image after convolution. Raises ------ KernelException if either Kernel2D psf dimension is odd """ if self.mask.shape[0] % 2 == 0 or self.mask.shape[1] % 2 == 0: raise exc.KernelException("Kernel2D Kernel2D must be odd") convolved_array_2d = scipy.signal.convolve2d(array, self.native, mode="same") convolved_array_1d = array_2d_util.array_2d_slim_from( mask_2d=mask, array_2d_native=convolved_array_2d, sub_size=1) return array_2d.Array2D(array=convolved_array_1d, mask=mask.mask_sub_1)
def magnification_2d_from_grid(self, grid): jacobian = self.jacobian_from_grid(grid=grid) det_jacobian = jacobian[0][0] * jacobian[1][1] - jacobian[0][1] * jacobian[1][0] return array_2d.Array2D(array=1 / det_jacobian, mask=grid.mask)
def grid_pixel_indexes_from_grid_scaled_1d(self, grid_scaled_1d): """ Convert a grid of (y,x) scaled coordinates to a grid of (y,x) pixel 1D indexes. Pixel coordinates are \ returned as integers such that they are the pixel from the top-left of the 2D grid going rights and then \ downwards. For example: - The pixel at the top-left, whose 2D index is [0,0], corresponds to 1D index 0. - The fifth pixel on the top row, whose 2D index is [0,5], corresponds to 1D index 4. - The first pixel on the second row, whose 2D index is [0,1], has 1D index 10 if a row has 10 pixels. The scaled coordinate origin is defined by the class attribute origin, and coordinates are shifted to this \ origin before computing their 1D grid pixel indexes. Parameters ---------- grid_scaled_1d: np.ndarray The grid of (y,x) coordinates in scaled units. """ grid_pixel_indexes_1d = grid_2d_util.grid_pixel_indexes_2d_slim_from( grid_scaled_2d_slim=grid_scaled_1d, shape_native=self.shape, pixel_scales=self.pixel_scales, origin=self.origin, ).astype("int") return array_2d.Array2D(array=grid_pixel_indexes_1d, mask=self.edge_mask.mask_sub_1)
def shear_via_jacobian_from_grid(self, grid, jacobian=None): shear_y = -0.5 * (jacobian[0][1] + jacobian[1][0]) shear_x = 0.5 * (jacobian[1][1] - jacobian[0][0]) return array_2d.Array2D( array=(shear_x ** 2 + shear_y ** 2) ** 0.5, mask=grid.mask )
def mapped_reconstructed_image(self): reconstructed_image = inversion_util.mapped_reconstructed_data_from( mapping_matrix=self.blurred_mapping_matrix, reconstruction=self.reconstruction, ) return array_2d.Array2D( array=reconstructed_image, mask=self.mapper.source_grid_slim.mask.mask_sub_1 )
def radial_eigen_value_from_grid(self, grid, jacobian=None): convergence = self.convergence_via_jacobian_from_grid( grid=grid, jacobian=jacobian ) shear = self.shear_via_jacobian_from_grid(grid=grid, jacobian=jacobian) return array_2d.Array2D(array=1 - convergence + shear, mask=grid.mask)
def interpolated_array_from_array_interp(self, array_interp): """Use the precomputed vertexes and weight_list of a Delaunay gridding to interpolate a set of values computed on the interpolation grid to the Grid2DInterpolate's full grid. This function is taken from the SciPy interpolation method griddata (see https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html). It is adapted here to reuse pre-computed interpolation vertexes and weight_list for efficiency. Parameters ---------- array_interp : Array2D The results of the function evaluated using the interpolation grid, which is interpolated to the native resolution Array2D. """ interpolated_array = np.einsum("nj,nj->n", np.take(array_interp, self.vtx), self.wts) return array_2d.Array2D(array=interpolated_array, mask=self.mask)
def return_iterated_array_result( self, iterated_array: np.ndarray) -> array_2d.Array2D: """ Returns the resulting iterated array, by mapping it to 1D and then passing it back as an `Array2D` structure. Parameters ---------- iterated_array : np.ndarray Returns ------- iterated_array The resulting array computed via iteration. """ iterated_array_1d = array_2d_util.array_2d_slim_from( mask_2d=self.mask, array_2d_native=iterated_array, sub_size=1) return array_2d.Array2D(array=iterated_array_1d, mask=self.mask.mask_sub_1)
def transformed_mapping_matrix_from_mapping_matrix(self, mapping_matrix): transformed_mapping_matrix = 0 + 0j * np.zeros( (self.uv_wavelengths.shape[0], mapping_matrix.shape[1])) for source_pixel_1d_index in range(mapping_matrix.shape[1]): image_2d = array_2d_util.array_2d_native_from( array_2d_slim=mapping_matrix[:, source_pixel_1d_index], mask_2d=self.grid.mask, sub_size=1, ) image = array_2d.Array2D(array=image_2d, mask=self.grid.mask) visibilities = self.visibilities_from_image(image=image) transformed_mapping_matrix[:, source_pixel_1d_index] = visibilities return transformed_mapping_matrix
def structure_2d_from_result(self, result: np.ndarray): """ Convert a result from an ndarray to an aa.Array2D or aa.Grid2D structure, where the conversion depends on type(result) as follows: - 1D np.ndarray -> aa.Array2D - 2D np.ndarray -> aa.Grid2D This function is used by the grid_2d_to_structure decorator to convert the output result of a function to an autoarray structure when a `Grid2D` instance is passed to the decorated function. Parameters ---------- result : np.ndarray or [np.ndarray] The input result (e.g. of a decorated function) that is converted to a PyAutoArray structure. """ if len(result.shape) == 1: return array_2d.Array2D(array=result, mask=self.mask) else: if isinstance(result, Grid2DTransformedNumpy): return Grid2DTransformed(grid=result, mask=self.mask) return Grid2D(grid=result, mask=self.mask)
def convergence_via_jacobian_from_grid(self, grid, jacobian=None): convergence = 1 - 0.5 * (jacobian[0][0] + jacobian[1][1]) return array_2d.Array2D(array=convergence, mask=grid.mask)