def test_sbinterpolatedimage():
"""Test that we can make SBInterpolatedImages from Images of various types, and convert back.
"""
import time
t1 = time.time()
# for each type, try to make an SBInterpolatedImage, and check that when we draw an image from
# that SBInterpolatedImage that it is the same as the original
lan3 = galsim.Lanczos(3, True, 1.E-4)
lan3_2d = galsim.InterpolantXY(lan3)
ftypes = [np.float32, np.float64]
ref_array = np.array([[0.01, 0.08, 0.07, 0.02], [0.13, 0.38, 0.52, 0.06],
[0.09, 0.41, 0.44, 0.09], [0.04, 0.11, 0.10, 0.01]])
for array_type in ftypes:
image_in = galsim.ImageView[array_type](ref_array.astype(array_type))
np.testing.assert_array_equal(
ref_array.astype(array_type),
image_in.array,
err_msg=
"Array from input Image differs from reference array for type %s" %
array_type)
sbinterp = galsim.SBInterpolatedImage(image_in, lan3_2d, dx=1.0)
test_array = np.zeros(ref_array.shape, dtype=array_type)
image_out = galsim.ImageView[array_type](test_array, scale=1.0)
sbinterp.draw(image_out.view())
np.testing.assert_array_equal(
ref_array.astype(array_type),
image_out.array,
err_msg=
"Array from output Image differs from reference array for type %s"
% array_type)
# Lanczos doesn't quite get the flux right. Wrong at the 5th decimal place.
# Gary says that's expected -- Lanczos isn't technically flux conserving.
# He applied the 1st order correction to the flux, but expect to be wrong at around
# the 10^-5 level.
# Anyway, Quintic seems to be accurate enough.
quint = galsim.Quintic(1.e-4)
quint_2d = galsim.InterpolantXY(quint)
sbinterp = galsim.SBInterpolatedImage(image_in, quint_2d, dx=1.0)
sbinterp.setFlux(1.)
do_shoot(galsim.GSObject(sbinterp), image_out, "InterpolatedImage")
# Test kvalues
do_kvalue(galsim.GSObject(sbinterp), "InterpolatedImage")
t2 = time.time()
print 'time for %s = %.2f' % (funcname(), t2 - t1)
def simReal(real_galaxy,
target_PSF,
target_pixel_scale,
g1=0.0,
g2=0.0,
rotation_angle=None,
rand_rotate=True,
rng=None,
target_flux=1000.0,
image=None):
"""Function to simulate images (no added noise) from real galaxy training data.
This function takes a RealGalaxy from some training set, and manipulates it as needed to
simulate a (no-noise-added) image from some lower-resolution telescope. It thus requires a
target PSF (which could be an image, or one of our base classes) that represents all PSF
components including the pixel response, and a target pixel scale.
The default rotation option is to impose a random rotation to make irrelevant any real shears
in the galaxy training data (optionally, the RNG can be supplied). This default can be turned
off by setting `rand_rotate = False` or by requesting a specific rotation angle using the
`rotation_angle` keyword, in which case `rand_rotate` is ignored.
Optionally, the user can specify a shear (default 0). Finally, they can specify a flux
normalization for the final image, default 1000.
@param real_galaxy The RealGalaxy object to use, not modified in generating the
simulated image.
@param target_PSF The target PSF, either one of our base classes or an ImageView/Image.
@param target_pixel_scale The pixel scale for the final image, in arcsec.
@param g1 First component of shear to impose (components defined with respect
to pixel coordinates), default `g1 = 0.`
@param g2 Second component of shear to impose, default `g2 = 0.`
@param rotation_angle Angle by which to rotate the galaxy (must be a galsim.Angle
instance).
@param rand_rotate If `rand_rotate = True` (default) then impose a random rotation on
the training galaxy; this is ignored if `rotation_angle` is set.
@param rng A random number generator to use for selection of the random
rotation angle. (optional, may be any kind of galsim.BaseDeviate
or None)
@param target_flux The target flux in the output galaxy image, default
`target_flux = 1000.`
@param image As with the GSObject.draw() function, if an image is provided,
then it will be used and returned.
If `image=None`, then an appropriately sized image will be created.
@return A simulated galaxy image. The input RealGalaxy is unmodified.
"""
# do some checking of arguments
if not isinstance(real_galaxy, galsim.RealGalaxy):
raise RuntimeError("Error: simReal requires a RealGalaxy!")
for Class in galsim.Image.itervalues():
if isinstance(target_PSF, Class):
lan5 = galsim.Lanczos(5, conserve_flux=True, tol=1.e-4)
interp2d = galsim.InterpolantXY(lan5)
target_PSF = galsim.SBInterpolatedImage(target_PSF.view(),
xInterp=interp2d,
dx=target_pixel_scale)
break
for Class in galsim.ImageView.itervalues():
if isinstance(target_PSF, Class):
lan5 = galsim.Lanczos(5, conserve_flux=True, tol=1.e-4)
interp2d = galsim.InterpolantXY(lan5)
target_PSF = galsim.SBInterpolatedImage(target_PSF,
xInterp=interp2d,
dx=target_pixel_scale)
break
if isinstance(target_PSF, galsim.GSObject):
target_PSF = target_PSF.SBProfile
if not isinstance(target_PSF, galsim.SBProfile):
raise RuntimeError(
"Error: target PSF is not an Image, ImageView, SBProfile, or GSObject!"
)
if rotation_angle != None and not isinstance(rotation_angle, galsim.Angle):
raise RuntimeError(
"Error: specified rotation angle is not an Angle instance!")
if (target_pixel_scale < real_galaxy.pixel_scale):
import warnings
message = "Warning: requested pixel scale is higher resolution than original!"
warnings.warn(message)
import math # needed for pi, sqrt below
g = math.sqrt(g1**2 + g2**2)
if g > 1:
raise RuntimeError("Error: requested shear is >1!")
# make sure target PSF is normalized
target_PSF.setFlux(1.0)
real_galaxy_copy = real_galaxy.copy()
# rotate
if rotation_angle != None:
real_galaxy_copy.applyRotation(rotation_angle)
elif rotation_angle == None and rand_rotate == True:
if rng == None:
uniform_deviate = galsim.UniformDeviate()
elif isinstance(rng, galsim.BaseDeviate):
uniform_deviate = galsim.UniformDeviate(rng)
else:
raise TypeError(
"The rng provided to drawShoot is not a BaseDeviate")
rand_angle = galsim.Angle(math.pi * uniform_deviate(), galsim.radians)
real_galaxy_copy.applyRotation(rand_angle)
# set fluxes
real_galaxy_copy.setFlux(target_flux)
# shear
if (g1 != 0.0 or g2 != 0.0):
real_galaxy_copy.applyShear(g1=g1, g2=g2)
# convolve, resample
out_gal = galsim.Convolve([real_galaxy_copy, galsim.GSObject(target_PSF)])
image = out_gal.draw(image=image, dx=target_pixel_scale)
# return simulated image
return image
def test_shapelet_adjustments():
"""Test that adjusting the Shapelet profile in various ways does the right thing
"""
ftypes = [np.float32, np.float64]
nx = 128
ny = 128
scale = 0.2
im = galsim.ImageF(nx, ny, scale=scale)
sigma = 1.8
order = 6
bvec = [
1.3, # n = 0
0.02,
0.03, # n = 1
0.23,
-0.19,
0.08, # n = 2
0.01,
0.02,
0.04,
-0.03, # n = 3
-0.09,
0.07,
-0.11,
-0.08,
0.11, # n = 4
-0.03,
-0.02,
-0.08,
0.01,
-0.06,
-0.03, # n = 5
0.06,
-0.02,
0.00,
-0.05,
-0.04,
0.01,
0.09
] # n = 6
ref_shapelet = galsim.Shapelet(sigma=sigma, order=order, bvec=bvec)
ref_im = galsim.ImageF(nx, ny)
ref_shapelet.drawImage(ref_im, scale=scale)
# Test PQ and NM access
np.testing.assert_equal(ref_shapelet.getPQ(0, 0), (bvec[0], 0))
np.testing.assert_equal(ref_shapelet.getPQ(1, 1), (bvec[5], 0))
np.testing.assert_equal(ref_shapelet.getPQ(1, 2), (bvec[8], -bvec[9]))
np.testing.assert_equal(ref_shapelet.getPQ(3, 2), (bvec[19], bvec[20]))
np.testing.assert_equal(ref_shapelet.getNM(0, 0), (bvec[0], 0))
np.testing.assert_equal(ref_shapelet.getNM(2, 0), (bvec[5], 0))
np.testing.assert_equal(ref_shapelet.getNM(3, -1), (bvec[8], -bvec[9]))
np.testing.assert_equal(ref_shapelet.getNM(5, 1), (bvec[19], bvec[20]))
# Test that the Shapelet withFlux does the same thing as the GSObject withFlux
gsref_shapelet = galsim.GSObject(
ref_shapelet) # Make it opaque to the Shapelet versions
gsref_shapelet.withFlux(23.).drawImage(ref_im, method='no_pixel')
shapelet = galsim.Shapelet(sigma=sigma, order=order, bvec=bvec)
shapelet.withFlux(23.).drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet withFlux disagrees with GSObject withFlux")
# Test that scaling the Shapelet flux does the same thing as the GSObject scaling
(gsref_shapelet * 0.23).drawImage(ref_im, method='no_pixel')
(shapelet * 0.23).drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet *= 0.23 disagrees with GSObject *= 0.23")
# Test that the Shapelet rotate does the same thing as the GSObject rotate
gsref_shapelet.rotate(23. * galsim.degrees).drawImage(ref_im,
method='no_pixel')
shapelet.rotate(23. * galsim.degrees).drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet rotate disagrees with GSObject rotate")
# Test that the Shapelet dilate does the same thing as the GSObject dilate
gsref_shapelet.dilate(1.3).drawImage(ref_im, method='no_pixel')
shapelet.dilate(1.3).drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet dilate disagrees with GSObject dilate")
# Test that the Shapelet expand does the same thing as the GSObject expand
gsref_shapelet.expand(1.7).drawImage(ref_im, method='no_pixel')
shapelet.expand(1.7).drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet expand disagrees with GSObject expand")
# Test that the Shapelet magnify does the same thing as the GSObject magnify
gsref_shapelet.magnify(0.8).drawImage(ref_im, method='no_pixel')
shapelet.magnify(0.8).drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet magnify disagrees with GSObject magnify")
# Test that lens works on Shapelet
gsref_shapelet.lens(-0.05, 0.15, 1.1).drawImage(ref_im, method='no_pixel')
shapelet.lens(-0.05, 0.15, 1.1).drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet lens disagrees with GSObject lens")
def test_shapelet_adjustments():
"""Test that adjusting the Shapelet profile in various ways does the right thing
"""
import time
t1 = time.time()
ftypes = [np.float32, np.float64]
nx = 128
ny = 128
scale = 0.2
im = galsim.ImageF(nx,ny, scale=scale)
sigma = 1.8
order = 6
bvec = [1.3, # n = 0
0.02, 0.03, # n = 1
0.23, -0.19, 0.08, # n = 2
0.01, 0.02, 0.04, -0.03, # n = 3
-0.09, 0.07, -0.11, -0.08, 0.11, # n = 4
-0.03, -0.02, -0.08, 0.01, -0.06, -0.03, # n = 5
0.06, -0.02, 0.00, -0.05, -0.04, 0.01, 0.09 ] # n = 6
ref_shapelet = galsim.Shapelet(sigma=sigma, order=order, bvec=bvec)
ref_im = galsim.ImageF(nx,ny)
ref_shapelet.drawImage(ref_im, scale=scale)
# Test that the Shapelet withFlux does the same thing as the GSObject withFlux
gsref_shapelet = galsim.GSObject(ref_shapelet) # Make it opaque to the Shapelet versions
gsref_shapelet.withFlux(23.).drawImage(ref_im, method='no_pixel')
shapelet = galsim.Shapelet(sigma=sigma, order=order, bvec=bvec)
shapelet.withFlux(23.).drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array, ref_im.array, 6,
err_msg="Shapelet withFlux disagrees with GSObject withFlux")
# Test that scaling the Shapelet flux does the same thing as the GSObject scaling
gsref_shapelet *= 0.23
gsref_shapelet.drawImage(ref_im, method='no_pixel')
shapelet *= 0.23
shapelet.drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array, ref_im.array, 6,
err_msg="Shapelet *= 0.23 disagrees with GSObject *= 0.23")
# Test that the Shapelet rotate does the same thing as the GSObject rotate
gsref_shapelet.rotate(23. * galsim.degrees).drawImage(ref_im, method='no_pixel')
shapelet.rotate(23. * galsim.degrees).drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array, ref_im.array, 6,
err_msg="Shapelet rotate disagrees with GSObject rotate")
# Test that the Shapelet dilate does the same thing as the GSObject dilate
gsref_shapelet.dilate(1.3).drawImage(ref_im, method='no_pixel')
shapelet.dilate(1.3).drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array, ref_im.array, 6,
err_msg="Shapelet dilate disagrees with GSObject dilate")
# Test that the Shapelet magnify does the same thing as the GSObject magnify
gsref_shapelet.magnify(0.8).drawImage(ref_im, method='no_pixel')
shapelet.magnify(0.8).drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array, ref_im.array, 6,
err_msg="Shapelet magnify disagrees with GSObject magnify")
# Test that lens works on Shapelet
gsref_shapelet.lens(-0.05, 0.15, 1.1).drawImage(ref_im, method='no_pixel')
shapelet.lens(-0.05, 0.15, 1.1).drawImage(im, method='no_pixel')
np.testing.assert_array_almost_equal(
im.array, ref_im.array, 6,
err_msg="Shapelet lens disagrees with GSObject lens")
t2 = time.time()
print 'time for %s = %.2f'%(funcname(),t2-t1)
def test_shapelet_adjustments():
"""Test that adjusting the Shapelet profile in various ways does the right thing
"""
import time
t1 = time.time()
ftypes = [np.float32, np.float64]
nx = 128
ny = 128
scale = 0.2
im = galsim.ImageF(nx, ny, scale=scale)
sigma = 1.8
order = 6
bvec = [
1.3, # n = 0
0.02,
0.03, # n = 1
0.23,
-0.19,
0.08, # n = 2
0.01,
0.02,
0.04,
-0.03, # n = 3
-0.09,
0.07,
-0.11,
-0.08,
0.11, # n = 4
-0.03,
-0.02,
-0.08,
0.01,
-0.06,
-0.03, # n = 5
0.06,
-0.02,
0.00,
-0.05,
-0.04,
0.01,
0.09
] # n = 6
ref_shapelet = galsim.Shapelet(sigma=sigma, order=order, bvec=bvec)
ref_im = galsim.ImageF(nx, ny)
ref_shapelet.draw(ref_im, scale=scale)
# Test setSigma
shapelet = galsim.Shapelet(sigma=1., order=order, bvec=bvec)
shapelet.setSigma(sigma)
shapelet.draw(im)
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet set with setSigma disagrees with reference Shapelet")
# Test setBVec
shapelet = galsim.Shapelet(sigma=sigma, order=order)
shapelet.setBVec(bvec)
shapelet.draw(im)
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet set with setBVec disagrees with reference Shapelet")
# Test setOrder
shapelet = galsim.Shapelet(sigma=sigma, order=2)
shapelet.setOrder(order)
shapelet.setBVec(bvec)
shapelet.draw(im)
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet set with setOrder disagrees with reference Shapelet")
# Test that changing the order preserves the values to the extent possible.
shapelet = galsim.Shapelet(sigma=sigma, order=order, bvec=bvec)
shapelet.setOrder(10)
np.testing.assert_array_equal(
shapelet.getBVec()[0:28],
bvec,
err_msg="Shapelet setOrder to larger doesn't preserve existing values."
)
np.testing.assert_array_equal(
shapelet.getBVec()[28:66],
np.zeros(66 - 28),
err_msg="Shapelet setOrder to larger doesn't fill with zeros.")
shapelet.setOrder(6)
np.testing.assert_array_equal(
shapelet.getBVec(),
bvec,
err_msg=
"Shapelet setOrder back to original from larger doesn't preserve existing values."
)
shapelet.setOrder(3)
np.testing.assert_array_equal(
shapelet.getBVec()[0:10],
bvec[0:10],
err_msg="Shapelet setOrder to smaller doesn't preserve existing values."
)
shapelet.setOrder(6)
np.testing.assert_array_equal(
shapelet.getBVec()[0:10],
bvec[0:10],
err_msg=
"Shapelet setOrder back to original from smaller doesn't preserve existing values."
)
shapelet.setOrder(6)
np.testing.assert_array_equal(
shapelet.getBVec()[10:28],
np.zeros(28 - 10),
err_msg=
"Shapelet setOrder back to original from smaller doesn't fill with zeros."
)
# Test that setting a Shapelet with setNM gives the right profile
shapelet = galsim.Shapelet(sigma=sigma, order=order)
i = 0
for n in range(order + 1):
for m in range(n, -1, -2):
if m == 0:
shapelet.setNM(n, m, bvec[i])
i = i + 1
else:
shapelet.setNM(n, m, bvec[i], bvec[i + 1])
i = i + 2
shapelet.draw(im)
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet set with setNM disagrees with reference Shapelet")
# Test that setting a Shapelet with setPQ gives the right profile
shapelet = galsim.Shapelet(sigma=sigma, order=order)
i = 0
for n in range(order + 1):
for m in range(n, -1, -2):
p = (n + m) / 2
q = (n - m) / 2
if m == 0:
shapelet.setPQ(p, q, bvec[i])
i = i + 1
else:
shapelet.setPQ(p, q, bvec[i], bvec[i + 1])
i = i + 2
shapelet.draw(im)
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet set with setPQ disagrees with reference Shapelet")
# Test that the Shapelet setFlux does the same thing as the GSObject setFlux
gsref_shapelet = galsim.GSObject(
ref_shapelet) # Make it opaque to the Shapelet versions
gsref_shapelet.setFlux(23.)
gsref_shapelet.draw(ref_im)
shapelet = galsim.Shapelet(sigma=sigma, order=order, bvec=bvec)
shapelet.setFlux(23.)
shapelet.draw(im)
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet setFlux disagrees with GSObject setFlux")
# Test that the Shapelet scaleFlux does the same thing as the GSObject scaleFlux
gsref_shapelet.scaleFlux(0.23)
gsref_shapelet.draw(ref_im)
shapelet.scaleFlux(0.23)
shapelet.draw(im)
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet setFlux disagrees with SObject scaleFlux")
# Test that the Shapelet applyRotation does the same thing as the GSObject applyRotation
gsref_shapelet.applyRotation(23. * galsim.degrees)
gsref_shapelet.draw(ref_im)
shapelet.applyRotation(23. * galsim.degrees)
shapelet.draw(im)
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet applyRotation disagrees with GSObject applyRotation")
# Test that the Shapelet applyDilation does the same thing as the GSObject applyDilation
gsref_shapelet.applyDilation(1.3)
gsref_shapelet.draw(ref_im)
shapelet.applyDilation(1.3)
shapelet.draw(im)
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet applyDilation disagrees with GSObject applyDilation")
# Test that the Shapelet applyMagnification does the same thing as the GSObject
# applyMagnification
gsref_shapelet.applyMagnification(0.8)
gsref_shapelet.draw(ref_im)
shapelet.applyMagnification(0.8)
shapelet.draw(im)
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg=
"Shapelet applyMagnification disagrees with GSObject applyMagnification"
)
# Test that applyLensing works on Shapelet
gsref_shapelet.applyLensing(-0.05, 0.15, 1.1)
gsref_shapelet.draw(ref_im)
shapelet.applyLensing(-0.05, 0.15, 1.1)
shapelet.draw(im)
np.testing.assert_array_almost_equal(
im.array,
ref_im.array,
6,
err_msg="Shapelet applyLensing disagrees with GSObject applyLensing")
t2 = time.time()
print 'time for %s = %.2f' % (funcname(), t2 - t1)
