def _GetAngleValue(param):
""" @brief Convert a string consisting of a value and an angle unit into an Angle.
"""
try :
value, unit = param.rsplit(None,1)
value = float(value)
unit = galsim.angle.get_angle_unit(unit)
return galsim.Angle(value, unit)
except (TypeError, AttributeError) as e: # pragma: no cover
raise AttributeError("Unable to parse %s as an Angle. Caught %s"%(param,e))
def _GetAngleValue(param):
""" @brief Convert a string consisting of a value and an angle unit into an Angle.
"""
try :
value, unit = param.rsplit(None,1)
value = float(value)
unit = galsim.AngleUnit.from_name(unit)
return galsim.Angle(value, unit)
except (ValueError, TypeError, AttributeError) as e:
raise galsim.GalSimConfigError("Unable to parse %s as an Angle. Caught %s"%(param,e))
def _GetAngleValue(param, param_name):
""" @brief Convert a string consisting of a value and an angle unit into an Angle.
"""
try :
value, unit = param.rsplit(None,1)
value = float(value)
unit = galsim.angle.get_angle_unit(unit)
return galsim.Angle(value, unit)
except Exception as e:
raise AttributeError("Unable to parse %s param = %s as an Angle."%(param_name,param))
def interp_galsim_sinc(data_hr, data_lr, diff_psf, angle, h_hr, h_lr):
'''Apply resampling from galsim
Prameters
---------
data_hr: galsim Image
galsim Image object with the high resolution simulated image and its WCS
data_lr: galsim Image
galsim Image object with the low resolution simulated image and its WCS
diff_hr: numpy array
difference kernel betwee the high and low resolution psf
angle: float
angle between high and low resolution images
h_hr: float
scale of the high resolution pixel (arcsec)
h_lr: float
scale of the low resolution pixel (arcsec)
Returns
-------
interp_gal: galsim.Image
image interpolated at low resolution
'''
# Load data
im_hr = data_hr[None, :, :]
im_lr = data_lr[None, :, :]
_, n_hr, n_hr = im_hr.shape
_, n_lr, n_lr = im_lr.shape
# Interpolate hr image
gal_hr = galsim.InterpolatedImage(
galsim.Image(im_hr[0]),
scale=h_hr,
gsparams=galsim.GSParams(kvalue_accuracy=10**-3.5),
x_interpolant='Sinc')
# Rotate hr galaxy to lr frame
rot_gal = gal_hr.rotate(galsim.Angle(angle, galsim.radians))
# Convolve hr galaxy by diff kernel at hr
conv_gal = galsim.Convolve(rot_gal, diff_psf)
# Downsamples to low resolution
interp_gal = conv_gal.drawImage(
nx=n_lr,
ny=n_lr,
scale=h_lr,
method='no_pixel',
)
return interp_gal
def encode_examples(hparams, task_id=0, sample="25.2", cosmos_dir=None, exclusion_level="marginal", min_flux=0.):
"""
Generates and yields postage stamps obtained with GalSim.
"""
catalog = galsim.COSMOSCatalog(sample=sample, dir=cosmos_dir, exclusion_level=exclusion_level, min_flux=min_flux)
index = range(task_id * hparams.example_per_shard,
min((task_id+1) * hparams.example_per_shard, catalog.getNObjects()))
# Extracts additional information about the galaxies
cat_param = catalog.param_cat[catalog.orig_index]
# bparams = cat_param['bulgefit']
sparams = cat_param['sersicfit']
cat_param = append_fields(cat_param, 'sersic_q', sparams[:, 3])
cat_param = append_fields(cat_param, 'sersic_n', sparams[:, 2])
for ind in index:
# Draw a galaxy using GalSim, any kind of operation can be done here
gal = catalog.makeGalaxy(ind, noise_pad_size=hparams.img_len * hparams.pixel_scale)
psf = gal.original_psf
# Apply random rotation if requested
if hasattr(hparams, "rotation") and hparams.rotation:
rotation_angle = galsim.Angle(-np.random.rand() * 2 * np.pi,
galsim.radians)
gal = gal.rotate(rotation_angle)
psf = psf.rotate(rotation_angle)
# We save the corresponding attributes for this galaxy
if hasattr(hparams, 'attributes'):
params = cat_param[ind]
attributes = {k: params[k] for k in hparams.attributes}
else:
attributes = None
# Utility function encodes the postage stamp for serialized features
yield draw_and_encode_stamp(gal, psf,
stamp_size=hparams.img_len,
pixel_scale=hparams.pixel_scale,
attributes=attributes)
def generateGaussianTrainingSet():
img_size = 32
destination = 'testImages/'
#sizes = np.array([3.,3.5,4.,4.5,5.,5.5,6.])
sizes = np.array([2.5, 3.75, 4.25, 5.35, 5.9, 6.2])
N_sizes = len(sizes)
N_shears = 4 #16
N_angles = 10 #72
N_train = N_sizes * N_shears * N_angles
if N_train < img_size**2:
print "Too few training images to generate an \
overcomplete dictionary"
pos_angles = np.linspace(0., 180., N_angles)
shears = np.arange(0., 1., 1. / N_shears)
print "No. of training images = ", N_train
img = galsim.Image(img_size, img_size)
print "Generating training images ... "
gal_flux = 1.e5
noise = 30
for N_size in xrange(N_sizes):
for N_shear in xrange(N_shears):
for N_angle in xrange(N_angles):
g = galsim.Gaussian(sigma=sizes[N_size], flux=gal_flux)
theta = galsim.Angle(pos_angles[N_angle], galsim.degrees)
g = g.shear(g=shears[N_shear], beta=theta)
g.drawImage(image=img)
img.addNoise(galsim.GaussianNoise(sigma=noise))
fname = 'test_' + str(N_size).zfill(2) + '_' + str(
N_shear).zfill(2) + '_' + str(N_angle).zfill(2)
img.write(fname + '.fits', dir=destination)
print "Finished generating " + str(N_train) + " training images."
print "Destination folder: " + str(destination)
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_angle():
"""Test basic construction and use of Angle and AngleUnit classes
"""
# First Angle:
theta1 = numpy.pi / 4. * galsim.radians
theta2 = 45 * galsim.degrees
theta3 = 3 * galsim.hours
theta4 = 45 * 60 * galsim.arcmin
theta5 = galsim.Angle(45 * 3600,
galsim.arcsec) # Check explicit installation too.
assert theta1.rad() == numpy.pi / 4.
numpy.testing.assert_almost_equal(theta2.rad(), numpy.pi / 4., decimal=12)
numpy.testing.assert_almost_equal(theta3.rad(), numpy.pi / 4., decimal=12)
numpy.testing.assert_almost_equal(theta4.rad(), numpy.pi / 4., decimal=12)
numpy.testing.assert_almost_equal(theta5.rad(), numpy.pi / 4., decimal=12)
# Check wrapping
theta6 = (45 + 360) * galsim.degrees
assert abs(theta6.rad() - theta1.rad()) > 6.
numpy.testing.assert_almost_equal(theta6.wrap().rad(),
theta1.rad(),
decimal=12)
theta7 = (45 - 360) * galsim.degrees
assert abs(theta7.rad() - theta1.rad()) > 6.
numpy.testing.assert_almost_equal(theta7.wrap().rad(),
theta1.rad(),
decimal=12)
# Check wrapping with non-default center
pi_rad = pi * galsim.radians
numpy.testing.assert_almost_equal(theta6.wrap(pi_rad).rad(),
theta1.rad(),
decimal=12)
numpy.testing.assert_almost_equal(theta6.rad(),
theta1.wrap(2 * pi_rad).rad(),
decimal=12)
numpy.testing.assert_almost_equal(theta6.rad(),
theta1.wrap(3 * pi_rad).rad(),
decimal=12)
numpy.testing.assert_almost_equal(theta7.rad(),
theta1.wrap(-pi_rad).rad(),
decimal=12)
numpy.testing.assert_almost_equal(theta7.rad(),
theta1.wrap(-2 * pi_rad).rad(),
decimal=12)
numpy.testing.assert_almost_equal(theta6.wrap(27 * galsim.radians).rad(),
theta1.wrap(27 * galsim.radians).rad(),
decimal=12)
numpy.testing.assert_almost_equal(theta7.wrap(-127 * galsim.radians).rad(),
theta1.wrap(-127 * galsim.radians).rad(),
decimal=12)
# Make a new AngleUnit as described in the AngleUnit docs
gradians = galsim.AngleUnit(2. * numpy.pi / 400.)
theta8 = 50 * gradians
numpy.testing.assert_almost_equal(theta8.rad(), numpy.pi / 4., decimal=12)
# Check simple math
numpy.testing.assert_almost_equal((theta1 + theta2).rad(),
numpy.pi / 2.,
decimal=12)
numpy.testing.assert_almost_equal((4 * theta3).rad(), numpy.pi, decimal=12)
numpy.testing.assert_almost_equal((4 * theta4 - theta2).rad(),
0.75 * numpy.pi,
decimal=12)
numpy.testing.assert_almost_equal((theta5 / 2.).rad(),
numpy.pi / 8.,
decimal=12)
numpy.testing.assert_almost_equal(theta3 / galsim.radians,
numpy.pi / 4.,
decimal=12)
numpy.testing.assert_almost_equal(theta1 / galsim.hours, 3., decimal=12)
numpy.testing.assert_almost_equal(galsim.hours / galsim.arcmin,
15 * 60,
decimal=12)
# Check picklability
do_pickle(galsim.radians)
do_pickle(galsim.degrees)
do_pickle(galsim.hours)
do_pickle(galsim.arcmin)
do_pickle(galsim.arcsec)
do_pickle(gradians)
do_pickle(theta1)
do_pickle(theta2)
do_pickle(theta3)
do_pickle(theta4)
do_pickle(theta5)
do_pickle(theta6)
do_pickle(theta7)
do_pickle(theta8)
def generator(self, data_dir, tmp_dir, dataset_split, task_id=-1):
"""
Generates and yields postage stamps obtained with GalSim.
"""
p = self.get_hparams()
try:
# try to use default galsim path to the data
catalog = galsim.COSMOSCatalog()
except:
# If that fails, tries to use the specified tmp_dir
catalog = galsim.COSMOSCatalog(dir=tmp_dir +
'/COSMOS_25.2_training_sample')
# Create a list of galaxy indices for this task, remember, there is a task
# per shard, each shard is 1000 galaxies.
assert (task_id > -1)
index = range(
task_id * p.example_per_shard,
min((task_id + 1) * p.example_per_shard, catalog.getNObjects()))
# Extracts additional information about the galaxies
cat_param = catalog.param_cat[catalog.orig_index]
from numpy.lib.recfunctions import append_fields
import numpy as np
bparams = cat_param['bulgefit']
sparams = cat_param['sersicfit']
# Parameters for a 2 component fit
cat_param = append_fields(cat_param, 'bulge_q', bparams[:, 11])
cat_param = append_fields(cat_param, 'bulge_beta', bparams[:, 15])
cat_param = append_fields(cat_param, 'disk_q', bparams[:, 3])
cat_param = append_fields(cat_param, 'disk_beta', bparams[:, 7])
cat_param = append_fields(cat_param, 'bulge_hlr', cat_param['hlr'][:,
1])
cat_param = append_fields(
cat_param, 'bulge_flux_log10',
np.where(cat_param['use_bulgefit'] == 1,
np.log10(cat_param['flux'][:, 1]),
np.zeros(len(cat_param))))
cat_param = append_fields(cat_param, 'disk_hlr', cat_param['hlr'][:,
2])
cat_param = append_fields(
cat_param, 'disk_flux_log10',
np.where(cat_param['use_bulgefit'] == 1,
np.log10(cat_param['flux'][:, 2]),
np.log10(cat_param['flux'][:, 0])))
# Parameters for a single component fit
cat_param = append_fields(cat_param, 'sersic_flux_log10',
np.log10(sparams[:, 0]))
cat_param = append_fields(cat_param, 'sersic_q', sparams[:, 3])
cat_param = append_fields(cat_param, 'sersic_hlr', sparams[:, 1])
cat_param = append_fields(cat_param, 'sersic_n', sparams[:, 2])
cat_param = append_fields(cat_param, 'sersic_beta', sparams[:, 7])
for ind in index:
# Draw a galaxy using GalSim, any kind of operation can be done here
gal = catalog.makeGalaxy(ind,
noise_pad_size=p.img_len * p.pixel_scale *
2)
# We apply the orginal psf if a different PSF is not requested
if hasattr(p, "psf"):
psf = p.psf
else:
psf = gal.original_psf
# Apply random rotation if requested
if hasattr(p, "rotation") and p.rotation:
rotation_angle = galsim.Angle(-np.random.rand() * 2 * np.pi,
galsim.radians)
gal = gal.rotate(rotation_angle)
psf = psf.rotate(rotation_angle)
# We save the corresponding attributes for this galaxy
if hasattr(p, 'attributes'):
params = cat_param[ind]
attributes = {k: params[k] for k in p.attributes}
else:
attributes = None
# Utility function encodes the postage stamp for serialized features
yield galsim_utils.draw_and_encode_stamp(gal,
psf,
stamp_size=p.img_len,
pixel_scale=p.pixel_scale,
attributes=attributes)
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): # pragma: no cover
"""Deprecated method 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 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: 0]
@param g2 Second component of shear to impose, [default: 0]
@param rotation_angle Angle by which to rotate the galaxy (must be an Angle
instance). [default: None]
@param rand_rotate Should the galaxy be rotated by some random angle? [default: True;
unless `rotation_angle` is set, then False]
@param rng A BaseDeviate instance to use for the random selection or rotation
angle. [default: None]
@param target_flux The target flux in the output galaxy image, [default: 1000.]
@param image As with the GSObject.drawImage() function, if an image is provided,
then it will be used and returned. [default: None, which means an
appropriately-sized image will be created.]
@return a simulated galaxy image.
"""
from .deprecated import depr
depr('simReal', 1.5, '',
'This method has been deprecated due to lack of widespread use. If you '+
'have a need for it, please open an issue requesting that it be reinstated.')
# do some checking of arguments
if not isinstance(real_galaxy, galsim.RealGalaxy):
raise RuntimeError("Error: simReal requires a RealGalaxy!")
if isinstance(target_PSF, galsim.Image):
target_PSF = galsim.InterpolatedImage(target_PSF, scale=target_pixel_scale)
if not isinstance(target_PSF, galsim.GSObject):
raise RuntimeError("Error: target PSF is not an Image or GSObject!")
if rotation_angle is not 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 = target_PSF.withFlux(1.0)
# rotate
if rotation_angle is not None:
real_galaxy = real_galaxy.rotate(rotation_angle)
elif rotation_angle is None and rand_rotate == True:
if rng is None:
ud = galsim.UniformDeviate()
elif isinstance(rng,galsim.BaseDeviate):
ud = galsim.UniformDeviate(rng)
else:
raise TypeError("The rng provided is not a BaseDeviate")
rand_angle = galsim.Angle(math.pi*ud(), galsim.radians)
real_galaxy = real_galaxy.rotate(rand_angle)
# set fluxes
real_galaxy = real_galaxy.withFlux(target_flux)
# shear
if (g1 != 0.0 or g2 != 0.0):
real_galaxy = real_galaxy.shear(g1=g1, g2=g2)
# convolve, resample
out_gal = galsim.Convolve([real_galaxy, target_PSF])
image = out_gal.drawImage(image=image, scale=target_pixel_scale, method='no_pixel')
# return simulated image
return image
def test_angle():
"""Test basic construction and use of Angle and AngleUnit classes
"""
# First Angle:
theta1 = pi / 4. * galsim.radians
theta2 = 45 * galsim.degrees
theta3 = 3 * galsim.hours
theta4 = 45 * 60 * galsim.arcmin
theta5 = galsim.Angle(45 * 3600,
galsim.arcsec) # Check explicit installation too.
theta6 = galsim._Angle(
pi / 4.) # Underscore constructor implicitly uses radians
assert theta1.rad == pi / 4.
numpy.testing.assert_almost_equal(theta2.rad, pi / 4., decimal=12)
numpy.testing.assert_almost_equal(theta3.rad, pi / 4., decimal=12)
numpy.testing.assert_almost_equal(theta4.rad, pi / 4., decimal=12)
numpy.testing.assert_almost_equal(theta5.rad, pi / 4., decimal=12)
numpy.testing.assert_almost_equal(theta6.rad, pi / 4., decimal=12)
# Check wrapping
theta6 = (45 + 360) * galsim.degrees
assert abs(theta6.rad - theta1.rad) > 6.
numpy.testing.assert_almost_equal(theta6.wrap().rad,
theta1.rad,
decimal=12)
# Check trig calls
numpy.testing.assert_almost_equal(theta6.sin(), theta1.sin(), decimal=12)
numpy.testing.assert_almost_equal(theta6.cos(), theta1.cos(), decimal=12)
numpy.testing.assert_almost_equal(theta6.tan(), theta1.tan(), decimal=12)
numpy.testing.assert_almost_equal(theta6.sin(), math.sqrt(0.5), decimal=12)
numpy.testing.assert_almost_equal(theta6.cos(), math.sqrt(0.5), decimal=12)
numpy.testing.assert_almost_equal(theta6.tan(), 1., decimal=12)
numpy.testing.assert_array_almost_equal(theta6.sincos(),
math.sqrt(0.5),
decimal=12)
theta7 = (45 - 360) * galsim.degrees
assert abs(theta7.rad - theta1.rad) > 6.
numpy.testing.assert_almost_equal(theta7.wrap().rad,
theta1.rad,
decimal=12)
# Check wrapping with non-default center
pi_rad = pi * galsim.radians
numpy.testing.assert_almost_equal(theta6.wrap(pi_rad).rad,
theta1.rad,
decimal=12)
numpy.testing.assert_almost_equal(theta6.rad,
theta1.wrap(2 * pi_rad).rad,
decimal=12)
numpy.testing.assert_almost_equal(theta6.rad,
theta1.wrap(3 * pi_rad).rad,
decimal=12)
numpy.testing.assert_almost_equal(theta7.rad,
theta1.wrap(-pi_rad).rad,
decimal=12)
numpy.testing.assert_almost_equal(theta7.rad,
theta1.wrap(-2 * pi_rad).rad,
decimal=12)
numpy.testing.assert_almost_equal(theta6.wrap(27 * galsim.radians).rad,
theta1.wrap(27 * galsim.radians).rad,
decimal=12)
numpy.testing.assert_almost_equal(theta7.wrap(-127 * galsim.radians).rad,
theta1.wrap(-127 * galsim.radians).rad,
decimal=12)
# Make a new AngleUnit as described in the AngleUnit docs
gradians = galsim.AngleUnit(2. * pi / 400.)
theta8 = 50 * gradians
numpy.testing.assert_almost_equal(theta8.rad, pi / 4., decimal=12)
numpy.testing.assert_almost_equal(theta8 / gradians, 50., decimal=12)
numpy.testing.assert_almost_equal(gradians.value,
2. * pi / 400.,
decimal=12)
numpy.testing.assert_almost_equal(gradians / galsim.radians,
2. * pi / 400.,
decimal=12)
# Check simple math
numpy.testing.assert_almost_equal((theta1 + theta2).rad,
pi / 2.,
decimal=12)
numpy.testing.assert_almost_equal((4 * theta3).rad, pi, decimal=12)
numpy.testing.assert_almost_equal((4 * theta4 - theta2).rad,
0.75 * pi,
decimal=12)
numpy.testing.assert_almost_equal((theta5 / 2.).rad, pi / 8., decimal=12)
numpy.testing.assert_almost_equal(theta3 / galsim.radians,
pi / 4.,
decimal=12)
numpy.testing.assert_almost_equal(theta1 / galsim.hours, 3., decimal=12)
numpy.testing.assert_almost_equal(galsim.hours / galsim.arcmin,
15 * 60,
decimal=12)
# Check copy constructor
theta9 = galsim.Angle(theta1)
numpy.testing.assert_equal(theta9.rad, theta1.rad)
# Check picklability
do_pickle(galsim.radians)
do_pickle(galsim.degrees)
do_pickle(galsim.hours)
do_pickle(galsim.arcmin)
do_pickle(galsim.arcsec)
do_pickle(gradians)
do_pickle(theta1)
do_pickle(theta2)
do_pickle(theta3)
do_pickle(theta4)
do_pickle(theta5)
do_pickle(theta6)
do_pickle(theta7)
do_pickle(theta8)
# Check invalid constructors
assert_raises(TypeError, galsim.AngleUnit, galsim.degrees)
assert_raises(ValueError, galsim.AngleUnit, 'spam')
assert_raises(TypeError, galsim.AngleUnit, 1, 3)
assert_raises(TypeError, galsim.Angle, 3.4)
assert_raises(TypeError, galsim.Angle, theta1, galsim.degrees)
assert_raises(ValueError, galsim.Angle, 'spam', galsim.degrees)
assert_raises(TypeError, galsim.Angle, 1, 3)
def _make_galaxy(params):
"""
Draws the galaxy, psf and noise power spectrum on a postage stamp
"""
gal, psf, noise_image, in_pixel_scale, var, stamp_size, pixel_scale = params
real_params = (galsim.Image(np.ascontiguousarray(gal),
scale=in_pixel_scale),
galsim.Image(np.ascontiguousarray(psf),
scale=in_pixel_scale),
galsim.Image(np.ascontiguousarray(noise_image),
scale=in_pixel_scale), in_pixel_scale, var)
gal = galsim.RealGalaxy(real_params,
noise_pad_size=stamp_size * pixel_scale)
psf = gal.original_psf
gal = galsim.Convolve(gal, gal.original_psf)
# Random rotation of the galaxy
rotation_angle = galsim.Angle(-np.random.rand() * 2 * np.pi,
galsim.radians)
g = gal.rotate(rotation_angle)
p = psf.rotate(rotation_angle)
# Draw the Fourier domain image of the galaxy
imC = galsim.ImageCF(stamp_size,
stamp_size,
scale=2. * np.pi / (pixel_scale * stamp_size))
imCp = galsim.ImageCF(stamp_size,
stamp_size,
scale=2. * np.pi / (pixel_scale * stamp_size))
g.drawKImage(image=imC)
p.drawKImage(image=imCp)
# Keep track of the pixels with 0 value
mask = ~(np.fft.fftshift(imC.array)[:, :(stamp_size) // 2 + 1] == 0)
# Inverse Fourier transform of the image
# TODO: figure out why we need 2 fftshifts....
im = np.fft.fftshift(np.fft.ifft2(np.fft.fftshift(
imC.array))).real.astype('float32')
# Transform the psf array into proper format for Theano
im_psf = np.fft.fftshift(imCp.array)[:, :(stamp_size // 2 +
1)].astype('complex64')
# Compute noise power spectrum
ps = g.noise._get_update_rootps((stamp_size, stamp_size),
wcs=galsim.PixelScale(pixel_scale))
# The following comes from correlatednoise.py
rt2 = np.sqrt(2.)
shape = (stamp_size, stamp_size)
ps[0, 0] = rt2 * ps[0, 0]
# Then make the changes necessary for even sized arrays
if shape[1] % 2 == 0: # x dimension even
ps[0, shape[1] // 2] = rt2 * ps[0, shape[1] // 2]
if shape[0] % 2 == 0: # y dimension even
ps[shape[0] // 2, 0] = rt2 * ps[shape[0] // 2, 0]
# Both dimensions even
if shape[1] % 2 == 0:
ps[shape[0] // 2, shape[1] // 2] = rt2 * \
ps[shape[0] // 2, shape[1] // 2]
# Apply mask to power spectrum so that it is very large outside maxk
ps = np.where(mask, np.log(ps**2), 10).astype('float32')
return im, im_psf, ps
def generateBDTrainingSet(btt):
gsp = galsim.GSParams(maximum_fft_size=16384)
img_size = 64
destination = 'trainImages/'
# PSF description
lam = 1580 #nm
diam = 2.4 #m
obscuration = 0.3
PSF = galsim.OpticalPSF(lam=lam, diameter=diam, obscuration=obscuration)
# Bulge component
n_bulge = 4.0
bulge_Re_arr = np.array([3.5, 4., 4.5, 5., 5.5, 6., 6.5]) # pixels
#sizes = np.array([2.5,3.75,4.25,5.35,5.9,6.2])
#Disk component
n_disk = 1.0
disk_scaleRadius_arr = bulge_Re_arr
N_sizes = len(bulge_Re_arr) * len(disk_scaleRadius_arr)
N_shears = 4 #16
N_angles = 10 #72
N_train = N_sizes * (N_shears**2) * (N_angles**2)
if N_train < img_size**2:
print "Too few training images to generate an \
overcomplete dictionary"
theta_values = np.linspace(0., 180., N_angles).tolist() # degrees
pos_angles = [
galsim.Angle(theta, galsim.degrees) for theta in theta_values
]
shears = np.arange(0., 1., 1. / N_shears)
print "No. of training images = ", N_train
img = galsim.Image(img_size, img_size)
print "Generating training images ... "
gal_flux = 5.e5
noise = 10
for N_bulge_size in xrange(len(bulge_Re_arr)):
for N_disk_size in xrange(len(disk_scaleRadius_arr)):
bulge = galsim.Sersic(n=n_bulge,
half_light_radius=bulge_Re_arr[N_bulge_size],
gsparams=gsp)
disk = galsim.Sersic(
n=n_disk,
scale_radius=disk_scaleRadius_arr[N_disk_size],
gsparams=gsp)
for N_bulge_shear in xrange(N_shears):
for N_bulge_pos in xrange(N_angles):
B = bulge.shear(g=shears[N_bulge_shear],
beta=pos_angles[N_bulge_pos])
for N_disk_shear in xrange(N_shears):
for N_disk_pos in xrange(N_angles):
D = disk.shear(g=shears[N_disk_shear],
beta=pos_angles[N_disk_pos])
gal = btt * gal_flux * B + (1. -
btt) * gal_flux * D
gal = galsim.Convolve([gal, PSF])
gal.drawImage(image=img)
img.addNoise(galsim.GaussianNoise(sigma=noise))
fname = 'trainBD_'+str(N_btt).zfill(2)+'_'+str(N_bulge_size).zfill(2)+'_'+str(N_disk_size).zfill(2)+\
'_'+str(N_bulge_shear).zfill(2)+'_'+str(N_bulge_pos).zfill(2)+'_'+str(N_disk_shear).zfill(2)+\
'_'+str(N_disk_pos).zfill(2)
img.write(fname + '.fits', dir=destination)
print "Finished generating " + str(
N_train) + " training images with bulge+disk components"
