def _calc_cat_convex_hull(self):
"""
Calculate spherical polygon corresponding to the convex hull bounding
the sources in the catalog.
"""
if self.wcs is None or self.catalog is None:
return
x = self.catalog['x']
y = self.catalog['y']
ra, dec = convex_hull(x, y, wcs=self.wcs_pix2world)
if len(ra) == 0:
# no points
raise RuntimeError("Unexpected error: Contact sofware developer")
elif len(ra) == 1:
# one point. build a small box around it:
x, y = convex_hull(x, y, wcs=None)
xv = [x[0] - 0.5, x[0] - 0.5, x[0] + 0.5, x[0] + 0.5, x[0] - 0.5]
yv = [y[0] - 0.5, y[0] + 0.5, y[0] + 0.5, y[0] - 0.5, y[0] - 0.5]
ra, dec = self.wcs_pix2world(xv, yv)
elif len(ra) == 3:
# two points. build a small box around them:
x, y = convex_hull(x, y, wcs=None)
vx = -(y[1] - y[0])
vy = x[1] - x[0]
norm = 2.0 * np.sqrt(vx * vx + vy * vy)
vx /= norm
vy /= norm
xv = [x[0] + vx, x[1] + vx, x[1] + vx, x[0] - vx, x[0] + vx]
yv = [y[0] + vy, y[1] + vy, y[1] + vy, x[0] - vx, x[0] + vx]
ra, dec = self.wcs_pix2world(xv, yv)
# TODO: for strange reasons, occasionally ra[0] != ra[-1] and/or
# dec[0] != dec[-1] (even though we close the polygon in the
# previous two lines). Then SphericalPolygon fails because
# points are not closed. Threfore we force it to be closed:
ra[-1] = ra[0]
dec[-1] = dec[0]
self._radec = [(ra, dec)]
self._polygon = SphericalPolygon.from_radec(ra, dec)
self._poly_area = np.fabs(self._polygon.area())
def _calc_sky_orig(self, overlap=None, delta=True):
"""
Compute sky background value.
Parameters
----------
overlap : SkyImage, SkyGroup, SphericalPolygon, list of tuples, \
None, optional
Another `SkyImage`, `SkyGroup`,
:py:class:`stsci.sphere.polygons.SphericalPolygon`, or
a list of tuples of (RA, DEC) of vertices of a spherical
polygon. This parameter is used to indicate that sky statistics
should computed only in the region of intersection of *this*
image with the polygon indicated by `overlap`. When `overlap` is
`None`, sky statistics will be computed over the entire image.
delta : bool, optional
Should this function return absolute sky value or the difference
between the computed value and the value of the sky stored in the
`sky` property.
Returns
-------
skyval : float, None
Computed sky value (absolute or relative to the `sky` attribute).
If there are no valid data to perform this computations (e.g.,
because this image does not overlap with the image indicated by
`overlap`), `skyval` will be set to `None`.
npix : int
Number of pixels used to compute sky statistics.
polyarea : float
Area (in srad) of the polygon that bounds data used to compute
sky statistics.
"""
if overlap is None:
if self.mask is None:
data = self.image
else:
data = self.image[self.mask]
polyarea = self.poly_area
else:
fill_mask = np.zeros(self.image.shape, dtype=bool)
if isinstance(overlap, (SkyImage, SkyGroup, SphericalPolygon)):
intersection = self.intersection(overlap)
polyarea = np.fabs(intersection.area())
radec = intersection.to_radec()
else: # assume a list of (ra, dec) tuples:
radec = []
polyarea = 0.0
for r, d in overlap:
poly = SphericalPolygon.from_radec(r, d)
polyarea1 = np.fabs(poly.area())
if polyarea1 == 0.0 or len(r) < 4:
continue
polyarea += polyarea1
radec.append(self.intersection(poly).to_radec())
if polyarea == 0.0:
return (None, 0, 0.0)
for ra, dec in radec:
if len(ra) < 4:
continue
# set pixels in 'fill_mask' that are inside a polygon to True:
x, y = self.wcs_inv(ra, dec, 0)
poly_vert = list(zip(*[x, y]))
polygon = region.Polygon(True, poly_vert)
fill_mask = polygon.scan(fill_mask)
if self.mask is not None:
fill_mask &= self.mask
data = self.image[fill_mask]
if data.size < 1:
return (None, 0, 0.0)
# Calculate sky
try:
skyval, npix = self._skystat(data)
except ValueError:
return (None, 0, 0.0)
if delta:
skyval -= self._sky
return skyval, npix, polyarea
def calc_bounding_polygon(self, stepsize=None):
""" Compute image's bounding polygon.
Parameters
----------
stepsize : int, None, optional
Indicates the maximum separation between two adjacent vertices
of the bounding polygon along each side of the image. Corners
of the image are included automatically. If `stepsize` is `None`,
bounding polygon will contain only vertices of the image.
"""
ny, nx = self.image.shape
if stepsize is None:
nintx = 2
ninty = 2
else:
nintx = max(2, int(np.ceil((nx + 1.0) / stepsize)))
ninty = max(2, int(np.ceil((ny + 1.0) / stepsize)))
xs = np.linspace(-0.5, nx - 0.5, nintx, dtype=np.float)
ys = np.linspace(-0.5, ny - 0.5, ninty, dtype=np.float)[1:-1]
nptx = xs.size
npty = ys.size
npts = 2 * (nptx + npty)
borderx = np.empty((npts + 1,), dtype=np.float)
bordery = np.empty((npts + 1,), dtype=np.float)
# "bottom" points:
borderx[:nptx] = xs
bordery[:nptx] = -0.5
# "right"
sl = np.s_[nptx:nptx + npty]
borderx[sl] = nx - 0.5
bordery[sl] = ys
# "top"
sl = np.s_[nptx + npty:2 * nptx + npty]
borderx[sl] = xs[::-1]
bordery[sl] = ny - 0.5
# "left"
sl = np.s_[2 * nptx + npty:-1]
borderx[sl] = -0.5
bordery[sl] = ys[::-1]
# close polygon:
borderx[-1] = borderx[0]
bordery[-1] = bordery[0]
ra, dec = self.wcs_fwd(borderx, bordery, 0)
# TODO: for strange reasons, occasionally ra[0] != ra[-1] and/or
# dec[0] != dec[-1] (even though we close the polygon in the
# previous two lines). Then SphericalPolygon fails because
# points are not closed. Threfore we force it to be closed:
ra[-1] = ra[0]
dec[-1] = dec[0]
self._radec = [(ra, dec)]
self._polygon = SphericalPolygon.from_radec(ra, dec)
self._poly_area = np.fabs(self._polygon.area())
def _calc_sky_orig(self, overlap=None, delta=True):
"""
Compute sky background value.
Parameters
----------
overlap : SkyImage, SkyGroup, SphericalPolygon, list of tuples, \
None, optional
Another `SkyImage`, `SkyGroup`,
:py:class:`stsci.sphere.polygons.SphericalPolygon`, or
a list of tuples of (RA, DEC) of vertices of a spherical
polygon. This parameter is used to indicate that sky statistics
should computed only in the region of intersection of *this*
image with the polygon indicated by `overlap`. When `overlap` is
`None`, sky statistics will be computed over the entire image.
delta : bool, optional
Should this function return absolute sky value or the difference
between the computed value and the value of the sky stored in the
`sky` property.
Returns
-------
skyval : float, None
Computed sky value (absolute or relative to the `sky` attribute).
If there are no valid data to perform this computations (e.g.,
because this image does not overlap with the image indicated by
`overlap`), `skyval` will be set to `None`.
npix : int
Number of pixels used to compute sky statistics.
polyarea : float
Area (in srad) of the polygon that bounds data used to compute
sky statistics.
"""
if overlap is None:
if self.mask is None:
data = self.image
else:
data = self.image[self.mask]
polyarea = self.poly_area
else:
fill_mask = np.zeros(self.image.shape, dtype=bool)
if isinstance(overlap, (SkyImage, SkyGroup, SphericalPolygon)):
intersection = self.intersection(overlap)
polyarea = np.fabs(intersection.area())
radec = intersection.to_radec()
else: # assume a list of (ra, dec) tuples:
radec = []
polyarea = 0.0
for r, d in overlap:
poly = SphericalPolygon.from_radec(r, d)
polyarea1 = np.fabs(poly.area())
if polyarea1 == 0.0 or len(r) < 4:
continue
polyarea += polyarea1
radec.append(self.intersection(poly).to_radec())
if polyarea == 0.0:
return (None, 0, 0.0)
for ra, dec in radec:
if len(ra) < 4:
continue
# set pixels in 'fill_mask' that are inside a polygon to True:
x, y = self.wcs_inv(ra, dec, 0)
poly_vert = list(zip(*[x, y]))
polygon = region.Polygon(True, poly_vert)
fill_mask = polygon.scan(fill_mask)
if self.mask is not None:
fill_mask &= self.mask
data = self.image[fill_mask]
if data.size < 1:
return (None, 0, 0.0)
# Calculate sky
try:
skyval, npix = self._skystat(data)
except ValueError:
return (None, 0, 0.0)
if delta:
skyval -= self._sky
return skyval, npix, polyarea
def calc_bounding_polygon(self, stepsize=None):
""" Compute image's bounding polygon.
Parameters
----------
stepsize : int, None, optional
Indicates the maximum separation between two adjacent vertices
of the bounding polygon along each side of the image. Corners
of the image are included automatically. If `stepsize` is `None`,
bounding polygon will contain only vertices of the image.
"""
ny, nx = self.image.shape
if stepsize == None:
nintx = 2
ninty = 2
else:
nintx = max(2, int(np.ceil((nx + 1.0) / stepsize)))
ninty = max(2, int(np.ceil((ny + 1.0) / stepsize)))
xs = np.linspace(-0.5, nx - 0.5, nintx, dtype=np.float)
ys = np.linspace(-0.5, ny - 0.5, ninty, dtype=np.float)[1:-1]
nptx = xs.size
npty = ys.size
npts = 2 * (nptx + npty)
borderx = np.empty((npts + 1, ), dtype=np.float)
bordery = np.empty((npts + 1, ), dtype=np.float)
# "bottom" points:
borderx[:nptx] = xs
bordery[:nptx] = -0.5
# "right"
sl = np.s_[nptx:nptx + npty]
borderx[sl] = nx - 0.5
bordery[sl] = ys
# "top"
sl = np.s_[nptx + npty:2 * nptx + npty]
borderx[sl] = xs[::-1]
bordery[sl] = ny - 0.5
# "left"
sl = np.s_[2 * nptx + npty:-1]
borderx[sl] = -0.5
bordery[sl] = ys[::-1]
# close polygon:
borderx[-1] = borderx[0]
bordery[-1] = bordery[0]
ra, dec = self.wcs_fwd(borderx, bordery, 0)
# TODO: for strange reasons, occasionally ra[0] != ra[-1] and/or
# dec[0] != dec[-1] (even though we close the polygon in the
# previous two lines). Then SphericalPolygon fails because
# points are not closed. Threfore we force it to be closed:
ra[-1] = ra[0]
dec[-1] = dec[0]
self._radec = [(ra, dec)]
self._polygon = SphericalPolygon.from_radec(ra, dec)
self._poly_area = np.fabs(self._polygon.area())