def compare_dft_vs_photon_object(gsobject,
psf_object=None,
rng=None,
pixel_scale=1.,
size=512,
wmult=4.,
abs_tol_ellip=1.e-5,
abs_tol_size=1.e-5,
n_trials_per_iter=32,
n_photons_per_trial=1e7,
moments=True,
hsm=False):
"""Take an input object (with optional PSF) and render it in two ways comparing results at high
precision.
Using both photon shooting (via drawShoot()) and Discrete Fourier Transform (via draw()) to
render images, we compare the numerical values of adaptive moments estimates of size and
ellipticity to check consistency.
This function takes actual GSObjects as its input, but because these are not yet picklable this
means that the internals cannot be parallelized using the Python multiprocessing module. For
a parallelized function, that instead uses a config dictionary to specify the test objects, see
the function compare_dft_vs_photon_config() in this module.
We generate successive sets of `n_trials_per_iter` photon-shot images, using
`n_photons_per_trial` photons in each image, until the standard error on the mean absolute size
and ellipticity drop below `abs_tol_size` and `abs_tol_ellip`. We then output a
ComparisonShapeData object which stores the results.
Note that `n_photons_per_trial` should be large (>~ 1e6) to ensure that any biases detected
between the photon shooting and DFT-drawn images are due to numerical differences rather than
biases on adaptive moments due to noise itself, a generic feature in this work. This can be
verified with a convergence test.
@param gsobject The GSObject for which this test is to be performed (prior
to PSF convolution if a PSF is also supplied via `psf_object`).
Note that this function will automatically handle integration over
a Pixel of width `pixel_scale`, so a Pixel should not be included in
the supplied `gsobject` (unless you really mean to include it, which
will be very rare in normal usage).
@param psf_object Optional additional PSF for tests of convolved objects, also a
GSObject. Note that this function will automatically handle
integration over a Pixel of width `pixel_scale`, so this should not
be included in the supplied `psf_object`. [default: None]
@param rng A BaseDeviate or derived deviate class instance to provide
the pseudo random numbers for the photon shooting. [default: None]
@param pixel_scale The pixel scale to use in the test images. [default: 1]
@param size The size of the images in the rendering tests - all test images
are currently square. [default: 512]
@param wmult The `wmult` parameter used in .draw() (see the GSObject .draw()
method docs via `help(galsim.GSObject.draw)` for more details).
[default: 4]
@param abs_tol_ellip The test will keep iterating, adding ever greater numbers of
trials, until estimates of the 1-sigma standard error on mean
ellipticity moments from photon-shot images are smaller than this
param value. [default: 1.e-5]
@param abs_tol_size The test will keep iterating, adding ever greater numbers of
trials, until estimates of the 1-sigma standard error on mean
size moments from photon-shot images are smaller than this param
value. [default: 1.e-5]
@param n_trials_per_iter Number of trial images used to estimate (or successively
re-estimate) the standard error on the delta quantities above for
each iteration of the tests. [default: 32]
@param n_photons_per_trial Number of photons shot in drawShoot() for each trial. This should
be large enough that any noise bias (a.k.a. noise rectification
bias) on moments estimates is small. [default: 1e7]
@param moments Set True to compare rendered images using AdaptiveMoments
estimates of simple observed estimates. [default: True]
@param hsm Should the rendered images be compared using HSM shear estimates?
(i.e. including a PSF correction for shears) [not implemented]
"""
import sys
import logging
import time
# Some sanity checks on inputs
if hsm is True:
if psf_object is None:
raise ValueError(
'An input psf_object is required for HSM shear estimate testing.'
)
else:
# Raise an apologetic exception about the HSM not yet being implemented!
raise NotImplementedError('Sorry, HSM tests not yet implemented!')
if rng is None:
rng = galsim.BaseDeviate()
# Then define some convenience functions for handling lists and multiple trial operations
def _mean(array_like):
return np.mean(np.asarray(array_like))
def _stderr(array_like):
return np.std(np.asarray(array_like)) / np.sqrt(len(array_like))
def _shoot_trials_single(gsobject, ntrials, dx, imsize, rng, n_photons):
"""Convenience function to run `ntrials` and collect the results, uses only a single core.
Uses a Python for loop but this is very unlikely to be a rate determining factor provided
n_photons is suitably large (>1e6).
"""
g1obslist = []
g2obslist = []
sigmalist = []
im = galsim.ImageF(imsize, imsize)
for i in xrange(ntrials):
gsobject.drawShoot(im, dx=dx, n_photons=n_photons, rng=rng)
res = im.FindAdaptiveMom()
g1obslist.append(res.observed_shape.g1)
g2obslist.append(res.observed_shape.g2)
sigmalist.append(res.moments_sigma)
logging.debug('Completed ' + str(i + 1) + '/' + str(ntrials) +
' trials in this iteration')
#im.write('check_shoot_trial'+str(i + 1)) CHECK IMAGE
return g1obslist, g2obslist, sigmalist
# OK, that's the end of the helper functions-within-helper functions, back to the main unit
# Start the timer
t1 = time.time()
# If a PSF is supplied, do the convolution, otherwise just use the gal_object
if psf_object is None:
logging.info(
'No psf_object supplied, running tests using input gsobject only')
test_object = gsobject
else:
logging.info(
'Generating test_object by convolving gsobject with input psf_object'
)
test_object = galsim.Convolve([gsobject, psf_object])
# Draw the FFT image, only needs to be done once
# For the FFT drawn image we need to include the galsim.Pixel, for the photon shooting we don't!
test_object_pixelized = galsim.Convolve(
[test_object, galsim.Pixel(pixel_scale)])
im_draw = galsim.ImageF(size, size)
test_object_pixelized.draw(im_draw, dx=pixel_scale, wmult=wmult)
res_draw = im_draw.FindAdaptiveMom()
sigma_draw = res_draw.moments_sigma
g1obs_draw = res_draw.observed_shape.g1
g2obs_draw = res_draw.observed_shape.g2
# Setup storage lists for the trial shooting results
sigma_shoot_list = []
g1obs_shoot_list = []
g2obs_shoot_list = []
sigmaerr = 666. # Slightly kludgy but will not accidentally fail the first `while` condition
g1obserr = 666.
g2obserr = 666.
# Initialize iteration counter
itercount = 0
# Then begin while loop, farming out sets of n_trials_per_iter trials until we get the
# statistical accuracy we require
while (g1obserr > abs_tol_ellip) or (g2obserr > abs_tol_ellip) or (
sigmaerr > abs_tol_size):
# Run the trials using helper function
g1obs_list_tmp, g2obs_list_tmp, sigma_list_tmp = _shoot_trials_single(
test_object, n_trials_per_iter, pixel_scale, size, rng,
n_photons_per_trial)
# Collect results and calculate new standard error
g1obs_shoot_list.extend(g1obs_list_tmp)
g2obs_shoot_list.extend(g2obs_list_tmp)
sigma_shoot_list.extend(sigma_list_tmp)
g1obserr = _stderr(g1obs_shoot_list)
g2obserr = _stderr(g2obs_shoot_list)
sigmaerr = _stderr(sigma_shoot_list)
itercount += 1
sys.stdout.write(
"."
) # This doesn't add a carriage return at the end of the line, nice!
logging.debug('Completed ' + str(itercount) + ' iterations')
logging.debug('(g1obserr, g2obserr, sigmaerr) = ' + str(g1obserr) +
', ' + str(g2obserr) + ', ' + str(sigmaerr))
sys.stdout.write("\n")
# Take the runtime and collate results into a ComparisonShapeData
runtime = time.time() - t1
results = ComparisonShapeData(g1obs_draw,
g2obs_draw,
sigma_draw,
_mean(g1obs_shoot_list),
_mean(g2obs_shoot_list),
_mean(sigma_shoot_list),
g1obserr,
g2obserr,
sigmaerr,
size,
pixel_scale,
wmult,
itercount,
n_trials_per_iter,
n_photons_per_trial,
runtime,
gsobject=gsobject,
psf_object=psf_object)
logging.info('\n' + str(results))
return results
def estimate(n, p, g1, g2, el, s, show_last_gal, plot_progression, update_freq,
typ, pxl):
shear = []
shear.append(g1) # lensing shear to apply
shear.append(g2)
stamp_xsize = p
stamp_ysize = p
random_seed = 4218409
pixel_scale = 1.0
sky_level = 1.e6
gal_sigma = s
gal_flux = 1.0
###########
print "\nPixel width and height is", p
print "Applied shear is", shear
print "Galaxy sigma in pixels", s
print "Ellipticity is", el
print "Number of galaxies is", n, '\n'
if pxl:
print "Will convolve with pixel"
else:
print "Will not convolve with pixel"
if typ == 'g':
print "Galaxy type is gaussian"
elif typ == 'e':
print "Galaxy type is exponential"
else:
print "Galaxy type unrecognized. Sersic not implemented yet."
#gi=(sqrt(1+el)-sqrt(1-el))/(sqrt(1+el)+sqrt(1-el)) #shear due to intrinsic ellipticity
px = []
py = []
py2 = []
py3 = []
py4 = []
img = galsim.ImageD(stamp_xsize, stamp_ysize, scale=pixel_scale)
first_in_pair = True
storeXY(stamp_xsize, stamp_ysize)
#storeXY(3,3)
#print XX
#print YY
#print XY
#start = timeit.default_timer()
for i in range(0, n):
ud = galsim.UniformDeviate(random_seed + i)
if first_in_pair:
theta = ud() * 2. * pi * galsim.radians
first_in_pair = False
else:
theta += 90 * galsim.degrees
first_in_pair = True
if typ == 'g':
profile = galsim.Gaussian(sigma=gal_sigma, flux=gal_flux)
elif typ == 'e':
profile = galsim.Exponential(scale_radius=gal_sigma / 2.,
flux=gal_flux)
else:
print "Unrecognized galaxy type"
sys.exit(2)
gal = profile.createSheared(e=el, beta=theta)
#gal=profile
g = sqrt(shear[0]**2. + shear[1]**2.)
gal.applyLensing(g1=shear[0], g2=shear[1], mu=1. / (1. - 2. * (g**2.)))
if pxl:
pix = galsim.Pixel(pixel_scale)
final = galsim.Convolve([gal, pix])
else:
final = gal
#psf = galsim.Gaussian(sigma=1.0)
final.draw(img)
#myimg=drawEllipse(shear[0],shear[1],stamp_xsize,stamp_ysize,s)
infarr = img.array
q = getQuad(infarr, pxl, *np.shape(infarr))
E = polE(q)
if ((i % update_freq) is 0) and (i > 0):
print "Done " + str(i) + " galaxies..."
py.append(0.5 * E[0])
py2.append(0.5 * E[1])
if plot_progression:
px.append(i + 1)
py3.append(np.array(py).mean())
py4.append(np.array(py2).mean())
#stop = timeit.default_timer()
#print "\nAverage time spent on one galaxy: ", (stop-start)/(i+1)
if plot_progression:
plt.clf()
ax = plt.subplot(1, 1, 1)
ax.set_xlabel("Number of galaxies")
ax.set_ylabel("Inferred shear")
ax.plot(px, py3, 'ro')
ax.plot(px, py4, 'bx')
ax.axhline(y=shear[0])
ax.axhline(y=shear[1])
print "\nApplied shear is " + str(shear)
for i, pp in enumerate([py, py2]):
## we are doing this clever rotation
## so we need to reduce by 2
pp = [(pp[2 * c] + pp[2 * c + 1]) / 2.0 for c in range(len(pp) / 2)]
p = np.array(pp)
inf = p.mean()
sh = shear[i]
err = p.std() / sqrt(len(p))
print "Inferred shear" + str(
i + 1) + " is", inf, "+/-", err, "off by ", (
inf - sh) * 100 / sh, " %", (inf - sh) / err, " sigma"
if show_last_gal:
plt.subplot(2, 2, 1)
arr = img.array / img.array.sum()
plt.imshow(arr, interpolation='nearest')
plt.colorbar()
#plt.subplot (2,2,2)
#plt.imshow(myimg, interpolation='nearest')
#plt.colorbar()
#plt.subplot (2,2,3)
#plt.imshow((arr-myimg)/(myimg+arr+1e-5), interpolation='nearest')
#plt.imshow((arr-myimg)/(myimg+1e-5), interpolation='nearest')
#plt.imshow(img.array-img2.array, interpolation='nearest')
#plt.colorbar()
if show_last_gal or plot_progression:
plt.show()
def test_operations_simple():
"""Simple test of operations on InterpolatedImage: shear, magnification, rotation, shifting."""
import time
t1 = time.time()
# Make some nontrivial image that can be described in terms of sums and convolutions of
# GSObjects. We want this to be somewhat hard to describe, but should be at least
# critically-sampled, so put in an Airy PSF.
gal_flux = 1000.
pix_scale = 0.03 # arcsec
bulge_frac = 0.3
bulge_hlr = 0.3 # arcsec
bulge_e = 0.15
bulge_pos_angle = 30. * galsim.degrees
disk_hlr = 0.6 # arcsec
disk_e = 0.5
disk_pos_angle = 60. * galsim.degrees
lam = 800 # nm NB: don't use lambda - that's a reserved word.
tel_diam = 2.4 # meters
lam_over_diam = lam * 1.e-9 / tel_diam # radians
lam_over_diam *= 206265 # arcsec
im_size = 512
bulge = galsim.Sersic(4, half_light_radius=bulge_hlr)
bulge.applyShear(e=bulge_e, beta=bulge_pos_angle)
disk = galsim.Exponential(half_light_radius=disk_hlr)
disk.applyShear(e=disk_e, beta=disk_pos_angle)
gal = bulge_frac * bulge + (1. - bulge_frac) * disk
gal.setFlux(gal_flux)
psf = galsim.Airy(lam_over_diam)
pix = galsim.Pixel(pix_scale)
obj = galsim.Convolve(gal, psf, pix)
im = obj.draw(dx=pix_scale)
# Turn it into an InterpolatedImage with default param settings
int_im = galsim.InterpolatedImage(im)
# Shear it, and compare with expectations from GSObjects directly
test_g1 = -0.07
test_g2 = 0.1
test_decimal = 2 # in % difference, i.e. 2 means 1% agreement
comp_region = 30 # compare the central region of this linear size
test_int_im = int_im.createSheared(g1=test_g1, g2=test_g2)
ref_obj = obj.createSheared(g1=test_g1, g2=test_g2)
# make large images
im = galsim.ImageD(im_size, im_size)
ref_im = galsim.ImageD(im_size, im_size)
test_int_im.draw(image=im, dx=pix_scale)
ref_obj.draw(image=ref_im, dx=pix_scale)
# define subregion for comparison
new_bounds = galsim.BoundsI(1, comp_region, 1, comp_region)
new_bounds.shift((im_size - comp_region) / 2, (im_size - comp_region) / 2)
im_sub = im.subImage(new_bounds)
ref_im_sub = ref_im.subImage(new_bounds)
diff_im = im_sub - ref_im_sub
rel = diff_im / im_sub
zeros_arr = np.zeros((comp_region, comp_region))
# require relative difference to be smaller than some amount
np.testing.assert_array_almost_equal(
rel.array,
zeros_arr,
test_decimal,
err_msg='Sheared InterpolatedImage disagrees with reference')
# Magnify it, and compare with expectations from GSObjects directly
test_mag = 1.08
test_decimal = 2 # in % difference, i.e. 2 means 1% agreement
comp_region = 30 # compare the central region of this linear size
test_int_im = int_im.createMagnified(test_mag)
ref_obj = obj.createMagnified(test_mag)
# make large images
im = galsim.ImageD(im_size, im_size)
ref_im = galsim.ImageD(im_size, im_size)
test_int_im.draw(image=im, dx=pix_scale)
ref_obj.draw(image=ref_im, dx=pix_scale)
# define subregion for comparison
new_bounds = galsim.BoundsI(1, comp_region, 1, comp_region)
new_bounds.shift((im_size - comp_region) / 2, (im_size - comp_region) / 2)
im_sub = im.subImage(new_bounds)
ref_im_sub = ref_im.subImage(new_bounds)
diff_im = im_sub - ref_im_sub
rel = diff_im / im_sub
zeros_arr = np.zeros((comp_region, comp_region))
# require relative difference to be smaller than some amount
np.testing.assert_array_almost_equal(
rel.array,
zeros_arr,
test_decimal,
err_msg='Magnified InterpolatedImage disagrees with reference')
# Lens it (shear and magnify), and compare with expectations from GSObjects directly
test_g1 = -0.03
test_g2 = -0.04
test_mag = 0.74
test_decimal = 2 # in % difference, i.e. 2 means 1% agreement
comp_region = 30 # compare the central region of this linear size
test_int_im = int_im.createLensed(test_g1, test_g2, test_mag)
ref_obj = obj.createLensed(test_g1, test_g2, test_mag)
# make large images
im = galsim.ImageD(im_size, im_size)
ref_im = galsim.ImageD(im_size, im_size)
test_int_im.draw(image=im, dx=pix_scale)
ref_obj.draw(image=ref_im, dx=pix_scale)
# define subregion for comparison
new_bounds = galsim.BoundsI(1, comp_region, 1, comp_region)
new_bounds.shift((im_size - comp_region) / 2, (im_size - comp_region) / 2)
im_sub = im.subImage(new_bounds)
ref_im_sub = ref_im.subImage(new_bounds)
diff_im = im_sub - ref_im_sub
rel = diff_im / im_sub
zeros_arr = np.zeros((comp_region, comp_region))
# require relative difference to be smaller than some amount
np.testing.assert_array_almost_equal(
rel.array,
zeros_arr,
test_decimal,
err_msg='Lensed InterpolatedImage disagrees with reference')
# Rotate it, and compare with expectations from GSObjects directly
test_rot_angle = 32. * galsim.degrees
test_decimal = 2 # in % difference, i.e. 2 means 1% agreement
comp_region = 30 # compare the central region of this linear size
test_int_im = int_im.createRotated(test_rot_angle)
ref_obj = obj.createRotated(test_rot_angle)
# make large images
im = galsim.ImageD(im_size, im_size)
ref_im = galsim.ImageD(im_size, im_size)
test_int_im.draw(image=im, dx=pix_scale)
ref_obj.draw(image=ref_im, dx=pix_scale)
# define subregion for comparison
new_bounds = galsim.BoundsI(1, comp_region, 1, comp_region)
new_bounds.shift((im_size - comp_region) / 2, (im_size - comp_region) / 2)
im_sub = im.subImage(new_bounds)
ref_im_sub = ref_im.subImage(new_bounds)
diff_im = im_sub - ref_im_sub
rel = diff_im / im_sub
zeros_arr = np.zeros((comp_region, comp_region))
# require relative difference to be smaller than some amount
np.testing.assert_array_almost_equal(
rel.array,
zeros_arr,
test_decimal,
err_msg='Rotated InterpolatedImage disagrees with reference')
# Shift it, and compare with expectations from GSObjects directly
x_shift = -0.31
y_shift = 0.87
test_decimal = 2 # in % difference, i.e. 2 means 1% agreement
comp_region = 30 # compare the central region of this linear size
test_int_im = int_im.createShifted(x_shift, y_shift)
ref_obj = obj.createShifted(x_shift, y_shift)
# make large images
im = galsim.ImageD(im_size, im_size)
ref_im = galsim.ImageD(im_size, im_size)
test_int_im.draw(image=im, dx=pix_scale)
ref_obj.draw(image=ref_im, dx=pix_scale)
# define subregion for comparison
new_bounds = galsim.BoundsI(1, comp_region, 1, comp_region)
new_bounds.shift((im_size - comp_region) / 2, (im_size - comp_region) / 2)
im_sub = im.subImage(new_bounds)
ref_im_sub = ref_im.subImage(new_bounds)
diff_im = im_sub - ref_im_sub
rel = diff_im / im_sub
zeros_arr = np.zeros((comp_region, comp_region))
# require relative difference to be smaller than some amount
np.testing.assert_array_almost_equal(
rel.array,
zeros_arr,
test_decimal,
err_msg='Shifted InterpolatedImage disagrees with reference')
t2 = time.time()
print 'time for %s = %.2f' % (funcname(), t2 - t1)
def test_flip():
"""Test several ways to flip a profile
"""
# The Shapelet profile has the advantage of being fast and not circularly symmetric, so
# it is a good test of the actual code for doing the flips (in SBTransform).
# But since the bug Rachel reported in #645 was actually in SBInterpolatedImage
# (one calculation implicitly assumed dx > 0), it seems worthwhile to run through all the
# classes to make sure we hit everything with negative steps for dx and dy.
prof_list = [
galsim.Shapelet(sigma=0.17, order=2,
bvec=[1.7, 0.01,0.03, 0.29, 0.33, -0.18]),
]
if __name__ == "__main__":
image_dir = './real_comparison_images'
catalog_file = 'test_catalog.fits'
rgc = galsim.RealGalaxyCatalog(catalog_file, dir=image_dir)
# Some of these are slow, so only do the Shapelet test as part of the normal unit tests.
prof_list += [
galsim.Airy(lam_over_diam=0.17, flux=1.7),
galsim.Airy(lam_over_diam=0.17, obscuration=0.2, flux=1.7),
# Box gets rendered with real-space convolution. The default accuracy isn't quite
# enough to get the flip to match at 6 decimal places.
galsim.Box(0.17, 0.23, flux=1.7,
gsparams=galsim.GSParams(realspace_relerr=1.e-6)),
# Without being convolved by anything with a reasonable k cutoff, this needs
# a very large fft.
galsim.DeVaucouleurs(half_light_radius=0.17, flux=1.7),
# I don't really understand why this needs a lower maxk_threshold to work, but
# without it, the k-space tests fail.
galsim.Exponential(scale_radius=0.17, flux=1.7,
gsparams=galsim.GSParams(maxk_threshold=1.e-4)),
galsim.Gaussian(sigma=0.17, flux=1.7),
galsim.Kolmogorov(fwhm=0.17, flux=1.7),
galsim.Moffat(beta=2.5, fwhm=0.17, flux=1.7),
galsim.Moffat(beta=2.5, fwhm=0.17, flux=1.7, trunc=0.82),
galsim.OpticalPSF(lam_over_diam=0.17, obscuration=0.2, nstruts=6,
coma1=0.2, coma2=0.5, defocus=-0.1, flux=1.7),
# Like with Box, we need to increase the real-space convolution accuracy.
# This time lowering both relerr and abserr.
galsim.Pixel(0.23, flux=1.7,
gsparams=galsim.GSParams(realspace_relerr=1.e-6,
realspace_abserr=1.e-8)),
# Note: RealGalaxy should not be rendered directly because of the deconvolution.
# Here we convolve it by a Gaussian that is slightly larger than the original PSF.
galsim.Convolve([ galsim.RealGalaxy(rgc, index=0, flux=1.7), # "Real" RealGalaxy
galsim.Gaussian(sigma=0.08) ]),
galsim.Convolve([ galsim.RealGalaxy(rgc, index=1, flux=1.7), # "Fake" RealGalaxy
galsim.Gaussian(sigma=0.08) ]), # (cf. test_real.py)
galsim.Spergel(nu=-0.19, half_light_radius=0.17, flux=1.7),
galsim.Spergel(nu=0., half_light_radius=0.17, flux=1.7),
galsim.Spergel(nu=0.8, half_light_radius=0.17, flux=1.7),
galsim.Sersic(n=2.3, half_light_radius=0.17, flux=1.7),
galsim.Sersic(n=2.3, half_light_radius=0.17, flux=1.7, trunc=0.82),
# The shifts here caught a bug in how SBTransform handled the recentering.
# Two of the shifts (0.125 and 0.375) lead back to 0.0 happening on an integer
# index, which now works correctly.
galsim.Sum([ galsim.Gaussian(sigma=0.17, flux=1.7).shift(-0.2,0.125),
galsim.Exponential(scale_radius=0.23, flux=3.1).shift(0.375,0.23)]),
galsim.TopHat(0.23, flux=1.7),
# Box and Pixel use real-space convolution. Convolve with a Gaussian to get fft.
galsim.Convolve([ galsim.Box(0.17, 0.23, flux=1.7).shift(-0.2,0.1),
galsim.Gaussian(sigma=0.09) ]),
galsim.Convolve([ galsim.TopHat(0.17, flux=1.7).shift(-0.275,0.125),
galsim.Gaussian(sigma=0.09) ]),
# Test something really crazy with several layers worth of transformations
galsim.Convolve([
galsim.Sum([
galsim.Gaussian(sigma=0.17, flux=1.7).shear(g1=0.1,g2=0.2).shift(2,3),
galsim.Kolmogorov(fwhm=0.33, flux=3.9).transform(0.31,0.19,-0.23,0.33) * 88.,
galsim.Box(0.11, 0.44, flux=4).rotate(33 * galsim.degrees) / 1.9
]).shift(-0.3,1),
galsim.AutoConvolve(galsim.TopHat(0.5).shear(g1=0.3,g2=0)).rotate(3*galsim.degrees),
(galsim.AutoCorrelate(galsim.Box(0.2, 0.3)) * 11).shift(3,2).shift(2,-3) * 0.31
]).shift(0,0).transform(0,-1,-1,0).shift(-1,1)
]
s = galsim.Shear(g1=0.11, g2=-0.21)
s1 = galsim.Shear(g1=0.11, g2=0.21) # Appropriate for the flips around x and y axes
s2 = galsim.Shear(g1=-0.11, g2=-0.21) # Appropriate for the flip around x=y
# Also use shears with just a g1 to get dx != dy, but dxy, dyx = 0.
q = galsim.Shear(g1=0.11, g2=0.)
q1 = galsim.Shear(g1=0.11, g2=0.) # Appropriate for the flips around x and y axes
q2 = galsim.Shear(g1=-0.11, g2=0.) # Appropriate for the flip around x=y
decimal=6 # Oddly, these aren't as precise as I would have expected.
# Even when we only go to this many digits of accuracy, the Exponential needed
# a lower than default value for maxk_threshold.
im = galsim.ImageD(16,16, scale=0.05)
for prof in prof_list:
print('prof = ',prof)
# Not all profiles are expected to have a max_sb value close to the maximum pixel value,
# so mark the ones where we don't want to require this to be true.
close_maxsb = True
name = str(prof)
if ('DeVauc' in name or 'Sersic' in name or 'Spergel' in name or
'Optical' in name or 'shift' in name):
close_maxsb = False
# Make sure we hit all 4 fill functions.
# image_x uses fillXValue with izero, jzero
# image_x1 uses fillXValue with izero, jzero, and unequal dx,dy
# image_x2 uses fillXValue with dxy, dyx
# image_k uses fillKValue with izero, jzero
# image_k1 uses fillKValue with izero, jzero, and unequal dx,dy
# image_k2 uses fillKValue with dxy, dyx
image_x = prof.drawImage(image=im.copy(), method='no_pixel')
image_x1 = prof.shear(q).drawImage(image=im.copy(), method='no_pixel')
image_x2 = prof.shear(s).drawImage(image=im.copy(), method='no_pixel')
image_k = prof.drawImage(image=im.copy())
image_k1 = prof.shear(q).drawImage(image=im.copy())
image_k2 = prof.shear(s).drawImage(image=im.copy())
if close_maxsb:
np.testing.assert_allclose(
image_x.array.max(), prof.max_sb*im.scale**2, rtol=0.2,
err_msg="max_sb did not match maximum pixel value")
np.testing.assert_allclose(
image_x1.array.max(), prof.shear(q).max_sb*im.scale**2, rtol=0.2,
err_msg="max_sb did not match maximum pixel value")
np.testing.assert_allclose(
image_x2.array.max(), prof.shear(s).max_sb*im.scale**2, rtol=0.2,
err_msg="max_sb did not match maximum pixel value")
# Flip around y axis (i.e. x -> -x)
flip1 = prof.transform(-1, 0, 0, 1)
image2_x = flip1.drawImage(image=im.copy(), method='no_pixel')
np.testing.assert_array_almost_equal(
image_x.array, image2_x.array[:,::-1], decimal=decimal,
err_msg="Flipping image around y-axis failed x test")
image2_x1 = flip1.shear(q1).drawImage(image=im.copy(), method='no_pixel')
np.testing.assert_array_almost_equal(
image_x1.array, image2_x1.array[:,::-1], decimal=decimal,
err_msg="Flipping image around y-axis failed x1 test")
image2_x2 = flip1.shear(s1).drawImage(image=im.copy(), method='no_pixel')
np.testing.assert_array_almost_equal(
image_x2.array, image2_x2.array[:,::-1], decimal=decimal,
err_msg="Flipping image around y-axis failed x2 test")
image2_k = flip1.drawImage(image=im.copy())
np.testing.assert_array_almost_equal(
image_k.array, image2_k.array[:,::-1], decimal=decimal,
err_msg="Flipping image around y-axis failed k test")
image2_k1 = flip1.shear(q1).drawImage(image=im.copy())
np.testing.assert_array_almost_equal(
image_k1.array, image2_k1.array[:,::-1], decimal=decimal,
err_msg="Flipping image around y-axis failed k1 test")
image2_k2 = flip1.shear(s1).drawImage(image=im.copy())
np.testing.assert_array_almost_equal(
image_k2.array, image2_k2.array[:,::-1], decimal=decimal,
err_msg="Flipping image around y-axis failed k2 test")
if close_maxsb:
np.testing.assert_allclose(
image2_x.array.max(), flip1.max_sb*im.scale**2, rtol=0.2,
err_msg="max_sb did not match maximum pixel value")
np.testing.assert_allclose(
image2_x1.array.max(), flip1.shear(q).max_sb*im.scale**2, rtol=0.2,
err_msg="max_sb did not match maximum pixel value")
np.testing.assert_allclose(
image2_x2.array.max(), flip1.shear(s).max_sb*im.scale**2, rtol=0.2,
err_msg="max_sb did not match maximum pixel value")
# Flip around x axis (i.e. y -> -y)
flip2 = prof.transform(1, 0, 0, -1)
image2_x = flip2.drawImage(image=im.copy(), method='no_pixel')
np.testing.assert_array_almost_equal(
image_x.array, image2_x.array[::-1,:], decimal=decimal,
err_msg="Flipping image around x-axis failed x test")
image2_x1 = flip2.shear(q1).drawImage(image=im.copy(), method='no_pixel')
np.testing.assert_array_almost_equal(
image_x1.array, image2_x1.array[::-1,:], decimal=decimal,
err_msg="Flipping image around x-axis failed x1 test")
image2_x2 = flip2.shear(s1).drawImage(image=im.copy(), method='no_pixel')
np.testing.assert_array_almost_equal(
image_x2.array, image2_x2.array[::-1,:], decimal=decimal,
err_msg="Flipping image around x-axis failed x2 test")
image2_k = flip2.drawImage(image=im.copy())
np.testing.assert_array_almost_equal(
image_k.array, image2_k.array[::-1,:], decimal=decimal,
err_msg="Flipping image around x-axis failed k test")
image2_k1 = flip2.shear(q1).drawImage(image=im.copy())
np.testing.assert_array_almost_equal(
image_k1.array, image2_k1.array[::-1,:], decimal=decimal,
err_msg="Flipping image around x-axis failed k1 test")
image2_k2 = flip2.shear(s1).drawImage(image=im.copy())
np.testing.assert_array_almost_equal(
image_k2.array, image2_k2.array[::-1,:], decimal=decimal,
err_msg="Flipping image around x-axis failed k2 test")
if close_maxsb:
np.testing.assert_allclose(
image2_x.array.max(), flip2.max_sb*im.scale**2, rtol=0.2,
err_msg="max_sb did not match maximum pixel value")
np.testing.assert_allclose(
image2_x1.array.max(), flip2.shear(q).max_sb*im.scale**2, rtol=0.2,
err_msg="max_sb did not match maximum pixel value")
np.testing.assert_allclose(
image2_x2.array.max(), flip2.shear(s).max_sb*im.scale**2, rtol=0.2,
err_msg="max_sb did not match maximum pixel value")
# Flip around x=y (i.e. y -> x, x -> y)
flip3 = prof.transform(0, 1, 1, 0)
image2_x = flip3.drawImage(image=im.copy(), method='no_pixel')
np.testing.assert_array_almost_equal(
image_x.array, np.transpose(image2_x.array), decimal=decimal,
err_msg="Flipping image around x=y failed x test")
image2_x1 = flip3.shear(q2).drawImage(image=im.copy(), method='no_pixel')
np.testing.assert_array_almost_equal(
image_x1.array, np.transpose(image2_x1.array), decimal=decimal,
err_msg="Flipping image around x=y failed x1 test")
image2_x2 = flip3.shear(s2).drawImage(image=im.copy(), method='no_pixel')
np.testing.assert_array_almost_equal(
image_x2.array, np.transpose(image2_x2.array), decimal=decimal,
err_msg="Flipping image around x=y failed x2 test")
image2_k = flip3.drawImage(image=im.copy())
np.testing.assert_array_almost_equal(
image_k.array, np.transpose(image2_k.array), decimal=decimal,
err_msg="Flipping image around x=y failed k test")
image2_k1 = flip3.shear(q2).drawImage(image=im.copy())
np.testing.assert_array_almost_equal(
image_k1.array, np.transpose(image2_k1.array), decimal=decimal,
err_msg="Flipping image around x=y failed k1 test")
image2_k2 = flip3.shear(s2).drawImage(image=im.copy())
np.testing.assert_array_almost_equal(
image_k2.array, np.transpose(image2_k2.array), decimal=decimal,
err_msg="Flipping image around x=y failed k2 test")
if close_maxsb:
np.testing.assert_allclose(
image2_x.array.max(), flip3.max_sb*im.scale**2, rtol=0.2,
err_msg="max_sb did not match maximum pixel value")
np.testing.assert_allclose(
image2_x1.array.max(), flip3.shear(q).max_sb*im.scale**2, rtol=0.2,
err_msg="max_sb did not match maximum pixel value")
np.testing.assert_allclose(
image2_x2.array.max(), flip3.shear(s).max_sb*im.scale**2, rtol=0.2,
err_msg="max_sb did not match maximum pixel value")
do_pickle(prof, lambda x: x.drawImage(image=im.copy(), method='no_pixel'))
do_pickle(flip1, lambda x: x.drawImage(image=im.copy(), method='no_pixel'))
do_pickle(flip2, lambda x: x.drawImage(image=im.copy(), method='no_pixel'))
do_pickle(flip3, lambda x: x.drawImage(image=im.copy(), method='no_pixel'))
do_pickle(prof)
do_pickle(flip1)
do_pickle(flip2)
do_pickle(flip3)
def test_convolve():
"""Test the convolution of a Moffat and a Box SBProfile against a known result.
"""
import time
t1 = time.time()
dx = 0.2
# Using an exact Maple calculation for the comparison. Only accurate to 4 decimal places.
savedImg = galsim.fits.read(os.path.join(imgdir, "moffat_pixel.fits"))
myImg = galsim.ImageF(savedImg.bounds, scale=dx)
myImg.setCenter(0, 0)
# Code was formerly:
# psf = galsim.Moffat(beta=1.5, truncationFWHM=4, flux=1, half_light_radius=1)
#
# ...but this is no longer quite so simple since we changed the handling of trunc to be in
# physical units. However, the same profile can be constructed using
# fwhm=1.0927449310213702,
# as calculated by interval bisection in devutils/external/calculate_moffat_radii.py
fwhm_backwards_compatible = 1.0927449310213702
psf = galsim.Moffat(beta=1.5,
fwhm=fwhm_backwards_compatible,
trunc=4 * fwhm_backwards_compatible,
flux=1)
pixel = galsim.Pixel(scale=dx, flux=1.)
# Note: Since both of these have hard edges, GalSim wants to do this with real_space=True.
# Here we are intentionally tesing the Fourier convolution, so we want to suppress the
# warning that GalSim emits.
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore")
# We'll do the real space convolution below
conv = galsim.Convolve([psf, pixel], real_space=False)
conv.draw(myImg,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
4,
err_msg="Moffat convolved with Pixel disagrees with expected result"
)
# Other ways to do the convolution:
conv = galsim.Convolve(psf, pixel, real_space=False)
conv.draw(myImg,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
4,
err_msg=
"Using GSObject Convolve(psf,pixel) disagrees with expected result"
)
# Check with default_params
conv = galsim.Convolve([psf, pixel],
real_space=False,
gsparams=default_params)
conv.draw(myImg,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
4,
err_msg=
"Using GSObject Convolve([psf,pixel]) with default_params disagrees with"
"expected result")
conv = galsim.Convolve([psf, pixel],
real_space=False,
gsparams=galsim.GSParams())
conv.draw(myImg,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
4,
err_msg=
"Using GSObject Convolve([psf,pixel]) with GSParams() disagrees with"
"expected result")
# Test photon shooting.
do_shoot(conv, myImg, "Moffat * Pixel")
t2 = time.time()
print 'time for %s = %.2f' % (funcname(), t2 - t1)
tot_time_meas += (t2 - t1)
mean_e1 += res.corrected_e1
mean_e2 += res.corrected_e2
time_per_call = tot_time_meas / ntest
mean_e1 /= ntest
mean_e2 /= ntest
# check results
print "\nFor image size ", imsize, " per side, with noise, time to estimate shear was ", time_per_call, " per call"
print "Final results for e1, e2: ", mean_e1, mean_e2
# let's try something more complicated, like Sersic n=3 (same HLR as the Gaussian)
# and Kolmogorov with same FWHM of 2.5 pix, convolved with pixel
# do our conclusions still hold?
psf = galsim.Kolmogorov(fwhm=psf_fwhm)
gal = galsim.Sersic(3, half_light_radius=gal_hlr, flux=gal_flux)
pix = galsim.Pixel(pixel_scale)
gal.applyShear(e1=gal_e1, e2=gal_e2)
obj = galsim.Convolve(gal, psf, pix)
epsf = galsim.Convolve(psf, pix)
im_obj = galsim.ImageF(imsize, imsize)
im_epsf = galsim.ImageF(imsize, imsize)
im_obj = obj.draw(image=im_obj, dx=pixel_scale)
im_epsf = epsf.draw(image=im_epsf, dx=pixel_scale)
# get adaptive moments some number of times so we can average over the calls to get an average speed
time_mom = 0.0
time_shear = 0.0
for i in range(ntest):
t1 = time.time()
res1 = im_obj.FindAdaptiveMom(strict=False)
t2 = time.time()
def test_realspace_distorted_convolve():
"""
The same as above, but both the Moffat and the Box are sheared, rotated and shifted
to stress test the code that deals with this for real-space convolutions that wouldn't
be tested otherwise.
"""
import time
t1 = time.time()
dx = 0.2
saved_img = galsim.fits.read(
os.path.join(imgdir, "moffat_pixel_distorted.fits"))
img = galsim.ImageF(saved_img.bounds, scale=dx)
img.setCenter(0, 0)
fwhm_backwards_compatible = 1.0927449310213702
psf = galsim.Moffat(beta=1.5,
half_light_radius=1,
trunc=4 * fwhm_backwards_compatible,
flux=1)
#psf = galsim.Moffat(beta=1.5, fwhm=fwhm_backwards_compatible,
#trunc=4*fwhm_backwards_compatible, flux=1)
psf.applyShear(g1=0.11, g2=0.17)
psf.applyRotation(13 * galsim.degrees)
pixel = galsim.Pixel(scale=dx, flux=1.)
pixel.applyShear(g1=0.2, g2=0.0)
pixel.applyRotation(80 * galsim.degrees)
pixel.applyShift(0.13, 0.27)
# NB: real-space is chosen automatically
conv = galsim.Convolve([psf, pixel])
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using Convolve([psf,pixel]) (distorted) disagrees with expected result"
)
# Check with default_params
conv = galsim.Convolve([psf, pixel], gsparams=default_params)
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using Convolve([psf,pixel]) (distorted) with default_params disagrees with "
"expected result")
conv = galsim.Convolve([psf, pixel], gsparams=galsim.GSParams())
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using Convolve([psf,pixel]) (distorted) with GSParams() disagrees with "
"expected result")
# Other ways to do the convolution:
conv = galsim.Convolve(psf, pixel)
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using Convolve(psf,pixel) (distorted) disagrees with expected result")
# The real-space convolution algorithm is not (trivially) independent of the order of
# the two things being convolved. So check the opposite order.
conv = galsim.Convolve([pixel, psf])
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using Convolve([pixel,psf]) (distorted) disagrees with expected result"
)
t2 = time.time()
print 'time for %s = %.2f' % (funcname(), t2 - t1)
def test_realspace_shearconvolve():
"""Test the real-space convolution of a sheared Gaussian and a Box SBProfile against a
known result.
"""
import time
t1 = time.time()
e1 = 0.04
e2 = 0.0
myShear = galsim.Shear(e1=e1, e2=e2)
dx = 0.2
saved_img = galsim.fits.read(
os.path.join(imgdir, "gauss_smallshear_convolve_box.fits"))
img = galsim.ImageF(saved_img.bounds, scale=dx)
img.setCenter(0, 0)
psf = galsim.Gaussian(flux=1, sigma=1)
psf.applyShear(e1=e1, e2=e2)
pixel = galsim.Pixel(scale=dx, flux=1.)
conv = galsim.Convolve([psf, pixel], real_space=True)
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) disagrees with expected result")
# Check with default_params
conv = galsim.Convolve([psf, pixel],
real_space=True,
gsparams=default_params)
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) with default_params disagrees with "
"expected result")
conv = galsim.Convolve([psf, pixel],
real_space=True,
gsparams=galsim.GSParams())
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) with GSParams() disagrees with "
"expected result")
# Other ways to do the convolution:
conv = galsim.Convolve(psf, pixel, real_space=True)
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve(psf,pixel) disagrees with expected result")
# The real-space convolution algorithm is not (trivially) independent of the order of
# the two things being convolved. So check the opposite order.
conv = galsim.Convolve([pixel, psf], real_space=True)
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve([pixel,psf]) disagrees with expected result")
t2 = time.time()
print 'time for %s = %.2f' % (funcname(), t2 - t1)
def test_realspace_convolve():
"""Test the real-space convolution of a Moffat and a Box SBProfile against a known result.
"""
import time
t1 = time.time()
dx = 0.2
# Note: Using an image created from Maple "exact" calculations.
saved_img = galsim.fits.read(os.path.join(imgdir, "moffat_pixel.fits"))
img = galsim.ImageF(saved_img.bounds, scale=dx)
img.setCenter(0, 0)
# Code was formerly:
# psf = galsim.Moffat(beta=1.5, truncationFWHM=4, flux=1, half_light_radius=1)
#
# ...but this is no longer quite so simple since we changed the handling of trunc to be in
# physical units. However, the same profile can be constructed using
# fwhm=1.0927449310213702,
# as calculated by interval bisection in devutils/external/calculate_moffat_radii.py
fwhm_backwards_compatible = 1.0927449310213702
psf = galsim.Moffat(beta=1.5,
half_light_radius=1,
trunc=4 * fwhm_backwards_compatible,
flux=1)
#psf = galsim.Moffat(beta=1.5, fwhm=fwhm_backwards_compatible,
#trunc=4*fwhm_backwards_compatible, flux=1)
pixel = galsim.Pixel(scale=dx, flux=1.)
conv = galsim.Convolve([psf, pixel], real_space=True)
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) disagrees with expected result")
# Check with default_params
conv = galsim.Convolve([psf, pixel],
real_space=True,
gsparams=default_params)
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) with default_params disagrees with "
"expected result")
conv = galsim.Convolve([psf, pixel],
real_space=True,
gsparams=galsim.GSParams())
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) with GSParams() disagrees with "
"expected result")
# Other ways to do the convolution:
conv = galsim.Convolve(psf, pixel, real_space=True)
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve(psf,pixel) disagrees with expected result")
# The real-space convolution algorithm is not (trivially) independent of the order of
# the two things being convolved. So check the opposite order.
conv = galsim.Convolve([pixel, psf], real_space=True)
conv.draw(img,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve([pixel,psf]) disagrees with expected result")
# Test kvalues
do_kvalue(conv, "Truncated Moffat convolved with Box")
t2 = time.time()
print 'time for %s = %.2f' % (funcname(), t2 - t1)
def test_shearconvolve():
"""Test the convolution of a sheared Gaussian and a Box SBProfile against a known result.
"""
import time
t1 = time.time()
e1 = 0.04
e2 = 0.0
myShear = galsim.Shear(e1=e1, e2=e2)
dx = 0.2
savedImg = galsim.fits.read(
os.path.join(imgdir, "gauss_smallshear_convolve_box.fits"))
myImg = galsim.ImageF(savedImg.bounds, scale=dx)
myImg.setCenter(0, 0)
psf = galsim.Gaussian(flux=1, sigma=1)
psf2 = psf.createSheared(e1=e1, e2=e2)
psf.applyShear(e1=e1, e2=e2)
pixel = galsim.Pixel(scale=dx, flux=1.)
conv = galsim.Convolve([psf, pixel])
conv.draw(myImg,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) disagrees with expected result")
conv2 = galsim.Convolve([psf2, pixel])
conv2.draw(myImg,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) disagrees with expected result")
# Check with default_params
conv = galsim.Convolve([psf, pixel], gsparams=default_params)
conv.draw(myImg,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) with default_params disagrees with "
"expected result")
conv = galsim.Convolve([psf, pixel], gsparams=galsim.GSParams())
conv.draw(myImg,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) with GSParams() disagrees with "
"expected result")
# Other ways to do the convolution:
conv = galsim.Convolve(psf, pixel)
conv.draw(myImg,
scale=dx,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg=
"Using GSObject Convolve(psf,pixel) disagrees with expected result")
# Test photon shooting.
do_shoot(conv, myImg, "sheared Gaussian * Pixel")
t2 = time.time()
print 'time for %s = %.2f' % (funcname(), t2 - t1)
#From Chihway's config file
photon=0
Pixelsize=0.2
full_image = galsim.ImageF(128, 128)
full_image.setCenter(2657,3044)
full_image.setScale(0.2)
im_center = full_image.bounds.center()
im_center = galsim.PositionD(im_center.x, im_center.y)
Atmseeing = 0.6
Airmass = 1.0
atm_psf = galsim.Kolmogorov(fwhm = Atmseeing*Airmass**0.6)
Optpsfbeta = 3
Optpsfsize = 0.35
Optpsftrunc = 3.*Optpsfsize
opt_psf=galsim.Moffat(beta=Optpsfbeta, fwhm=Optpsfsize, trunc=Optpsftrunc)
pix = galsim.Pixel(0.2)
#decide if using photon shooting or not
psf=galsim.Convolve([atm_psf, opt_psf, pix])
if (photon == 0):
psf=galsim.Convolve([atm_psf, opt_psf, pix])
if (photon == 1):
psf=galsim.Convolve([atm_psf, opt_psf])
#Bright galaxy
#corresponds to line 24645 in storedproc.dat
x=512.84819306
y=652.163783834
z=0.215078294
galFlux=int(19861.5428849*25)
#Define wavelengths, ellipticities, and magnitudes
new_params = galsim.hsm.HSMParams(max_amoment=6.0e7, max_mom2_iter=10000000)
big_fft_params = galsim.GSParams(maximum_fft_size=4096)
mag_gal_vec = [18, 19, 20, 21, 22, 23, 24]
e1_vec, e2_vec, r_measured_vec = [], [], []
print "mag_vec, ratio_vec", mag_vec, ratio_vec
for mag in mag_gal_vec:
gal_flux = 6e4 * 2.521**(m_zero - mag)
gal = galsim.Convolve(galsim.Gaussian(flux=gal_flux,
sigma=gal_sigma).shear(
galsim.Shear(e1=0.0, e2=0.0)),
galsim.Pixel(pixel_scale),
gsparams=big_fft_params)
measurement_function(gal,
e1_inter_vec=e1_vec,
e2_inter_vec=e2_vec,
size_inter_vec=r_measured_vec,
noise=None,
string='Gausian, no noise',
type=type)
prop = fm.FontProperties(size=7)
alpha = 0.6
fig = plt.figure()
ax = fig.add_subplot(111)
ax.errorbar(mag_vec,
ratio_vec,
def test_interleaveImages():
# 1a) With galsim Gaussian
g = galsim.Gaussian(sigma=3.7,flux=1000.)
gal = galsim.Convolve([g,galsim.Pixel(1.0)])
im_list = []
offset_list = []
n = 2
for j in range(n):
for i in range(n):
im = galsim.Image(16*n,16*n)
offset = galsim.PositionD(-(i+0.5)/n+0.5,-(j+0.5)/n+0.5)
offset_list.append(offset)
gal.drawImage(image=im,method='no_pixel',offset=offset,scale=0.5)
im_list.append(im)
scale = im.scale
# Input to N as an int
img = galsim.utilities.interleaveImages(im_list,n,offsets=offset_list)
im = galsim.Image(16*n*n,16*n*n)
g = galsim.Gaussian(sigma=3.7,flux=1000.*n*n)
gal = galsim.Convolve([g,galsim.Pixel(1.0)])
gal.drawImage(image=im,method='no_pixel',offset=galsim.PositionD(0.0,0.0),scale=1.*scale/n)
np.testing.assert_array_equal(img.array,im.array,\
err_msg="Interleaved Gaussian images do not match")
assert im.wcs == img.wcs
# 1b) With im_list and offsets permuted
offset_list = []
# An elegant way of generating the default offsets
DX = np.arange(0.0,-1.0,-1.0/n)
DX -= DX.mean()
DY = DX
for dy in DY:
for dx in DX:
offset = galsim.PositionD(dx,dy)
offset_list.append(offset)
np.random.seed(42) # for generating the same random permutation everytime
rand_idx = np.random.permutation(len(offset_list))
im_list_randperm = [im_list[idx] for idx in rand_idx]
offset_list_randperm = [offset_list[idx] for idx in rand_idx]
# Input to N as a tuple
img_randperm = galsim.utilities.interleaveImages(im_list_randperm,(n,n),offsets=offset_list_randperm)
np.testing.assert_array_equal(img_randperm.array,img.array,\
err_msg="Interleaved images do not match when 'offsets' is supplied")
assert img_randperm.scale == img.scale
# 1c) Catching errors in offsets
offset_list = []
im_list = []
n = 5
# Generate approximate offsets
DX = np.array([-0.67,-0.33,0.,0.33,0.67])
DY = DX
for dy in DY:
for dx in DX:
offset = galsim.PositionD(dx,dy)
offset_list.append(offset)
im = galsim.Image(16,16)
gal.drawImage(image=im,offset=offset,method='no_pixel')
im_list.append(im)
try:
N = (n,n)
np.testing.assert_raises(ValueError,galsim.utilities.interleaveImages,im_list,N,offset_list)
except ImportError:
print("The assert_raises tests require nose")
offset_list = []
im_list = []
n = 5
DX = np.arange(0.,1.,1./n)
DY = DX
for dy in DY:
for dx in DX:
offset = galsim.PositionD(dx,dy)
offset_list.append(offset)
im = galsim.Image(16,16)
gal.drawImage(image=im,offset=offset,method='no_pixel')
im_list.append(im)
try:
N = (n,n)
np.testing.assert_raises(ValueError, galsim.utilities.interleaveImages,
im_list, N, offset_list)
except ImportError:
print("The assert_raises tests require nose")
# 2a) Increase resolution along one direction - square to rectangular images
n = 2
g = galsim.Gaussian(sigma=3.7,flux=100.)
gal1 = g.shear(g=1.*(n**2-1)/(n**2+1),beta=0.0*galsim.radians)
im_list = []
offset_list = []
# Generating offsets in a natural way
DY = np.arange(0.0,1.0,1.0/(n*n))
DY -= DY.mean()
for dy in DY:
im = galsim.Image(16,16)
offset = galsim.PositionD(0.0,dy)
offset_list.append(offset)
gal1.drawImage(im,offset=offset,method='no_pixel',scale=2.0)
im_list.append(im)
img = galsim.utilities.interleaveImages(im_list, N=[1,n**2], offsets=offset_list,
add_flux=False, suppress_warnings=True)
im = galsim.Image(16,16*n*n)
# The interleaved image has the total flux averaged out since `add_flux = False'
gal = galsim.Gaussian(sigma=3.7*n,flux=100.)
gal.drawImage(image=im,method='no_pixel',scale=2.0)
np.testing.assert_array_equal(im.array, img.array,
err_msg="Sheared gaussian not interleaved correctly")
assert img.wcs == galsim.JacobianWCS(2.0,0.0,0.0,2./(n**2))
# 2b) Increase resolution along one direction - rectangular to square images
n = 2
g = galsim.Gaussian(sigma=3.7,flux=100.)
gal2 = g.shear(g=1.*(n**2-1)/(n**2+1),beta=90.*galsim.degrees)
im_list = []
offset_list = []
# Generating offsets in a natural way
DX = np.arange(0.0,1.0,1.0/n**2)
DX -= DX.mean()
for dx in DX:
offset = galsim.PositionD(dx,0.0)
offset_list.append(offset)
im = galsim.Image(16,16*n*n)
gal2.drawImage(im,offset=offset,method='no_pixel',scale=3.0)
im_list.append(im)
img = galsim.utilities.interleaveImages(im_list, N=np.array([n**2,1]), offsets=offset_list,
suppress_warnings=True)
im = galsim.Image(16*n*n,16*n*n)
gal = galsim.Gaussian(sigma=3.7,flux=100.*n*n)
scale = im_list[0].scale
gal.drawImage(image=im,scale=1.*scale/n,method='no_pixel')
np.testing.assert_array_equal(im.array, img.array,
err_msg="Sheared gaussian not interleaved correctly")
assert img.wcs == galsim.JacobianWCS(1.*scale/n**2,0.0,0.0,scale)
# 3) Check compatability with deInterleaveImage
n = 3
g = galsim.Gaussian(sigma=3.7,flux=100.)
# break symmetry to detect possible bugs in deInterleaveImage
gal = g.shear(g=0.2,beta=0.*galsim.degrees)
im_list = []
offset_list = []
# Generating offsets in the order they would be returned by deInterleaveImage, for convenience
for i in range(n):
for j in range(n):
im = galsim.Image(16*n,16*n)
offset = galsim.PositionD(-(i+0.5)/n+0.5,-(j+0.5)/n+0.5)
offset_list.append(offset)
gal.drawImage(image=im,method='no_pixel',offset=offset,scale=0.5)
im.setOrigin(3,3) # for non-trivial bounds
im_list.append(im)
img = galsim.utilities.interleaveImages(im_list,N=n,offsets=offset_list)
im_list_1, offset_list_1 = galsim.utilities.deInterleaveImage(img, N=n)
for k in range(n**2):
assert offset_list_1[k] == offset_list[k]
np.testing.assert_array_equal(im_list_1[k].array, im_list[k].array)
assert im_list_1[k].wcs == im_list[k].wcs
assert im_list[k].origin() == img.origin()
assert im_list[k].bounds == im_list_1[k].bounds
# Checking for non-default flux option
img = galsim.utilities.interleaveImages(im_list,N=n,offsets=offset_list,add_flux=False)
im_list_2, offset_list_2 = galsim.utilities.deInterleaveImage(img,N=n,conserve_flux=True)
for k in range(n**2):
assert offset_list_2[k] == offset_list[k]
np.testing.assert_array_equal(im_list_2[k].array, im_list[k].array)
assert im_list_2[k].wcs == im_list[k].wcs