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
