def predict_2d(vis: Union[BlockVisibility, Visibility], model: Image, gcfcf=None, **kwargs) -> Union[BlockVisibility, Visibility]: """ Predict using convolutional degridding. This is at the bottom of the layering i.e. all transforms are eventually expressed in terms of this function. Any shifting needed is performed here. :param vis: Visibility to be predicted :param model: model image :param gcfcf: (Grid correction function i.e. in image space, Convolution function i.e. in uv space) :return: resulting visibility (in place works) """ if model is None: return vis assert isinstance(vis, Visibility), vis _, _, ny, nx = model.data.shape if gcfcf is None: gcf, cf = create_pswf_convolutionfunction(model, support=get_parameter(kwargs, "support", 6), oversampling=get_parameter(kwargs, "oversampling", 128)) else: gcf, cf = gcfcf griddata = create_griddata_from_image(model) griddata = fft_image_to_griddata(model, griddata, gcf) vis = degrid_visibility_from_griddata(vis, griddata=griddata, cf=cf) # Now we can shift the visibility from the image frame to the original visibility frame svis = shift_vis_to_image(vis, model, tangent=True, inverse=True) return svis
def test_fill_pswf_to_convolutionfunction_nooversampling(self): oversampling = 1 support = 6 gcf, cf = create_pswf_convolutionfunction(self.image, oversampling=oversampling, support=support) assert numpy.max(numpy.abs(cf.data)) > 0.0 export_image_to_fits( gcf, "%s/test_convolutionfunction_pswf_nooversampling_gcf.fits" % self.dir) cf_image = convert_convolutionfunction_to_image(cf) cf_image.data = numpy.real(cf_image.data) export_image_to_fits( cf_image, "%s/test_convolutionfunction_pwsf_nooversampling_cf.fits" % self.dir) peak_location = numpy.unravel_index(numpy.argmax(numpy.abs(cf.data)), cf.shape) assert numpy.abs(cf.data[peak_location] - 0.18712109669890536 + 0j) < 1e-7, cf.data[peak_location] assert peak_location == (0, 0, 0, 0, 0, 3, 3), peak_location u_peak, v_peak = cf.grid_wcs.sub([1, 2]).wcs_pix2world( peak_location[-2], peak_location[-1], 0) assert numpy.abs(u_peak) < 1e-7, u_peak assert numpy.abs(v_peak) < 1e-7, u_peak
def invert_2d(vis: Visibility, im: Image, dopsf: bool = False, normalize: bool = True, gcfcf=None, **kwargs) -> (Image, numpy.ndarray): """ Invert using 2D convolution function, using the specified convolution function Use the image im as a template. Do PSF in a separate call. This is at the bottom of the layering i.e. all transforms are eventually expressed in terms of this function. . Any shifting needed is performed here. :param vis: Visibility to be inverted :param im: image template (not changed) :param dopsf: Make the psf instead of the dirty image :param normalize: Normalize by the sum of weights (True) :param gcfcf: (Grid correction function i.e. in image space, Convolution function i.e. in uv space) :return: resulting image """ if not isinstance(vis, Visibility): svis = coalesce_visibility(vis, **kwargs) else: svis = copy_visibility(vis) if dopsf: svis.data['vis'] = numpy.ones_like(svis.data['vis']) svis = shift_vis_to_image(svis, im, tangent=True, inverse=False) if gcfcf is None: gcf, cf = create_pswf_convolutionfunction( im, support=get_parameter(kwargs, "support", 6), oversampling=get_parameter(kwargs, "oversampling", 128)) else: gcf, cf = gcfcf griddata = create_griddata_from_image(im) griddata, sumwt = grid_visibility_to_griddata(svis, griddata=griddata, cf=cf) imaginary = get_parameter(kwargs, "imaginary", False) if imaginary: result0, result1 = fft_griddata_to_image(griddata, gcf, imaginary=imaginary) log.debug("invert_2d: retaining imaginary part of dirty image") if normalize: result0 = normalize_sumwt(result0, sumwt) result1 = normalize_sumwt(result1, sumwt) return result0, sumwt, result1 else: result = fft_griddata_to_image(griddata, gcf) if normalize: result = normalize_sumwt(result, sumwt) return result, sumwt
def test_griddata_predict_pswf(self): self.actualSetUp(zerow=True) gcf, cf = create_pswf_convolutionfunction(self.model, support=6, oversampling=256) griddata = create_griddata_from_image(self.model) griddata = fft_image_to_griddata(self.model, griddata, gcf) newvis = degrid_visibility_from_griddata(self.vis, griddata=griddata, cf=cf) newvis.data['vis'][...] -= self.vis.data['vis'][...] qa = qa_visibility(newvis) assert qa.data['rms'] < 0.7, str(qa)
def test_griddata_invert_pswf_w(self): self.actualSetUp(zerow=False) gcf, cf = create_pswf_convolutionfunction(self.model, support=6, oversampling=32) griddata = create_griddata_from_image(self.model) griddata, sumwt = grid_visibility_to_griddata(self.vis, griddata=griddata, cf=cf) im = fft_griddata_to_image(griddata, gcf) im = normalize_sumwt(im, sumwt) export_image_to_fits(im, '%s/test_gridding_dirty_pswf_w.fits' % self.dir) self.check_peaks(im, 96.62754566597258, tol=1e-7)
def test_griddata_invert_pswf(self): self.actualSetUp(zerow=True) gcf, cf = create_pswf_convolutionfunction(self.model, support=6, oversampling=32) griddata = create_griddata_from_image(self.model) griddata, sumwt = grid_visibility_to_griddata(self.vis, griddata=griddata, cf=cf) im = fft_griddata_to_image(griddata, gcf) im = normalize_sumwt(im, sumwt) if self.persist: export_image_to_fits(im, '%s/test_gridding_dirty_pswf.fits' % self.dir) self.check_peaks(im, 97.00435128311616, tol=1e-7)
def weight_visibility(vis, model, gcfcf=None, weighting='uniform', **kwargs): """ Weight the visibility data This is done collectively so the weights are summed over all vis_lists and then corrected :param vis_list: :param model_imagelist: Model required to determine weighting parameters :param weighting: Type of weighting :param kwargs: Parameters for functions in graphs :return: List of vis_graphs """ assert isinstance(vis, Visibility), vis if gcfcf is None: gcfcf = create_pswf_convolutionfunction(model) griddata = create_griddata_from_image(model) griddata, sumwt = grid_weight_to_griddata(vis, griddata, gcfcf[1]) vis = griddata_reweight(vis, griddata, gcfcf[1]) return vis