def prepare_mosaic(self, image, fov_deg):
"""Prepare a new (blank) mosaic image based on the pointing of
the parameter image
"""
header = image.get_header()
ra_deg, dec_deg = header['CRVAL1'], header['CRVAL2']
data_np = image.get_data()
self.bg_ref = iqcalc.get_median(data_np)
# TODO: handle skew (differing rotation for each axis)?
skew_limit = self.settings.get('skew_limit', 0.1)
(rot_deg, cdelt1, cdelt2) = wcs.get_rotation_and_scale(header,
skew_threshold=skew_limit)
self.logger.debug("image0 rot=%f cdelt1=%f cdelt2=%f" % (
rot_deg, cdelt1, cdelt2))
# TODO: handle differing pixel scale for each axis?
px_scale = math.fabs(cdelt1)
cdbase = [numpy.sign(cdelt1), numpy.sign(cdelt2)]
#cdbase = [1, 1]
self.logger.debug("creating blank image to hold mosaic")
self.fv.gui_do(self._prepare_mosaic1)
img_mosaic = dp.create_blank_image(ra_deg, dec_deg,
fov_deg, px_scale,
rot_deg,
cdbase=cdbase,
logger=self.logger,
pfx='mosaic')
## imname = 'mosaic%d' % (self.mosaic_count)
## img_mosaic.set(name=imname)
## self.mosaic_count += 1
imname = img_mosaic.get('name', image.get('name', "NoName"))
# avoid making a thumbnail of this if seed image is also that way
nothumb = not self.settings.get('make_thumbs', False)
img_mosaic.set(nothumb=image.get('nothumb', nothumb))
# TODO: fill in interesting/select object headers from seed image
header = img_mosaic.get_header()
(rot, cdelt1, cdelt2) = wcs.get_rotation_and_scale(header,
skew_threshold=skew_limit)
self.logger.debug("mosaic rot=%f cdelt1=%f cdelt2=%f" % (
rot, cdelt1, cdelt2))
self.img_mosaic = img_mosaic
self.fv.gui_call(self.fv.add_image, imname, img_mosaic,
chname=self.mosaic_chname)
return img_mosaic
def prepare_mosaic(self, image, fov_deg):
"""Prepare a new (blank) mosaic image based on the pointing of
the parameter image
"""
header = image.get_header()
ra_deg, dec_deg = header['CRVAL1'], header['CRVAL2']
data_np = image.get_data()
self.bg_ref = iqcalc.get_median(data_np)
# TODO: handle skew (differing rotation for each axis)?
skew_limit = self.settings.get('skew_limit', 0.1)
(rot_deg, cdelt1,
cdelt2) = wcs.get_rotation_and_scale(header,
skew_threshold=skew_limit)
self.logger.debug("image0 rot=%f cdelt1=%f cdelt2=%f" %
(rot_deg, cdelt1, cdelt2))
# TODO: handle differing pixel scale for each axis?
px_scale = math.fabs(cdelt1)
cdbase = [numpy.sign(cdelt1), numpy.sign(cdelt2)]
#cdbase = [1, 1]
self.logger.debug("creating blank image to hold mosaic")
self.fv.gui_do(self._prepare_mosaic1)
img_mosaic = dp.create_blank_image(ra_deg,
dec_deg,
fov_deg,
px_scale,
rot_deg,
cdbase=cdbase,
logger=self.logger,
pfx='mosaic')
## imname = 'mosaic%d' % (self.mosaic_count)
## img_mosaic.set(name=imname)
## self.mosaic_count += 1
imname = img_mosaic.get('name', "NoName")
header = img_mosaic.get_header()
(rot, cdelt1,
cdelt2) = wcs.get_rotation_and_scale(header,
skew_threshold=skew_limit)
self.logger.debug("mosaic rot=%f cdelt1=%f cdelt2=%f" %
(rot, cdelt1, cdelt2))
self.img_mosaic = img_mosaic
self.fv.gui_call(self.fv.add_image,
imname,
img_mosaic,
chname=self.mosaic_chname)
def prepare_mosaic(self, image, fov_deg):
"""Prepare a new (blank) mosaic image based on the pointing of
the parameter image
"""
header = image.get_header()
ra_deg, dec_deg = header['CRVAL1'], header['CRVAL2']
data_np = image.get_data()
self.bg_ref = iqcalc.get_median(data_np)
# TODO: handle skew (differing rotation for each axis)?
(rot_deg, cdelt1, cdelt2) = wcs.get_rotation_and_scale(header)
self.logger.debug("image0 rot=%f cdelt1=%f cdelt2=%f" % (
rot_deg, cdelt1, cdelt2))
# TODO: handle differing pixel scale for each axis?
px_scale = math.fabs(cdelt1)
cdbase = [numpy.sign(cdelt1), numpy.sign(cdelt2)]
#cdbase = [1, 1]
self.logger.debug("creating blank image to hold mosaic")
self.fv.gui_do(self._prepare_mosaic1)
img_mosaic = dp.create_blank_image(ra_deg, dec_deg,
fov_deg, px_scale,
rot_deg,
cdbase=cdbase,
logger=self.logger,
pfx='mosaic')
## imname = 'mosaic%d' % (self.mosaic_count)
## img_mosaic.set(name=imname)
## self.mosaic_count += 1
imname = img_mosaic.get('name', "NoName")
header = img_mosaic.get_header()
(rot, cdelt1, cdelt2) = wcs.get_rotation_and_scale(header)
self.logger.debug("mosaic rot=%f cdelt1=%f cdelt2=%f" % (
rot, cdelt1, cdelt2))
self.img_mosaic = img_mosaic
self.fv.gui_call(self.fv.add_image, imname, img_mosaic,
chname=self.mosaic_chname)
def prepare_mosaic(self, image, fov_deg, name=None):
"""Prepare a new (blank) mosaic image based on the pointing of
the parameter image
"""
header = image.get_header()
ra_deg, dec_deg = header['CRVAL1'], header['CRVAL2']
data_np = image.get_data()
#dtype = data_np.dtype
dtype = None
self.bg_ref = iqcalc.get_median(data_np)
# TODO: handle skew (differing rotation for each axis)?
skew_limit = self.settings.get('skew_limit', 0.1)
(rot_deg, cdelt1,
cdelt2) = wcs.get_rotation_and_scale(header,
skew_threshold=skew_limit)
self.logger.debug("image0 rot=%f cdelt1=%f cdelt2=%f" %
(rot_deg, cdelt1, cdelt2))
# TODO: handle differing pixel scale for each axis?
px_scale = math.fabs(cdelt1)
cdbase = [numpy.sign(cdelt1), numpy.sign(cdelt2)]
reuse_image = self.settings.get('reuse_image', False)
if (not reuse_image) or (self.img_mosaic is None):
self.logger.debug("creating blank image to hold mosaic")
self.fv.gui_do(self._prepare_mosaic1, "Creating blank image...")
# GC old mosaic
self.img_mosaic = None
img_mosaic = dp.create_blank_image(ra_deg,
dec_deg,
fov_deg,
px_scale,
rot_deg,
cdbase=cdbase,
logger=self.logger,
pfx='mosaic',
dtype=dtype)
if name is not None:
img_mosaic.set(name=name)
imname = img_mosaic.get('name', image.get('name', "NoName"))
# avoid making a thumbnail of this if seed image is also that way
nothumb = not self.settings.get('make_thumbs', False)
if nothumb:
img_mosaic.set(nothumb=True)
else:
# image is not on disk, set indication for other plugins
img_mosaic.set(path=None)
# TODO: fill in interesting/select object headers from seed image
self.img_mosaic = img_mosaic
self.fv.gui_call(self.fv.add_image,
imname,
img_mosaic,
chname=self.mosaic_chname)
else:
# <-- reuse image (faster)
self.logger.debug("Reusing previous mosaic image")
self.fv.gui_do(self._prepare_mosaic1,
"Reusing previous mosaic image...")
img_mosaic = dp.recycle_image(self.img_mosaic,
ra_deg,
dec_deg,
fov_deg,
px_scale,
rot_deg,
cdbase=cdbase,
logger=self.logger,
pfx='mosaic')
header = img_mosaic.get_header()
(rot, cdelt1,
cdelt2) = wcs.get_rotation_and_scale(header,
skew_threshold=skew_limit)
self.logger.debug("mosaic rot=%f cdelt1=%f cdelt2=%f" %
(rot, cdelt1, cdelt2))
return img_mosaic
def mosaic_inline(self,
imagelist,
bg_ref=None,
trim_px=None,
merge=False,
allow_expand=True,
expand_pad_deg=0.01,
max_expand_pct=None,
update_minmax=True,
suppress_callback=False):
"""Drops new images into the current image (if there is room),
relocating them according the WCS between the two images.
"""
# Get our own (mosaic) rotation and scale
header = self.get_header()
((xrot_ref, yrot_ref),
(cdelt1_ref, cdelt2_ref)) = wcs.get_xy_rotation_and_scale(header)
scale_x, scale_y = math.fabs(cdelt1_ref), math.fabs(cdelt2_ref)
# drop each image in the right place in the new data array
mydata = self._get_data()
count = 1
res = []
for image in imagelist:
name = image.get('name', 'image%d' % (count))
count += 1
data_np = image._get_data()
if 0 in data_np.shape:
self.logger.info("Skipping image with zero length axis")
continue
# Calculate sky position at the center of the piece
ctr_x, ctr_y = trcalc.get_center(data_np)
ra, dec = image.pixtoradec(ctr_x, ctr_y)
# User specified a trim? If so, trim edge pixels from each
# side of the array
ht, wd = data_np.shape[:2]
if trim_px:
xlo, xhi = trim_px, wd - trim_px
ylo, yhi = trim_px, ht - trim_px
data_np = data_np[ylo:yhi, xlo:xhi, ...]
ht, wd = data_np.shape[:2]
# If caller asked us to match background of pieces then
# get the median of this piece
if bg_ref is not None:
bg = iqcalc.get_median(data_np)
bg_inc = bg_ref - bg
data_np = data_np + bg_inc
# Determine max/min to update our values
if update_minmax:
maxval = numpy.nanmax(data_np)
minval = numpy.nanmin(data_np)
self.maxval = max(self.maxval, maxval)
self.minval = min(self.minval, minval)
# Get rotation and scale of piece
header = image.get_header()
((xrot, yrot), (cdelt1,
cdelt2)) = wcs.get_xy_rotation_and_scale(header)
self.logger.debug("image(%s) xrot=%f yrot=%f cdelt1=%f "
"cdelt2=%f" % (name, xrot, yrot, cdelt1, cdelt2))
# scale if necessary
# TODO: combine with rotation?
if (not numpy.isclose(math.fabs(cdelt1), scale_x)
or not numpy.isclose(math.fabs(cdelt2), scale_y)):
nscale_x = math.fabs(cdelt1) / scale_x
nscale_y = math.fabs(cdelt2) / scale_y
self.logger.debug("scaling piece by x(%f), y(%f)" %
(nscale_x, nscale_y))
data_np, (ascale_x, ascale_y) = trcalc.get_scaled_cutout_basic(
data_np,
0,
0,
wd - 1,
ht - 1,
nscale_x,
nscale_y,
logger=self.logger)
# Rotate piece into our orientation, according to wcs
rot_dx, rot_dy = xrot - xrot_ref, yrot - yrot_ref
flip_x = False
flip_y = False
# Optomization for 180 rotations
if (numpy.isclose(math.fabs(rot_dx), 180.0)
or numpy.isclose(math.fabs(rot_dy), 180.0)):
rotdata = trcalc.transform(data_np, flip_x=True, flip_y=True)
rot_dx = 0.0
rot_dy = 0.0
else:
rotdata = data_np
# Finish with any necessary rotation of piece
if not numpy.isclose(rot_dy, 0.0):
rot_deg = rot_dy
self.logger.debug("rotating %s by %f deg" % (name, rot_deg))
rotdata = trcalc.rotate(
rotdata,
rot_deg,
#rotctr_x=ctr_x, rotctr_y=ctr_y
logger=self.logger)
# Flip X due to negative CDELT1
if numpy.sign(cdelt1) != numpy.sign(cdelt1_ref):
flip_x = True
# Flip Y due to negative CDELT2
if numpy.sign(cdelt2) != numpy.sign(cdelt2_ref):
flip_y = True
if flip_x or flip_y:
rotdata = trcalc.transform(rotdata,
flip_x=flip_x,
flip_y=flip_y)
# Get size and data of new image
ht, wd = rotdata.shape[:2]
ctr_x, ctr_y = trcalc.get_center(rotdata)
# Find location of image piece (center) in our array
x0, y0 = self.radectopix(ra, dec)
# Merge piece as closely as possible into our array
# Unfortunately we lose a little precision rounding to the
# nearest pixel--can't be helped with this approach
x0, y0 = int(round(x0)), int(round(y0))
self.logger.debug("Fitting image '%s' into mosaic at %d,%d" %
(name, x0, y0))
# This is for useful debugging info only
my_ctr_x, my_ctr_y = trcalc.get_center(mydata)
off_x, off_y = x0 - my_ctr_x, y0 - my_ctr_y
self.logger.debug("centering offsets: %d,%d" % (off_x, off_y))
# Sanity check piece placement
xlo, xhi = x0 - ctr_x, x0 + wd - ctr_x
ylo, yhi = y0 - ctr_y, y0 + ht - ctr_y
assert (xhi - xlo == wd), \
Exception("Width differential %d != %d" % (xhi - xlo, wd))
assert (yhi - ylo == ht), \
Exception("Height differential %d != %d" % (yhi - ylo, ht))
mywd, myht = self.get_size()
if xlo < 0 or xhi > mywd or ylo < 0 or yhi > myht:
if not allow_expand:
raise Exception("New piece doesn't fit on image and "
"allow_expand=False")
# <-- Resize our data array to allow the new image
# determine amount to pad expansion by
expand_x = max(int(expand_pad_deg / scale_x), 0)
expand_y = max(int(expand_pad_deg / scale_y), 0)
nx1_off, nx2_off = 0, 0
if xlo < 0:
nx1_off = abs(xlo) + expand_x
if xhi > mywd:
nx2_off = (xhi - mywd) + expand_x
xlo, xhi = xlo + nx1_off, xhi + nx1_off
ny1_off, ny2_off = 0, 0
if ylo < 0:
ny1_off = abs(ylo) + expand_y
if yhi > myht:
ny2_off = (yhi - myht) + expand_y
ylo, yhi = ylo + ny1_off, yhi + ny1_off
new_wd = mywd + nx1_off + nx2_off
new_ht = myht + ny1_off + ny2_off
# sanity check on new mosaic size
old_area = mywd * myht
new_area = new_wd * new_ht
expand_pct = new_area / old_area
if ((max_expand_pct is not None)
and (expand_pct > max_expand_pct)):
raise Exception("New area exceeds current one by %.2f %%;"
"increase max_expand_pct (%.2f) to allow" %
(expand_pct * 100, max_expand_pct))
# go for it!
new_data = numpy.zeros((new_ht, new_wd))
# place current data into new data
new_data[ny1_off:ny1_off + myht, nx1_off:nx1_off + mywd] = \
mydata
self._data = new_data
mydata = new_data
if (nx1_off > 0) or (ny1_off > 0):
# Adjust our WCS for relocation of the reference pixel
crpix1, crpix2 = self.get_keywords_list('CRPIX1', 'CRPIX2')
kwds = dict(CRPIX1=crpix1 + nx1_off,
CRPIX2=crpix2 + ny1_off)
self.update_keywords(kwds)
# fit image piece into our array
try:
if merge:
mydata[ylo:yhi, xlo:xhi, ...] += rotdata[0:ht, 0:wd, ...]
else:
idx = (mydata[ylo:yhi, xlo:xhi, ...] == 0.0)
mydata[ylo:yhi, xlo:xhi, ...][idx] = \
rotdata[0:ht, 0:wd, ...][idx]
except Exception as e:
self.logger.error("Error fitting tile: %s" % (str(e)))
raise
res.append((xlo, ylo, xhi, yhi))
# TODO: recalculate min and max values
# Can't use usual techniques because it adds too much time to the
# mosacing
#self._set_minmax()
# Notify watchers that our data has changed
if not suppress_callback:
self.make_callback('modified')
return res
def mosaic_inline(self, imagelist, bg_ref=None, trim_px=None,
merge=False):
"""Drops new images into the current image (if there is room),
relocating them according the WCS between the two images.
"""
# For determining our orientation
ra0, dec0 = self.pixtoradec(0, 0)
ra1, dec1 = self.pixtoradec(self.width-1, self.height-1)
# Get our own (mosaic) rotation and scale
header = self.get_header()
((xrot_ref, yrot_ref),
(cdelt1_ref, cdelt2_ref)) = wcs.get_xy_rotation_and_scale(header)
ref_rot = yrot_ref
scale_x, scale_y = math.fabs(cdelt1_ref), math.fabs(cdelt2_ref)
# drop each image in the right place in the new data array
mydata = self.get_data()
count = 1
for image in imagelist:
name = image.get('name', 'image%d' % (count))
count += 1
data_np = image.get_data()
# Calculate sky position at the center of the piece
ctr_x, ctr_y = trcalc.get_center(data_np)
ra, dec = image.pixtoradec(ctr_x, ctr_y)
# User specified a trim? If so, trim edge pixels from each
# side of the array
ht, wd = data_np.shape[:2]
if trim_px:
xlo, xhi = trim_px, wd - trim_px
ylo, yhi = trim_px, ht - trim_px
data_np = data_np[ylo:yhi, xlo:xhi, ...]
ht, wd = data_np.shape[:2]
# If caller asked us to match background of pieces then
# get the median of this piece
if bg_ref != None:
bg = iqcalc.get_median(data_np)
bg_inc = bg_ref - bg
#print "bg=%f inc=%f" % (bg, bg_inc)
data_np = data_np + bg_inc
# Get rotation and scale of piece
header = image.get_header()
((xrot, yrot),
(cdelt1, cdelt2)) = wcs.get_xy_rotation_and_scale(header)
self.logger.debug("image(%s) xrot=%f yrot=%f cdelt1=%f cdelt2=%f" % (
name, xrot, yrot, cdelt1, cdelt2))
# scale if necessary
# TODO: combine with rotation?
if ((math.fabs(cdelt1) != scale_x) or
(math.fabs(cdelt2) != scale_y)):
nscale_x = math.fabs(cdelt1) / scale_x
nscale_y = math.fabs(cdelt2) / scale_y
self.logger.debug("scaling piece by x(%f), y(%f)" % (
nscale_x, nscale_y))
data_np, (ascale_x, ascale_y) = trcalc.get_scaled_cutout_basic(
data_np, 0, 0, wd-1, ht-1, nscale_x, nscale_y)
# Rotate piece into our orientation, according to wcs
rot_dx, rot_dy = xrot - xrot_ref, yrot - yrot_ref
flip_x = False
flip_y = False
## # Flip X due to negative CDELT1
## if numpy.sign(cdelt1) < 0:
## flip_x = True
## # Flip Y due to negative CDELT2
## if numpy.sign(cdelt2) < 0:
## flip_y = True
# Optomization for 180 rotations
if math.fabs(rot_dx) == 180.0:
flip_x = not flip_x
rot_dx = 0.0
if math.fabs(rot_dy) == 180.0:
flip_y = not flip_y
rot_dy = 0.0
self.logger.debug("flip_x=%s flip_y=%s" % (flip_x, flip_y))
rotdata = trcalc.transform(data_np, flip_x=flip_x, flip_y=flip_y)
# Finish with any necessary rotation of piece
if rot_dy != 0.0:
rot_deg = rot_dy
self.logger.debug("rotating %s by %f deg" % (name, rot_deg))
rotdata = trcalc.rotate(rotdata, rot_deg,
#rotctr_x=ctr_x, rotctr_y=ctr_y
)
# Get size and data of new image
ht, wd = rotdata.shape[:2]
ctr_x, ctr_y = trcalc.get_center(rotdata)
# Find location of image piece (center) in our array
x0, y0 = self.radectopix(ra, dec)
# Merge piece as closely as possible into our array
# Unfortunately we lose a little precision rounding to the
# nearest pixel--can't be helped with this approach
x0, y0 = int(round(x0)), int(round(y0))
self.logger.debug("Fitting image '%s' into mosaic at %d,%d" % (
name, x0, y0))
# Sanity check piece placement
xlo, xhi = x0 - ctr_x, x0 + wd - ctr_x
ylo, yhi = y0 - ctr_y, y0 + ht - ctr_y
assert (xhi - xlo == wd), \
Exception("Width differential %d != %d" % (xhi - xlo, wd))
assert (yhi - ylo == ht), \
Exception("Height differential %d != %d" % (yhi - ylo, ht))
# fit image piece into our array, not overwriting any data
# already written
try:
if merge:
mydata[ylo:yhi, xlo:xhi, ...] += rotdata[0:ht, 0:wd, ...]
else:
idx = (mydata[ylo:yhi, xlo:xhi, ...] == 0.0)
#print idx.shape, rotdata.shape
mydata[ylo:yhi, xlo:xhi, ...][idx] = \
rotdata[0:ht, 0:wd, ...][idx]
except Exception as e:
self.logger.error("Error fitting tile: %s" % (str(e)))
raise
# TODO: recalculate min and max values
# Can't use usual techniques because it adds too much time to the
# mosacing
#self._set_minmax()
# Notify watchers that our data has changed
self.make_callback('modified')
return (xlo, ylo, xhi, yhi)
def mosaic_inline(self, imagelist, bg_ref=None, trim_px=None,
merge=False, allow_expand=True, expand_pad_deg=0.01,
max_expand_pct=None,
update_minmax=True, suppress_callback=False):
"""Drops new images into the current image (if there is room),
relocating them according the WCS between the two images.
"""
# Get our own (mosaic) rotation and scale
header = self.get_header()
((xrot_ref, yrot_ref),
(cdelt1_ref, cdelt2_ref)) = wcs.get_xy_rotation_and_scale(header)
ref_rot = yrot_ref
scale_x, scale_y = math.fabs(cdelt1_ref), math.fabs(cdelt2_ref)
# drop each image in the right place in the new data array
mydata = self._get_data()
count = 1
for image in imagelist:
name = image.get('name', 'image%d' % (count))
count += 1
data_np = image._get_data()
# Calculate sky position at the center of the piece
ctr_x, ctr_y = trcalc.get_center(data_np)
ra, dec = image.pixtoradec(ctr_x, ctr_y)
# User specified a trim? If so, trim edge pixels from each
# side of the array
ht, wd = data_np.shape[:2]
if trim_px:
xlo, xhi = trim_px, wd - trim_px
ylo, yhi = trim_px, ht - trim_px
data_np = data_np[ylo:yhi, xlo:xhi, ...]
ht, wd = data_np.shape[:2]
# If caller asked us to match background of pieces then
# get the median of this piece
if bg_ref is not None:
bg = iqcalc.get_median(data_np)
bg_inc = bg_ref - bg
#print "bg=%f inc=%f" % (bg, bg_inc)
data_np = data_np + bg_inc
# Determine max/min to update our values
if update_minmax:
maxval = numpy.nanmax(data_np)
minval = numpy.nanmin(data_np)
self.maxval = max(self.maxval, maxval)
self.minval = min(self.minval, minval)
# Get rotation and scale of piece
header = image.get_header()
((xrot, yrot),
(cdelt1, cdelt2)) = wcs.get_xy_rotation_and_scale(header)
self.logger.debug("image(%s) xrot=%f yrot=%f cdelt1=%f cdelt2=%f" % (
name, xrot, yrot, cdelt1, cdelt2))
# scale if necessary
# TODO: combine with rotation?
if (not numpy.isclose(math.fabs(cdelt1), scale_x) or
not numpy.isclose(math.fabs(cdelt2), scale_y)):
nscale_x = math.fabs(cdelt1) / scale_x
nscale_y = math.fabs(cdelt2) / scale_y
self.logger.debug("scaling piece by x(%f), y(%f)" % (
nscale_x, nscale_y))
data_np, (ascale_x, ascale_y) = trcalc.get_scaled_cutout_basic(
data_np, 0, 0, wd-1, ht-1, nscale_x, nscale_y)
# Rotate piece into our orientation, according to wcs
rot_dx, rot_dy = xrot - xrot_ref, yrot - yrot_ref
flip_x = False
flip_y = False
## # Flip X due to negative CDELT1
## if numpy.sign(cdelt1) < 0:
## flip_x = True
## # Flip Y due to negative CDELT2
## if numpy.sign(cdelt2) < 0:
## flip_y = True
# Optomization for 180 rotations
if numpy.isclose(math.fabs(rot_dx), 180.0):
flip_x = not flip_x
rot_dx = 0.0
if numpy.isclose(math.fabs(rot_dy), 180.0):
flip_y = not flip_y
rot_dy = 0.0
self.logger.debug("flip_x=%s flip_y=%s" % (flip_x, flip_y))
if flip_x or flip_y:
rotdata = trcalc.transform(data_np,
flip_x=flip_x, flip_y=flip_y)
else:
rotdata = data_np
# Finish with any necessary rotation of piece
if not numpy.isclose(rot_dy, 0.0):
rot_deg = rot_dy
self.logger.debug("rotating %s by %f deg" % (name, rot_deg))
rotdata = trcalc.rotate(rotdata, rot_deg,
#rotctr_x=ctr_x, rotctr_y=ctr_y
)
# Get size and data of new image
ht, wd = rotdata.shape[:2]
ctr_x, ctr_y = trcalc.get_center(rotdata)
# Find location of image piece (center) in our array
x0, y0 = self.radectopix(ra, dec)
# Merge piece as closely as possible into our array
# Unfortunately we lose a little precision rounding to the
# nearest pixel--can't be helped with this approach
x0, y0 = int(round(x0)), int(round(y0))
self.logger.debug("Fitting image '%s' into mosaic at %d,%d" % (
name, x0, y0))
# This is for useful debugging info only
my_ctr_x, my_ctr_y = trcalc.get_center(mydata)
off_x, off_y = x0 - my_ctr_x, y0 - my_ctr_y
self.logger.debug("centering offsets: %d,%d" % (off_x, off_y))
# Sanity check piece placement
xlo, xhi = x0 - ctr_x, x0 + wd - ctr_x
ylo, yhi = y0 - ctr_y, y0 + ht - ctr_y
assert (xhi - xlo == wd), \
Exception("Width differential %d != %d" % (xhi - xlo, wd))
assert (yhi - ylo == ht), \
Exception("Height differential %d != %d" % (yhi - ylo, ht))
mywd, myht = self.get_size()
if xlo < 0 or xhi > mywd or ylo < 0 or yhi > myht:
if not allow_expand:
raise Exception("New piece doesn't fit on image and allow_expand=False")
#<-- Resize our data array to allow the new image
# determine amount to pad expansion by
expand_x = max(int(expand_pad_deg / scale_x), 0)
expand_y = max(int(expand_pad_deg / scale_y), 0)
nx1_off, nx2_off = 0, 0
if xlo < 0:
nx1_off = abs(xlo) + expand_x
if xhi > mywd:
nx2_off = (xhi - mywd) + expand_x
xlo, xhi = xlo + nx1_off, xhi + nx1_off
ny1_off, ny2_off = 0, 0
if ylo < 0:
ny1_off = abs(ylo) + expand_y
if yhi > myht:
ny2_off = (yhi - myht) + expand_y
ylo, yhi = ylo + ny1_off, yhi + ny1_off
new_wd = mywd + nx1_off + nx2_off
new_ht = myht + ny1_off + ny2_off
# sanity check on new mosaic size
old_area = mywd * myht
new_area = new_wd * new_ht
expand_pct = new_area / old_area
if ((max_expand_pct is not None) and
(expand_pct > max_expand_pct)):
raise Exception("New area exceeds current one by %.2f %%;"
"increase max_expand_pct (%.2f) to allow" %
(expand_pct*100, max_expand_pct))
# go for it!
new_data = numpy.zeros((new_ht, new_wd))
# place current data into new data
new_data[ny1_off:ny1_off+myht, nx1_off:nx1_off+mywd] = \
mydata
self._data = new_data
mydata = new_data
if (nx1_off > 0) or (ny1_off > 0):
# Adjust our WCS for relocation of the reference pixel
crpix1, crpix2 = self.get_keywords_list('CRPIX1', 'CRPIX2')
kwds = dict(CRPIX1=crpix1 + nx1_off,
CRPIX2=crpix2 + ny1_off)
self.update_keywords(kwds)
# fit image piece into our array
try:
if merge:
mydata[ylo:yhi, xlo:xhi, ...] += rotdata[0:ht, 0:wd, ...]
else:
idx = (mydata[ylo:yhi, xlo:xhi, ...] == 0.0)
mydata[ylo:yhi, xlo:xhi, ...][idx] = \
rotdata[0:ht, 0:wd, ...][idx]
except Exception as e:
self.logger.error("Error fitting tile: %s" % (str(e)))
raise
# TODO: recalculate min and max values
# Can't use usual techniques because it adds too much time to the
# mosacing
#self._set_minmax()
# Notify watchers that our data has changed
if not suppress_callback:
self.make_callback('modified')
return (xlo, ylo, xhi, yhi)
def test_get_mean_median_nan():
arr = np.array([np.nan, np.inf])
assert np.isnan(iqcalc.get_mean(arr))
assert np.isnan(iqcalc.get_median(arr))
def test_get_mean_median(arr, ans):
assert iqcalc.get_mean(arr) == ans
assert iqcalc.get_median(arr) == ans
def prepare_mosaic(self, image, fov_deg, name=None):
"""Prepare a new (blank) mosaic image based on the pointing of
the parameter image
"""
header = image.get_header()
ra_deg, dec_deg = header['CRVAL1'], header['CRVAL2']
data_np = image.get_data()
#dtype = data_np.dtype
dtype = None
self.bg_ref = iqcalc.get_median(data_np)
# TODO: handle skew (differing rotation for each axis)?
skew_limit = self.settings.get('skew_limit', 0.1)
(rot_deg, cdelt1, cdelt2) = wcs.get_rotation_and_scale(header,
skew_threshold=skew_limit)
self.logger.debug("image0 rot=%f cdelt1=%f cdelt2=%f" % (
rot_deg, cdelt1, cdelt2))
# TODO: handle differing pixel scale for each axis?
px_scale = math.fabs(cdelt1)
cdbase = [numpy.sign(cdelt1), numpy.sign(cdelt2)]
reuse_image = self.settings.get('reuse_image', False)
if (not reuse_image) or (self.img_mosaic is None):
self.logger.debug("creating blank image to hold mosaic")
self.fv.gui_do(self._prepare_mosaic1, "Creating blank image...")
# GC old mosaic
self.img_mosaic = None
img_mosaic = dp.create_blank_image(ra_deg, dec_deg,
fov_deg, px_scale,
rot_deg,
cdbase=cdbase,
logger=self.logger,
pfx='mosaic',
dtype=dtype)
if name is not None:
img_mosaic.set(name=name)
imname = img_mosaic.get('name', image.get('name', "NoName"))
# avoid making a thumbnail of this if seed image is also that way
nothumb = not self.settings.get('make_thumbs', False)
if nothumb:
img_mosaic.set(nothumb=True)
else:
# image is not on disk, set indication for other plugins
img_mosaic.set(path=None)
# TODO: fill in interesting/select object headers from seed image
self.img_mosaic = img_mosaic
self.fv.gui_call(self.fv.add_image, imname, img_mosaic,
chname=self.mosaic_chname)
else:
# <-- reuse image (faster)
self.logger.debug("Reusing previous mosaic image")
self.fv.gui_do(self._prepare_mosaic1, "Reusing previous mosaic image...")
img_mosaic = dp.recycle_image(self.img_mosaic,
ra_deg, dec_deg,
fov_deg, px_scale,
rot_deg,
cdbase=cdbase,
logger=self.logger,
pfx='mosaic')
header = img_mosaic.get_header()
(rot, cdelt1, cdelt2) = wcs.get_rotation_and_scale(header,
skew_threshold=skew_limit)
self.logger.debug("mosaic rot=%f cdelt1=%f cdelt2=%f" % (
rot, cdelt1, cdelt2))
return img_mosaic
def test_get_mean_median_nan():
arr = np.array([np.nan, np.inf])
assert np.isnan(iqcalc.get_mean(arr))
assert np.isnan(iqcalc.get_median(arr))
def test_get_mean_median(arr, ans):
assert iqcalc.get_mean(arr) == ans
assert iqcalc.get_median(arr) == ans
def mosaic_inline(self, imagelist, bg_ref=None, trim_px=None,
merge=False):
"""Drops new images into the current image (if there is room),
relocating them according the WCS between the two images.
"""
# Get our own (mosaic) rotation and scale
header = self.get_header()
((xrot_ref, yrot_ref),
(cdelt1_ref, cdelt2_ref)) = wcs.get_xy_rotation_and_scale(header)
ref_rot = yrot_ref
scale_x, scale_y = math.fabs(cdelt1_ref), math.fabs(cdelt2_ref)
# drop each image in the right place in the new data array
mydata = self._get_data()
count = 1
for image in imagelist:
name = image.get('name', 'image%d' % (count))
count += 1
data_np = image._get_data()
# Calculate sky position at the center of the piece
ctr_x, ctr_y = trcalc.get_center(data_np)
ra, dec = image.pixtoradec(ctr_x, ctr_y)
# User specified a trim? If so, trim edge pixels from each
# side of the array
ht, wd = data_np.shape[:2]
if trim_px:
xlo, xhi = trim_px, wd - trim_px
ylo, yhi = trim_px, ht - trim_px
data_np = data_np[ylo:yhi, xlo:xhi, ...]
ht, wd = data_np.shape[:2]
# If caller asked us to match background of pieces then
# get the median of this piece
if bg_ref != None:
bg = iqcalc.get_median(data_np)
bg_inc = bg_ref - bg
#print "bg=%f inc=%f" % (bg, bg_inc)
data_np = data_np + bg_inc
# Get rotation and scale of piece
header = image.get_header()
((xrot, yrot),
(cdelt1, cdelt2)) = wcs.get_xy_rotation_and_scale(header)
self.logger.debug("image(%s) xrot=%f yrot=%f cdelt1=%f cdelt2=%f" % (
name, xrot, yrot, cdelt1, cdelt2))
# scale if necessary
# TODO: combine with rotation?
if ((math.fabs(cdelt1) != scale_x) or
(math.fabs(cdelt2) != scale_y)):
nscale_x = math.fabs(cdelt1) / scale_x
nscale_y = math.fabs(cdelt2) / scale_y
self.logger.debug("scaling piece by x(%f), y(%f)" % (
nscale_x, nscale_y))
data_np, (ascale_x, ascale_y) = trcalc.get_scaled_cutout_basic(
data_np, 0, 0, wd-1, ht-1, nscale_x, nscale_y)
# Rotate piece into our orientation, according to wcs
rot_dx, rot_dy = xrot - xrot_ref, yrot - yrot_ref
flip_x = False
flip_y = False
## # Flip X due to negative CDELT1
## if numpy.sign(cdelt1) < 0:
## flip_x = True
## # Flip Y due to negative CDELT2
## if numpy.sign(cdelt2) < 0:
## flip_y = True
# Optomization for 180 rotations
if math.fabs(rot_dx) == 180.0:
flip_x = not flip_x
rot_dx = 0.0
if math.fabs(rot_dy) == 180.0:
flip_y = not flip_y
rot_dy = 0.0
self.logger.debug("flip_x=%s flip_y=%s" % (flip_x, flip_y))
rotdata = trcalc.transform(data_np, flip_x=flip_x, flip_y=flip_y)
# Finish with any necessary rotation of piece
if rot_dy != 0.0:
rot_deg = rot_dy
self.logger.debug("rotating %s by %f deg" % (name, rot_deg))
rotdata = trcalc.rotate(rotdata, rot_deg,
#rotctr_x=ctr_x, rotctr_y=ctr_y
)
# Get size and data of new image
ht, wd = rotdata.shape[:2]
ctr_x, ctr_y = trcalc.get_center(rotdata)
# Find location of image piece (center) in our array
x0, y0 = self.radectopix(ra, dec)
# Merge piece as closely as possible into our array
# Unfortunately we lose a little precision rounding to the
# nearest pixel--can't be helped with this approach
x0, y0 = int(round(x0)), int(round(y0))
self.logger.debug("Fitting image '%s' into mosaic at %d,%d" % (
name, x0, y0))
# This is for useful debugging info only
my_ctr_x, my_ctr_y = trcalc.get_center(mydata)
off_x, off_y = x0 - my_ctr_x, y0 - my_ctr_y
self.logger.debug("centering offsets: %d,%d" % (off_x, off_y))
# Sanity check piece placement
xlo, xhi = x0 - ctr_x, x0 + wd - ctr_x
ylo, yhi = y0 - ctr_y, y0 + ht - ctr_y
assert (xhi - xlo == wd), \
Exception("Width differential %d != %d" % (xhi - xlo, wd))
assert (yhi - ylo == ht), \
Exception("Height differential %d != %d" % (yhi - ylo, ht))
# fit image piece into our array, not overwriting any data
# already written
try:
if merge:
mydata[ylo:yhi, xlo:xhi, ...] += rotdata[0:ht, 0:wd, ...]
else:
idx = (mydata[ylo:yhi, xlo:xhi, ...] == 0.0)
#print idx.shape, rotdata.shape
mydata[ylo:yhi, xlo:xhi, ...][idx] = \
rotdata[0:ht, 0:wd, ...][idx]
except Exception as e:
self.logger.error("Error fitting tile: %s" % (str(e)))
raise
# TODO: recalculate min and max values
# Can't use usual techniques because it adds too much time to the
# mosacing
#self._set_minmax()
# Notify watchers that our data has changed
self.make_callback('modified')
return (xlo, ylo, xhi, yhi)
