repository_name stringlengths 5 67 | func_path_in_repository stringlengths 4 234 | func_name stringlengths 0 314 | whole_func_string stringlengths 52 3.87M | language stringclasses 6 values | func_code_string stringlengths 52 3.87M | func_code_tokens listlengths 15 672k | func_documentation_string stringlengths 1 47.2k | func_documentation_tokens listlengths 1 3.92k | split_name stringclasses 1 value | func_code_url stringlengths 85 339 |
|---|---|---|---|---|---|---|---|---|---|---|
PaulHancock/Aegean | AegeanTools/regions.py | Region.sky_within | def sky_within(self, ra, dec, degin=False):
"""
Test whether a sky position is within this region
Parameters
----------
ra, dec : float
Sky position.
degin : bool
If True the ra/dec is interpreted as degrees, otherwise as radians.
Default = False.
Returns
-------
within : bool
True if the given position is within one of the region's pixels.
"""
sky = self.radec2sky(ra, dec)
if degin:
sky = np.radians(sky)
theta_phi = self.sky2ang(sky)
# Set values that are nan to be zero and record a mask
mask = np.bitwise_not(np.logical_and.reduce(np.isfinite(theta_phi), axis=1))
theta_phi[mask, :] = 0
theta, phi = theta_phi.transpose()
pix = hp.ang2pix(2**self.maxdepth, theta, phi, nest=True)
pixelset = self.get_demoted()
result = np.in1d(pix, list(pixelset))
# apply the mask and set the shonky values to False
result[mask] = False
return result | python | def sky_within(self, ra, dec, degin=False):
"""
Test whether a sky position is within this region
Parameters
----------
ra, dec : float
Sky position.
degin : bool
If True the ra/dec is interpreted as degrees, otherwise as radians.
Default = False.
Returns
-------
within : bool
True if the given position is within one of the region's pixels.
"""
sky = self.radec2sky(ra, dec)
if degin:
sky = np.radians(sky)
theta_phi = self.sky2ang(sky)
# Set values that are nan to be zero and record a mask
mask = np.bitwise_not(np.logical_and.reduce(np.isfinite(theta_phi), axis=1))
theta_phi[mask, :] = 0
theta, phi = theta_phi.transpose()
pix = hp.ang2pix(2**self.maxdepth, theta, phi, nest=True)
pixelset = self.get_demoted()
result = np.in1d(pix, list(pixelset))
# apply the mask and set the shonky values to False
result[mask] = False
return result | [
"def",
"sky_within",
"(",
"self",
",",
"ra",
",",
"dec",
",",
"degin",
"=",
"False",
")",
":",
"sky",
"=",
"self",
".",
"radec2sky",
"(",
"ra",
",",
"dec",
")",
"if",
"degin",
":",
"sky",
"=",
"np",
".",
"radians",
"(",
"sky",
")",
"theta_phi",
... | Test whether a sky position is within this region
Parameters
----------
ra, dec : float
Sky position.
degin : bool
If True the ra/dec is interpreted as degrees, otherwise as radians.
Default = False.
Returns
-------
within : bool
True if the given position is within one of the region's pixels. | [
"Test",
"whether",
"a",
"sky",
"position",
"is",
"within",
"this",
"region"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L223-L257 |
PaulHancock/Aegean | AegeanTools/regions.py | Region.union | def union(self, other, renorm=True):
"""
Add another Region by performing union on their pixlists.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
renorm : bool
Perform renormalisation after the operation?
Default = True.
"""
# merge the pixels that are common to both
for d in range(1, min(self.maxdepth, other.maxdepth)+1):
self.add_pixels(other.pixeldict[d], d)
# if the other region is at higher resolution, then include a degraded version of the remaining pixels.
if self.maxdepth < other.maxdepth:
for d in range(self.maxdepth+1, other.maxdepth+1):
for p in other.pixeldict[d]:
# promote this pixel to self.maxdepth
pp = p/4**(d-self.maxdepth)
self.pixeldict[self.maxdepth].add(pp)
if renorm:
self._renorm()
return | python | def union(self, other, renorm=True):
"""
Add another Region by performing union on their pixlists.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
renorm : bool
Perform renormalisation after the operation?
Default = True.
"""
# merge the pixels that are common to both
for d in range(1, min(self.maxdepth, other.maxdepth)+1):
self.add_pixels(other.pixeldict[d], d)
# if the other region is at higher resolution, then include a degraded version of the remaining pixels.
if self.maxdepth < other.maxdepth:
for d in range(self.maxdepth+1, other.maxdepth+1):
for p in other.pixeldict[d]:
# promote this pixel to self.maxdepth
pp = p/4**(d-self.maxdepth)
self.pixeldict[self.maxdepth].add(pp)
if renorm:
self._renorm()
return | [
"def",
"union",
"(",
"self",
",",
"other",
",",
"renorm",
"=",
"True",
")",
":",
"# merge the pixels that are common to both",
"for",
"d",
"in",
"range",
"(",
"1",
",",
"min",
"(",
"self",
".",
"maxdepth",
",",
"other",
".",
"maxdepth",
")",
"+",
"1",
... | Add another Region by performing union on their pixlists.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
renorm : bool
Perform renormalisation after the operation?
Default = True. | [
"Add",
"another",
"Region",
"by",
"performing",
"union",
"on",
"their",
"pixlists",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L259-L285 |
PaulHancock/Aegean | AegeanTools/regions.py | Region.without | def without(self, other):
"""
Subtract another Region by performing a difference operation on their pixlists.
Requires both regions to have the same maxdepth.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
"""
# work only on the lowest level
# TODO: Allow this to be done for regions with different depths.
if not (self.maxdepth == other.maxdepth): raise AssertionError("Regions must have the same maxdepth")
self._demote_all()
opd = set(other.get_demoted())
self.pixeldict[self.maxdepth].difference_update(opd)
self._renorm()
return | python | def without(self, other):
"""
Subtract another Region by performing a difference operation on their pixlists.
Requires both regions to have the same maxdepth.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
"""
# work only on the lowest level
# TODO: Allow this to be done for regions with different depths.
if not (self.maxdepth == other.maxdepth): raise AssertionError("Regions must have the same maxdepth")
self._demote_all()
opd = set(other.get_demoted())
self.pixeldict[self.maxdepth].difference_update(opd)
self._renorm()
return | [
"def",
"without",
"(",
"self",
",",
"other",
")",
":",
"# work only on the lowest level",
"# TODO: Allow this to be done for regions with different depths.",
"if",
"not",
"(",
"self",
".",
"maxdepth",
"==",
"other",
".",
"maxdepth",
")",
":",
"raise",
"AssertionError",
... | Subtract another Region by performing a difference operation on their pixlists.
Requires both regions to have the same maxdepth.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined. | [
"Subtract",
"another",
"Region",
"by",
"performing",
"a",
"difference",
"operation",
"on",
"their",
"pixlists",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L287-L305 |
PaulHancock/Aegean | AegeanTools/regions.py | Region.intersect | def intersect(self, other):
"""
Combine with another Region by performing intersection on their pixlists.
Requires both regions to have the same maxdepth.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
"""
# work only on the lowest level
# TODO: Allow this to be done for regions with different depths.
if not (self.maxdepth == other.maxdepth): raise AssertionError("Regions must have the same maxdepth")
self._demote_all()
opd = set(other.get_demoted())
self.pixeldict[self.maxdepth].intersection_update(opd)
self._renorm()
return | python | def intersect(self, other):
"""
Combine with another Region by performing intersection on their pixlists.
Requires both regions to have the same maxdepth.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
"""
# work only on the lowest level
# TODO: Allow this to be done for regions with different depths.
if not (self.maxdepth == other.maxdepth): raise AssertionError("Regions must have the same maxdepth")
self._demote_all()
opd = set(other.get_demoted())
self.pixeldict[self.maxdepth].intersection_update(opd)
self._renorm()
return | [
"def",
"intersect",
"(",
"self",
",",
"other",
")",
":",
"# work only on the lowest level",
"# TODO: Allow this to be done for regions with different depths.",
"if",
"not",
"(",
"self",
".",
"maxdepth",
"==",
"other",
".",
"maxdepth",
")",
":",
"raise",
"AssertionError"... | Combine with another Region by performing intersection on their pixlists.
Requires both regions to have the same maxdepth.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined. | [
"Combine",
"with",
"another",
"Region",
"by",
"performing",
"intersection",
"on",
"their",
"pixlists",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L307-L325 |
PaulHancock/Aegean | AegeanTools/regions.py | Region.symmetric_difference | def symmetric_difference(self, other):
"""
Combine with another Region by performing the symmetric difference of their pixlists.
Requires both regions to have the same maxdepth.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
"""
# work only on the lowest level
# TODO: Allow this to be done for regions with different depths.
if not (self.maxdepth == other.maxdepth): raise AssertionError("Regions must have the same maxdepth")
self._demote_all()
opd = set(other.get_demoted())
self.pixeldict[self.maxdepth].symmetric_difference_update(opd)
self._renorm()
return | python | def symmetric_difference(self, other):
"""
Combine with another Region by performing the symmetric difference of their pixlists.
Requires both regions to have the same maxdepth.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined.
"""
# work only on the lowest level
# TODO: Allow this to be done for regions with different depths.
if not (self.maxdepth == other.maxdepth): raise AssertionError("Regions must have the same maxdepth")
self._demote_all()
opd = set(other.get_demoted())
self.pixeldict[self.maxdepth].symmetric_difference_update(opd)
self._renorm()
return | [
"def",
"symmetric_difference",
"(",
"self",
",",
"other",
")",
":",
"# work only on the lowest level",
"# TODO: Allow this to be done for regions with different depths.",
"if",
"not",
"(",
"self",
".",
"maxdepth",
"==",
"other",
".",
"maxdepth",
")",
":",
"raise",
"Asse... | Combine with another Region by performing the symmetric difference of their pixlists.
Requires both regions to have the same maxdepth.
Parameters
----------
other : :class:`AegeanTools.regions.Region`
The region to be combined. | [
"Combine",
"with",
"another",
"Region",
"by",
"performing",
"the",
"symmetric",
"difference",
"of",
"their",
"pixlists",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L327-L345 |
PaulHancock/Aegean | AegeanTools/regions.py | Region.write_reg | def write_reg(self, filename):
"""
Write a ds9 region file that represents this region as a set of diamonds.
Parameters
----------
filename : str
File to write
"""
with open(filename, 'w') as out:
for d in range(1, self.maxdepth+1):
for p in self.pixeldict[d]:
line = "fk5; polygon("
# the following int() gets around some problems with np.int64 that exist prior to numpy v 1.8.1
vectors = list(zip(*hp.boundaries(2**d, int(p), step=1, nest=True)))
positions = []
for sky in self.vec2sky(np.array(vectors), degrees=True):
ra, dec = sky
pos = SkyCoord(ra/15, dec, unit=(u.degree, u.degree))
positions.append(pos.ra.to_string(sep=':', precision=2))
positions.append(pos.dec.to_string(sep=':', precision=2))
line += ','.join(positions)
line += ")"
print(line, file=out)
return | python | def write_reg(self, filename):
"""
Write a ds9 region file that represents this region as a set of diamonds.
Parameters
----------
filename : str
File to write
"""
with open(filename, 'w') as out:
for d in range(1, self.maxdepth+1):
for p in self.pixeldict[d]:
line = "fk5; polygon("
# the following int() gets around some problems with np.int64 that exist prior to numpy v 1.8.1
vectors = list(zip(*hp.boundaries(2**d, int(p), step=1, nest=True)))
positions = []
for sky in self.vec2sky(np.array(vectors), degrees=True):
ra, dec = sky
pos = SkyCoord(ra/15, dec, unit=(u.degree, u.degree))
positions.append(pos.ra.to_string(sep=':', precision=2))
positions.append(pos.dec.to_string(sep=':', precision=2))
line += ','.join(positions)
line += ")"
print(line, file=out)
return | [
"def",
"write_reg",
"(",
"self",
",",
"filename",
")",
":",
"with",
"open",
"(",
"filename",
",",
"'w'",
")",
"as",
"out",
":",
"for",
"d",
"in",
"range",
"(",
"1",
",",
"self",
".",
"maxdepth",
"+",
"1",
")",
":",
"for",
"p",
"in",
"self",
"."... | Write a ds9 region file that represents this region as a set of diamonds.
Parameters
----------
filename : str
File to write | [
"Write",
"a",
"ds9",
"region",
"file",
"that",
"represents",
"this",
"region",
"as",
"a",
"set",
"of",
"diamonds",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L347-L371 |
PaulHancock/Aegean | AegeanTools/regions.py | Region.write_fits | def write_fits(self, filename, moctool=''):
"""
Write a fits file representing the MOC of this region.
Parameters
----------
filename : str
File to write
moctool : str
String to be written to fits header with key "MOCTOOL".
Default = ''
"""
datafile = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'MOC.fits')
hdulist = fits.open(datafile)
cols = fits.Column(name='NPIX', array=self._uniq(), format='1K')
tbhdu = fits.BinTableHDU.from_columns([cols])
hdulist[1] = tbhdu
hdulist[1].header['PIXTYPE'] = ('HEALPIX ', 'HEALPix magic code')
hdulist[1].header['ORDERING'] = ('NUNIQ ', 'NUNIQ coding method')
hdulist[1].header['COORDSYS'] = ('C ', 'ICRS reference frame')
hdulist[1].header['MOCORDER'] = (self.maxdepth, 'MOC resolution (best order)')
hdulist[1].header['MOCTOOL'] = (moctool, 'Name of the MOC generator')
hdulist[1].header['MOCTYPE'] = ('CATALOG', 'Source type (IMAGE or CATALOG)')
hdulist[1].header['MOCID'] = (' ', 'Identifier of the collection')
hdulist[1].header['ORIGIN'] = (' ', 'MOC origin')
time = datetime.datetime.utcnow()
hdulist[1].header['DATE'] = (datetime.datetime.strftime(time, format="%Y-%m-%dT%H:%m:%SZ"), 'MOC creation date')
hdulist.writeto(filename, overwrite=True)
return | python | def write_fits(self, filename, moctool=''):
"""
Write a fits file representing the MOC of this region.
Parameters
----------
filename : str
File to write
moctool : str
String to be written to fits header with key "MOCTOOL".
Default = ''
"""
datafile = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'MOC.fits')
hdulist = fits.open(datafile)
cols = fits.Column(name='NPIX', array=self._uniq(), format='1K')
tbhdu = fits.BinTableHDU.from_columns([cols])
hdulist[1] = tbhdu
hdulist[1].header['PIXTYPE'] = ('HEALPIX ', 'HEALPix magic code')
hdulist[1].header['ORDERING'] = ('NUNIQ ', 'NUNIQ coding method')
hdulist[1].header['COORDSYS'] = ('C ', 'ICRS reference frame')
hdulist[1].header['MOCORDER'] = (self.maxdepth, 'MOC resolution (best order)')
hdulist[1].header['MOCTOOL'] = (moctool, 'Name of the MOC generator')
hdulist[1].header['MOCTYPE'] = ('CATALOG', 'Source type (IMAGE or CATALOG)')
hdulist[1].header['MOCID'] = (' ', 'Identifier of the collection')
hdulist[1].header['ORIGIN'] = (' ', 'MOC origin')
time = datetime.datetime.utcnow()
hdulist[1].header['DATE'] = (datetime.datetime.strftime(time, format="%Y-%m-%dT%H:%m:%SZ"), 'MOC creation date')
hdulist.writeto(filename, overwrite=True)
return | [
"def",
"write_fits",
"(",
"self",
",",
"filename",
",",
"moctool",
"=",
"''",
")",
":",
"datafile",
"=",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"__file__",
")",
")",
",... | Write a fits file representing the MOC of this region.
Parameters
----------
filename : str
File to write
moctool : str
String to be written to fits header with key "MOCTOOL".
Default = '' | [
"Write",
"a",
"fits",
"file",
"representing",
"the",
"MOC",
"of",
"this",
"region",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L373-L402 |
PaulHancock/Aegean | AegeanTools/regions.py | Region._uniq | def _uniq(self):
"""
Create a list of all the pixels that cover this region.
This list contains overlapping pixels of different orders.
Returns
-------
pix : list
A list of HEALPix pixel numbers.
"""
pd = []
for d in range(1, self.maxdepth):
pd.extend(map(lambda x: int(4**(d+1) + x), self.pixeldict[d]))
return sorted(pd) | python | def _uniq(self):
"""
Create a list of all the pixels that cover this region.
This list contains overlapping pixels of different orders.
Returns
-------
pix : list
A list of HEALPix pixel numbers.
"""
pd = []
for d in range(1, self.maxdepth):
pd.extend(map(lambda x: int(4**(d+1) + x), self.pixeldict[d]))
return sorted(pd) | [
"def",
"_uniq",
"(",
"self",
")",
":",
"pd",
"=",
"[",
"]",
"for",
"d",
"in",
"range",
"(",
"1",
",",
"self",
".",
"maxdepth",
")",
":",
"pd",
".",
"extend",
"(",
"map",
"(",
"lambda",
"x",
":",
"int",
"(",
"4",
"**",
"(",
"d",
"+",
"1",
... | Create a list of all the pixels that cover this region.
This list contains overlapping pixels of different orders.
Returns
-------
pix : list
A list of HEALPix pixel numbers. | [
"Create",
"a",
"list",
"of",
"all",
"the",
"pixels",
"that",
"cover",
"this",
"region",
".",
"This",
"list",
"contains",
"overlapping",
"pixels",
"of",
"different",
"orders",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L404-L417 |
PaulHancock/Aegean | AegeanTools/regions.py | Region.radec2sky | def radec2sky(ra, dec):
"""
Convert [ra], [dec] to [(ra[0], dec[0]),....]
and also ra,dec to [(ra,dec)] if ra/dec are not iterable
Parameters
----------
ra, dec : float or iterable
Sky coordinates
Returns
-------
sky : numpy.array
array of (ra,dec) coordinates.
"""
try:
sky = np.array(list(zip(ra, dec)))
except TypeError:
sky = np.array([(ra, dec)])
return sky | python | def radec2sky(ra, dec):
"""
Convert [ra], [dec] to [(ra[0], dec[0]),....]
and also ra,dec to [(ra,dec)] if ra/dec are not iterable
Parameters
----------
ra, dec : float or iterable
Sky coordinates
Returns
-------
sky : numpy.array
array of (ra,dec) coordinates.
"""
try:
sky = np.array(list(zip(ra, dec)))
except TypeError:
sky = np.array([(ra, dec)])
return sky | [
"def",
"radec2sky",
"(",
"ra",
",",
"dec",
")",
":",
"try",
":",
"sky",
"=",
"np",
".",
"array",
"(",
"list",
"(",
"zip",
"(",
"ra",
",",
"dec",
")",
")",
")",
"except",
"TypeError",
":",
"sky",
"=",
"np",
".",
"array",
"(",
"[",
"(",
"ra",
... | Convert [ra], [dec] to [(ra[0], dec[0]),....]
and also ra,dec to [(ra,dec)] if ra/dec are not iterable
Parameters
----------
ra, dec : float or iterable
Sky coordinates
Returns
-------
sky : numpy.array
array of (ra,dec) coordinates. | [
"Convert",
"[",
"ra",
"]",
"[",
"dec",
"]",
"to",
"[",
"(",
"ra",
"[",
"0",
"]",
"dec",
"[",
"0",
"]",
")",
"....",
"]",
"and",
"also",
"ra",
"dec",
"to",
"[",
"(",
"ra",
"dec",
")",
"]",
"if",
"ra",
"/",
"dec",
"are",
"not",
"iterable"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L420-L439 |
PaulHancock/Aegean | AegeanTools/regions.py | Region.sky2ang | def sky2ang(sky):
"""
Convert ra,dec coordinates to theta,phi coordinates
ra -> phi
dec -> theta
Parameters
----------
sky : numpy.array
Array of (ra,dec) coordinates.
See :func:`AegeanTools.regions.Region.radec2sky`
Returns
-------
theta_phi : numpy.array
Array of (theta,phi) coordinates.
"""
try:
theta_phi = sky.copy()
except AttributeError as _:
theta_phi = np.array(sky)
theta_phi[:, [1, 0]] = theta_phi[:, [0, 1]]
theta_phi[:, 0] = np.pi/2 - theta_phi[:, 0]
# # force 0<=theta<=2pi
# theta_phi[:, 0] -= 2*np.pi*(theta_phi[:, 0]//(2*np.pi))
# # and now -pi<=theta<=pi
# theta_phi[:, 0] -= (theta_phi[:, 0] > np.pi)*2*np.pi
return theta_phi | python | def sky2ang(sky):
"""
Convert ra,dec coordinates to theta,phi coordinates
ra -> phi
dec -> theta
Parameters
----------
sky : numpy.array
Array of (ra,dec) coordinates.
See :func:`AegeanTools.regions.Region.radec2sky`
Returns
-------
theta_phi : numpy.array
Array of (theta,phi) coordinates.
"""
try:
theta_phi = sky.copy()
except AttributeError as _:
theta_phi = np.array(sky)
theta_phi[:, [1, 0]] = theta_phi[:, [0, 1]]
theta_phi[:, 0] = np.pi/2 - theta_phi[:, 0]
# # force 0<=theta<=2pi
# theta_phi[:, 0] -= 2*np.pi*(theta_phi[:, 0]//(2*np.pi))
# # and now -pi<=theta<=pi
# theta_phi[:, 0] -= (theta_phi[:, 0] > np.pi)*2*np.pi
return theta_phi | [
"def",
"sky2ang",
"(",
"sky",
")",
":",
"try",
":",
"theta_phi",
"=",
"sky",
".",
"copy",
"(",
")",
"except",
"AttributeError",
"as",
"_",
":",
"theta_phi",
"=",
"np",
".",
"array",
"(",
"sky",
")",
"theta_phi",
"[",
":",
",",
"[",
"1",
",",
"0",... | Convert ra,dec coordinates to theta,phi coordinates
ra -> phi
dec -> theta
Parameters
----------
sky : numpy.array
Array of (ra,dec) coordinates.
See :func:`AegeanTools.regions.Region.radec2sky`
Returns
-------
theta_phi : numpy.array
Array of (theta,phi) coordinates. | [
"Convert",
"ra",
"dec",
"coordinates",
"to",
"theta",
"phi",
"coordinates",
"ra",
"-",
">",
"phi",
"dec",
"-",
">",
"theta"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L442-L469 |
PaulHancock/Aegean | AegeanTools/regions.py | Region.sky2vec | def sky2vec(cls, sky):
"""
Convert sky positions in to 3d-vectors on the unit sphere.
Parameters
----------
sky : numpy.array
Sky coordinates as an array of (ra,dec)
Returns
-------
vec : numpy.array
Unit vectors as an array of (x,y,z)
See Also
--------
:func:`AegeanTools.regions.Region.vec2sky`
"""
theta_phi = cls.sky2ang(sky)
theta, phi = map(np.array, list(zip(*theta_phi)))
vec = hp.ang2vec(theta, phi)
return vec | python | def sky2vec(cls, sky):
"""
Convert sky positions in to 3d-vectors on the unit sphere.
Parameters
----------
sky : numpy.array
Sky coordinates as an array of (ra,dec)
Returns
-------
vec : numpy.array
Unit vectors as an array of (x,y,z)
See Also
--------
:func:`AegeanTools.regions.Region.vec2sky`
"""
theta_phi = cls.sky2ang(sky)
theta, phi = map(np.array, list(zip(*theta_phi)))
vec = hp.ang2vec(theta, phi)
return vec | [
"def",
"sky2vec",
"(",
"cls",
",",
"sky",
")",
":",
"theta_phi",
"=",
"cls",
".",
"sky2ang",
"(",
"sky",
")",
"theta",
",",
"phi",
"=",
"map",
"(",
"np",
".",
"array",
",",
"list",
"(",
"zip",
"(",
"*",
"theta_phi",
")",
")",
")",
"vec",
"=",
... | Convert sky positions in to 3d-vectors on the unit sphere.
Parameters
----------
sky : numpy.array
Sky coordinates as an array of (ra,dec)
Returns
-------
vec : numpy.array
Unit vectors as an array of (x,y,z)
See Also
--------
:func:`AegeanTools.regions.Region.vec2sky` | [
"Convert",
"sky",
"positions",
"in",
"to",
"3d",
"-",
"vectors",
"on",
"the",
"unit",
"sphere",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L472-L493 |
PaulHancock/Aegean | AegeanTools/regions.py | Region.vec2sky | def vec2sky(cls, vec, degrees=False):
"""
Convert [x,y,z] vectors into sky coordinates ra,dec
Parameters
----------
vec : numpy.array
Unit vectors as an array of (x,y,z)
degrees
Returns
-------
sky : numpy.array
Sky coordinates as an array of (ra,dec)
See Also
--------
:func:`AegeanTools.regions.Region.sky2vec`
"""
theta, phi = hp.vec2ang(vec)
ra = phi
dec = np.pi/2-theta
if degrees:
ra = np.degrees(ra)
dec = np.degrees(dec)
return cls.radec2sky(ra, dec) | python | def vec2sky(cls, vec, degrees=False):
"""
Convert [x,y,z] vectors into sky coordinates ra,dec
Parameters
----------
vec : numpy.array
Unit vectors as an array of (x,y,z)
degrees
Returns
-------
sky : numpy.array
Sky coordinates as an array of (ra,dec)
See Also
--------
:func:`AegeanTools.regions.Region.sky2vec`
"""
theta, phi = hp.vec2ang(vec)
ra = phi
dec = np.pi/2-theta
if degrees:
ra = np.degrees(ra)
dec = np.degrees(dec)
return cls.radec2sky(ra, dec) | [
"def",
"vec2sky",
"(",
"cls",
",",
"vec",
",",
"degrees",
"=",
"False",
")",
":",
"theta",
",",
"phi",
"=",
"hp",
".",
"vec2ang",
"(",
"vec",
")",
"ra",
"=",
"phi",
"dec",
"=",
"np",
".",
"pi",
"/",
"2",
"-",
"theta",
"if",
"degrees",
":",
"r... | Convert [x,y,z] vectors into sky coordinates ra,dec
Parameters
----------
vec : numpy.array
Unit vectors as an array of (x,y,z)
degrees
Returns
-------
sky : numpy.array
Sky coordinates as an array of (ra,dec)
See Also
--------
:func:`AegeanTools.regions.Region.sky2vec` | [
"Convert",
"[",
"x",
"y",
"z",
"]",
"vectors",
"into",
"sky",
"coordinates",
"ra",
"dec"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/regions.py#L496-L523 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.from_header | def from_header(cls, header, beam=None, lat=None):
"""
Create a new WCSHelper class from the given header.
Parameters
----------
header : `astropy.fits.HDUHeader` or string
The header to be used to create the WCS helper
beam : :class:`AegeanTools.fits_image.Beam` or None
The synthesized beam. If the supplied beam is None then one is constructed form the header.
lat : float
The latitude of the telescope.
Returns
-------
obj : :class:`AegeanTools.wcs_helpers.WCSHelper`
A helper object.
"""
try:
wcs = pywcs.WCS(header, naxis=2)
except: # TODO: figure out what error is being thrown
wcs = pywcs.WCS(str(header), naxis=2)
if beam is None:
beam = get_beam(header)
else:
beam = beam
if beam is None:
logging.critical("Cannot determine beam information")
_, pixscale = get_pixinfo(header)
refpix = (header['CRPIX1'], header['CRPIX2'])
return cls(wcs, beam, pixscale, refpix, lat) | python | def from_header(cls, header, beam=None, lat=None):
"""
Create a new WCSHelper class from the given header.
Parameters
----------
header : `astropy.fits.HDUHeader` or string
The header to be used to create the WCS helper
beam : :class:`AegeanTools.fits_image.Beam` or None
The synthesized beam. If the supplied beam is None then one is constructed form the header.
lat : float
The latitude of the telescope.
Returns
-------
obj : :class:`AegeanTools.wcs_helpers.WCSHelper`
A helper object.
"""
try:
wcs = pywcs.WCS(header, naxis=2)
except: # TODO: figure out what error is being thrown
wcs = pywcs.WCS(str(header), naxis=2)
if beam is None:
beam = get_beam(header)
else:
beam = beam
if beam is None:
logging.critical("Cannot determine beam information")
_, pixscale = get_pixinfo(header)
refpix = (header['CRPIX1'], header['CRPIX2'])
return cls(wcs, beam, pixscale, refpix, lat) | [
"def",
"from_header",
"(",
"cls",
",",
"header",
",",
"beam",
"=",
"None",
",",
"lat",
"=",
"None",
")",
":",
"try",
":",
"wcs",
"=",
"pywcs",
".",
"WCS",
"(",
"header",
",",
"naxis",
"=",
"2",
")",
"except",
":",
"# TODO: figure out what error is bein... | Create a new WCSHelper class from the given header.
Parameters
----------
header : `astropy.fits.HDUHeader` or string
The header to be used to create the WCS helper
beam : :class:`AegeanTools.fits_image.Beam` or None
The synthesized beam. If the supplied beam is None then one is constructed form the header.
lat : float
The latitude of the telescope.
Returns
-------
obj : :class:`AegeanTools.wcs_helpers.WCSHelper`
A helper object. | [
"Create",
"a",
"new",
"WCSHelper",
"class",
"from",
"the",
"given",
"header",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L62-L97 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.from_file | def from_file(cls, filename, beam=None):
"""
Create a new WCSHelper class from a given fits file.
Parameters
----------
filename : string
The file to be read
beam : :class:`AegeanTools.fits_image.Beam` or None
The synthesized beam. If the supplied beam is None then one is constructed form the header.
Returns
-------
obj : :class:`AegeanTools.wcs_helpers.WCSHelper`
A helper object
"""
header = fits.getheader(filename)
return cls.from_header(header, beam) | python | def from_file(cls, filename, beam=None):
"""
Create a new WCSHelper class from a given fits file.
Parameters
----------
filename : string
The file to be read
beam : :class:`AegeanTools.fits_image.Beam` or None
The synthesized beam. If the supplied beam is None then one is constructed form the header.
Returns
-------
obj : :class:`AegeanTools.wcs_helpers.WCSHelper`
A helper object
"""
header = fits.getheader(filename)
return cls.from_header(header, beam) | [
"def",
"from_file",
"(",
"cls",
",",
"filename",
",",
"beam",
"=",
"None",
")",
":",
"header",
"=",
"fits",
".",
"getheader",
"(",
"filename",
")",
"return",
"cls",
".",
"from_header",
"(",
"header",
",",
"beam",
")"
] | Create a new WCSHelper class from a given fits file.
Parameters
----------
filename : string
The file to be read
beam : :class:`AegeanTools.fits_image.Beam` or None
The synthesized beam. If the supplied beam is None then one is constructed form the header.
Returns
-------
obj : :class:`AegeanTools.wcs_helpers.WCSHelper`
A helper object | [
"Create",
"a",
"new",
"WCSHelper",
"class",
"from",
"a",
"given",
"fits",
"file",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L100-L118 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.pix2sky | def pix2sky(self, pixel):
"""
Convert pixel coordinates into sky coordinates.
Parameters
----------
pixel : (float, float)
The (x,y) pixel coordinates
Returns
-------
sky : (float, float)
The (ra,dec) sky coordinates in degrees
"""
x, y = pixel
# wcs and pyfits have oposite ideas of x/y
return self.wcs.wcs_pix2world([[y, x]], 1)[0] | python | def pix2sky(self, pixel):
"""
Convert pixel coordinates into sky coordinates.
Parameters
----------
pixel : (float, float)
The (x,y) pixel coordinates
Returns
-------
sky : (float, float)
The (ra,dec) sky coordinates in degrees
"""
x, y = pixel
# wcs and pyfits have oposite ideas of x/y
return self.wcs.wcs_pix2world([[y, x]], 1)[0] | [
"def",
"pix2sky",
"(",
"self",
",",
"pixel",
")",
":",
"x",
",",
"y",
"=",
"pixel",
"# wcs and pyfits have oposite ideas of x/y",
"return",
"self",
".",
"wcs",
".",
"wcs_pix2world",
"(",
"[",
"[",
"y",
",",
"x",
"]",
"]",
",",
"1",
")",
"[",
"0",
"]"... | Convert pixel coordinates into sky coordinates.
Parameters
----------
pixel : (float, float)
The (x,y) pixel coordinates
Returns
-------
sky : (float, float)
The (ra,dec) sky coordinates in degrees | [
"Convert",
"pixel",
"coordinates",
"into",
"sky",
"coordinates",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L120-L137 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.sky2pix | def sky2pix(self, pos):
"""
Convert sky coordinates into pixel coordinates.
Parameters
----------
pos : (float, float)
The (ra, dec) sky coordinates (degrees)
Returns
-------
pixel : (float, float)
The (x,y) pixel coordinates
"""
pixel = self.wcs.wcs_world2pix([pos], 1)
# wcs and pyfits have oposite ideas of x/y
return [pixel[0][1], pixel[0][0]] | python | def sky2pix(self, pos):
"""
Convert sky coordinates into pixel coordinates.
Parameters
----------
pos : (float, float)
The (ra, dec) sky coordinates (degrees)
Returns
-------
pixel : (float, float)
The (x,y) pixel coordinates
"""
pixel = self.wcs.wcs_world2pix([pos], 1)
# wcs and pyfits have oposite ideas of x/y
return [pixel[0][1], pixel[0][0]] | [
"def",
"sky2pix",
"(",
"self",
",",
"pos",
")",
":",
"pixel",
"=",
"self",
".",
"wcs",
".",
"wcs_world2pix",
"(",
"[",
"pos",
"]",
",",
"1",
")",
"# wcs and pyfits have oposite ideas of x/y",
"return",
"[",
"pixel",
"[",
"0",
"]",
"[",
"1",
"]",
",",
... | Convert sky coordinates into pixel coordinates.
Parameters
----------
pos : (float, float)
The (ra, dec) sky coordinates (degrees)
Returns
-------
pixel : (float, float)
The (x,y) pixel coordinates | [
"Convert",
"sky",
"coordinates",
"into",
"pixel",
"coordinates",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L139-L156 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.sky2pix_vec | def sky2pix_vec(self, pos, r, pa):
"""
Convert a vector from sky to pixel coords.
The vector has a magnitude, angle, and an origin on the sky.
Parameters
----------
pos : (float, float)
The (ra, dec) of the origin of the vector (degrees).
r : float
The magnitude or length of the vector (degrees).
pa : float
The position angle of the vector (degrees).
Returns
-------
x, y : float
The pixel coordinates of the origin.
r, theta : float
The magnitude (pixels) and angle (degrees) of the vector.
"""
ra, dec = pos
x, y = self.sky2pix(pos)
a = translate(ra, dec, r, pa)
locations = self.sky2pix(a)
x_off, y_off = locations
a = np.sqrt((x - x_off) ** 2 + (y - y_off) ** 2)
theta = np.degrees(np.arctan2((y_off - y), (x_off - x)))
return x, y, a, theta | python | def sky2pix_vec(self, pos, r, pa):
"""
Convert a vector from sky to pixel coords.
The vector has a magnitude, angle, and an origin on the sky.
Parameters
----------
pos : (float, float)
The (ra, dec) of the origin of the vector (degrees).
r : float
The magnitude or length of the vector (degrees).
pa : float
The position angle of the vector (degrees).
Returns
-------
x, y : float
The pixel coordinates of the origin.
r, theta : float
The magnitude (pixels) and angle (degrees) of the vector.
"""
ra, dec = pos
x, y = self.sky2pix(pos)
a = translate(ra, dec, r, pa)
locations = self.sky2pix(a)
x_off, y_off = locations
a = np.sqrt((x - x_off) ** 2 + (y - y_off) ** 2)
theta = np.degrees(np.arctan2((y_off - y), (x_off - x)))
return x, y, a, theta | [
"def",
"sky2pix_vec",
"(",
"self",
",",
"pos",
",",
"r",
",",
"pa",
")",
":",
"ra",
",",
"dec",
"=",
"pos",
"x",
",",
"y",
"=",
"self",
".",
"sky2pix",
"(",
"pos",
")",
"a",
"=",
"translate",
"(",
"ra",
",",
"dec",
",",
"r",
",",
"pa",
")",... | Convert a vector from sky to pixel coords.
The vector has a magnitude, angle, and an origin on the sky.
Parameters
----------
pos : (float, float)
The (ra, dec) of the origin of the vector (degrees).
r : float
The magnitude or length of the vector (degrees).
pa : float
The position angle of the vector (degrees).
Returns
-------
x, y : float
The pixel coordinates of the origin.
r, theta : float
The magnitude (pixels) and angle (degrees) of the vector. | [
"Convert",
"a",
"vector",
"from",
"sky",
"to",
"pixel",
"coords",
".",
"The",
"vector",
"has",
"a",
"magnitude",
"angle",
"and",
"an",
"origin",
"on",
"the",
"sky",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L158-L189 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.pix2sky_vec | def pix2sky_vec(self, pixel, r, theta):
"""
Given and input position and vector in pixel coordinates, calculate
the equivalent position and vector in sky coordinates.
Parameters
----------
pixel : (int,int)
origin of vector in pixel coordinates
r : float
magnitude of vector in pixels
theta : float
angle of vector in degrees
Returns
-------
ra, dec : float
The (ra, dec) of the origin point (degrees).
r, pa : float
The magnitude and position angle of the vector (degrees).
"""
ra1, dec1 = self.pix2sky(pixel)
x, y = pixel
a = [x + r * np.cos(np.radians(theta)),
y + r * np.sin(np.radians(theta))]
locations = self.pix2sky(a)
ra2, dec2 = locations
a = gcd(ra1, dec1, ra2, dec2)
pa = bear(ra1, dec1, ra2, dec2)
return ra1, dec1, a, pa | python | def pix2sky_vec(self, pixel, r, theta):
"""
Given and input position and vector in pixel coordinates, calculate
the equivalent position and vector in sky coordinates.
Parameters
----------
pixel : (int,int)
origin of vector in pixel coordinates
r : float
magnitude of vector in pixels
theta : float
angle of vector in degrees
Returns
-------
ra, dec : float
The (ra, dec) of the origin point (degrees).
r, pa : float
The magnitude and position angle of the vector (degrees).
"""
ra1, dec1 = self.pix2sky(pixel)
x, y = pixel
a = [x + r * np.cos(np.radians(theta)),
y + r * np.sin(np.radians(theta))]
locations = self.pix2sky(a)
ra2, dec2 = locations
a = gcd(ra1, dec1, ra2, dec2)
pa = bear(ra1, dec1, ra2, dec2)
return ra1, dec1, a, pa | [
"def",
"pix2sky_vec",
"(",
"self",
",",
"pixel",
",",
"r",
",",
"theta",
")",
":",
"ra1",
",",
"dec1",
"=",
"self",
".",
"pix2sky",
"(",
"pixel",
")",
"x",
",",
"y",
"=",
"pixel",
"a",
"=",
"[",
"x",
"+",
"r",
"*",
"np",
".",
"cos",
"(",
"n... | Given and input position and vector in pixel coordinates, calculate
the equivalent position and vector in sky coordinates.
Parameters
----------
pixel : (int,int)
origin of vector in pixel coordinates
r : float
magnitude of vector in pixels
theta : float
angle of vector in degrees
Returns
-------
ra, dec : float
The (ra, dec) of the origin point (degrees).
r, pa : float
The magnitude and position angle of the vector (degrees). | [
"Given",
"and",
"input",
"position",
"and",
"vector",
"in",
"pixel",
"coordinates",
"calculate",
"the",
"equivalent",
"position",
"and",
"vector",
"in",
"sky",
"coordinates",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L191-L220 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.sky2pix_ellipse | def sky2pix_ellipse(self, pos, a, b, pa):
"""
Convert an ellipse from sky to pixel coordinates.
Parameters
----------
pos : (float, float)
The (ra, dec) of the ellipse center (degrees).
a, b, pa: float
The semi-major axis, semi-minor axis and position angle of the ellipse (degrees).
Returns
-------
x,y : float
The (x, y) pixel coordinates of the ellipse center.
sx, sy : float
The major and minor axes (FWHM) in pixels.
theta : float
The rotation angle of the ellipse (degrees).
theta = 0 corresponds to the ellipse being aligned with the x-axis.
"""
ra, dec = pos
x, y = self.sky2pix(pos)
x_off, y_off = self.sky2pix(translate(ra, dec, a, pa))
sx = np.hypot((x - x_off), (y - y_off))
theta = np.arctan2((y_off - y), (x_off - x))
x_off, y_off = self.sky2pix(translate(ra, dec, b, pa - 90))
sy = np.hypot((x - x_off), (y - y_off))
theta2 = np.arctan2((y_off - y), (x_off - x)) - np.pi / 2
# The a/b vectors are perpendicular in sky space, but not always in pixel space
# so we have to account for this by calculating the angle between the two vectors
# and modifying the minor axis length
defect = theta - theta2
sy *= abs(np.cos(defect))
return x, y, sx, sy, np.degrees(theta) | python | def sky2pix_ellipse(self, pos, a, b, pa):
"""
Convert an ellipse from sky to pixel coordinates.
Parameters
----------
pos : (float, float)
The (ra, dec) of the ellipse center (degrees).
a, b, pa: float
The semi-major axis, semi-minor axis and position angle of the ellipse (degrees).
Returns
-------
x,y : float
The (x, y) pixel coordinates of the ellipse center.
sx, sy : float
The major and minor axes (FWHM) in pixels.
theta : float
The rotation angle of the ellipse (degrees).
theta = 0 corresponds to the ellipse being aligned with the x-axis.
"""
ra, dec = pos
x, y = self.sky2pix(pos)
x_off, y_off = self.sky2pix(translate(ra, dec, a, pa))
sx = np.hypot((x - x_off), (y - y_off))
theta = np.arctan2((y_off - y), (x_off - x))
x_off, y_off = self.sky2pix(translate(ra, dec, b, pa - 90))
sy = np.hypot((x - x_off), (y - y_off))
theta2 = np.arctan2((y_off - y), (x_off - x)) - np.pi / 2
# The a/b vectors are perpendicular in sky space, but not always in pixel space
# so we have to account for this by calculating the angle between the two vectors
# and modifying the minor axis length
defect = theta - theta2
sy *= abs(np.cos(defect))
return x, y, sx, sy, np.degrees(theta) | [
"def",
"sky2pix_ellipse",
"(",
"self",
",",
"pos",
",",
"a",
",",
"b",
",",
"pa",
")",
":",
"ra",
",",
"dec",
"=",
"pos",
"x",
",",
"y",
"=",
"self",
".",
"sky2pix",
"(",
"pos",
")",
"x_off",
",",
"y_off",
"=",
"self",
".",
"sky2pix",
"(",
"t... | Convert an ellipse from sky to pixel coordinates.
Parameters
----------
pos : (float, float)
The (ra, dec) of the ellipse center (degrees).
a, b, pa: float
The semi-major axis, semi-minor axis and position angle of the ellipse (degrees).
Returns
-------
x,y : float
The (x, y) pixel coordinates of the ellipse center.
sx, sy : float
The major and minor axes (FWHM) in pixels.
theta : float
The rotation angle of the ellipse (degrees).
theta = 0 corresponds to the ellipse being aligned with the x-axis. | [
"Convert",
"an",
"ellipse",
"from",
"sky",
"to",
"pixel",
"coordinates",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L222-L261 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.pix2sky_ellipse | def pix2sky_ellipse(self, pixel, sx, sy, theta):
"""
Convert an ellipse from pixel to sky coordinates.
Parameters
----------
pixel : (float, float)
The (x, y) coordinates of the center of the ellipse.
sx, sy : float
The major and minor axes (FHWM) of the ellipse, in pixels.
theta : float
The rotation angle of the ellipse (degrees).
theta = 0 corresponds to the ellipse being aligned with the x-axis.
Returns
-------
ra, dec : float
The (ra, dec) coordinates of the center of the ellipse (degrees).
a, b : float
The semi-major and semi-minor axis of the ellipse (degrees).
pa : float
The position angle of the ellipse (degrees).
"""
ra, dec = self.pix2sky(pixel)
x, y = pixel
v_sx = [x + sx * np.cos(np.radians(theta)),
y + sx * np.sin(np.radians(theta))]
ra2, dec2 = self.pix2sky(v_sx)
major = gcd(ra, dec, ra2, dec2)
pa = bear(ra, dec, ra2, dec2)
v_sy = [x + sy * np.cos(np.radians(theta - 90)),
y + sy * np.sin(np.radians(theta - 90))]
ra2, dec2 = self.pix2sky(v_sy)
minor = gcd(ra, dec, ra2, dec2)
pa2 = bear(ra, dec, ra2, dec2) - 90
# The a/b vectors are perpendicular in sky space, but not always in pixel space
# so we have to account for this by calculating the angle between the two vectors
# and modifying the minor axis length
defect = pa - pa2
minor *= abs(np.cos(np.radians(defect)))
return ra, dec, major, minor, pa | python | def pix2sky_ellipse(self, pixel, sx, sy, theta):
"""
Convert an ellipse from pixel to sky coordinates.
Parameters
----------
pixel : (float, float)
The (x, y) coordinates of the center of the ellipse.
sx, sy : float
The major and minor axes (FHWM) of the ellipse, in pixels.
theta : float
The rotation angle of the ellipse (degrees).
theta = 0 corresponds to the ellipse being aligned with the x-axis.
Returns
-------
ra, dec : float
The (ra, dec) coordinates of the center of the ellipse (degrees).
a, b : float
The semi-major and semi-minor axis of the ellipse (degrees).
pa : float
The position angle of the ellipse (degrees).
"""
ra, dec = self.pix2sky(pixel)
x, y = pixel
v_sx = [x + sx * np.cos(np.radians(theta)),
y + sx * np.sin(np.radians(theta))]
ra2, dec2 = self.pix2sky(v_sx)
major = gcd(ra, dec, ra2, dec2)
pa = bear(ra, dec, ra2, dec2)
v_sy = [x + sy * np.cos(np.radians(theta - 90)),
y + sy * np.sin(np.radians(theta - 90))]
ra2, dec2 = self.pix2sky(v_sy)
minor = gcd(ra, dec, ra2, dec2)
pa2 = bear(ra, dec, ra2, dec2) - 90
# The a/b vectors are perpendicular in sky space, but not always in pixel space
# so we have to account for this by calculating the angle between the two vectors
# and modifying the minor axis length
defect = pa - pa2
minor *= abs(np.cos(np.radians(defect)))
return ra, dec, major, minor, pa | [
"def",
"pix2sky_ellipse",
"(",
"self",
",",
"pixel",
",",
"sx",
",",
"sy",
",",
"theta",
")",
":",
"ra",
",",
"dec",
"=",
"self",
".",
"pix2sky",
"(",
"pixel",
")",
"x",
",",
"y",
"=",
"pixel",
"v_sx",
"=",
"[",
"x",
"+",
"sx",
"*",
"np",
"."... | Convert an ellipse from pixel to sky coordinates.
Parameters
----------
pixel : (float, float)
The (x, y) coordinates of the center of the ellipse.
sx, sy : float
The major and minor axes (FHWM) of the ellipse, in pixels.
theta : float
The rotation angle of the ellipse (degrees).
theta = 0 corresponds to the ellipse being aligned with the x-axis.
Returns
-------
ra, dec : float
The (ra, dec) coordinates of the center of the ellipse (degrees).
a, b : float
The semi-major and semi-minor axis of the ellipse (degrees).
pa : float
The position angle of the ellipse (degrees). | [
"Convert",
"an",
"ellipse",
"from",
"pixel",
"to",
"sky",
"coordinates",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L263-L307 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.get_pixbeam_pixel | def get_pixbeam_pixel(self, x, y):
"""
Determine the beam in pixels at the given location in pixel coordinates.
Parameters
----------
x , y : float
The pixel coordinates at which the beam is determined.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
A beam object, with a/b/pa in pixel coordinates.
"""
ra, dec = self.pix2sky((x, y))
return self.get_pixbeam(ra, dec) | python | def get_pixbeam_pixel(self, x, y):
"""
Determine the beam in pixels at the given location in pixel coordinates.
Parameters
----------
x , y : float
The pixel coordinates at which the beam is determined.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
A beam object, with a/b/pa in pixel coordinates.
"""
ra, dec = self.pix2sky((x, y))
return self.get_pixbeam(ra, dec) | [
"def",
"get_pixbeam_pixel",
"(",
"self",
",",
"x",
",",
"y",
")",
":",
"ra",
",",
"dec",
"=",
"self",
".",
"pix2sky",
"(",
"(",
"x",
",",
"y",
")",
")",
"return",
"self",
".",
"get_pixbeam",
"(",
"ra",
",",
"dec",
")"
] | Determine the beam in pixels at the given location in pixel coordinates.
Parameters
----------
x , y : float
The pixel coordinates at which the beam is determined.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
A beam object, with a/b/pa in pixel coordinates. | [
"Determine",
"the",
"beam",
"in",
"pixels",
"at",
"the",
"given",
"location",
"in",
"pixel",
"coordinates",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L309-L324 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.get_beam | def get_beam(self, ra, dec):
"""
Determine the beam at the given sky location.
Parameters
----------
ra, dec : float
The sky coordinates at which the beam is determined.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
A beam object, with a/b/pa in sky coordinates
"""
# check to see if we need to scale the major axis based on the declination
if self.lat is None:
factor = 1
else:
# this works if the pa is zero. For non-zero pa it's a little more difficult
factor = np.cos(np.radians(dec - self.lat))
return Beam(self.beam.a / factor, self.beam.b, self.beam.pa) | python | def get_beam(self, ra, dec):
"""
Determine the beam at the given sky location.
Parameters
----------
ra, dec : float
The sky coordinates at which the beam is determined.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
A beam object, with a/b/pa in sky coordinates
"""
# check to see if we need to scale the major axis based on the declination
if self.lat is None:
factor = 1
else:
# this works if the pa is zero. For non-zero pa it's a little more difficult
factor = np.cos(np.radians(dec - self.lat))
return Beam(self.beam.a / factor, self.beam.b, self.beam.pa) | [
"def",
"get_beam",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"# check to see if we need to scale the major axis based on the declination",
"if",
"self",
".",
"lat",
"is",
"None",
":",
"factor",
"=",
"1",
"else",
":",
"# this works if the pa is zero. For non-zero pa ... | Determine the beam at the given sky location.
Parameters
----------
ra, dec : float
The sky coordinates at which the beam is determined.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
A beam object, with a/b/pa in sky coordinates | [
"Determine",
"the",
"beam",
"at",
"the",
"given",
"sky",
"location",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L326-L346 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.get_pixbeam | def get_pixbeam(self, ra, dec):
"""
Determine the beam in pixels at the given location in sky coordinates.
Parameters
----------
ra , dec : float
The sly coordinates at which the beam is determined.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
A beam object, with a/b/pa in pixel coordinates.
"""
if ra is None:
ra, dec = self.pix2sky(self.refpix)
pos = [ra, dec]
beam = self.get_beam(ra, dec)
_, _, major, minor, theta = self.sky2pix_ellipse(pos, beam.a, beam.b, beam.pa)
if major < minor:
major, minor = minor, major
theta -= 90
if theta < -180:
theta += 180
if not np.isfinite(theta):
theta = 0
if not all(np.isfinite([major, minor, theta])):
beam = None
else:
beam = Beam(major, minor, theta)
return beam | python | def get_pixbeam(self, ra, dec):
"""
Determine the beam in pixels at the given location in sky coordinates.
Parameters
----------
ra , dec : float
The sly coordinates at which the beam is determined.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
A beam object, with a/b/pa in pixel coordinates.
"""
if ra is None:
ra, dec = self.pix2sky(self.refpix)
pos = [ra, dec]
beam = self.get_beam(ra, dec)
_, _, major, minor, theta = self.sky2pix_ellipse(pos, beam.a, beam.b, beam.pa)
if major < minor:
major, minor = minor, major
theta -= 90
if theta < -180:
theta += 180
if not np.isfinite(theta):
theta = 0
if not all(np.isfinite([major, minor, theta])):
beam = None
else:
beam = Beam(major, minor, theta)
return beam | [
"def",
"get_pixbeam",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"if",
"ra",
"is",
"None",
":",
"ra",
",",
"dec",
"=",
"self",
".",
"pix2sky",
"(",
"self",
".",
"refpix",
")",
"pos",
"=",
"[",
"ra",
",",
"dec",
"]",
"beam",
"=",
"self",
".... | Determine the beam in pixels at the given location in sky coordinates.
Parameters
----------
ra , dec : float
The sly coordinates at which the beam is determined.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
A beam object, with a/b/pa in pixel coordinates. | [
"Determine",
"the",
"beam",
"in",
"pixels",
"at",
"the",
"given",
"location",
"in",
"sky",
"coordinates",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L348-L381 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.get_beamarea_deg2 | def get_beamarea_deg2(self, ra, dec):
"""
Calculate the area of the synthesized beam in square degrees.
Parameters
----------
ra, dec : float
The sky coordinates at which the calculation is made.
Returns
-------
area : float
The beam area in square degrees.
"""
barea = abs(self.beam.a * self.beam.b * np.pi) # in deg**2 at reference coords
if self.lat is not None:
barea /= np.cos(np.radians(dec - self.lat))
return barea | python | def get_beamarea_deg2(self, ra, dec):
"""
Calculate the area of the synthesized beam in square degrees.
Parameters
----------
ra, dec : float
The sky coordinates at which the calculation is made.
Returns
-------
area : float
The beam area in square degrees.
"""
barea = abs(self.beam.a * self.beam.b * np.pi) # in deg**2 at reference coords
if self.lat is not None:
barea /= np.cos(np.radians(dec - self.lat))
return barea | [
"def",
"get_beamarea_deg2",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"barea",
"=",
"abs",
"(",
"self",
".",
"beam",
".",
"a",
"*",
"self",
".",
"beam",
".",
"b",
"*",
"np",
".",
"pi",
")",
"# in deg**2 at reference coords",
"if",
"self",
".",
... | Calculate the area of the synthesized beam in square degrees.
Parameters
----------
ra, dec : float
The sky coordinates at which the calculation is made.
Returns
-------
area : float
The beam area in square degrees. | [
"Calculate",
"the",
"area",
"of",
"the",
"synthesized",
"beam",
"in",
"square",
"degrees",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L383-L400 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.get_beamarea_pix | def get_beamarea_pix(self, ra, dec):
"""
Calculate the beam area in square pixels.
Parameters
----------
ra, dec : float
The sky coordinates at which the calculation is made
dec
Returns
-------
area : float
The beam area in square pixels.
"""
parea = abs(self.pixscale[0] * self.pixscale[1]) # in deg**2 at reference coords
barea = self.get_beamarea_deg2(ra, dec)
return barea / parea | python | def get_beamarea_pix(self, ra, dec):
"""
Calculate the beam area in square pixels.
Parameters
----------
ra, dec : float
The sky coordinates at which the calculation is made
dec
Returns
-------
area : float
The beam area in square pixels.
"""
parea = abs(self.pixscale[0] * self.pixscale[1]) # in deg**2 at reference coords
barea = self.get_beamarea_deg2(ra, dec)
return barea / parea | [
"def",
"get_beamarea_pix",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"parea",
"=",
"abs",
"(",
"self",
".",
"pixscale",
"[",
"0",
"]",
"*",
"self",
".",
"pixscale",
"[",
"1",
"]",
")",
"# in deg**2 at reference coords",
"barea",
"=",
"self",
".",
... | Calculate the beam area in square pixels.
Parameters
----------
ra, dec : float
The sky coordinates at which the calculation is made
dec
Returns
-------
area : float
The beam area in square pixels. | [
"Calculate",
"the",
"beam",
"area",
"in",
"square",
"pixels",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L402-L419 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | WCSHelper.sky_sep | def sky_sep(self, pix1, pix2):
"""
calculate the GCD sky separation (degrees) between two pixels.
Parameters
----------
pix1, pix2 : (float, float)
The (x,y) pixel coordinates for the two positions.
Returns
-------
dist : float
The distance between the two points (degrees).
"""
pos1 = self.pix2sky(pix1)
pos2 = self.pix2sky(pix2)
sep = gcd(pos1[0], pos1[1], pos2[0], pos2[1])
return sep | python | def sky_sep(self, pix1, pix2):
"""
calculate the GCD sky separation (degrees) between two pixels.
Parameters
----------
pix1, pix2 : (float, float)
The (x,y) pixel coordinates for the two positions.
Returns
-------
dist : float
The distance between the two points (degrees).
"""
pos1 = self.pix2sky(pix1)
pos2 = self.pix2sky(pix2)
sep = gcd(pos1[0], pos1[1], pos2[0], pos2[1])
return sep | [
"def",
"sky_sep",
"(",
"self",
",",
"pix1",
",",
"pix2",
")",
":",
"pos1",
"=",
"self",
".",
"pix2sky",
"(",
"pix1",
")",
"pos2",
"=",
"self",
".",
"pix2sky",
"(",
"pix2",
")",
"sep",
"=",
"gcd",
"(",
"pos1",
"[",
"0",
"]",
",",
"pos1",
"[",
... | calculate the GCD sky separation (degrees) between two pixels.
Parameters
----------
pix1, pix2 : (float, float)
The (x,y) pixel coordinates for the two positions.
Returns
-------
dist : float
The distance between the two points (degrees). | [
"calculate",
"the",
"GCD",
"sky",
"separation",
"(",
"degrees",
")",
"between",
"two",
"pixels",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L421-L438 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | PSFHelper.get_psf_sky | def get_psf_sky(self, ra, dec):
"""
Determine the local psf at a given sky location.
The psf is returned in degrees.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
a, b, pa : float
The psf semi-major axis, semi-minor axis, and position angle in (degrees).
If a psf is defined then it is the psf that is returned, otherwise the image
restoring beam is returned.
"""
# If we don't have a psf map then we just fall back to using the beam
# from the fits header (including ZA scaling)
if self.data is None:
beam = self.wcshelper.get_beam(ra, dec)
return beam.a, beam.b, beam.pa
x, y = self.sky2pix([ra, dec])
# We leave the interpolation in the hands of whoever is making these images
# clamping the x,y coords at the image boundaries just makes sense
x = int(np.clip(x, 0, self.data.shape[1] - 1))
y = int(np.clip(y, 0, self.data.shape[2] - 1))
psf_sky = self.data[:, x, y]
return psf_sky | python | def get_psf_sky(self, ra, dec):
"""
Determine the local psf at a given sky location.
The psf is returned in degrees.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
a, b, pa : float
The psf semi-major axis, semi-minor axis, and position angle in (degrees).
If a psf is defined then it is the psf that is returned, otherwise the image
restoring beam is returned.
"""
# If we don't have a psf map then we just fall back to using the beam
# from the fits header (including ZA scaling)
if self.data is None:
beam = self.wcshelper.get_beam(ra, dec)
return beam.a, beam.b, beam.pa
x, y = self.sky2pix([ra, dec])
# We leave the interpolation in the hands of whoever is making these images
# clamping the x,y coords at the image boundaries just makes sense
x = int(np.clip(x, 0, self.data.shape[1] - 1))
y = int(np.clip(y, 0, self.data.shape[2] - 1))
psf_sky = self.data[:, x, y]
return psf_sky | [
"def",
"get_psf_sky",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"# If we don't have a psf map then we just fall back to using the beam",
"# from the fits header (including ZA scaling)",
"if",
"self",
".",
"data",
"is",
"None",
":",
"beam",
"=",
"self",
".",
"wcshelp... | Determine the local psf at a given sky location.
The psf is returned in degrees.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
a, b, pa : float
The psf semi-major axis, semi-minor axis, and position angle in (degrees).
If a psf is defined then it is the psf that is returned, otherwise the image
restoring beam is returned. | [
"Determine",
"the",
"local",
"psf",
"at",
"a",
"given",
"sky",
"location",
".",
"The",
"psf",
"is",
"returned",
"in",
"degrees",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L474-L504 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | PSFHelper.get_psf_pix | def get_psf_pix(self, ra, dec):
"""
Determine the local psf (a,b,pa) at a given sky location.
The psf is in pixel coordinates.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
a, b, pa : float
The psf semi-major axis (pixels), semi-minor axis (pixels), and rotation angle (degrees).
If a psf is defined then it is the psf that is returned, otherwise the image
restoring beam is returned.
"""
psf_sky = self.get_psf_sky(ra, dec)
psf_pix = self.wcshelper.sky2pix_ellipse([ra, dec], psf_sky[0], psf_sky[1], psf_sky[2])[2:]
return psf_pix | python | def get_psf_pix(self, ra, dec):
"""
Determine the local psf (a,b,pa) at a given sky location.
The psf is in pixel coordinates.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
a, b, pa : float
The psf semi-major axis (pixels), semi-minor axis (pixels), and rotation angle (degrees).
If a psf is defined then it is the psf that is returned, otherwise the image
restoring beam is returned.
"""
psf_sky = self.get_psf_sky(ra, dec)
psf_pix = self.wcshelper.sky2pix_ellipse([ra, dec], psf_sky[0], psf_sky[1], psf_sky[2])[2:]
return psf_pix | [
"def",
"get_psf_pix",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"psf_sky",
"=",
"self",
".",
"get_psf_sky",
"(",
"ra",
",",
"dec",
")",
"psf_pix",
"=",
"self",
".",
"wcshelper",
".",
"sky2pix_ellipse",
"(",
"[",
"ra",
",",
"dec",
"]",
",",
"psf... | Determine the local psf (a,b,pa) at a given sky location.
The psf is in pixel coordinates.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
a, b, pa : float
The psf semi-major axis (pixels), semi-minor axis (pixels), and rotation angle (degrees).
If a psf is defined then it is the psf that is returned, otherwise the image
restoring beam is returned. | [
"Determine",
"the",
"local",
"psf",
"(",
"a",
"b",
"pa",
")",
"at",
"a",
"given",
"sky",
"location",
".",
"The",
"psf",
"is",
"in",
"pixel",
"coordinates",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L506-L527 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | PSFHelper.get_pixbeam | def get_pixbeam(self, ra, dec):
"""
Get the psf at the location specified in pixel coordinates.
The psf is also in pixel coordinates.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
a, b, pa : float
The psf semi-major axis (pixels), semi-minor axis (pixels), and rotation angle (degrees).
If a psf is defined then it is the psf that is returned, otherwise the image
restoring beam is returned.
"""
# If there is no psf image then just use the fits header (plus lat scaling) from the wcshelper
if self.data is None:
return self.wcshelper.get_pixbeam(ra, dec)
# get the beam from the psf image data
psf = self.get_psf_pix(ra, dec)
if not np.all(np.isfinite(psf)):
log.warn("PSF requested, returned Null")
return None
return Beam(psf[0], psf[1], psf[2]) | python | def get_pixbeam(self, ra, dec):
"""
Get the psf at the location specified in pixel coordinates.
The psf is also in pixel coordinates.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
a, b, pa : float
The psf semi-major axis (pixels), semi-minor axis (pixels), and rotation angle (degrees).
If a psf is defined then it is the psf that is returned, otherwise the image
restoring beam is returned.
"""
# If there is no psf image then just use the fits header (plus lat scaling) from the wcshelper
if self.data is None:
return self.wcshelper.get_pixbeam(ra, dec)
# get the beam from the psf image data
psf = self.get_psf_pix(ra, dec)
if not np.all(np.isfinite(psf)):
log.warn("PSF requested, returned Null")
return None
return Beam(psf[0], psf[1], psf[2]) | [
"def",
"get_pixbeam",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"# If there is no psf image then just use the fits header (plus lat scaling) from the wcshelper",
"if",
"self",
".",
"data",
"is",
"None",
":",
"return",
"self",
".",
"wcshelper",
".",
"get_pixbeam",
... | Get the psf at the location specified in pixel coordinates.
The psf is also in pixel coordinates.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
a, b, pa : float
The psf semi-major axis (pixels), semi-minor axis (pixels), and rotation angle (degrees).
If a psf is defined then it is the psf that is returned, otherwise the image
restoring beam is returned. | [
"Get",
"the",
"psf",
"at",
"the",
"location",
"specified",
"in",
"pixel",
"coordinates",
".",
"The",
"psf",
"is",
"also",
"in",
"pixel",
"coordinates",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L552-L578 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | PSFHelper.get_beam | def get_beam(self, ra, dec):
"""
Get the psf as a :class:`AegeanTools.fits_image.Beam` object.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
The psf at the given location.
"""
if self.data is None:
return self.wcshelper.beam
else:
psf = self.get_psf_sky(ra, dec)
if not all(np.isfinite(psf)):
return None
return Beam(psf[0], psf[1], psf[2]) | python | def get_beam(self, ra, dec):
"""
Get the psf as a :class:`AegeanTools.fits_image.Beam` object.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
The psf at the given location.
"""
if self.data is None:
return self.wcshelper.beam
else:
psf = self.get_psf_sky(ra, dec)
if not all(np.isfinite(psf)):
return None
return Beam(psf[0], psf[1], psf[2]) | [
"def",
"get_beam",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"if",
"self",
".",
"data",
"is",
"None",
":",
"return",
"self",
".",
"wcshelper",
".",
"beam",
"else",
":",
"psf",
"=",
"self",
".",
"get_psf_sky",
"(",
"ra",
",",
"dec",
")",
"if",... | Get the psf as a :class:`AegeanTools.fits_image.Beam` object.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
The psf at the given location. | [
"Get",
"the",
"psf",
"as",
"a",
":",
"class",
":",
"AegeanTools",
".",
"fits_image",
".",
"Beam",
"object",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L580-L600 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | PSFHelper.get_beamarea_pix | def get_beamarea_pix(self, ra, dec):
"""
Calculate the area of the beam in square pixels.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
area : float
The area of the beam in square pixels.
"""
beam = self.get_pixbeam(ra, dec)
if beam is None:
return 0
return beam.a * beam.b * np.pi | python | def get_beamarea_pix(self, ra, dec):
"""
Calculate the area of the beam in square pixels.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
area : float
The area of the beam in square pixels.
"""
beam = self.get_pixbeam(ra, dec)
if beam is None:
return 0
return beam.a * beam.b * np.pi | [
"def",
"get_beamarea_pix",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"beam",
"=",
"self",
".",
"get_pixbeam",
"(",
"ra",
",",
"dec",
")",
"if",
"beam",
"is",
"None",
":",
"return",
"0",
"return",
"beam",
".",
"a",
"*",
"beam",
".",
"b",
"*",
... | Calculate the area of the beam in square pixels.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
area : float
The area of the beam in square pixels. | [
"Calculate",
"the",
"area",
"of",
"the",
"beam",
"in",
"square",
"pixels",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L602-L619 |
PaulHancock/Aegean | AegeanTools/wcs_helpers.py | PSFHelper.get_beamarea_deg2 | def get_beamarea_deg2(self, ra, dec):
"""
Calculate the area of the beam in square degrees.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
area : float
The area of the beam in square degrees.
"""
beam = self.get_beam(ra, dec)
if beam is None:
return 0
return beam.a * beam.b * np.pi | python | def get_beamarea_deg2(self, ra, dec):
"""
Calculate the area of the beam in square degrees.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
area : float
The area of the beam in square degrees.
"""
beam = self.get_beam(ra, dec)
if beam is None:
return 0
return beam.a * beam.b * np.pi | [
"def",
"get_beamarea_deg2",
"(",
"self",
",",
"ra",
",",
"dec",
")",
":",
"beam",
"=",
"self",
".",
"get_beam",
"(",
"ra",
",",
"dec",
")",
"if",
"beam",
"is",
"None",
":",
"return",
"0",
"return",
"beam",
".",
"a",
"*",
"beam",
".",
"b",
"*",
... | Calculate the area of the beam in square degrees.
Parameters
----------
ra, dec : float
The sky position (degrees).
Returns
-------
area : float
The area of the beam in square degrees. | [
"Calculate",
"the",
"area",
"of",
"the",
"beam",
"in",
"square",
"degrees",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/wcs_helpers.py#L621-L639 |
PaulHancock/Aegean | AegeanTools/msq2.py | MarchingSquares.find_start_point | def find_start_point(self):
"""
Find the first location in our array that is not empty
"""
for i, row in enumerate(self.data):
for j, _ in enumerate(row):
if self.data[i, j] != 0: # or not np.isfinite(self.data[i,j]):
return i, j | python | def find_start_point(self):
"""
Find the first location in our array that is not empty
"""
for i, row in enumerate(self.data):
for j, _ in enumerate(row):
if self.data[i, j] != 0: # or not np.isfinite(self.data[i,j]):
return i, j | [
"def",
"find_start_point",
"(",
"self",
")",
":",
"for",
"i",
",",
"row",
"in",
"enumerate",
"(",
"self",
".",
"data",
")",
":",
"for",
"j",
",",
"_",
"in",
"enumerate",
"(",
"row",
")",
":",
"if",
"self",
".",
"data",
"[",
"i",
",",
"j",
"]",
... | Find the first location in our array that is not empty | [
"Find",
"the",
"first",
"location",
"in",
"our",
"array",
"that",
"is",
"not",
"empty"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L36-L43 |
PaulHancock/Aegean | AegeanTools/msq2.py | MarchingSquares.step | def step(self, x, y):
"""
Move from the current location to the next
Parameters
----------
x, y : int
The current location
"""
up_left = self.solid(x - 1, y - 1)
up_right = self.solid(x, y - 1)
down_left = self.solid(x - 1, y)
down_right = self.solid(x, y)
state = 0
self.prev = self.next
# which cells are filled?
if up_left:
state |= 1
if up_right:
state |= 2
if down_left:
state |= 4
if down_right:
state |= 8
# what is the next step?
if state in [1, 5, 13]:
self.next = self.UP
elif state in [2, 3, 7]:
self.next = self.RIGHT
elif state in [4, 12, 14]:
self.next = self.LEFT
elif state in [8, 10, 11]:
self.next = self.DOWN
elif state == 6:
if self.prev == self.UP:
self.next = self.LEFT
else:
self.next = self.RIGHT
elif state == 9:
if self.prev == self.RIGHT:
self.next = self.UP
else:
self.next = self.DOWN
else:
self.next = self.NOWHERE
return | python | def step(self, x, y):
"""
Move from the current location to the next
Parameters
----------
x, y : int
The current location
"""
up_left = self.solid(x - 1, y - 1)
up_right = self.solid(x, y - 1)
down_left = self.solid(x - 1, y)
down_right = self.solid(x, y)
state = 0
self.prev = self.next
# which cells are filled?
if up_left:
state |= 1
if up_right:
state |= 2
if down_left:
state |= 4
if down_right:
state |= 8
# what is the next step?
if state in [1, 5, 13]:
self.next = self.UP
elif state in [2, 3, 7]:
self.next = self.RIGHT
elif state in [4, 12, 14]:
self.next = self.LEFT
elif state in [8, 10, 11]:
self.next = self.DOWN
elif state == 6:
if self.prev == self.UP:
self.next = self.LEFT
else:
self.next = self.RIGHT
elif state == 9:
if self.prev == self.RIGHT:
self.next = self.UP
else:
self.next = self.DOWN
else:
self.next = self.NOWHERE
return | [
"def",
"step",
"(",
"self",
",",
"x",
",",
"y",
")",
":",
"up_left",
"=",
"self",
".",
"solid",
"(",
"x",
"-",
"1",
",",
"y",
"-",
"1",
")",
"up_right",
"=",
"self",
".",
"solid",
"(",
"x",
",",
"y",
"-",
"1",
")",
"down_left",
"=",
"self",... | Move from the current location to the next
Parameters
----------
x, y : int
The current location | [
"Move",
"from",
"the",
"current",
"location",
"to",
"the",
"next"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L45-L92 |
PaulHancock/Aegean | AegeanTools/msq2.py | MarchingSquares.solid | def solid(self, x, y):
"""
Determine whether the pixel x,y is nonzero
Parameters
----------
x, y : int
The pixel of interest.
Returns
-------
solid : bool
True if the pixel is not zero.
"""
if not(0 <= x < self.xsize) or not(0 <= y < self.ysize):
return False
if self.data[x, y] == 0:
return False
return True | python | def solid(self, x, y):
"""
Determine whether the pixel x,y is nonzero
Parameters
----------
x, y : int
The pixel of interest.
Returns
-------
solid : bool
True if the pixel is not zero.
"""
if not(0 <= x < self.xsize) or not(0 <= y < self.ysize):
return False
if self.data[x, y] == 0:
return False
return True | [
"def",
"solid",
"(",
"self",
",",
"x",
",",
"y",
")",
":",
"if",
"not",
"(",
"0",
"<=",
"x",
"<",
"self",
".",
"xsize",
")",
"or",
"not",
"(",
"0",
"<=",
"y",
"<",
"self",
".",
"ysize",
")",
":",
"return",
"False",
"if",
"self",
".",
"data"... | Determine whether the pixel x,y is nonzero
Parameters
----------
x, y : int
The pixel of interest.
Returns
-------
solid : bool
True if the pixel is not zero. | [
"Determine",
"whether",
"the",
"pixel",
"x",
"y",
"is",
"nonzero"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L94-L112 |
PaulHancock/Aegean | AegeanTools/msq2.py | MarchingSquares.walk_perimeter | def walk_perimeter(self, startx, starty):
"""
Starting at a point on the perimeter of a region, 'walk' the perimeter to return
to the starting point. Record the path taken.
Parameters
----------
startx, starty : int
The starting location. Assumed to be on the perimeter of a region.
Returns
-------
perimeter : list
A list of pixel coordinates [ [x1,y1], ...] that constitute the perimeter of the region.
"""
# checks
startx = max(startx, 0)
startx = min(startx, self.xsize)
starty = max(starty, 0)
starty = min(starty, self.ysize)
points = []
x, y = startx, starty
while True:
self.step(x, y)
if 0 <= x <= self.xsize and 0 <= y <= self.ysize:
points.append((x, y))
if self.next == self.UP:
y -= 1
elif self.next == self.LEFT:
x -= 1
elif self.next == self.DOWN:
y += 1
elif self.next == self.RIGHT:
x += 1
# stop if we meet some kind of error
elif self.next == self.NOWHERE:
break
# stop when we return to the starting location
if x == startx and y == starty:
break
return points | python | def walk_perimeter(self, startx, starty):
"""
Starting at a point on the perimeter of a region, 'walk' the perimeter to return
to the starting point. Record the path taken.
Parameters
----------
startx, starty : int
The starting location. Assumed to be on the perimeter of a region.
Returns
-------
perimeter : list
A list of pixel coordinates [ [x1,y1], ...] that constitute the perimeter of the region.
"""
# checks
startx = max(startx, 0)
startx = min(startx, self.xsize)
starty = max(starty, 0)
starty = min(starty, self.ysize)
points = []
x, y = startx, starty
while True:
self.step(x, y)
if 0 <= x <= self.xsize and 0 <= y <= self.ysize:
points.append((x, y))
if self.next == self.UP:
y -= 1
elif self.next == self.LEFT:
x -= 1
elif self.next == self.DOWN:
y += 1
elif self.next == self.RIGHT:
x += 1
# stop if we meet some kind of error
elif self.next == self.NOWHERE:
break
# stop when we return to the starting location
if x == startx and y == starty:
break
return points | [
"def",
"walk_perimeter",
"(",
"self",
",",
"startx",
",",
"starty",
")",
":",
"# checks",
"startx",
"=",
"max",
"(",
"startx",
",",
"0",
")",
"startx",
"=",
"min",
"(",
"startx",
",",
"self",
".",
"xsize",
")",
"starty",
"=",
"max",
"(",
"starty",
... | Starting at a point on the perimeter of a region, 'walk' the perimeter to return
to the starting point. Record the path taken.
Parameters
----------
startx, starty : int
The starting location. Assumed to be on the perimeter of a region.
Returns
-------
perimeter : list
A list of pixel coordinates [ [x1,y1], ...] that constitute the perimeter of the region. | [
"Starting",
"at",
"a",
"point",
"on",
"the",
"perimeter",
"of",
"a",
"region",
"walk",
"the",
"perimeter",
"to",
"return",
"to",
"the",
"starting",
"point",
".",
"Record",
"the",
"path",
"taken",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L114-L157 |
PaulHancock/Aegean | AegeanTools/msq2.py | MarchingSquares.do_march | def do_march(self):
"""
March about and trace the outline of our object
Returns
-------
perimeter : list
The pixels on the perimeter of the region [[x1, y1], ...]
"""
x, y = self.find_start_point()
perimeter = self.walk_perimeter(x, y)
return perimeter | python | def do_march(self):
"""
March about and trace the outline of our object
Returns
-------
perimeter : list
The pixels on the perimeter of the region [[x1, y1], ...]
"""
x, y = self.find_start_point()
perimeter = self.walk_perimeter(x, y)
return perimeter | [
"def",
"do_march",
"(",
"self",
")",
":",
"x",
",",
"y",
"=",
"self",
".",
"find_start_point",
"(",
")",
"perimeter",
"=",
"self",
".",
"walk_perimeter",
"(",
"x",
",",
"y",
")",
"return",
"perimeter"
] | March about and trace the outline of our object
Returns
-------
perimeter : list
The pixels on the perimeter of the region [[x1, y1], ...] | [
"March",
"about",
"and",
"trace",
"the",
"outline",
"of",
"our",
"object"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L159-L170 |
PaulHancock/Aegean | AegeanTools/msq2.py | MarchingSquares._blank_within | def _blank_within(self, perimeter):
"""
Blank all the pixels within the given perimeter.
Parameters
----------
perimeter : list
The perimeter of the region.
"""
# Method:
# scan around the perimeter filling 'up' from each pixel
# stopping when we reach the other boundary
for p in perimeter:
# if we are on the edge of the data then there is nothing to fill
if p[0] >= self.data.shape[0] or p[1] >= self.data.shape[1]:
continue
# if this pixel is blank then don't fill
if self.data[p] == 0:
continue
# blank this pixel
self.data[p] = 0
# blank until we reach the other perimeter
for i in range(p[1]+1, self.data.shape[1]):
q = p[0], i
# stop when we reach another part of the perimeter
if q in perimeter:
break
# fill everything in between, even inclusions
self.data[q] = 0
return | python | def _blank_within(self, perimeter):
"""
Blank all the pixels within the given perimeter.
Parameters
----------
perimeter : list
The perimeter of the region.
"""
# Method:
# scan around the perimeter filling 'up' from each pixel
# stopping when we reach the other boundary
for p in perimeter:
# if we are on the edge of the data then there is nothing to fill
if p[0] >= self.data.shape[0] or p[1] >= self.data.shape[1]:
continue
# if this pixel is blank then don't fill
if self.data[p] == 0:
continue
# blank this pixel
self.data[p] = 0
# blank until we reach the other perimeter
for i in range(p[1]+1, self.data.shape[1]):
q = p[0], i
# stop when we reach another part of the perimeter
if q in perimeter:
break
# fill everything in between, even inclusions
self.data[q] = 0
return | [
"def",
"_blank_within",
"(",
"self",
",",
"perimeter",
")",
":",
"# Method:",
"# scan around the perimeter filling 'up' from each pixel",
"# stopping when we reach the other boundary",
"for",
"p",
"in",
"perimeter",
":",
"# if we are on the edge of the data then there is nothing to f... | Blank all the pixels within the given perimeter.
Parameters
----------
perimeter : list
The perimeter of the region. | [
"Blank",
"all",
"the",
"pixels",
"within",
"the",
"given",
"perimeter",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L172-L205 |
PaulHancock/Aegean | AegeanTools/msq2.py | MarchingSquares.do_march_all | def do_march_all(self):
"""
Recursive march in the case that we have a fragmented shape.
Returns
-------
perimeters : [perimeter1, ...]
The perimeters of all the regions in the image.
See Also
--------
:func:`AegeanTools.msq2.MarchingSquares.do_march`
"""
# copy the data since we are going to be modifying it
data_copy = copy(self.data)
# iterate through finding an island, creating a perimeter,
# and then blanking the island
perimeters = []
p = self.find_start_point()
while p is not None:
x, y = p
perim = self.walk_perimeter(x, y)
perimeters.append(perim)
self._blank_within(perim)
p = self.find_start_point()
# restore the data
self.data = data_copy
return perimeters | python | def do_march_all(self):
"""
Recursive march in the case that we have a fragmented shape.
Returns
-------
perimeters : [perimeter1, ...]
The perimeters of all the regions in the image.
See Also
--------
:func:`AegeanTools.msq2.MarchingSquares.do_march`
"""
# copy the data since we are going to be modifying it
data_copy = copy(self.data)
# iterate through finding an island, creating a perimeter,
# and then blanking the island
perimeters = []
p = self.find_start_point()
while p is not None:
x, y = p
perim = self.walk_perimeter(x, y)
perimeters.append(perim)
self._blank_within(perim)
p = self.find_start_point()
# restore the data
self.data = data_copy
return perimeters | [
"def",
"do_march_all",
"(",
"self",
")",
":",
"# copy the data since we are going to be modifying it",
"data_copy",
"=",
"copy",
"(",
"self",
".",
"data",
")",
"# iterate through finding an island, creating a perimeter,",
"# and then blanking the island",
"perimeters",
"=",
"["... | Recursive march in the case that we have a fragmented shape.
Returns
-------
perimeters : [perimeter1, ...]
The perimeters of all the regions in the image.
See Also
--------
:func:`AegeanTools.msq2.MarchingSquares.do_march` | [
"Recursive",
"march",
"in",
"the",
"case",
"that",
"we",
"have",
"a",
"fragmented",
"shape",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/msq2.py#L207-L236 |
PaulHancock/Aegean | AegeanTools/fitting.py | elliptical_gaussian | def elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta):
"""
Generate a model 2d Gaussian with the given parameters.
Evaluate this model at the given locations x,y.
Parameters
----------
x, y : numeric or array-like
locations at which to evaluate the gaussian
amp : float
Peak value.
xo, yo : float
Center of the gaussian.
sx, sy : float
major/minor axes in sigmas
theta : float
position angle (degrees) CCW from x-axis
Returns
-------
data : numeric or array-like
Gaussian function evaluated at the x,y locations.
"""
try:
sint, cost = math.sin(np.radians(theta)), math.cos(np.radians(theta))
except ValueError as e:
if 'math domain error' in e.args:
sint, cost = np.nan, np.nan
xxo = x - xo
yyo = y - yo
exp = (xxo * cost + yyo * sint) ** 2 / sx ** 2 \
+ (xxo * sint - yyo * cost) ** 2 / sy ** 2
exp *= -1. / 2
return amp * np.exp(exp) | python | def elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta):
"""
Generate a model 2d Gaussian with the given parameters.
Evaluate this model at the given locations x,y.
Parameters
----------
x, y : numeric or array-like
locations at which to evaluate the gaussian
amp : float
Peak value.
xo, yo : float
Center of the gaussian.
sx, sy : float
major/minor axes in sigmas
theta : float
position angle (degrees) CCW from x-axis
Returns
-------
data : numeric or array-like
Gaussian function evaluated at the x,y locations.
"""
try:
sint, cost = math.sin(np.radians(theta)), math.cos(np.radians(theta))
except ValueError as e:
if 'math domain error' in e.args:
sint, cost = np.nan, np.nan
xxo = x - xo
yyo = y - yo
exp = (xxo * cost + yyo * sint) ** 2 / sx ** 2 \
+ (xxo * sint - yyo * cost) ** 2 / sy ** 2
exp *= -1. / 2
return amp * np.exp(exp) | [
"def",
"elliptical_gaussian",
"(",
"x",
",",
"y",
",",
"amp",
",",
"xo",
",",
"yo",
",",
"sx",
",",
"sy",
",",
"theta",
")",
":",
"try",
":",
"sint",
",",
"cost",
"=",
"math",
".",
"sin",
"(",
"np",
".",
"radians",
"(",
"theta",
")",
")",
","... | Generate a model 2d Gaussian with the given parameters.
Evaluate this model at the given locations x,y.
Parameters
----------
x, y : numeric or array-like
locations at which to evaluate the gaussian
amp : float
Peak value.
xo, yo : float
Center of the gaussian.
sx, sy : float
major/minor axes in sigmas
theta : float
position angle (degrees) CCW from x-axis
Returns
-------
data : numeric or array-like
Gaussian function evaluated at the x,y locations. | [
"Generate",
"a",
"model",
"2d",
"Gaussian",
"with",
"the",
"given",
"parameters",
".",
"Evaluate",
"this",
"model",
"at",
"the",
"given",
"locations",
"x",
"y",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L30-L63 |
PaulHancock/Aegean | AegeanTools/fitting.py | Cmatrix | def Cmatrix(x, y, sx, sy, theta):
"""
Construct a correlation matrix corresponding to the data.
The matrix assumes a gaussian correlation function.
Parameters
----------
x, y : array-like
locations at which to evaluate the correlation matirx
sx, sy : float
major/minor axes of the gaussian correlation function (sigmas)
theta : float
position angle of the gaussian correlation function (degrees)
Returns
-------
data : array-like
The C-matrix.
"""
C = np.vstack([elliptical_gaussian(x, y, 1, i, j, sx, sy, theta) for i, j in zip(x, y)])
return C | python | def Cmatrix(x, y, sx, sy, theta):
"""
Construct a correlation matrix corresponding to the data.
The matrix assumes a gaussian correlation function.
Parameters
----------
x, y : array-like
locations at which to evaluate the correlation matirx
sx, sy : float
major/minor axes of the gaussian correlation function (sigmas)
theta : float
position angle of the gaussian correlation function (degrees)
Returns
-------
data : array-like
The C-matrix.
"""
C = np.vstack([elliptical_gaussian(x, y, 1, i, j, sx, sy, theta) for i, j in zip(x, y)])
return C | [
"def",
"Cmatrix",
"(",
"x",
",",
"y",
",",
"sx",
",",
"sy",
",",
"theta",
")",
":",
"C",
"=",
"np",
".",
"vstack",
"(",
"[",
"elliptical_gaussian",
"(",
"x",
",",
"y",
",",
"1",
",",
"i",
",",
"j",
",",
"sx",
",",
"sy",
",",
"theta",
")",
... | Construct a correlation matrix corresponding to the data.
The matrix assumes a gaussian correlation function.
Parameters
----------
x, y : array-like
locations at which to evaluate the correlation matirx
sx, sy : float
major/minor axes of the gaussian correlation function (sigmas)
theta : float
position angle of the gaussian correlation function (degrees)
Returns
-------
data : array-like
The C-matrix. | [
"Construct",
"a",
"correlation",
"matrix",
"corresponding",
"to",
"the",
"data",
".",
"The",
"matrix",
"assumes",
"a",
"gaussian",
"correlation",
"function",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L66-L87 |
PaulHancock/Aegean | AegeanTools/fitting.py | Bmatrix | def Bmatrix(C):
"""
Calculate a matrix which is effectively the square root of the correlation matrix C
Parameters
----------
C : 2d array
A covariance matrix
Returns
-------
B : 2d array
A matrix B such the B.dot(B') = inv(C)
"""
# this version of finding the square root of the inverse matrix
# suggested by Cath Trott
L, Q = eigh(C)
# force very small eigenvalues to have some minimum non-zero value
minL = 1e-9*L[-1]
L[L < minL] = minL
S = np.diag(1 / np.sqrt(L))
B = Q.dot(S)
return B | python | def Bmatrix(C):
"""
Calculate a matrix which is effectively the square root of the correlation matrix C
Parameters
----------
C : 2d array
A covariance matrix
Returns
-------
B : 2d array
A matrix B such the B.dot(B') = inv(C)
"""
# this version of finding the square root of the inverse matrix
# suggested by Cath Trott
L, Q = eigh(C)
# force very small eigenvalues to have some minimum non-zero value
minL = 1e-9*L[-1]
L[L < minL] = minL
S = np.diag(1 / np.sqrt(L))
B = Q.dot(S)
return B | [
"def",
"Bmatrix",
"(",
"C",
")",
":",
"# this version of finding the square root of the inverse matrix",
"# suggested by Cath Trott",
"L",
",",
"Q",
"=",
"eigh",
"(",
"C",
")",
"# force very small eigenvalues to have some minimum non-zero value",
"minL",
"=",
"1e-9",
"*",
"... | Calculate a matrix which is effectively the square root of the correlation matrix C
Parameters
----------
C : 2d array
A covariance matrix
Returns
-------
B : 2d array
A matrix B such the B.dot(B') = inv(C) | [
"Calculate",
"a",
"matrix",
"which",
"is",
"effectively",
"the",
"square",
"root",
"of",
"the",
"correlation",
"matrix",
"C"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L90-L113 |
PaulHancock/Aegean | AegeanTools/fitting.py | jacobian | def jacobian(pars, x, y):
"""
Analytical calculation of the Jacobian for an elliptical gaussian
Will work for a model that contains multiple Gaussians, and for which
some components are not being fit (don't vary).
Parameters
----------
pars : lmfit.Model
The model parameters
x, y : list
Locations at which the jacobian is being evaluated
Returns
-------
j : 2d array
The Jacobian.
See Also
--------
:func:`AegeanTools.fitting.emp_jacobian`
"""
matrix = []
for i in range(pars['components'].value):
prefix = "c{0}_".format(i)
amp = pars[prefix + 'amp'].value
xo = pars[prefix + 'xo'].value
yo = pars[prefix + 'yo'].value
sx = pars[prefix + 'sx'].value
sy = pars[prefix + 'sy'].value
theta = pars[prefix + 'theta'].value
# The derivative with respect to component i doesn't depend on any other components
# thus the model should not contain the other components
model = elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta)
# precompute for speed
sint = np.sin(np.radians(theta))
cost = np.cos(np.radians(theta))
xxo = x - xo
yyo = y - yo
xcos, ycos = xxo * cost, yyo * cost
xsin, ysin = xxo * sint, yyo * sint
if pars[prefix + 'amp'].vary:
dmds = model / amp
matrix.append(dmds)
if pars[prefix + 'xo'].vary:
dmdxo = cost * (xcos + ysin) / sx ** 2 + sint * (xsin - ycos) / sy ** 2
dmdxo *= model
matrix.append(dmdxo)
if pars[prefix + 'yo'].vary:
dmdyo = sint * (xcos + ysin) / sx ** 2 - cost * (xsin - ycos) / sy ** 2
dmdyo *= model
matrix.append(dmdyo)
if pars[prefix + 'sx'].vary:
dmdsx = model / sx ** 3 * (xcos + ysin) ** 2
matrix.append(dmdsx)
if pars[prefix + 'sy'].vary:
dmdsy = model / sy ** 3 * (xsin - ycos) ** 2
matrix.append(dmdsy)
if pars[prefix + 'theta'].vary:
dmdtheta = model * (sy ** 2 - sx ** 2) * (xsin - ycos) * (xcos + ysin) / sx ** 2 / sy ** 2
matrix.append(dmdtheta)
return np.array(matrix) | python | def jacobian(pars, x, y):
"""
Analytical calculation of the Jacobian for an elliptical gaussian
Will work for a model that contains multiple Gaussians, and for which
some components are not being fit (don't vary).
Parameters
----------
pars : lmfit.Model
The model parameters
x, y : list
Locations at which the jacobian is being evaluated
Returns
-------
j : 2d array
The Jacobian.
See Also
--------
:func:`AegeanTools.fitting.emp_jacobian`
"""
matrix = []
for i in range(pars['components'].value):
prefix = "c{0}_".format(i)
amp = pars[prefix + 'amp'].value
xo = pars[prefix + 'xo'].value
yo = pars[prefix + 'yo'].value
sx = pars[prefix + 'sx'].value
sy = pars[prefix + 'sy'].value
theta = pars[prefix + 'theta'].value
# The derivative with respect to component i doesn't depend on any other components
# thus the model should not contain the other components
model = elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta)
# precompute for speed
sint = np.sin(np.radians(theta))
cost = np.cos(np.radians(theta))
xxo = x - xo
yyo = y - yo
xcos, ycos = xxo * cost, yyo * cost
xsin, ysin = xxo * sint, yyo * sint
if pars[prefix + 'amp'].vary:
dmds = model / amp
matrix.append(dmds)
if pars[prefix + 'xo'].vary:
dmdxo = cost * (xcos + ysin) / sx ** 2 + sint * (xsin - ycos) / sy ** 2
dmdxo *= model
matrix.append(dmdxo)
if pars[prefix + 'yo'].vary:
dmdyo = sint * (xcos + ysin) / sx ** 2 - cost * (xsin - ycos) / sy ** 2
dmdyo *= model
matrix.append(dmdyo)
if pars[prefix + 'sx'].vary:
dmdsx = model / sx ** 3 * (xcos + ysin) ** 2
matrix.append(dmdsx)
if pars[prefix + 'sy'].vary:
dmdsy = model / sy ** 3 * (xsin - ycos) ** 2
matrix.append(dmdsy)
if pars[prefix + 'theta'].vary:
dmdtheta = model * (sy ** 2 - sx ** 2) * (xsin - ycos) * (xcos + ysin) / sx ** 2 / sy ** 2
matrix.append(dmdtheta)
return np.array(matrix) | [
"def",
"jacobian",
"(",
"pars",
",",
"x",
",",
"y",
")",
":",
"matrix",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"pars",
"[",
"'components'",
"]",
".",
"value",
")",
":",
"prefix",
"=",
"\"c{0}_\"",
".",
"format",
"(",
"i",
")",
"amp",
"=... | Analytical calculation of the Jacobian for an elliptical gaussian
Will work for a model that contains multiple Gaussians, and for which
some components are not being fit (don't vary).
Parameters
----------
pars : lmfit.Model
The model parameters
x, y : list
Locations at which the jacobian is being evaluated
Returns
-------
j : 2d array
The Jacobian.
See Also
--------
:func:`AegeanTools.fitting.emp_jacobian` | [
"Analytical",
"calculation",
"of",
"the",
"Jacobian",
"for",
"an",
"elliptical",
"gaussian",
"Will",
"work",
"for",
"a",
"model",
"that",
"contains",
"multiple",
"Gaussians",
"and",
"for",
"which",
"some",
"components",
"are",
"not",
"being",
"fit",
"(",
"don"... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L116-L188 |
PaulHancock/Aegean | AegeanTools/fitting.py | lmfit_jacobian | def lmfit_jacobian(pars, x, y, errs=None, B=None, emp=False):
"""
Wrapper around :func:`AegeanTools.fitting.jacobian` and :func:`AegeanTools.fitting.emp_jacobian`
which gives the output in a format that is required for lmfit.
Parameters
----------
pars : lmfit.Model
The model parameters
x, y : list
Locations at which the jacobian is being evaluated
errs : list
a vector of 1\sigma errors (optional). Default = None
B : 2d-array
a B-matrix (optional) see :func:`AegeanTools.fitting.Bmatrix`
emp : bool
If true the use the empirical Jacobian, otherwise use the analytical one.
Default = False.
Returns
-------
j : 2d-array
A Jacobian.
See Also
--------
:func:`AegeanTools.fitting.Bmatrix`
:func:`AegeanTools.fitting.jacobian`
:func:`AegeanTools.fitting.emp_jacobian`
"""
if emp:
matrix = emp_jacobian(pars, x, y)
else:
# calculate in the normal way
matrix = jacobian(pars, x, y)
# now munge this to be as expected for lmfit
matrix = np.vstack(matrix)
if errs is not None:
matrix /= errs
# matrix = matrix.dot(errs)
if B is not None:
matrix = matrix.dot(B)
matrix = np.transpose(matrix)
return matrix | python | def lmfit_jacobian(pars, x, y, errs=None, B=None, emp=False):
"""
Wrapper around :func:`AegeanTools.fitting.jacobian` and :func:`AegeanTools.fitting.emp_jacobian`
which gives the output in a format that is required for lmfit.
Parameters
----------
pars : lmfit.Model
The model parameters
x, y : list
Locations at which the jacobian is being evaluated
errs : list
a vector of 1\sigma errors (optional). Default = None
B : 2d-array
a B-matrix (optional) see :func:`AegeanTools.fitting.Bmatrix`
emp : bool
If true the use the empirical Jacobian, otherwise use the analytical one.
Default = False.
Returns
-------
j : 2d-array
A Jacobian.
See Also
--------
:func:`AegeanTools.fitting.Bmatrix`
:func:`AegeanTools.fitting.jacobian`
:func:`AegeanTools.fitting.emp_jacobian`
"""
if emp:
matrix = emp_jacobian(pars, x, y)
else:
# calculate in the normal way
matrix = jacobian(pars, x, y)
# now munge this to be as expected for lmfit
matrix = np.vstack(matrix)
if errs is not None:
matrix /= errs
# matrix = matrix.dot(errs)
if B is not None:
matrix = matrix.dot(B)
matrix = np.transpose(matrix)
return matrix | [
"def",
"lmfit_jacobian",
"(",
"pars",
",",
"x",
",",
"y",
",",
"errs",
"=",
"None",
",",
"B",
"=",
"None",
",",
"emp",
"=",
"False",
")",
":",
"if",
"emp",
":",
"matrix",
"=",
"emp_jacobian",
"(",
"pars",
",",
"x",
",",
"y",
")",
"else",
":",
... | Wrapper around :func:`AegeanTools.fitting.jacobian` and :func:`AegeanTools.fitting.emp_jacobian`
which gives the output in a format that is required for lmfit.
Parameters
----------
pars : lmfit.Model
The model parameters
x, y : list
Locations at which the jacobian is being evaluated
errs : list
a vector of 1\sigma errors (optional). Default = None
B : 2d-array
a B-matrix (optional) see :func:`AegeanTools.fitting.Bmatrix`
emp : bool
If true the use the empirical Jacobian, otherwise use the analytical one.
Default = False.
Returns
-------
j : 2d-array
A Jacobian.
See Also
--------
:func:`AegeanTools.fitting.Bmatrix`
:func:`AegeanTools.fitting.jacobian`
:func:`AegeanTools.fitting.emp_jacobian` | [
"Wrapper",
"around",
":",
"func",
":",
"AegeanTools",
".",
"fitting",
".",
"jacobian",
"and",
":",
"func",
":",
"AegeanTools",
".",
"fitting",
".",
"emp_jacobian",
"which",
"gives",
"the",
"output",
"in",
"a",
"format",
"that",
"is",
"required",
"for",
"lm... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L228-L279 |
PaulHancock/Aegean | AegeanTools/fitting.py | hessian | def hessian(pars, x, y):
"""
Create a hessian matrix corresponding to the source model 'pars'
Only parameters that vary will contribute to the hessian.
Thus there will be a total of nvar x nvar entries, each of which is a
len(x) x len(y) array.
Parameters
----------
pars : lmfit.Parameters
The model
x, y : list
locations at which to evaluate the Hessian
Returns
-------
h : np.array
Hessian. Shape will be (nvar, nvar, len(x), len(y))
See Also
--------
:func:`AegeanTools.fitting.emp_hessian`
"""
j = 0 # keeping track of the number of variable parameters
# total number of variable parameters
ntvar = np.sum([pars[k].vary for k in pars.keys() if k != 'components'])
# construct an empty matrix of the correct size
hmat = np.zeros((ntvar, ntvar, x.shape[0], x.shape[1]))
npvar = 0
for i in range(pars['components'].value):
prefix = "c{0}_".format(i)
amp = pars[prefix + 'amp'].value
xo = pars[prefix + 'xo'].value
yo = pars[prefix + 'yo'].value
sx = pars[prefix + 'sx'].value
sy = pars[prefix + 'sy'].value
theta = pars[prefix + 'theta'].value
amp_var = pars[prefix + 'amp'].vary
xo_var = pars[prefix + 'xo'].vary
yo_var = pars[prefix + 'yo'].vary
sx_var = pars[prefix + 'sx'].vary
sy_var = pars[prefix + 'sy'].vary
theta_var = pars[prefix + 'theta'].vary
# precomputed for speed
model = elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta)
sint = np.sin(np.radians(theta))
sin2t = np.sin(np.radians(2*theta))
cost = np.cos(np.radians(theta))
cos2t = np.cos(np.radians(2*theta))
sx2 = sx**2
sy2 = sy**2
xxo = x-xo
yyo = y-yo
xcos, ycos = xxo*cost, yyo*cost
xsin, ysin = xxo*sint, yyo*sint
if amp_var:
k = npvar # second round of keeping track of variable params
# H(amp,amp)/G = 0
hmat[j][k] = 0
k += 1
if xo_var:
# H(amp,xo)/G = 1.0*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t))/(amp*sx**2*sy**2)
hmat[j][k] = (xsin - ycos)*sint/sy2 + (xcos + ysin)*cost/sx2
hmat[j][k] *= model
k += 1
if yo_var:
# H(amp,yo)/G = 1.0*(-sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t))/(amp*sx**2*sy**2)
hmat[j][k] = -(xsin - ycos)*cost/sy2 + (xcos + ysin)*sint/sx2
hmat[j][k] *= model/amp
k += 1
if sx_var:
# H(amp,sx)/G = 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))**2/(amp*sx**3)
hmat[j][k] = (xcos + ysin)**2
hmat[j][k] *= model/(amp*sx**3)
k += 1
if sy_var:
# H(amp,sy) = 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))**2/(amp*sy**3)
hmat[j][k] = (xsin - ycos)**2
hmat[j][k] *= model/(amp*sy**3)
k += 1
if theta_var:
# H(amp,t) = (-1.0*sx**2 + sy**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))/(amp*sx**2*sy**2)
hmat[j][k] = (xsin - ycos)*(xcos + ysin)
hmat[j][k] *= sy2-sx2
hmat[j][k] *= model/(amp*sx2*sy2)
# k += 1
j += 1
if xo_var:
k = npvar
if amp_var:
# H(xo,amp)/G = H(amp,xo)
hmat[j][k] = hmat[k][j]
k += 1
# if xo_var:
# H(xo,xo)/G = 1.0*(-sx**2*sy**2*(sx**2*sin(t)**2 + sy**2*cos(t)**2) + (sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t))**2)/(sx**4*sy**4)
hmat[j][k] = -sx2*sy2*(sx2*sint**2 + sy2*cost**2)
hmat[j][k] += (sx2*(xsin - ycos)*sint + sy2*(xcos + ysin)*cost)**2
hmat[j][k] *= model/ (sx2**2*sy2**2)
k += 1
if yo_var:
# H(xo,yo)/G = 1.0*(sx**2*sy**2*(sx**2 - sy**2)*sin(2*t)/2 - (sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t)))/(sx**4*sy**4)
hmat[j][k] = sx2*sy2*(sx2 - sy2)*sin2t/2
hmat[j][k] -= (sx2*(xsin - ycos)*sint + sy2*(xcos + ysin)*cost)*(sx2*(xsin -ycos)*cost - sy2*(xcos + ysin)*sint)
hmat[j][k] *= model / (sx**4*sy**4)
k += 1
if sx_var:
# H(xo,sx) = ((x - xo)*cos(t) + (y - yo)*sin(t))*(-2.0*sx**2*sy**2*cos(t) + 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t)))/(sx**5*sy**2)
hmat[j][k] = (xcos + ysin)
hmat[j][k] *= -2*sx2*sy2*cost + (xcos + ysin)*(sx2*(xsin - ycos)*sint + sy2*(xcos + ysin)*cost)
hmat[j][k] *= model / (sx**5*sy2)
k += 1
if sy_var:
# H(xo,sy) = ((x - xo)*sin(t) + (-y + yo)*cos(t))*(-2.0*sx**2*sy**2*sin(t) + 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t)))/(sx2*sy**5)
hmat[j][k] = (xsin - ycos)
hmat[j][k] *= -2*sx2*sy2*sint + (xsin - ycos)*(sx2*(xsin - ycos)*sint + sy2*(xcos + ysin)*cost)
hmat[j][k] *= model/(sx2*sy**5)
k += 1
if theta_var:
# H(xo,t) = 1.0*(sx**2*sy**2*(sx**2 - sy**2)*(x*sin(2*t) - xo*sin(2*t) - y*cos(2*t) + yo*cos(2*t)) + (-sx**2 + 1.0*sy**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t)))/(sx**4*sy**4)
# second part
hmat[j][k] = (sy2-sx2)*(xsin - ycos)*(xcos + ysin)
hmat[j][k] *= sx2*(xsin -ycos)*sint + sy2*(xcos + ysin)*cost
# first part
hmat[j][k] += sx2*sy2*(sx2 - sy2)*(xxo*sin2t -yyo*cos2t)
hmat[j][k] *= model/(sx**4*sy**4)
# k += 1
j += 1
if yo_var:
k = npvar
if amp_var:
# H(yo,amp)/G = H(amp,yo)
hmat[j][k] = hmat[0][2]
k += 1
if xo_var:
# H(yo,xo)/G = H(xo,yo)/G
hmat[j][k] =hmat[1][2]
k += 1
# if yo_var:
# H(yo,yo)/G = 1.0*(-sx**2*sy**2*(sx**2*cos(t)**2 + sy**2*sin(t)**2) + (sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t))**2)/(sx**4*sy**4)
hmat[j][k] = (sx2*(xsin - ycos)*cost - sy2*(xcos + ysin)*sint)**2 / (sx2**2*sy2**2)
hmat[j][k] -= cost**2/sy2 + sint**2/sx2
hmat[j][k] *= model
k += 1
if sx_var:
# H(yo,sx)/G = -((x - xo)*cos(t) + (y - yo)*sin(t))*(2.0*sx**2*sy**2*sin(t) + 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))*(sx**2*((x - xo)*sin(t) - (y - yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t)))/(sx**5*sy**2)
hmat[j][k] = -1*(xcos + ysin)
hmat[j][k] *= 2*sx2*sy2*sint + (xcos + ysin)*(sx2*(xsin - ycos)*cost - sy2*(xcos + ysin)*sint)
hmat[j][k] *= model/(sx**5*sy2)
k += 1
if sy_var:
# H(yo,sy)/G = ((x - xo)*sin(t) + (-y + yo)*cos(t))*(2.0*sx**2*sy**2*cos(t) - 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t)))/(sx**2*sy**5)
hmat[j][k] = (xsin -ycos)
hmat[j][k] *= 2*sx2*sy2*cost - (xsin - ycos)*(sx2*(xsin - ycos)*cost - sy2*(xcos + ysin)*sint)
hmat[j][k] *= model/(sx2*sy**5)
k += 1
if theta_var:
# H(yo,t)/G = 1.0*(sx**2*sy**2*(sx**2*(-x*cos(2*t) + xo*cos(2*t) - y*sin(2*t) + yo*sin(2*t)) + sy**2*(x*cos(2*t) - xo*cos(2*t) + y*sin(2*t) - yo*sin(2*t))) + (1.0*sx**2 - sy**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t)))/(sx**4*sy**4)
hmat[j][k] = (sx2 - sy2)*(xsin - ycos)*(xcos + ysin)
hmat[j][k] *= (sx2*(xsin - ycos)*cost - sy2*(xcos + ysin)*sint)
hmat[j][k] += sx2*sy2*(sx2-sy2)*(-x*cos2t + xo*cos2t - y*sin2t + yo*sin2t)
hmat[j][k] *= model/(sx**4*sy**4)
# k += 1
j += 1
if sx_var:
k = npvar
if amp_var:
# H(sx,amp)/G = H(amp,sx)/G
hmat[j][k] = hmat[k][j]
k += 1
if xo_var:
# H(sx,xo)/G = H(xo,sx)/G
hmat[j][k] = hmat[k][j]
k += 1
if yo_var:
# H(sx,yo)/G = H(yo/sx)/G
hmat[j][k] = hmat[k][j]
k += 1
# if sx_var:
# H(sx,sx)/G = (-3.0*sx**2 + 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))**2)*((x - xo)*cos(t) + (y - yo)*sin(t))**2/sx**6
hmat[j][k] = -3*sx2 + (xcos + ysin)**2
hmat[j][k] *= (xcos + ysin)**2
hmat[j][k] *= model/sx**6
k += 1
if sy_var:
# H(sx,sy)/G = 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))**2*((x - xo)*cos(t) + (y - yo)*sin(t))**2/(sx**3*sy**3)
hmat[j][k] = (xsin - ycos)**2 * (xcos + ysin)**2
hmat[j][k] *= model/(sx**3*sy**3)
k += 1
if theta_var:
# H(sx,t)/G = (-2.0*sx**2*sy**2 + 1.0*(-sx**2 + sy**2)*((x - xo)*cos(t) + (y - yo)*sin(t))**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))/(sx**5*sy**2)
hmat[j][k] = -2*sx2*sy2 + (sy2 - sx2)*(xcos + ysin)**2
hmat[j][k] *= (xsin -ycos)*(xcos + ysin)
hmat[j][k] *= model/(sx**5*sy**2)
# k += 1
j += 1
if sy_var:
k = npvar
if amp_var:
# H(sy,amp)/G = H(amp,sy)/G
hmat[j][k] = hmat[k][j]
k += 1
if xo_var:
# H(sy,xo)/G = H(xo,sy)/G
hmat[j][k] = hmat[k][j]
k += 1
if yo_var:
# H(sy,yo)/G = H(yo/sy)/G
hmat[j][k] = hmat[k][j]
k += 1
if sx_var:
# H(sy,sx)/G = H(sx,sy)/G
hmat[j][k] = hmat[k][j]
k += 1
# if sy_var:
# H(sy,sy)/G = (-3.0*sy**2 + 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))**2/sy**6
hmat[j][k] = -3*sy2 + (xsin - ycos)**2
hmat[j][k] *= (xsin - ycos)**2
hmat[j][k] *= model/sy**6
k += 1
if theta_var:
# H(sy,t)/G = (2.0*sx**2*sy**2 + 1.0*(-sx**2 + sy**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))/(sx**2*sy**5)
hmat[j][k] = 2*sx2*sy2 + (sy2 - sx2)*(xsin - ycos)**2
hmat[j][k] *= (xsin - ycos)*(xcos + ysin)
hmat[j][k] *= model/(sx**2*sy**5)
# k += 1
j += 1
if theta_var:
k = npvar
if amp_var:
# H(t,amp)/G = H(amp,t)/G
hmat[j][k] = hmat[k][j]
k += 1
if xo_var:
# H(t,xo)/G = H(xo,t)/G
hmat[j][k] = hmat[k][j]
k += 1
if yo_var:
# H(t,yo)/G = H(yo/t)/G
hmat[j][k] = hmat[k][j]
k += 1
if sx_var:
# H(t,sx)/G = H(sx,t)/G
hmat[j][k] = hmat[k][j]
k += 1
if sy_var:
# H(t,sy)/G = H(sy,t)/G
hmat[j][k] = hmat[k][j]
k += 1
# if theta_var:
# H(t,t)/G = (sx**2*sy**2*(sx**2*(((x - xo)*sin(t) + (-y + yo)*cos(t))**2 - 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))**2) + sy**2*(-1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))**2 + ((x - xo)*cos(t) + (y - yo)*sin(t))**2)) + (sx**2 - 1.0*sy**2)**2*((x - xo)*sin(t) + (-y + yo)*cos(t))**2*((x - xo)*cos(t) + (y - yo)*sin(t))**2)/(sx**4*sy**4)
hmat[j][k] = sx2*sy2
hmat[j][k] *= sx2*((xsin - ycos)**2 - (xcos + ysin)**2) + sy2*((xcos + ysin)**2 - (xsin - ycos)**2)
hmat[j][k] += (sx2 - sy2)**2*(xsin - ycos)**2*(xcos + ysin)**2
hmat[j][k] *= model/(sx**4*sy**4)
# j += 1
# save the number of variables for the next iteration
# as we need to start our indexing at this number
npvar = k
return np.array(hmat) | python | def hessian(pars, x, y):
"""
Create a hessian matrix corresponding to the source model 'pars'
Only parameters that vary will contribute to the hessian.
Thus there will be a total of nvar x nvar entries, each of which is a
len(x) x len(y) array.
Parameters
----------
pars : lmfit.Parameters
The model
x, y : list
locations at which to evaluate the Hessian
Returns
-------
h : np.array
Hessian. Shape will be (nvar, nvar, len(x), len(y))
See Also
--------
:func:`AegeanTools.fitting.emp_hessian`
"""
j = 0 # keeping track of the number of variable parameters
# total number of variable parameters
ntvar = np.sum([pars[k].vary for k in pars.keys() if k != 'components'])
# construct an empty matrix of the correct size
hmat = np.zeros((ntvar, ntvar, x.shape[0], x.shape[1]))
npvar = 0
for i in range(pars['components'].value):
prefix = "c{0}_".format(i)
amp = pars[prefix + 'amp'].value
xo = pars[prefix + 'xo'].value
yo = pars[prefix + 'yo'].value
sx = pars[prefix + 'sx'].value
sy = pars[prefix + 'sy'].value
theta = pars[prefix + 'theta'].value
amp_var = pars[prefix + 'amp'].vary
xo_var = pars[prefix + 'xo'].vary
yo_var = pars[prefix + 'yo'].vary
sx_var = pars[prefix + 'sx'].vary
sy_var = pars[prefix + 'sy'].vary
theta_var = pars[prefix + 'theta'].vary
# precomputed for speed
model = elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta)
sint = np.sin(np.radians(theta))
sin2t = np.sin(np.radians(2*theta))
cost = np.cos(np.radians(theta))
cos2t = np.cos(np.radians(2*theta))
sx2 = sx**2
sy2 = sy**2
xxo = x-xo
yyo = y-yo
xcos, ycos = xxo*cost, yyo*cost
xsin, ysin = xxo*sint, yyo*sint
if amp_var:
k = npvar # second round of keeping track of variable params
# H(amp,amp)/G = 0
hmat[j][k] = 0
k += 1
if xo_var:
# H(amp,xo)/G = 1.0*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t))/(amp*sx**2*sy**2)
hmat[j][k] = (xsin - ycos)*sint/sy2 + (xcos + ysin)*cost/sx2
hmat[j][k] *= model
k += 1
if yo_var:
# H(amp,yo)/G = 1.0*(-sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t))/(amp*sx**2*sy**2)
hmat[j][k] = -(xsin - ycos)*cost/sy2 + (xcos + ysin)*sint/sx2
hmat[j][k] *= model/amp
k += 1
if sx_var:
# H(amp,sx)/G = 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))**2/(amp*sx**3)
hmat[j][k] = (xcos + ysin)**2
hmat[j][k] *= model/(amp*sx**3)
k += 1
if sy_var:
# H(amp,sy) = 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))**2/(amp*sy**3)
hmat[j][k] = (xsin - ycos)**2
hmat[j][k] *= model/(amp*sy**3)
k += 1
if theta_var:
# H(amp,t) = (-1.0*sx**2 + sy**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))/(amp*sx**2*sy**2)
hmat[j][k] = (xsin - ycos)*(xcos + ysin)
hmat[j][k] *= sy2-sx2
hmat[j][k] *= model/(amp*sx2*sy2)
# k += 1
j += 1
if xo_var:
k = npvar
if amp_var:
# H(xo,amp)/G = H(amp,xo)
hmat[j][k] = hmat[k][j]
k += 1
# if xo_var:
# H(xo,xo)/G = 1.0*(-sx**2*sy**2*(sx**2*sin(t)**2 + sy**2*cos(t)**2) + (sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t))**2)/(sx**4*sy**4)
hmat[j][k] = -sx2*sy2*(sx2*sint**2 + sy2*cost**2)
hmat[j][k] += (sx2*(xsin - ycos)*sint + sy2*(xcos + ysin)*cost)**2
hmat[j][k] *= model/ (sx2**2*sy2**2)
k += 1
if yo_var:
# H(xo,yo)/G = 1.0*(sx**2*sy**2*(sx**2 - sy**2)*sin(2*t)/2 - (sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t)))/(sx**4*sy**4)
hmat[j][k] = sx2*sy2*(sx2 - sy2)*sin2t/2
hmat[j][k] -= (sx2*(xsin - ycos)*sint + sy2*(xcos + ysin)*cost)*(sx2*(xsin -ycos)*cost - sy2*(xcos + ysin)*sint)
hmat[j][k] *= model / (sx**4*sy**4)
k += 1
if sx_var:
# H(xo,sx) = ((x - xo)*cos(t) + (y - yo)*sin(t))*(-2.0*sx**2*sy**2*cos(t) + 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t)))/(sx**5*sy**2)
hmat[j][k] = (xcos + ysin)
hmat[j][k] *= -2*sx2*sy2*cost + (xcos + ysin)*(sx2*(xsin - ycos)*sint + sy2*(xcos + ysin)*cost)
hmat[j][k] *= model / (sx**5*sy2)
k += 1
if sy_var:
# H(xo,sy) = ((x - xo)*sin(t) + (-y + yo)*cos(t))*(-2.0*sx**2*sy**2*sin(t) + 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t)))/(sx2*sy**5)
hmat[j][k] = (xsin - ycos)
hmat[j][k] *= -2*sx2*sy2*sint + (xsin - ycos)*(sx2*(xsin - ycos)*sint + sy2*(xcos + ysin)*cost)
hmat[j][k] *= model/(sx2*sy**5)
k += 1
if theta_var:
# H(xo,t) = 1.0*(sx**2*sy**2*(sx**2 - sy**2)*(x*sin(2*t) - xo*sin(2*t) - y*cos(2*t) + yo*cos(2*t)) + (-sx**2 + 1.0*sy**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*sin(t) + sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*cos(t)))/(sx**4*sy**4)
# second part
hmat[j][k] = (sy2-sx2)*(xsin - ycos)*(xcos + ysin)
hmat[j][k] *= sx2*(xsin -ycos)*sint + sy2*(xcos + ysin)*cost
# first part
hmat[j][k] += sx2*sy2*(sx2 - sy2)*(xxo*sin2t -yyo*cos2t)
hmat[j][k] *= model/(sx**4*sy**4)
# k += 1
j += 1
if yo_var:
k = npvar
if amp_var:
# H(yo,amp)/G = H(amp,yo)
hmat[j][k] = hmat[0][2]
k += 1
if xo_var:
# H(yo,xo)/G = H(xo,yo)/G
hmat[j][k] =hmat[1][2]
k += 1
# if yo_var:
# H(yo,yo)/G = 1.0*(-sx**2*sy**2*(sx**2*cos(t)**2 + sy**2*sin(t)**2) + (sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t))**2)/(sx**4*sy**4)
hmat[j][k] = (sx2*(xsin - ycos)*cost - sy2*(xcos + ysin)*sint)**2 / (sx2**2*sy2**2)
hmat[j][k] -= cost**2/sy2 + sint**2/sx2
hmat[j][k] *= model
k += 1
if sx_var:
# H(yo,sx)/G = -((x - xo)*cos(t) + (y - yo)*sin(t))*(2.0*sx**2*sy**2*sin(t) + 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))*(sx**2*((x - xo)*sin(t) - (y - yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t)))/(sx**5*sy**2)
hmat[j][k] = -1*(xcos + ysin)
hmat[j][k] *= 2*sx2*sy2*sint + (xcos + ysin)*(sx2*(xsin - ycos)*cost - sy2*(xcos + ysin)*sint)
hmat[j][k] *= model/(sx**5*sy2)
k += 1
if sy_var:
# H(yo,sy)/G = ((x - xo)*sin(t) + (-y + yo)*cos(t))*(2.0*sx**2*sy**2*cos(t) - 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t)))/(sx**2*sy**5)
hmat[j][k] = (xsin -ycos)
hmat[j][k] *= 2*sx2*sy2*cost - (xsin - ycos)*(sx2*(xsin - ycos)*cost - sy2*(xcos + ysin)*sint)
hmat[j][k] *= model/(sx2*sy**5)
k += 1
if theta_var:
# H(yo,t)/G = 1.0*(sx**2*sy**2*(sx**2*(-x*cos(2*t) + xo*cos(2*t) - y*sin(2*t) + yo*sin(2*t)) + sy**2*(x*cos(2*t) - xo*cos(2*t) + y*sin(2*t) - yo*sin(2*t))) + (1.0*sx**2 - sy**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))*(sx**2*((x - xo)*sin(t) + (-y + yo)*cos(t))*cos(t) - sy**2*((x - xo)*cos(t) + (y - yo)*sin(t))*sin(t)))/(sx**4*sy**4)
hmat[j][k] = (sx2 - sy2)*(xsin - ycos)*(xcos + ysin)
hmat[j][k] *= (sx2*(xsin - ycos)*cost - sy2*(xcos + ysin)*sint)
hmat[j][k] += sx2*sy2*(sx2-sy2)*(-x*cos2t + xo*cos2t - y*sin2t + yo*sin2t)
hmat[j][k] *= model/(sx**4*sy**4)
# k += 1
j += 1
if sx_var:
k = npvar
if amp_var:
# H(sx,amp)/G = H(amp,sx)/G
hmat[j][k] = hmat[k][j]
k += 1
if xo_var:
# H(sx,xo)/G = H(xo,sx)/G
hmat[j][k] = hmat[k][j]
k += 1
if yo_var:
# H(sx,yo)/G = H(yo/sx)/G
hmat[j][k] = hmat[k][j]
k += 1
# if sx_var:
# H(sx,sx)/G = (-3.0*sx**2 + 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))**2)*((x - xo)*cos(t) + (y - yo)*sin(t))**2/sx**6
hmat[j][k] = -3*sx2 + (xcos + ysin)**2
hmat[j][k] *= (xcos + ysin)**2
hmat[j][k] *= model/sx**6
k += 1
if sy_var:
# H(sx,sy)/G = 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))**2*((x - xo)*cos(t) + (y - yo)*sin(t))**2/(sx**3*sy**3)
hmat[j][k] = (xsin - ycos)**2 * (xcos + ysin)**2
hmat[j][k] *= model/(sx**3*sy**3)
k += 1
if theta_var:
# H(sx,t)/G = (-2.0*sx**2*sy**2 + 1.0*(-sx**2 + sy**2)*((x - xo)*cos(t) + (y - yo)*sin(t))**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))/(sx**5*sy**2)
hmat[j][k] = -2*sx2*sy2 + (sy2 - sx2)*(xcos + ysin)**2
hmat[j][k] *= (xsin -ycos)*(xcos + ysin)
hmat[j][k] *= model/(sx**5*sy**2)
# k += 1
j += 1
if sy_var:
k = npvar
if amp_var:
# H(sy,amp)/G = H(amp,sy)/G
hmat[j][k] = hmat[k][j]
k += 1
if xo_var:
# H(sy,xo)/G = H(xo,sy)/G
hmat[j][k] = hmat[k][j]
k += 1
if yo_var:
# H(sy,yo)/G = H(yo/sy)/G
hmat[j][k] = hmat[k][j]
k += 1
if sx_var:
# H(sy,sx)/G = H(sx,sy)/G
hmat[j][k] = hmat[k][j]
k += 1
# if sy_var:
# H(sy,sy)/G = (-3.0*sy**2 + 1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))**2/sy**6
hmat[j][k] = -3*sy2 + (xsin - ycos)**2
hmat[j][k] *= (xsin - ycos)**2
hmat[j][k] *= model/sy**6
k += 1
if theta_var:
# H(sy,t)/G = (2.0*sx**2*sy**2 + 1.0*(-sx**2 + sy**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))**2)*((x - xo)*sin(t) + (-y + yo)*cos(t))*((x - xo)*cos(t) + (y - yo)*sin(t))/(sx**2*sy**5)
hmat[j][k] = 2*sx2*sy2 + (sy2 - sx2)*(xsin - ycos)**2
hmat[j][k] *= (xsin - ycos)*(xcos + ysin)
hmat[j][k] *= model/(sx**2*sy**5)
# k += 1
j += 1
if theta_var:
k = npvar
if amp_var:
# H(t,amp)/G = H(amp,t)/G
hmat[j][k] = hmat[k][j]
k += 1
if xo_var:
# H(t,xo)/G = H(xo,t)/G
hmat[j][k] = hmat[k][j]
k += 1
if yo_var:
# H(t,yo)/G = H(yo/t)/G
hmat[j][k] = hmat[k][j]
k += 1
if sx_var:
# H(t,sx)/G = H(sx,t)/G
hmat[j][k] = hmat[k][j]
k += 1
if sy_var:
# H(t,sy)/G = H(sy,t)/G
hmat[j][k] = hmat[k][j]
k += 1
# if theta_var:
# H(t,t)/G = (sx**2*sy**2*(sx**2*(((x - xo)*sin(t) + (-y + yo)*cos(t))**2 - 1.0*((x - xo)*cos(t) + (y - yo)*sin(t))**2) + sy**2*(-1.0*((x - xo)*sin(t) + (-y + yo)*cos(t))**2 + ((x - xo)*cos(t) + (y - yo)*sin(t))**2)) + (sx**2 - 1.0*sy**2)**2*((x - xo)*sin(t) + (-y + yo)*cos(t))**2*((x - xo)*cos(t) + (y - yo)*sin(t))**2)/(sx**4*sy**4)
hmat[j][k] = sx2*sy2
hmat[j][k] *= sx2*((xsin - ycos)**2 - (xcos + ysin)**2) + sy2*((xcos + ysin)**2 - (xsin - ycos)**2)
hmat[j][k] += (sx2 - sy2)**2*(xsin - ycos)**2*(xcos + ysin)**2
hmat[j][k] *= model/(sx**4*sy**4)
# j += 1
# save the number of variables for the next iteration
# as we need to start our indexing at this number
npvar = k
return np.array(hmat) | [
"def",
"hessian",
"(",
"pars",
",",
"x",
",",
"y",
")",
":",
"j",
"=",
"0",
"# keeping track of the number of variable parameters",
"# total number of variable parameters",
"ntvar",
"=",
"np",
".",
"sum",
"(",
"[",
"pars",
"[",
"k",
"]",
".",
"vary",
"for",
... | Create a hessian matrix corresponding to the source model 'pars'
Only parameters that vary will contribute to the hessian.
Thus there will be a total of nvar x nvar entries, each of which is a
len(x) x len(y) array.
Parameters
----------
pars : lmfit.Parameters
The model
x, y : list
locations at which to evaluate the Hessian
Returns
-------
h : np.array
Hessian. Shape will be (nvar, nvar, len(x), len(y))
See Also
--------
:func:`AegeanTools.fitting.emp_hessian` | [
"Create",
"a",
"hessian",
"matrix",
"corresponding",
"to",
"the",
"source",
"model",
"pars",
"Only",
"parameters",
"that",
"vary",
"will",
"contribute",
"to",
"the",
"hessian",
".",
"Thus",
"there",
"will",
"be",
"a",
"total",
"of",
"nvar",
"x",
"nvar",
"e... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L282-L572 |
PaulHancock/Aegean | AegeanTools/fitting.py | emp_hessian | def emp_hessian(pars, x, y):
"""
Calculate the hessian matrix empirically.
Create a hessian matrix corresponding to the source model 'pars'
Only parameters that vary will contribute to the hessian.
Thus there will be a total of nvar x nvar entries, each of which is a
len(x) x len(y) array.
Parameters
----------
pars : lmfit.Parameters
The model
x, y : list
locations at which to evaluate the Hessian
Returns
-------
h : np.array
Hessian. Shape will be (nvar, nvar, len(x), len(y))
Notes
-----
Uses :func:`AegeanTools.fitting.emp_jacobian` to calculate the first order derivatives.
See Also
--------
:func:`AegeanTools.fitting.hessian`
"""
eps = 1e-5
matrix = []
for i in range(pars['components'].value):
model = emp_jacobian(pars, x, y)
prefix = "c{0}_".format(i)
for p in ['amp', 'xo', 'yo', 'sx', 'sy', 'theta']:
if pars[prefix+p].vary:
pars[prefix+p].value += eps
dm2didj = emp_jacobian(pars, x, y) - model
matrix.append(dm2didj/eps)
pars[prefix+p].value -= eps
matrix = np.array(matrix)
return matrix | python | def emp_hessian(pars, x, y):
"""
Calculate the hessian matrix empirically.
Create a hessian matrix corresponding to the source model 'pars'
Only parameters that vary will contribute to the hessian.
Thus there will be a total of nvar x nvar entries, each of which is a
len(x) x len(y) array.
Parameters
----------
pars : lmfit.Parameters
The model
x, y : list
locations at which to evaluate the Hessian
Returns
-------
h : np.array
Hessian. Shape will be (nvar, nvar, len(x), len(y))
Notes
-----
Uses :func:`AegeanTools.fitting.emp_jacobian` to calculate the first order derivatives.
See Also
--------
:func:`AegeanTools.fitting.hessian`
"""
eps = 1e-5
matrix = []
for i in range(pars['components'].value):
model = emp_jacobian(pars, x, y)
prefix = "c{0}_".format(i)
for p in ['amp', 'xo', 'yo', 'sx', 'sy', 'theta']:
if pars[prefix+p].vary:
pars[prefix+p].value += eps
dm2didj = emp_jacobian(pars, x, y) - model
matrix.append(dm2didj/eps)
pars[prefix+p].value -= eps
matrix = np.array(matrix)
return matrix | [
"def",
"emp_hessian",
"(",
"pars",
",",
"x",
",",
"y",
")",
":",
"eps",
"=",
"1e-5",
"matrix",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"pars",
"[",
"'components'",
"]",
".",
"value",
")",
":",
"model",
"=",
"emp_jacobian",
"(",
"pars",
","... | Calculate the hessian matrix empirically.
Create a hessian matrix corresponding to the source model 'pars'
Only parameters that vary will contribute to the hessian.
Thus there will be a total of nvar x nvar entries, each of which is a
len(x) x len(y) array.
Parameters
----------
pars : lmfit.Parameters
The model
x, y : list
locations at which to evaluate the Hessian
Returns
-------
h : np.array
Hessian. Shape will be (nvar, nvar, len(x), len(y))
Notes
-----
Uses :func:`AegeanTools.fitting.emp_jacobian` to calculate the first order derivatives.
See Also
--------
:func:`AegeanTools.fitting.hessian` | [
"Calculate",
"the",
"hessian",
"matrix",
"empirically",
".",
"Create",
"a",
"hessian",
"matrix",
"corresponding",
"to",
"the",
"source",
"model",
"pars",
"Only",
"parameters",
"that",
"vary",
"will",
"contribute",
"to",
"the",
"hessian",
".",
"Thus",
"there",
... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L575-L615 |
PaulHancock/Aegean | AegeanTools/fitting.py | nan_acf | def nan_acf(noise):
"""
Calculate the autocorrelation function of the noise
where the noise is a 2d array that may contain nans
Parameters
----------
noise : 2d-array
Noise image.
Returns
-------
acf : 2d-array
The ACF.
"""
corr = np.zeros(noise.shape)
ix,jx = noise.shape
for i in range(ix):
si_min = slice(i, None, None)
si_max = slice(None, ix-i, None)
for j in range(jx):
sj_min = slice(j, None, None)
sj_max = slice(None, jx-j, None)
if np.all(np.isnan(noise[si_min, sj_min])) or np.all(np.isnan(noise[si_max, sj_max])):
corr[i, j] = np.nan
else:
corr[i, j] = np.nansum(noise[si_min, sj_min] * noise[si_max, sj_max])
# return the normalised acf
return corr / np.nanmax(corr) | python | def nan_acf(noise):
"""
Calculate the autocorrelation function of the noise
where the noise is a 2d array that may contain nans
Parameters
----------
noise : 2d-array
Noise image.
Returns
-------
acf : 2d-array
The ACF.
"""
corr = np.zeros(noise.shape)
ix,jx = noise.shape
for i in range(ix):
si_min = slice(i, None, None)
si_max = slice(None, ix-i, None)
for j in range(jx):
sj_min = slice(j, None, None)
sj_max = slice(None, jx-j, None)
if np.all(np.isnan(noise[si_min, sj_min])) or np.all(np.isnan(noise[si_max, sj_max])):
corr[i, j] = np.nan
else:
corr[i, j] = np.nansum(noise[si_min, sj_min] * noise[si_max, sj_max])
# return the normalised acf
return corr / np.nanmax(corr) | [
"def",
"nan_acf",
"(",
"noise",
")",
":",
"corr",
"=",
"np",
".",
"zeros",
"(",
"noise",
".",
"shape",
")",
"ix",
",",
"jx",
"=",
"noise",
".",
"shape",
"for",
"i",
"in",
"range",
"(",
"ix",
")",
":",
"si_min",
"=",
"slice",
"(",
"i",
",",
"N... | Calculate the autocorrelation function of the noise
where the noise is a 2d array that may contain nans
Parameters
----------
noise : 2d-array
Noise image.
Returns
-------
acf : 2d-array
The ACF. | [
"Calculate",
"the",
"autocorrelation",
"function",
"of",
"the",
"noise",
"where",
"the",
"noise",
"is",
"a",
"2d",
"array",
"that",
"may",
"contain",
"nans"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L618-L647 |
PaulHancock/Aegean | AegeanTools/fitting.py | make_ita | def make_ita(noise, acf=None):
"""
Create the matrix ita of the noise where the noise may be a masked array
where ita(x,y) is the correlation between pixel pairs that have the same separation as x and y.
Parameters
----------
noise : 2d-array
The noise image
acf : 2d-array
The autocorrelation matrix. (None = calculate from data).
Default = None.
Returns
-------
ita : 2d-array
The matrix ita
"""
if acf is None:
acf = nan_acf(noise)
# s should be the number of non-masked pixels
s = np.count_nonzero(np.isfinite(noise))
# the indices of the non-masked pixels
xm, ym = np.where(np.isfinite(noise))
ita = np.zeros((s, s))
# iterate over the pixels
for i, (x1, y1) in enumerate(zip(xm, ym)):
for j, (x2, y2) in enumerate(zip(xm, ym)):
k = abs(x1-x2)
l = abs(y1-y2)
ita[i, j] = acf[k, l]
return ita | python | def make_ita(noise, acf=None):
"""
Create the matrix ita of the noise where the noise may be a masked array
where ita(x,y) is the correlation between pixel pairs that have the same separation as x and y.
Parameters
----------
noise : 2d-array
The noise image
acf : 2d-array
The autocorrelation matrix. (None = calculate from data).
Default = None.
Returns
-------
ita : 2d-array
The matrix ita
"""
if acf is None:
acf = nan_acf(noise)
# s should be the number of non-masked pixels
s = np.count_nonzero(np.isfinite(noise))
# the indices of the non-masked pixels
xm, ym = np.where(np.isfinite(noise))
ita = np.zeros((s, s))
# iterate over the pixels
for i, (x1, y1) in enumerate(zip(xm, ym)):
for j, (x2, y2) in enumerate(zip(xm, ym)):
k = abs(x1-x2)
l = abs(y1-y2)
ita[i, j] = acf[k, l]
return ita | [
"def",
"make_ita",
"(",
"noise",
",",
"acf",
"=",
"None",
")",
":",
"if",
"acf",
"is",
"None",
":",
"acf",
"=",
"nan_acf",
"(",
"noise",
")",
"# s should be the number of non-masked pixels",
"s",
"=",
"np",
".",
"count_nonzero",
"(",
"np",
".",
"isfinite",... | Create the matrix ita of the noise where the noise may be a masked array
where ita(x,y) is the correlation between pixel pairs that have the same separation as x and y.
Parameters
----------
noise : 2d-array
The noise image
acf : 2d-array
The autocorrelation matrix. (None = calculate from data).
Default = None.
Returns
-------
ita : 2d-array
The matrix ita | [
"Create",
"the",
"matrix",
"ita",
"of",
"the",
"noise",
"where",
"the",
"noise",
"may",
"be",
"a",
"masked",
"array",
"where",
"ita",
"(",
"x",
"y",
")",
"is",
"the",
"correlation",
"between",
"pixel",
"pairs",
"that",
"have",
"the",
"same",
"separation"... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L650-L682 |
PaulHancock/Aegean | AegeanTools/fitting.py | RB_bias | def RB_bias(data, pars, ita=None, acf=None):
"""
Calculate the expected bias on each of the parameters in the model pars.
Only parameters that are allowed to vary will have a bias.
Calculation follows the description of Refrieger & Brown 1998 (cite).
Parameters
----------
data : 2d-array
data that was fit
pars : lmfit.Parameters
The model
ita : 2d-array
The ita matrix (optional).
acf : 2d-array
The acf for the data.
Returns
-------
bias : array
The bias on each of the parameters
"""
log.info("data {0}".format(data.shape))
nparams = np.sum([pars[k].vary for k in pars.keys() if k != 'components'])
# masked pixels
xm, ym = np.where(np.isfinite(data))
# all pixels
x, y = np.indices(data.shape)
# Create the jacobian as an AxN array accounting for the masked pixels
j = np.array(np.vsplit(lmfit_jacobian(pars, xm, ym).T, nparams)).reshape(nparams, -1)
h = hessian(pars, x, y)
# mask the hessian to be AxAxN array
h = h[:, :, xm, ym]
Hij = np.einsum('ik,jk', j, j)
Dij = np.linalg.inv(Hij)
Bijk = np.einsum('ip,jkp', j, h)
Eilkm = np.einsum('il,km', Dij, Dij)
Cimn_1 = -1 * np.einsum('krj,ir,km,jn', Bijk, Dij, Dij, Dij)
Cimn_2 = -1./2 * np.einsum('rkj,ir,km,jn', Bijk, Dij, Dij, Dij)
Cimn = Cimn_1 + Cimn_2
if ita is None:
# N is the noise (data-model)
N = data - ntwodgaussian_lmfit(pars)(x, y)
if acf is None:
acf = nan_acf(N)
ita = make_ita(N, acf=acf)
log.info('acf.shape {0}'.format(acf.shape))
log.info('acf[0] {0}'.format(acf[0]))
log.info('ita.shape {0}'.format(ita.shape))
log.info('ita[0] {0}'.format(ita[0]))
# Included for completeness but not required
# now mask/ravel the noise
# N = N[np.isfinite(N)].ravel()
# Pi = np.einsum('ip,p', j, N)
# Qij = np.einsum('ijp,p', h, N)
Vij = np.einsum('ip,jq,pq', j, j, ita)
Uijk = np.einsum('ip,jkq,pq', j, h, ita)
bias_1 = np.einsum('imn, mn', Cimn, Vij)
bias_2 = np.einsum('ilkm, mlk', Eilkm, Uijk)
bias = bias_1 + bias_2
log.info('bias {0}'.format(bias))
return bias | python | def RB_bias(data, pars, ita=None, acf=None):
"""
Calculate the expected bias on each of the parameters in the model pars.
Only parameters that are allowed to vary will have a bias.
Calculation follows the description of Refrieger & Brown 1998 (cite).
Parameters
----------
data : 2d-array
data that was fit
pars : lmfit.Parameters
The model
ita : 2d-array
The ita matrix (optional).
acf : 2d-array
The acf for the data.
Returns
-------
bias : array
The bias on each of the parameters
"""
log.info("data {0}".format(data.shape))
nparams = np.sum([pars[k].vary for k in pars.keys() if k != 'components'])
# masked pixels
xm, ym = np.where(np.isfinite(data))
# all pixels
x, y = np.indices(data.shape)
# Create the jacobian as an AxN array accounting for the masked pixels
j = np.array(np.vsplit(lmfit_jacobian(pars, xm, ym).T, nparams)).reshape(nparams, -1)
h = hessian(pars, x, y)
# mask the hessian to be AxAxN array
h = h[:, :, xm, ym]
Hij = np.einsum('ik,jk', j, j)
Dij = np.linalg.inv(Hij)
Bijk = np.einsum('ip,jkp', j, h)
Eilkm = np.einsum('il,km', Dij, Dij)
Cimn_1 = -1 * np.einsum('krj,ir,km,jn', Bijk, Dij, Dij, Dij)
Cimn_2 = -1./2 * np.einsum('rkj,ir,km,jn', Bijk, Dij, Dij, Dij)
Cimn = Cimn_1 + Cimn_2
if ita is None:
# N is the noise (data-model)
N = data - ntwodgaussian_lmfit(pars)(x, y)
if acf is None:
acf = nan_acf(N)
ita = make_ita(N, acf=acf)
log.info('acf.shape {0}'.format(acf.shape))
log.info('acf[0] {0}'.format(acf[0]))
log.info('ita.shape {0}'.format(ita.shape))
log.info('ita[0] {0}'.format(ita[0]))
# Included for completeness but not required
# now mask/ravel the noise
# N = N[np.isfinite(N)].ravel()
# Pi = np.einsum('ip,p', j, N)
# Qij = np.einsum('ijp,p', h, N)
Vij = np.einsum('ip,jq,pq', j, j, ita)
Uijk = np.einsum('ip,jkq,pq', j, h, ita)
bias_1 = np.einsum('imn, mn', Cimn, Vij)
bias_2 = np.einsum('ilkm, mlk', Eilkm, Uijk)
bias = bias_1 + bias_2
log.info('bias {0}'.format(bias))
return bias | [
"def",
"RB_bias",
"(",
"data",
",",
"pars",
",",
"ita",
"=",
"None",
",",
"acf",
"=",
"None",
")",
":",
"log",
".",
"info",
"(",
"\"data {0}\"",
".",
"format",
"(",
"data",
".",
"shape",
")",
")",
"nparams",
"=",
"np",
".",
"sum",
"(",
"[",
"pa... | Calculate the expected bias on each of the parameters in the model pars.
Only parameters that are allowed to vary will have a bias.
Calculation follows the description of Refrieger & Brown 1998 (cite).
Parameters
----------
data : 2d-array
data that was fit
pars : lmfit.Parameters
The model
ita : 2d-array
The ita matrix (optional).
acf : 2d-array
The acf for the data.
Returns
-------
bias : array
The bias on each of the parameters | [
"Calculate",
"the",
"expected",
"bias",
"on",
"each",
"of",
"the",
"parameters",
"in",
"the",
"model",
"pars",
".",
"Only",
"parameters",
"that",
"are",
"allowed",
"to",
"vary",
"will",
"have",
"a",
"bias",
".",
"Calculation",
"follows",
"the",
"description"... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L685-L757 |
PaulHancock/Aegean | AegeanTools/fitting.py | bias_correct | def bias_correct(params, data, acf=None):
"""
Calculate and apply a bias correction to the given fit parameters
Parameters
----------
params : lmfit.Parameters
The model parameters. These will be modified.
data : 2d-array
The data which was used in the fitting
acf : 2d-array
ACF of the data. Default = None.
Returns
-------
None
See Also
--------
:func:`AegeanTools.fitting.RB_bias`
"""
bias = RB_bias(data, params, acf=acf)
i = 0
for p in params:
if 'theta' in p:
continue
if params[p].vary:
params[p].value -= bias[i]
i += 1
return | python | def bias_correct(params, data, acf=None):
"""
Calculate and apply a bias correction to the given fit parameters
Parameters
----------
params : lmfit.Parameters
The model parameters. These will be modified.
data : 2d-array
The data which was used in the fitting
acf : 2d-array
ACF of the data. Default = None.
Returns
-------
None
See Also
--------
:func:`AegeanTools.fitting.RB_bias`
"""
bias = RB_bias(data, params, acf=acf)
i = 0
for p in params:
if 'theta' in p:
continue
if params[p].vary:
params[p].value -= bias[i]
i += 1
return | [
"def",
"bias_correct",
"(",
"params",
",",
"data",
",",
"acf",
"=",
"None",
")",
":",
"bias",
"=",
"RB_bias",
"(",
"data",
",",
"params",
",",
"acf",
"=",
"acf",
")",
"i",
"=",
"0",
"for",
"p",
"in",
"params",
":",
"if",
"'theta'",
"in",
"p",
"... | Calculate and apply a bias correction to the given fit parameters
Parameters
----------
params : lmfit.Parameters
The model parameters. These will be modified.
data : 2d-array
The data which was used in the fitting
acf : 2d-array
ACF of the data. Default = None.
Returns
-------
None
See Also
--------
:func:`AegeanTools.fitting.RB_bias` | [
"Calculate",
"and",
"apply",
"a",
"bias",
"correction",
"to",
"the",
"given",
"fit",
"parameters"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L760-L792 |
PaulHancock/Aegean | AegeanTools/fitting.py | condon_errors | def condon_errors(source, theta_n, psf=None):
"""
Calculate the parameter errors for a fitted source
using the description of Condon'97
All parameters are assigned errors, assuming that all params were fit.
If some params were held fixed then these errors are overestimated.
Parameters
----------
source : :class:`AegeanTools.models.SimpleSource`
The source which was fit.
theta_n : float or None
A measure of the beam sampling. (See Condon'97).
psf : :class:`AegeanTools.fits_image.Beam`
The psf at the location of the source.
Returns
-------
None
"""
# indices for the calculation or rho
alphas = {'amp': (3. / 2, 3. / 2),
'major': (5. / 2, 1. / 2),
'xo': (5. / 2, 1. / 2),
'minor': (1. / 2, 5. / 2),
'yo': (1. / 2, 5. / 2),
'pa': (1. / 2, 5. / 2)}
major = source.a / 3600. # degrees
minor = source.b / 3600. # degrees
phi = np.radians(source.pa) # radians
if psf is not None:
beam = psf.get_beam(source.ra, source.dec)
if beam is not None:
theta_n = np.hypot(beam.a, beam.b)
print(beam, theta_n)
if theta_n is None:
source.err_a = source.err_b = source.err_peak_flux = source.err_pa = source.err_int_flux = 0.0
return
smoothing = major * minor / (theta_n ** 2)
factor1 = (1 + (major / theta_n))
factor2 = (1 + (minor / theta_n))
snr = source.peak_flux / source.local_rms
# calculation of rho2 depends on the parameter being used so we lambda this into a function
rho2 = lambda x: smoothing / 4 * factor1 ** alphas[x][0] * factor2 ** alphas[x][1] * snr ** 2
source.err_peak_flux = source.peak_flux * np.sqrt(2 / rho2('amp'))
source.err_a = major * np.sqrt(2 / rho2('major')) * 3600. # arcsec
source.err_b = minor * np.sqrt(2 / rho2('minor')) * 3600. # arcsec
err_xo2 = 2. / rho2('xo') * major ** 2 / (8 * np.log(2)) # Condon'97 eq 21
err_yo2 = 2. / rho2('yo') * minor ** 2 / (8 * np.log(2))
source.err_ra = np.sqrt(err_xo2 * np.sin(phi)**2 + err_yo2 * np.cos(phi)**2)
source.err_dec = np.sqrt(err_xo2 * np.cos(phi)**2 + err_yo2 * np.sin(phi)**2)
if (major == 0) or (minor == 0):
source.err_pa = ERR_MASK
# if major/minor are very similar then we should not be able to figure out what pa is.
elif abs(2 * (major-minor) / (major+minor)) < 0.01:
source.err_pa = ERR_MASK
else:
source.err_pa = np.degrees(np.sqrt(4 / rho2('pa')) * (major * minor / (major ** 2 - minor ** 2)))
# integrated flux error
err2 = (source.err_peak_flux / source.peak_flux) ** 2
err2 += (theta_n ** 2 / (major * minor)) * ((source.err_a / source.a) ** 2 + (source.err_b / source.b) ** 2)
source.err_int_flux = source.int_flux * np.sqrt(err2)
return | python | def condon_errors(source, theta_n, psf=None):
"""
Calculate the parameter errors for a fitted source
using the description of Condon'97
All parameters are assigned errors, assuming that all params were fit.
If some params were held fixed then these errors are overestimated.
Parameters
----------
source : :class:`AegeanTools.models.SimpleSource`
The source which was fit.
theta_n : float or None
A measure of the beam sampling. (See Condon'97).
psf : :class:`AegeanTools.fits_image.Beam`
The psf at the location of the source.
Returns
-------
None
"""
# indices for the calculation or rho
alphas = {'amp': (3. / 2, 3. / 2),
'major': (5. / 2, 1. / 2),
'xo': (5. / 2, 1. / 2),
'minor': (1. / 2, 5. / 2),
'yo': (1. / 2, 5. / 2),
'pa': (1. / 2, 5. / 2)}
major = source.a / 3600. # degrees
minor = source.b / 3600. # degrees
phi = np.radians(source.pa) # radians
if psf is not None:
beam = psf.get_beam(source.ra, source.dec)
if beam is not None:
theta_n = np.hypot(beam.a, beam.b)
print(beam, theta_n)
if theta_n is None:
source.err_a = source.err_b = source.err_peak_flux = source.err_pa = source.err_int_flux = 0.0
return
smoothing = major * minor / (theta_n ** 2)
factor1 = (1 + (major / theta_n))
factor2 = (1 + (minor / theta_n))
snr = source.peak_flux / source.local_rms
# calculation of rho2 depends on the parameter being used so we lambda this into a function
rho2 = lambda x: smoothing / 4 * factor1 ** alphas[x][0] * factor2 ** alphas[x][1] * snr ** 2
source.err_peak_flux = source.peak_flux * np.sqrt(2 / rho2('amp'))
source.err_a = major * np.sqrt(2 / rho2('major')) * 3600. # arcsec
source.err_b = minor * np.sqrt(2 / rho2('minor')) * 3600. # arcsec
err_xo2 = 2. / rho2('xo') * major ** 2 / (8 * np.log(2)) # Condon'97 eq 21
err_yo2 = 2. / rho2('yo') * minor ** 2 / (8 * np.log(2))
source.err_ra = np.sqrt(err_xo2 * np.sin(phi)**2 + err_yo2 * np.cos(phi)**2)
source.err_dec = np.sqrt(err_xo2 * np.cos(phi)**2 + err_yo2 * np.sin(phi)**2)
if (major == 0) or (minor == 0):
source.err_pa = ERR_MASK
# if major/minor are very similar then we should not be able to figure out what pa is.
elif abs(2 * (major-minor) / (major+minor)) < 0.01:
source.err_pa = ERR_MASK
else:
source.err_pa = np.degrees(np.sqrt(4 / rho2('pa')) * (major * minor / (major ** 2 - minor ** 2)))
# integrated flux error
err2 = (source.err_peak_flux / source.peak_flux) ** 2
err2 += (theta_n ** 2 / (major * minor)) * ((source.err_a / source.a) ** 2 + (source.err_b / source.b) ** 2)
source.err_int_flux = source.int_flux * np.sqrt(err2)
return | [
"def",
"condon_errors",
"(",
"source",
",",
"theta_n",
",",
"psf",
"=",
"None",
")",
":",
"# indices for the calculation or rho",
"alphas",
"=",
"{",
"'amp'",
":",
"(",
"3.",
"/",
"2",
",",
"3.",
"/",
"2",
")",
",",
"'major'",
":",
"(",
"5.",
"/",
"2... | Calculate the parameter errors for a fitted source
using the description of Condon'97
All parameters are assigned errors, assuming that all params were fit.
If some params were held fixed then these errors are overestimated.
Parameters
----------
source : :class:`AegeanTools.models.SimpleSource`
The source which was fit.
theta_n : float or None
A measure of the beam sampling. (See Condon'97).
psf : :class:`AegeanTools.fits_image.Beam`
The psf at the location of the source.
Returns
-------
None | [
"Calculate",
"the",
"parameter",
"errors",
"for",
"a",
"fitted",
"source",
"using",
"the",
"description",
"of",
"Condon",
"97",
"All",
"parameters",
"are",
"assigned",
"errors",
"assuming",
"that",
"all",
"params",
"were",
"fit",
".",
"If",
"some",
"params",
... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L795-L868 |
PaulHancock/Aegean | AegeanTools/fitting.py | errors | def errors(source, model, wcshelper):
"""
Convert pixel based errors into sky coord errors
Parameters
----------
source : :class:`AegeanTools.models.SimpleSource`
The source which was fit.
model : lmfit.Parameters
The model which was fit.
wcshelper : :class:`AegeanTools.wcs_helpers.WCSHelper`
WCS information.
Returns
-------
source : :class:`AegeanTools.models.SimpleSource`
The modified source obejct.
"""
# if the source wasn't fit then all errors are -1
if source.flags & (flags.NOTFIT | flags.FITERR):
source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK
source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK
return source
# copy the errors from the model
prefix = "c{0}_".format(source.source)
err_amp = model[prefix + 'amp'].stderr
xo, yo = model[prefix + 'xo'].value, model[prefix + 'yo'].value
err_xo = model[prefix + 'xo'].stderr
err_yo = model[prefix + 'yo'].stderr
sx, sy = model[prefix + 'sx'].value, model[prefix + 'sy'].value
err_sx = model[prefix + 'sx'].stderr
err_sy = model[prefix + 'sy'].stderr
theta = model[prefix + 'theta'].value
err_theta = model[prefix + 'theta'].stderr
source.err_peak_flux = err_amp
pix_errs = [err_xo, err_yo, err_sx, err_sy, err_theta]
log.debug("Pix errs: {0}".format(pix_errs))
ref = wcshelper.pix2sky([xo, yo])
# check to see if the reference position has a valid WCS coordinate
# It is possible for this to fail, even if the ra/dec conversion works elsewhere
if not all(np.isfinite(ref)):
source.flags |= flags.WCSERR
source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK
source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK
return source
# position errors
if model[prefix + 'xo'].vary and model[prefix + 'yo'].vary \
and all(np.isfinite([err_xo, err_yo])):
offset = wcshelper.pix2sky([xo + err_xo, yo + err_yo])
source.err_ra = gcd(ref[0], ref[1], offset[0], ref[1])
source.err_dec = gcd(ref[0], ref[1], ref[0], offset[1])
else:
source.err_ra = source.err_dec = -1
if model[prefix + 'theta'].vary and np.isfinite(err_theta):
# pa error
off1 = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))])
off2 = wcshelper.pix2sky(
[xo + sx * np.cos(np.radians(theta + err_theta)), yo + sy * np.sin(np.radians(theta + err_theta))])
source.err_pa = abs(bear(ref[0], ref[1], off1[0], off1[1]) - bear(ref[0], ref[1], off2[0], off2[1]))
else:
source.err_pa = ERR_MASK
if model[prefix + 'sx'].vary and model[prefix + 'sy'].vary \
and all(np.isfinite([err_sx, err_sy])):
# major axis error
ref = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))])
offset = wcshelper.pix2sky(
[xo + (sx + err_sx) * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))])
source.err_a = gcd(ref[0], ref[1], offset[0], offset[1]) * 3600
# minor axis error
ref = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta + 90)), yo + sy * np.sin(np.radians(theta + 90))])
offset = wcshelper.pix2sky(
[xo + sx * np.cos(np.radians(theta + 90)), yo + (sy + err_sy) * np.sin(np.radians(theta + 90))])
source.err_b = gcd(ref[0], ref[1], offset[0], offset[1]) * 3600
else:
source.err_a = source.err_b = ERR_MASK
sqerr = 0
sqerr += (source.err_peak_flux / source.peak_flux) ** 2 if source.err_peak_flux > 0 else 0
sqerr += (source.err_a / source.a) ** 2 if source.err_a > 0 else 0
sqerr += (source.err_b / source.b) ** 2 if source.err_b > 0 else 0
if sqerr == 0:
source.err_int_flux = ERR_MASK
else:
source.err_int_flux = abs(source.int_flux * np.sqrt(sqerr))
return source | python | def errors(source, model, wcshelper):
"""
Convert pixel based errors into sky coord errors
Parameters
----------
source : :class:`AegeanTools.models.SimpleSource`
The source which was fit.
model : lmfit.Parameters
The model which was fit.
wcshelper : :class:`AegeanTools.wcs_helpers.WCSHelper`
WCS information.
Returns
-------
source : :class:`AegeanTools.models.SimpleSource`
The modified source obejct.
"""
# if the source wasn't fit then all errors are -1
if source.flags & (flags.NOTFIT | flags.FITERR):
source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK
source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK
return source
# copy the errors from the model
prefix = "c{0}_".format(source.source)
err_amp = model[prefix + 'amp'].stderr
xo, yo = model[prefix + 'xo'].value, model[prefix + 'yo'].value
err_xo = model[prefix + 'xo'].stderr
err_yo = model[prefix + 'yo'].stderr
sx, sy = model[prefix + 'sx'].value, model[prefix + 'sy'].value
err_sx = model[prefix + 'sx'].stderr
err_sy = model[prefix + 'sy'].stderr
theta = model[prefix + 'theta'].value
err_theta = model[prefix + 'theta'].stderr
source.err_peak_flux = err_amp
pix_errs = [err_xo, err_yo, err_sx, err_sy, err_theta]
log.debug("Pix errs: {0}".format(pix_errs))
ref = wcshelper.pix2sky([xo, yo])
# check to see if the reference position has a valid WCS coordinate
# It is possible for this to fail, even if the ra/dec conversion works elsewhere
if not all(np.isfinite(ref)):
source.flags |= flags.WCSERR
source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK
source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK
return source
# position errors
if model[prefix + 'xo'].vary and model[prefix + 'yo'].vary \
and all(np.isfinite([err_xo, err_yo])):
offset = wcshelper.pix2sky([xo + err_xo, yo + err_yo])
source.err_ra = gcd(ref[0], ref[1], offset[0], ref[1])
source.err_dec = gcd(ref[0], ref[1], ref[0], offset[1])
else:
source.err_ra = source.err_dec = -1
if model[prefix + 'theta'].vary and np.isfinite(err_theta):
# pa error
off1 = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))])
off2 = wcshelper.pix2sky(
[xo + sx * np.cos(np.radians(theta + err_theta)), yo + sy * np.sin(np.radians(theta + err_theta))])
source.err_pa = abs(bear(ref[0], ref[1], off1[0], off1[1]) - bear(ref[0], ref[1], off2[0], off2[1]))
else:
source.err_pa = ERR_MASK
if model[prefix + 'sx'].vary and model[prefix + 'sy'].vary \
and all(np.isfinite([err_sx, err_sy])):
# major axis error
ref = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))])
offset = wcshelper.pix2sky(
[xo + (sx + err_sx) * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))])
source.err_a = gcd(ref[0], ref[1], offset[0], offset[1]) * 3600
# minor axis error
ref = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta + 90)), yo + sy * np.sin(np.radians(theta + 90))])
offset = wcshelper.pix2sky(
[xo + sx * np.cos(np.radians(theta + 90)), yo + (sy + err_sy) * np.sin(np.radians(theta + 90))])
source.err_b = gcd(ref[0], ref[1], offset[0], offset[1]) * 3600
else:
source.err_a = source.err_b = ERR_MASK
sqerr = 0
sqerr += (source.err_peak_flux / source.peak_flux) ** 2 if source.err_peak_flux > 0 else 0
sqerr += (source.err_a / source.a) ** 2 if source.err_a > 0 else 0
sqerr += (source.err_b / source.b) ** 2 if source.err_b > 0 else 0
if sqerr == 0:
source.err_int_flux = ERR_MASK
else:
source.err_int_flux = abs(source.int_flux * np.sqrt(sqerr))
return source | [
"def",
"errors",
"(",
"source",
",",
"model",
",",
"wcshelper",
")",
":",
"# if the source wasn't fit then all errors are -1",
"if",
"source",
".",
"flags",
"&",
"(",
"flags",
".",
"NOTFIT",
"|",
"flags",
".",
"FITERR",
")",
":",
"source",
".",
"err_peak_flux"... | Convert pixel based errors into sky coord errors
Parameters
----------
source : :class:`AegeanTools.models.SimpleSource`
The source which was fit.
model : lmfit.Parameters
The model which was fit.
wcshelper : :class:`AegeanTools.wcs_helpers.WCSHelper`
WCS information.
Returns
-------
source : :class:`AegeanTools.models.SimpleSource`
The modified source obejct. | [
"Convert",
"pixel",
"based",
"errors",
"into",
"sky",
"coord",
"errors"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L871-L969 |
PaulHancock/Aegean | AegeanTools/fitting.py | new_errors | def new_errors(source, model, wcshelper): # pragma: no cover
"""
Convert pixel based errors into sky coord errors
Uses covariance matrix for ra/dec errors
and calculus approach to a/b/pa errors
Parameters
----------
source : :class:`AegeanTools.models.SimpleSource`
The source which was fit.
model : lmfit.Parameters
The model which was fit.
wcshelper : :class:`AegeanTools.wcs_helpers.WCSHelper`
WCS information.
Returns
-------
source : :class:`AegeanTools.models.SimpleSource`
The modified source obejct.
"""
# if the source wasn't fit then all errors are -1
if source.flags & (flags.NOTFIT | flags.FITERR):
source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK
source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK
return source
# copy the errors/values from the model
prefix = "c{0}_".format(source.source)
err_amp = model[prefix + 'amp'].stderr
xo, yo = model[prefix + 'xo'].value, model[prefix + 'yo'].value
err_xo = model[prefix + 'xo'].stderr
err_yo = model[prefix + 'yo'].stderr
sx, sy = model[prefix + 'sx'].value, model[prefix + 'sy'].value
err_sx = model[prefix + 'sx'].stderr
err_sy = model[prefix + 'sy'].stderr
theta = model[prefix + 'theta'].value
err_theta = model[prefix + 'theta'].stderr
# the peak flux error doesn't need to be converted, just copied
source.err_peak_flux = err_amp
pix_errs = [err_xo, err_yo, err_sx, err_sy, err_theta]
# check for inf/nan errors -> these sources have poor fits.
if not all(a is not None and np.isfinite(a) for a in pix_errs):
source.flags |= flags.FITERR
source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK
source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK
return source
# calculate the reference coordinate
ref = wcshelper.pix2sky([xo, yo])
# check to see if the reference position has a valid WCS coordinate
# It is possible for this to fail, even if the ra/dec conversion works elsewhere
if not all(np.isfinite(ref)):
source.flags |= flags.WCSERR
source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK
source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK
return source
# calculate position errors by transforming the error ellipse
if model[prefix + 'xo'].vary and model[prefix + 'yo'].vary:
# determine the error ellipse from the Jacobian
mat = model.covar[1:3, 1:3]
if not(np.all(np.isfinite(mat))):
source.err_ra = source.err_dec = ERR_MASK
else:
(a, b), e = np.linalg.eig(mat)
pa = np.degrees(np.arctan2(*e[0]))
# transform this ellipse into sky coordinates
_, _, major, minor, pa = wcshelper.pix2sky_ellipse([xo, yo], a, b, pa)
# now determine the radius of the ellipse along the ra/dec directions.
source.err_ra = major*minor / np.hypot(major*np.sin(np.radians(pa)), minor*np.cos(np.radians(pa)))
source.err_dec = major*minor / np.hypot(major*np.cos(np.radians(pa)), minor*np.sin(np.radians(pa)))
else:
source.err_ra = source.err_dec = -1
if model[prefix + 'theta'].vary:
# pa error
off1 = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))])
# offset by 1 degree
off2 = wcshelper.pix2sky(
[xo + sx * np.cos(np.radians(theta + 1)), yo + sy * np.sin(np.radians(theta + 1))])
# scale the initial theta error by this amount
source.err_pa = abs(bear(ref[0], ref[1], off1[0], off1[1]) - bear(ref[0], ref[1], off2[0], off2[1])) * err_theta
else:
source.err_pa = ERR_MASK
if model[prefix + 'sx'].vary and model[prefix + 'sy'].vary:
# major axis error
ref = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))])
# offset by 0.1 pixels
offset = wcshelper.pix2sky(
[xo + (sx + 0.1) * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))])
source.err_a = gcd(ref[0], ref[1], offset[0], offset[1])/0.1 * err_sx * 3600
# minor axis error
ref = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta + 90)), yo + sy * np.sin(np.radians(theta + 90))])
# offset by 0.1 pixels
offset = wcshelper.pix2sky(
[xo + sx * np.cos(np.radians(theta + 90)), yo + (sy + 0.1) * np.sin(np.radians(theta + 90))])
source.err_b = gcd(ref[0], ref[1], offset[0], offset[1])/0.1*err_sy * 3600
else:
source.err_a = source.err_b = ERR_MASK
sqerr = 0
sqerr += (source.err_peak_flux / source.peak_flux) ** 2 if source.err_peak_flux > 0 else 0
sqerr += (source.err_a / source.a) ** 2 if source.err_a > 0 else 0
sqerr += (source.err_b / source.b) ** 2 if source.err_b > 0 else 0
source.err_int_flux = abs(source.int_flux * np.sqrt(sqerr))
return source | python | def new_errors(source, model, wcshelper): # pragma: no cover
"""
Convert pixel based errors into sky coord errors
Uses covariance matrix for ra/dec errors
and calculus approach to a/b/pa errors
Parameters
----------
source : :class:`AegeanTools.models.SimpleSource`
The source which was fit.
model : lmfit.Parameters
The model which was fit.
wcshelper : :class:`AegeanTools.wcs_helpers.WCSHelper`
WCS information.
Returns
-------
source : :class:`AegeanTools.models.SimpleSource`
The modified source obejct.
"""
# if the source wasn't fit then all errors are -1
if source.flags & (flags.NOTFIT | flags.FITERR):
source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK
source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK
return source
# copy the errors/values from the model
prefix = "c{0}_".format(source.source)
err_amp = model[prefix + 'amp'].stderr
xo, yo = model[prefix + 'xo'].value, model[prefix + 'yo'].value
err_xo = model[prefix + 'xo'].stderr
err_yo = model[prefix + 'yo'].stderr
sx, sy = model[prefix + 'sx'].value, model[prefix + 'sy'].value
err_sx = model[prefix + 'sx'].stderr
err_sy = model[prefix + 'sy'].stderr
theta = model[prefix + 'theta'].value
err_theta = model[prefix + 'theta'].stderr
# the peak flux error doesn't need to be converted, just copied
source.err_peak_flux = err_amp
pix_errs = [err_xo, err_yo, err_sx, err_sy, err_theta]
# check for inf/nan errors -> these sources have poor fits.
if not all(a is not None and np.isfinite(a) for a in pix_errs):
source.flags |= flags.FITERR
source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK
source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK
return source
# calculate the reference coordinate
ref = wcshelper.pix2sky([xo, yo])
# check to see if the reference position has a valid WCS coordinate
# It is possible for this to fail, even if the ra/dec conversion works elsewhere
if not all(np.isfinite(ref)):
source.flags |= flags.WCSERR
source.err_peak_flux = source.err_a = source.err_b = source.err_pa = ERR_MASK
source.err_ra = source.err_dec = source.err_int_flux = ERR_MASK
return source
# calculate position errors by transforming the error ellipse
if model[prefix + 'xo'].vary and model[prefix + 'yo'].vary:
# determine the error ellipse from the Jacobian
mat = model.covar[1:3, 1:3]
if not(np.all(np.isfinite(mat))):
source.err_ra = source.err_dec = ERR_MASK
else:
(a, b), e = np.linalg.eig(mat)
pa = np.degrees(np.arctan2(*e[0]))
# transform this ellipse into sky coordinates
_, _, major, minor, pa = wcshelper.pix2sky_ellipse([xo, yo], a, b, pa)
# now determine the radius of the ellipse along the ra/dec directions.
source.err_ra = major*minor / np.hypot(major*np.sin(np.radians(pa)), minor*np.cos(np.radians(pa)))
source.err_dec = major*minor / np.hypot(major*np.cos(np.radians(pa)), minor*np.sin(np.radians(pa)))
else:
source.err_ra = source.err_dec = -1
if model[prefix + 'theta'].vary:
# pa error
off1 = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))])
# offset by 1 degree
off2 = wcshelper.pix2sky(
[xo + sx * np.cos(np.radians(theta + 1)), yo + sy * np.sin(np.radians(theta + 1))])
# scale the initial theta error by this amount
source.err_pa = abs(bear(ref[0], ref[1], off1[0], off1[1]) - bear(ref[0], ref[1], off2[0], off2[1])) * err_theta
else:
source.err_pa = ERR_MASK
if model[prefix + 'sx'].vary and model[prefix + 'sy'].vary:
# major axis error
ref = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))])
# offset by 0.1 pixels
offset = wcshelper.pix2sky(
[xo + (sx + 0.1) * np.cos(np.radians(theta)), yo + sy * np.sin(np.radians(theta))])
source.err_a = gcd(ref[0], ref[1], offset[0], offset[1])/0.1 * err_sx * 3600
# minor axis error
ref = wcshelper.pix2sky([xo + sx * np.cos(np.radians(theta + 90)), yo + sy * np.sin(np.radians(theta + 90))])
# offset by 0.1 pixels
offset = wcshelper.pix2sky(
[xo + sx * np.cos(np.radians(theta + 90)), yo + (sy + 0.1) * np.sin(np.radians(theta + 90))])
source.err_b = gcd(ref[0], ref[1], offset[0], offset[1])/0.1*err_sy * 3600
else:
source.err_a = source.err_b = ERR_MASK
sqerr = 0
sqerr += (source.err_peak_flux / source.peak_flux) ** 2 if source.err_peak_flux > 0 else 0
sqerr += (source.err_a / source.a) ** 2 if source.err_a > 0 else 0
sqerr += (source.err_b / source.b) ** 2 if source.err_b > 0 else 0
source.err_int_flux = abs(source.int_flux * np.sqrt(sqerr))
return source | [
"def",
"new_errors",
"(",
"source",
",",
"model",
",",
"wcshelper",
")",
":",
"# pragma: no cover",
"# if the source wasn't fit then all errors are -1",
"if",
"source",
".",
"flags",
"&",
"(",
"flags",
".",
"NOTFIT",
"|",
"flags",
".",
"FITERR",
")",
":",
"sourc... | Convert pixel based errors into sky coord errors
Uses covariance matrix for ra/dec errors
and calculus approach to a/b/pa errors
Parameters
----------
source : :class:`AegeanTools.models.SimpleSource`
The source which was fit.
model : lmfit.Parameters
The model which was fit.
wcshelper : :class:`AegeanTools.wcs_helpers.WCSHelper`
WCS information.
Returns
-------
source : :class:`AegeanTools.models.SimpleSource`
The modified source obejct. | [
"Convert",
"pixel",
"based",
"errors",
"into",
"sky",
"coord",
"errors",
"Uses",
"covariance",
"matrix",
"for",
"ra",
"/",
"dec",
"errors",
"and",
"calculus",
"approach",
"to",
"a",
"/",
"b",
"/",
"pa",
"errors"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L972-L1088 |
PaulHancock/Aegean | AegeanTools/fitting.py | ntwodgaussian_lmfit | def ntwodgaussian_lmfit(params):
"""
Convert an lmfit.Parameters object into a function which calculates the model.
Parameters
----------
params : lmfit.Parameters
Model parameters, can have multiple components.
Returns
-------
model : func
A function f(x,y) that will compute the model.
"""
def rfunc(x, y):
"""
Compute the model given by params, at pixel coordinates x,y
Parameters
----------
x, y : numpy.ndarray
The x/y pixel coordinates at which the model is being evaluated
Returns
-------
result : numpy.ndarray
Model
"""
result = None
for i in range(params['components'].value):
prefix = "c{0}_".format(i)
# I hope this doesn't kill our run time
amp = np.nan_to_num(params[prefix + 'amp'].value)
xo = params[prefix + 'xo'].value
yo = params[prefix + 'yo'].value
sx = params[prefix + 'sx'].value
sy = params[prefix + 'sy'].value
theta = params[prefix + 'theta'].value
if result is not None:
result += elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta)
else:
result = elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta)
return result
return rfunc | python | def ntwodgaussian_lmfit(params):
"""
Convert an lmfit.Parameters object into a function which calculates the model.
Parameters
----------
params : lmfit.Parameters
Model parameters, can have multiple components.
Returns
-------
model : func
A function f(x,y) that will compute the model.
"""
def rfunc(x, y):
"""
Compute the model given by params, at pixel coordinates x,y
Parameters
----------
x, y : numpy.ndarray
The x/y pixel coordinates at which the model is being evaluated
Returns
-------
result : numpy.ndarray
Model
"""
result = None
for i in range(params['components'].value):
prefix = "c{0}_".format(i)
# I hope this doesn't kill our run time
amp = np.nan_to_num(params[prefix + 'amp'].value)
xo = params[prefix + 'xo'].value
yo = params[prefix + 'yo'].value
sx = params[prefix + 'sx'].value
sy = params[prefix + 'sy'].value
theta = params[prefix + 'theta'].value
if result is not None:
result += elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta)
else:
result = elliptical_gaussian(x, y, amp, xo, yo, sx, sy, theta)
return result
return rfunc | [
"def",
"ntwodgaussian_lmfit",
"(",
"params",
")",
":",
"def",
"rfunc",
"(",
"x",
",",
"y",
")",
":",
"\"\"\"\n Compute the model given by params, at pixel coordinates x,y\n\n Parameters\n ----------\n x, y : numpy.ndarray\n The x/y pixel coordinates... | Convert an lmfit.Parameters object into a function which calculates the model.
Parameters
----------
params : lmfit.Parameters
Model parameters, can have multiple components.
Returns
-------
model : func
A function f(x,y) that will compute the model. | [
"Convert",
"an",
"lmfit",
".",
"Parameters",
"object",
"into",
"a",
"function",
"which",
"calculates",
"the",
"model",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L1091-L1137 |
PaulHancock/Aegean | AegeanTools/fitting.py | do_lmfit | def do_lmfit(data, params, B=None, errs=None, dojac=True):
"""
Fit the model to the data
data may contain 'flagged' or 'masked' data with the value of np.NaN
Parameters
----------
data : 2d-array
Image data
params : lmfit.Parameters
Initial model guess.
B : 2d-array
B matrix to be used in residual calculations.
Default = None.
errs : 1d-array
dojac : bool
If true then an analytic jacobian will be passed to the fitting routine.
Returns
-------
result : ?
lmfit.minimize result.
params : lmfit.Params
Fitted model.
See Also
--------
:func:`AegeanTools.fitting.lmfit_jacobian`
"""
# copy the params so as not to change the initial conditions
# in case we want to use them elsewhere
params = copy.deepcopy(params)
data = np.array(data)
mask = np.where(np.isfinite(data))
def residual(params, **kwargs):
"""
The residual function required by lmfit
Parameters
----------
params: lmfit.Params
The parameters of the model being fit
Returns
-------
result : numpy.ndarray
Model - Data
"""
f = ntwodgaussian_lmfit(params) # A function describing the model
model = f(*mask) # The actual model
if B is None:
return model - data[mask]
else:
return (model - data[mask]).dot(B)
if dojac:
result = lmfit.minimize(residual, params, kws={'x': mask[0], 'y': mask[1], 'B': B, 'errs': errs}, Dfun=lmfit_jacobian)
else:
result = lmfit.minimize(residual, params, kws={'x': mask[0], 'y': mask[1], 'B': B, 'errs': errs})
# Remake the residual so that it is once again (model - data)
if B is not None:
result.residual = result.residual.dot(inv(B))
return result, params | python | def do_lmfit(data, params, B=None, errs=None, dojac=True):
"""
Fit the model to the data
data may contain 'flagged' or 'masked' data with the value of np.NaN
Parameters
----------
data : 2d-array
Image data
params : lmfit.Parameters
Initial model guess.
B : 2d-array
B matrix to be used in residual calculations.
Default = None.
errs : 1d-array
dojac : bool
If true then an analytic jacobian will be passed to the fitting routine.
Returns
-------
result : ?
lmfit.minimize result.
params : lmfit.Params
Fitted model.
See Also
--------
:func:`AegeanTools.fitting.lmfit_jacobian`
"""
# copy the params so as not to change the initial conditions
# in case we want to use them elsewhere
params = copy.deepcopy(params)
data = np.array(data)
mask = np.where(np.isfinite(data))
def residual(params, **kwargs):
"""
The residual function required by lmfit
Parameters
----------
params: lmfit.Params
The parameters of the model being fit
Returns
-------
result : numpy.ndarray
Model - Data
"""
f = ntwodgaussian_lmfit(params) # A function describing the model
model = f(*mask) # The actual model
if B is None:
return model - data[mask]
else:
return (model - data[mask]).dot(B)
if dojac:
result = lmfit.minimize(residual, params, kws={'x': mask[0], 'y': mask[1], 'B': B, 'errs': errs}, Dfun=lmfit_jacobian)
else:
result = lmfit.minimize(residual, params, kws={'x': mask[0], 'y': mask[1], 'B': B, 'errs': errs})
# Remake the residual so that it is once again (model - data)
if B is not None:
result.residual = result.residual.dot(inv(B))
return result, params | [
"def",
"do_lmfit",
"(",
"data",
",",
"params",
",",
"B",
"=",
"None",
",",
"errs",
"=",
"None",
",",
"dojac",
"=",
"True",
")",
":",
"# copy the params so as not to change the initial conditions",
"# in case we want to use them elsewhere",
"params",
"=",
"copy",
"."... | Fit the model to the data
data may contain 'flagged' or 'masked' data with the value of np.NaN
Parameters
----------
data : 2d-array
Image data
params : lmfit.Parameters
Initial model guess.
B : 2d-array
B matrix to be used in residual calculations.
Default = None.
errs : 1d-array
dojac : bool
If true then an analytic jacobian will be passed to the fitting routine.
Returns
-------
result : ?
lmfit.minimize result.
params : lmfit.Params
Fitted model.
See Also
--------
:func:`AegeanTools.fitting.lmfit_jacobian` | [
"Fit",
"the",
"model",
"to",
"the",
"data",
"data",
"may",
"contain",
"flagged",
"or",
"masked",
"data",
"with",
"the",
"value",
"of",
"np",
".",
"NaN"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L1140-L1210 |
PaulHancock/Aegean | AegeanTools/fitting.py | covar_errors | def covar_errors(params, data, errs, B, C=None):
"""
Take a set of parameters that were fit with lmfit, and replace the errors
with the 1\sigma errors calculated using the covariance matrix.
Parameters
----------
params : lmfit.Parameters
Model
data : 2d-array
Image data
errs : 2d-array ?
Image noise.
B : 2d-array
B matrix.
C : 2d-array
C matrix. Optional. If supplied then Bmatrix will not be used.
Returns
-------
params : lmfit.Parameters
Modified model.
"""
mask = np.where(np.isfinite(data))
# calculate the proper parameter errors and copy them across.
if C is not None:
try:
J = lmfit_jacobian(params, mask[0], mask[1], errs=errs)
covar = np.transpose(J).dot(inv(C)).dot(J)
onesigma = np.sqrt(np.diag(inv(covar)))
except (np.linalg.linalg.LinAlgError, ValueError) as _:
C = None
if C is None:
try:
J = lmfit_jacobian(params, mask[0], mask[1], B=B, errs=errs)
covar = np.transpose(J).dot(J)
onesigma = np.sqrt(np.diag(inv(covar)))
except (np.linalg.linalg.LinAlgError, ValueError) as _:
onesigma = [-2] * len(mask[0])
for i in range(params['components'].value):
prefix = "c{0}_".format(i)
j = 0
for p in ['amp', 'xo', 'yo', 'sx', 'sy', 'theta']:
if params[prefix + p].vary:
params[prefix + p].stderr = onesigma[j]
j += 1
return params | python | def covar_errors(params, data, errs, B, C=None):
"""
Take a set of parameters that were fit with lmfit, and replace the errors
with the 1\sigma errors calculated using the covariance matrix.
Parameters
----------
params : lmfit.Parameters
Model
data : 2d-array
Image data
errs : 2d-array ?
Image noise.
B : 2d-array
B matrix.
C : 2d-array
C matrix. Optional. If supplied then Bmatrix will not be used.
Returns
-------
params : lmfit.Parameters
Modified model.
"""
mask = np.where(np.isfinite(data))
# calculate the proper parameter errors and copy them across.
if C is not None:
try:
J = lmfit_jacobian(params, mask[0], mask[1], errs=errs)
covar = np.transpose(J).dot(inv(C)).dot(J)
onesigma = np.sqrt(np.diag(inv(covar)))
except (np.linalg.linalg.LinAlgError, ValueError) as _:
C = None
if C is None:
try:
J = lmfit_jacobian(params, mask[0], mask[1], B=B, errs=errs)
covar = np.transpose(J).dot(J)
onesigma = np.sqrt(np.diag(inv(covar)))
except (np.linalg.linalg.LinAlgError, ValueError) as _:
onesigma = [-2] * len(mask[0])
for i in range(params['components'].value):
prefix = "c{0}_".format(i)
j = 0
for p in ['amp', 'xo', 'yo', 'sx', 'sy', 'theta']:
if params[prefix + p].vary:
params[prefix + p].stderr = onesigma[j]
j += 1
return params | [
"def",
"covar_errors",
"(",
"params",
",",
"data",
",",
"errs",
",",
"B",
",",
"C",
"=",
"None",
")",
":",
"mask",
"=",
"np",
".",
"where",
"(",
"np",
".",
"isfinite",
"(",
"data",
")",
")",
"# calculate the proper parameter errors and copy them across.",
... | Take a set of parameters that were fit with lmfit, and replace the errors
with the 1\sigma errors calculated using the covariance matrix.
Parameters
----------
params : lmfit.Parameters
Model
data : 2d-array
Image data
errs : 2d-array ?
Image noise.
B : 2d-array
B matrix.
C : 2d-array
C matrix. Optional. If supplied then Bmatrix will not be used.
Returns
-------
params : lmfit.Parameters
Modified model. | [
"Take",
"a",
"set",
"of",
"parameters",
"that",
"were",
"fit",
"with",
"lmfit",
"and",
"replace",
"the",
"errors",
"with",
"the",
"1",
"\\",
"sigma",
"errors",
"calculated",
"using",
"the",
"covariance",
"matrix",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fitting.py#L1213-L1269 |
PaulHancock/Aegean | AegeanTools/BANE.py | barrier | def barrier(events, sid, kind='neighbour'):
"""
act as a multiprocessing barrier
"""
events[sid].set()
# only wait for the neighbours
if kind=='neighbour':
if sid > 0:
logging.debug("{0} is waiting for {1}".format(sid, sid - 1))
events[sid - 1].wait()
if sid < len(bkg_events) - 1:
logging.debug("{0} is waiting for {1}".format(sid, sid + 1))
events[sid + 1].wait()
# wait for all
else:
[e.wait() for e in events]
return | python | def barrier(events, sid, kind='neighbour'):
"""
act as a multiprocessing barrier
"""
events[sid].set()
# only wait for the neighbours
if kind=='neighbour':
if sid > 0:
logging.debug("{0} is waiting for {1}".format(sid, sid - 1))
events[sid - 1].wait()
if sid < len(bkg_events) - 1:
logging.debug("{0} is waiting for {1}".format(sid, sid + 1))
events[sid + 1].wait()
# wait for all
else:
[e.wait() for e in events]
return | [
"def",
"barrier",
"(",
"events",
",",
"sid",
",",
"kind",
"=",
"'neighbour'",
")",
":",
"events",
"[",
"sid",
"]",
".",
"set",
"(",
")",
"# only wait for the neighbours",
"if",
"kind",
"==",
"'neighbour'",
":",
"if",
"sid",
">",
"0",
":",
"logging",
".... | act as a multiprocessing barrier | [
"act",
"as",
"a",
"multiprocessing",
"barrier"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L34-L50 |
PaulHancock/Aegean | AegeanTools/BANE.py | sigmaclip | def sigmaclip(arr, lo, hi, reps=3):
"""
Perform sigma clipping on an array, ignoring non finite values.
During each iteration return an array whose elements c obey:
mean -std*lo < c < mean + std*hi
where mean/std are the mean std of the input array.
Parameters
----------
arr : iterable
An iterable array of numeric types.
lo : float
The negative clipping level.
hi : float
The positive clipping level.
reps : int
The number of iterations to perform.
Default = 3.
Returns
-------
mean : float
The mean of the array, possibly nan
std : float
The std of the array, possibly nan
Notes
-----
Scipy v0.16 now contains a comparable method that will ignore nan/inf values.
"""
clipped = np.array(arr)[np.isfinite(arr)]
if len(clipped) < 1:
return np.nan, np.nan
std = np.std(clipped)
mean = np.mean(clipped)
for _ in range(int(reps)):
clipped = clipped[np.where(clipped > mean-std*lo)]
clipped = clipped[np.where(clipped < mean+std*hi)]
pstd = std
if len(clipped) < 1:
break
std = np.std(clipped)
mean = np.mean(clipped)
if 2*abs(pstd-std)/(pstd+std) < 0.2:
break
return mean, std | python | def sigmaclip(arr, lo, hi, reps=3):
"""
Perform sigma clipping on an array, ignoring non finite values.
During each iteration return an array whose elements c obey:
mean -std*lo < c < mean + std*hi
where mean/std are the mean std of the input array.
Parameters
----------
arr : iterable
An iterable array of numeric types.
lo : float
The negative clipping level.
hi : float
The positive clipping level.
reps : int
The number of iterations to perform.
Default = 3.
Returns
-------
mean : float
The mean of the array, possibly nan
std : float
The std of the array, possibly nan
Notes
-----
Scipy v0.16 now contains a comparable method that will ignore nan/inf values.
"""
clipped = np.array(arr)[np.isfinite(arr)]
if len(clipped) < 1:
return np.nan, np.nan
std = np.std(clipped)
mean = np.mean(clipped)
for _ in range(int(reps)):
clipped = clipped[np.where(clipped > mean-std*lo)]
clipped = clipped[np.where(clipped < mean+std*hi)]
pstd = std
if len(clipped) < 1:
break
std = np.std(clipped)
mean = np.mean(clipped)
if 2*abs(pstd-std)/(pstd+std) < 0.2:
break
return mean, std | [
"def",
"sigmaclip",
"(",
"arr",
",",
"lo",
",",
"hi",
",",
"reps",
"=",
"3",
")",
":",
"clipped",
"=",
"np",
".",
"array",
"(",
"arr",
")",
"[",
"np",
".",
"isfinite",
"(",
"arr",
")",
"]",
"if",
"len",
"(",
"clipped",
")",
"<",
"1",
":",
"... | Perform sigma clipping on an array, ignoring non finite values.
During each iteration return an array whose elements c obey:
mean -std*lo < c < mean + std*hi
where mean/std are the mean std of the input array.
Parameters
----------
arr : iterable
An iterable array of numeric types.
lo : float
The negative clipping level.
hi : float
The positive clipping level.
reps : int
The number of iterations to perform.
Default = 3.
Returns
-------
mean : float
The mean of the array, possibly nan
std : float
The std of the array, possibly nan
Notes
-----
Scipy v0.16 now contains a comparable method that will ignore nan/inf values. | [
"Perform",
"sigma",
"clipping",
"on",
"an",
"array",
"ignoring",
"non",
"finite",
"values",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L53-L102 |
PaulHancock/Aegean | AegeanTools/BANE.py | _sf2 | def _sf2(args):
"""
A shallow wrapper for sigma_filter.
Parameters
----------
args : list
A list of arguments for sigma_filter
Returns
-------
None
"""
# an easier to debug traceback when multiprocessing
# thanks to https://stackoverflow.com/a/16618842/1710603
try:
return sigma_filter(*args)
except:
import traceback
raise Exception("".join(traceback.format_exception(*sys.exc_info()))) | python | def _sf2(args):
"""
A shallow wrapper for sigma_filter.
Parameters
----------
args : list
A list of arguments for sigma_filter
Returns
-------
None
"""
# an easier to debug traceback when multiprocessing
# thanks to https://stackoverflow.com/a/16618842/1710603
try:
return sigma_filter(*args)
except:
import traceback
raise Exception("".join(traceback.format_exception(*sys.exc_info()))) | [
"def",
"_sf2",
"(",
"args",
")",
":",
"# an easier to debug traceback when multiprocessing",
"# thanks to https://stackoverflow.com/a/16618842/1710603",
"try",
":",
"return",
"sigma_filter",
"(",
"*",
"args",
")",
"except",
":",
"import",
"traceback",
"raise",
"Exception",
... | A shallow wrapper for sigma_filter.
Parameters
----------
args : list
A list of arguments for sigma_filter
Returns
-------
None | [
"A",
"shallow",
"wrapper",
"for",
"sigma_filter",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L105-L124 |
PaulHancock/Aegean | AegeanTools/BANE.py | sigma_filter | def sigma_filter(filename, region, step_size, box_size, shape, domask, sid):
"""
Calculate the background and rms for a sub region of an image. The results are
written to shared memory - irms and ibkg.
Parameters
----------
filename : string
Fits file to open
region : list
Region within the fits file that is to be processed. (row_min, row_max).
step_size : (int, int)
The filtering step size
box_size : (int, int)
The size of the box over which the filter is applied (each step).
shape : tuple
The shape of the fits image
domask : bool
If true then copy the data mask to the output.
sid : int
The stripe number
Returns
-------
None
"""
ymin, ymax = region
logging.debug('rows {0}-{1} starting at {2}'.format(ymin, ymax, strftime("%Y-%m-%d %H:%M:%S", gmtime())))
# cut out the region of interest plus 1/2 the box size, but clip to the image size
data_row_min = max(0, ymin - box_size[0]//2)
data_row_max = min(shape[0], ymax + box_size[0]//2)
# Figure out how many axes are in the datafile
NAXIS = fits.getheader(filename)["NAXIS"]
with fits.open(filename, memmap=True) as a:
if NAXIS == 2:
data = a[0].section[data_row_min:data_row_max, 0:shape[1]]
elif NAXIS == 3:
data = a[0].section[0, data_row_min:data_row_max, 0:shape[1]]
elif NAXIS == 4:
data = a[0].section[0, 0, data_row_min:data_row_max, 0:shape[1]]
else:
logging.error("Too many NAXIS for me {0}".format(NAXIS))
logging.error("fix your file to be more sane")
raise Exception("Too many NAXIS")
row_len = shape[1]
logging.debug('data size is {0}'.format(data.shape))
def box(r, c):
"""
calculate the boundaries of the box centered at r,c
with size = box_size
"""
r_min = max(0, r - box_size[0] // 2)
r_max = min(data.shape[0] - 1, r + box_size[0] // 2)
c_min = max(0, c - box_size[1] // 2)
c_max = min(data.shape[1] - 1, c + box_size[1] // 2)
return r_min, r_max, c_min, c_max
# set up a grid of rows/cols at which we will compute the bkg/rms
rows = list(range(ymin-data_row_min, ymax-data_row_min, step_size[0]))
rows.append(ymax-data_row_min)
cols = list(range(0, shape[1], step_size[1]))
cols.append(shape[1])
# store the computed bkg/rms in this smaller array
vals = np.zeros(shape=(len(rows),len(cols)))
for i, row in enumerate(rows):
for j, col in enumerate(cols):
r_min, r_max, c_min, c_max = box(row, col)
new = data[r_min:r_max, c_min:c_max]
new = np.ravel(new)
bkg, _ = sigmaclip(new, 3, 3)
vals[i,j] = bkg
# indices of all the pixels within our region
gr, gc = np.mgrid[ymin-data_row_min:ymax-data_row_min, 0:shape[1]]
logging.debug("Interpolating bkg to sharemem")
ifunc = RegularGridInterpolator((rows, cols), vals)
for i in range(gr.shape[0]):
row = np.array(ifunc((gr[i], gc[i])), dtype=np.float32)
start_idx = np.ravel_multi_index((ymin+i, 0), shape)
end_idx = start_idx + row_len
ibkg[start_idx:end_idx] = row # np.ctypeslib.as_ctypes(row)
del ifunc
logging.debug(" ... done writing bkg")
# signal that the bkg is done for this region, and wait for neighbours
barrier(bkg_events, sid)
logging.debug("{0} background subtraction".format(sid))
for i in range(data_row_max - data_row_min):
start_idx = np.ravel_multi_index((data_row_min + i, 0), shape)
end_idx = start_idx + row_len
data[i, :] = data[i, :] - ibkg[start_idx:end_idx]
# reset/recycle the vals array
vals[:] = 0
for i, row in enumerate(rows):
for j, col in enumerate(cols):
r_min, r_max, c_min, c_max = box(row, col)
new = data[r_min:r_max, c_min:c_max]
new = np.ravel(new)
_ , rms = sigmaclip(new, 3, 3)
vals[i,j] = rms
logging.debug("Interpolating rm to sharemem rms")
ifunc = RegularGridInterpolator((rows, cols), vals)
for i in range(gr.shape[0]):
row = np.array(ifunc((gr[i], gc[i])), dtype=np.float32)
start_idx = np.ravel_multi_index((ymin+i, 0), shape)
end_idx = start_idx + row_len
irms[start_idx:end_idx] = row # np.ctypeslib.as_ctypes(row)
del ifunc
logging.debug(" .. done writing rms")
if domask:
barrier(mask_events, sid)
logging.debug("applying mask")
for i in range(gr.shape[0]):
mask = np.where(np.bitwise_not(np.isfinite(data[i + ymin-data_row_min,:])))[0]
for j in mask:
idx = np.ravel_multi_index((i + ymin,j),shape)
ibkg[idx] = np.nan
irms[idx] = np.nan
logging.debug(" ... done applying mask")
logging.debug('rows {0}-{1} finished at {2}'.format(ymin, ymax, strftime("%Y-%m-%d %H:%M:%S", gmtime())))
return | python | def sigma_filter(filename, region, step_size, box_size, shape, domask, sid):
"""
Calculate the background and rms for a sub region of an image. The results are
written to shared memory - irms and ibkg.
Parameters
----------
filename : string
Fits file to open
region : list
Region within the fits file that is to be processed. (row_min, row_max).
step_size : (int, int)
The filtering step size
box_size : (int, int)
The size of the box over which the filter is applied (each step).
shape : tuple
The shape of the fits image
domask : bool
If true then copy the data mask to the output.
sid : int
The stripe number
Returns
-------
None
"""
ymin, ymax = region
logging.debug('rows {0}-{1} starting at {2}'.format(ymin, ymax, strftime("%Y-%m-%d %H:%M:%S", gmtime())))
# cut out the region of interest plus 1/2 the box size, but clip to the image size
data_row_min = max(0, ymin - box_size[0]//2)
data_row_max = min(shape[0], ymax + box_size[0]//2)
# Figure out how many axes are in the datafile
NAXIS = fits.getheader(filename)["NAXIS"]
with fits.open(filename, memmap=True) as a:
if NAXIS == 2:
data = a[0].section[data_row_min:data_row_max, 0:shape[1]]
elif NAXIS == 3:
data = a[0].section[0, data_row_min:data_row_max, 0:shape[1]]
elif NAXIS == 4:
data = a[0].section[0, 0, data_row_min:data_row_max, 0:shape[1]]
else:
logging.error("Too many NAXIS for me {0}".format(NAXIS))
logging.error("fix your file to be more sane")
raise Exception("Too many NAXIS")
row_len = shape[1]
logging.debug('data size is {0}'.format(data.shape))
def box(r, c):
"""
calculate the boundaries of the box centered at r,c
with size = box_size
"""
r_min = max(0, r - box_size[0] // 2)
r_max = min(data.shape[0] - 1, r + box_size[0] // 2)
c_min = max(0, c - box_size[1] // 2)
c_max = min(data.shape[1] - 1, c + box_size[1] // 2)
return r_min, r_max, c_min, c_max
# set up a grid of rows/cols at which we will compute the bkg/rms
rows = list(range(ymin-data_row_min, ymax-data_row_min, step_size[0]))
rows.append(ymax-data_row_min)
cols = list(range(0, shape[1], step_size[1]))
cols.append(shape[1])
# store the computed bkg/rms in this smaller array
vals = np.zeros(shape=(len(rows),len(cols)))
for i, row in enumerate(rows):
for j, col in enumerate(cols):
r_min, r_max, c_min, c_max = box(row, col)
new = data[r_min:r_max, c_min:c_max]
new = np.ravel(new)
bkg, _ = sigmaclip(new, 3, 3)
vals[i,j] = bkg
# indices of all the pixels within our region
gr, gc = np.mgrid[ymin-data_row_min:ymax-data_row_min, 0:shape[1]]
logging.debug("Interpolating bkg to sharemem")
ifunc = RegularGridInterpolator((rows, cols), vals)
for i in range(gr.shape[0]):
row = np.array(ifunc((gr[i], gc[i])), dtype=np.float32)
start_idx = np.ravel_multi_index((ymin+i, 0), shape)
end_idx = start_idx + row_len
ibkg[start_idx:end_idx] = row # np.ctypeslib.as_ctypes(row)
del ifunc
logging.debug(" ... done writing bkg")
# signal that the bkg is done for this region, and wait for neighbours
barrier(bkg_events, sid)
logging.debug("{0} background subtraction".format(sid))
for i in range(data_row_max - data_row_min):
start_idx = np.ravel_multi_index((data_row_min + i, 0), shape)
end_idx = start_idx + row_len
data[i, :] = data[i, :] - ibkg[start_idx:end_idx]
# reset/recycle the vals array
vals[:] = 0
for i, row in enumerate(rows):
for j, col in enumerate(cols):
r_min, r_max, c_min, c_max = box(row, col)
new = data[r_min:r_max, c_min:c_max]
new = np.ravel(new)
_ , rms = sigmaclip(new, 3, 3)
vals[i,j] = rms
logging.debug("Interpolating rm to sharemem rms")
ifunc = RegularGridInterpolator((rows, cols), vals)
for i in range(gr.shape[0]):
row = np.array(ifunc((gr[i], gc[i])), dtype=np.float32)
start_idx = np.ravel_multi_index((ymin+i, 0), shape)
end_idx = start_idx + row_len
irms[start_idx:end_idx] = row # np.ctypeslib.as_ctypes(row)
del ifunc
logging.debug(" .. done writing rms")
if domask:
barrier(mask_events, sid)
logging.debug("applying mask")
for i in range(gr.shape[0]):
mask = np.where(np.bitwise_not(np.isfinite(data[i + ymin-data_row_min,:])))[0]
for j in mask:
idx = np.ravel_multi_index((i + ymin,j),shape)
ibkg[idx] = np.nan
irms[idx] = np.nan
logging.debug(" ... done applying mask")
logging.debug('rows {0}-{1} finished at {2}'.format(ymin, ymax, strftime("%Y-%m-%d %H:%M:%S", gmtime())))
return | [
"def",
"sigma_filter",
"(",
"filename",
",",
"region",
",",
"step_size",
",",
"box_size",
",",
"shape",
",",
"domask",
",",
"sid",
")",
":",
"ymin",
",",
"ymax",
"=",
"region",
"logging",
".",
"debug",
"(",
"'rows {0}-{1} starting at {2}'",
".",
"format",
... | Calculate the background and rms for a sub region of an image. The results are
written to shared memory - irms and ibkg.
Parameters
----------
filename : string
Fits file to open
region : list
Region within the fits file that is to be processed. (row_min, row_max).
step_size : (int, int)
The filtering step size
box_size : (int, int)
The size of the box over which the filter is applied (each step).
shape : tuple
The shape of the fits image
domask : bool
If true then copy the data mask to the output.
sid : int
The stripe number
Returns
-------
None | [
"Calculate",
"the",
"background",
"and",
"rms",
"for",
"a",
"sub",
"region",
"of",
"an",
"image",
".",
"The",
"results",
"are",
"written",
"to",
"shared",
"memory",
"-",
"irms",
"and",
"ibkg",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L127-L267 |
PaulHancock/Aegean | AegeanTools/BANE.py | filter_mc_sharemem | def filter_mc_sharemem(filename, step_size, box_size, cores, shape, nslice=None, domask=True):
"""
Calculate the background and noise images corresponding to the input file.
The calculation is done via a box-car approach and uses multiple cores and shared memory.
Parameters
----------
filename : str
Filename to be filtered.
step_size : (int, int)
Step size for the filter.
box_size : (int, int)
Box size for the filter.
cores : int
Number of cores to use. If None then use all available.
nslice : int
The image will be divided into this many horizontal stripes for processing.
Default = None = equal to cores
shape : (int, int)
The shape of the image in the given file.
domask : bool
True(Default) = copy data mask to output.
Returns
-------
bkg, rms : numpy.ndarray
The interpolated background and noise images.
"""
if cores is None:
cores = multiprocessing.cpu_count()
if (nslice is None) or (cores==1):
nslice = cores
img_y, img_x = shape
# initialise some shared memory
global ibkg
# bkg = np.ctypeslib.as_ctypes(np.empty(shape, dtype=np.float32))
# ibkg = multiprocessing.sharedctypes.Array(bkg._type_, bkg, lock=True)
ibkg = multiprocessing.Array('f', img_y*img_x)
global irms
#rms = np.ctypeslib.as_ctypes(np.empty(shape, dtype=np.float32))
#irms = multiprocessing.sharedctypes.Array(rms._type_, rms, lock=True)
irms = multiprocessing.Array('f', img_y * img_x)
logging.info("using {0} cores".format(cores))
logging.info("using {0} stripes".format(nslice))
if nslice > 1:
# box widths should be multiples of the step_size, and not zero
width_y = int(max(img_y/nslice/step_size[1], 1) * step_size[1])
# locations of the box edges
ymins = list(range(0, img_y, width_y))
ymaxs = list(range(width_y, img_y, width_y))
ymaxs.append(img_y)
else:
ymins = [0]
ymaxs = [img_y]
logging.debug("ymins {0}".format(ymins))
logging.debug("ymaxs {0}".format(ymaxs))
# create an event per stripe
global bkg_events, mask_events
bkg_events = [multiprocessing.Event() for _ in range(len(ymaxs))]
mask_events = [multiprocessing.Event() for _ in range(len(ymaxs))]
args = []
for i, region in enumerate(zip(ymins, ymaxs)):
args.append((filename, region, step_size, box_size, shape, domask, i))
# start a new process for each task, hopefully to reduce residual memory use
pool = multiprocessing.Pool(processes=cores, maxtasksperchild=1)
try:
# chunksize=1 ensures that we only send a single task to each process
pool.map_async(_sf2, args, chunksize=1).get(timeout=10000000)
except KeyboardInterrupt:
logging.error("Caught keyboard interrupt")
pool.close()
sys.exit(1)
pool.close()
pool.join()
bkg = np.reshape(np.array(ibkg[:], dtype=np.float32), shape)
rms = np.reshape(np.array(irms[:], dtype=np.float32), shape)
del ibkg, irms
return bkg, rms | python | def filter_mc_sharemem(filename, step_size, box_size, cores, shape, nslice=None, domask=True):
"""
Calculate the background and noise images corresponding to the input file.
The calculation is done via a box-car approach and uses multiple cores and shared memory.
Parameters
----------
filename : str
Filename to be filtered.
step_size : (int, int)
Step size for the filter.
box_size : (int, int)
Box size for the filter.
cores : int
Number of cores to use. If None then use all available.
nslice : int
The image will be divided into this many horizontal stripes for processing.
Default = None = equal to cores
shape : (int, int)
The shape of the image in the given file.
domask : bool
True(Default) = copy data mask to output.
Returns
-------
bkg, rms : numpy.ndarray
The interpolated background and noise images.
"""
if cores is None:
cores = multiprocessing.cpu_count()
if (nslice is None) or (cores==1):
nslice = cores
img_y, img_x = shape
# initialise some shared memory
global ibkg
# bkg = np.ctypeslib.as_ctypes(np.empty(shape, dtype=np.float32))
# ibkg = multiprocessing.sharedctypes.Array(bkg._type_, bkg, lock=True)
ibkg = multiprocessing.Array('f', img_y*img_x)
global irms
#rms = np.ctypeslib.as_ctypes(np.empty(shape, dtype=np.float32))
#irms = multiprocessing.sharedctypes.Array(rms._type_, rms, lock=True)
irms = multiprocessing.Array('f', img_y * img_x)
logging.info("using {0} cores".format(cores))
logging.info("using {0} stripes".format(nslice))
if nslice > 1:
# box widths should be multiples of the step_size, and not zero
width_y = int(max(img_y/nslice/step_size[1], 1) * step_size[1])
# locations of the box edges
ymins = list(range(0, img_y, width_y))
ymaxs = list(range(width_y, img_y, width_y))
ymaxs.append(img_y)
else:
ymins = [0]
ymaxs = [img_y]
logging.debug("ymins {0}".format(ymins))
logging.debug("ymaxs {0}".format(ymaxs))
# create an event per stripe
global bkg_events, mask_events
bkg_events = [multiprocessing.Event() for _ in range(len(ymaxs))]
mask_events = [multiprocessing.Event() for _ in range(len(ymaxs))]
args = []
for i, region in enumerate(zip(ymins, ymaxs)):
args.append((filename, region, step_size, box_size, shape, domask, i))
# start a new process for each task, hopefully to reduce residual memory use
pool = multiprocessing.Pool(processes=cores, maxtasksperchild=1)
try:
# chunksize=1 ensures that we only send a single task to each process
pool.map_async(_sf2, args, chunksize=1).get(timeout=10000000)
except KeyboardInterrupt:
logging.error("Caught keyboard interrupt")
pool.close()
sys.exit(1)
pool.close()
pool.join()
bkg = np.reshape(np.array(ibkg[:], dtype=np.float32), shape)
rms = np.reshape(np.array(irms[:], dtype=np.float32), shape)
del ibkg, irms
return bkg, rms | [
"def",
"filter_mc_sharemem",
"(",
"filename",
",",
"step_size",
",",
"box_size",
",",
"cores",
",",
"shape",
",",
"nslice",
"=",
"None",
",",
"domask",
"=",
"True",
")",
":",
"if",
"cores",
"is",
"None",
":",
"cores",
"=",
"multiprocessing",
".",
"cpu_co... | Calculate the background and noise images corresponding to the input file.
The calculation is done via a box-car approach and uses multiple cores and shared memory.
Parameters
----------
filename : str
Filename to be filtered.
step_size : (int, int)
Step size for the filter.
box_size : (int, int)
Box size for the filter.
cores : int
Number of cores to use. If None then use all available.
nslice : int
The image will be divided into this many horizontal stripes for processing.
Default = None = equal to cores
shape : (int, int)
The shape of the image in the given file.
domask : bool
True(Default) = copy data mask to output.
Returns
-------
bkg, rms : numpy.ndarray
The interpolated background and noise images. | [
"Calculate",
"the",
"background",
"and",
"noise",
"images",
"corresponding",
"to",
"the",
"input",
"file",
".",
"The",
"calculation",
"is",
"done",
"via",
"a",
"box",
"-",
"car",
"approach",
"and",
"uses",
"multiple",
"cores",
"and",
"shared",
"memory",
"."
... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L270-L363 |
PaulHancock/Aegean | AegeanTools/BANE.py | filter_image | def filter_image(im_name, out_base, step_size=None, box_size=None, twopass=False, cores=None, mask=True, compressed=False, nslice=None):
"""
Create a background and noise image from an input image.
Resulting images are written to `outbase_bkg.fits` and `outbase_rms.fits`
Parameters
----------
im_name : str or HDUList
Image to filter. Either a string filename or an astropy.io.fits.HDUList.
out_base : str
The output filename base. Will be modified to make _bkg and _rms files.
step_size : (int,int)
Tuple of the x,y step size in pixels
box_size : (int,int)
The size of the box in piexls
twopass : bool
Perform a second pass calculation to ensure that the noise is not contaminated by the background.
Default = False
cores : int
Number of CPU corse to use.
Default = all available
nslice : int
The image will be divided into this many horizontal stripes for processing.
Default = None = equal to cores
mask : bool
Mask the output array to contain np.nna wherever the input array is nan or not finite.
Default = true
compressed : bool
Return a compressed version of the background/noise images.
Default = False
Returns
-------
None
"""
header = fits.getheader(im_name)
shape = (header['NAXIS2'],header['NAXIS1'])
if step_size is None:
if 'BMAJ' in header and 'BMIN' in header:
beam_size = np.sqrt(abs(header['BMAJ']*header['BMIN']))
if 'CDELT1' in header:
pix_scale = np.sqrt(abs(header['CDELT1']*header['CDELT2']))
elif 'CD1_1' in header:
pix_scale = np.sqrt(abs(header['CD1_1']*header['CD2_2']))
if 'CD1_2' in header and 'CD2_1' in header:
if header['CD1_2'] != 0 or header['CD2_1']!=0:
logging.warning("CD1_2 and/or CD2_1 are non-zero and I don't know what to do with them")
logging.warning("Ingoring them")
else:
logging.warning("Cannot determine pixel scale, assuming 4 pixels per beam")
pix_scale = beam_size/4.
# default to 4x the synthesized beam width
step_size = int(np.ceil(4*beam_size/pix_scale))
else:
logging.info("BMAJ and/or BMIN not in fits header.")
logging.info("Assuming 4 pix/beam, so we have step_size = 16 pixels")
step_size = 16
step_size = (step_size, step_size)
if box_size is None:
# default to 6x the step size so we have ~ 30beams
box_size = (step_size[0]*6, step_size[1]*6)
if compressed:
if not step_size[0] == step_size[1]:
step_size = (min(step_size), min(step_size))
logging.info("Changing grid to be {0} so we can compress the output".format(step_size))
logging.info("using grid_size {0}, box_size {1}".format(step_size,box_size))
logging.info("on data shape {0}".format(shape))
bkg, rms = filter_mc_sharemem(im_name, step_size=step_size, box_size=box_size, cores=cores, shape=shape, nslice=nslice, domask=mask)
logging.info("done")
bkg_out = '_'.join([os.path.expanduser(out_base), 'bkg.fits'])
rms_out = '_'.join([os.path.expanduser(out_base), 'rms.fits'])
# add a comment to the fits header
header['HISTORY'] = 'BANE {0}-({1})'.format(__version__, __date__)
# compress
if compressed:
hdu = fits.PrimaryHDU(bkg)
hdu.header = copy.deepcopy(header)
hdulist = fits.HDUList([hdu])
compress(hdulist, step_size[0], bkg_out)
hdulist[0].header = copy.deepcopy(header)
hdulist[0].data = rms
compress(hdulist, step_size[0], rms_out)
return
write_fits(bkg, header, bkg_out)
write_fits(rms, header, rms_out) | python | def filter_image(im_name, out_base, step_size=None, box_size=None, twopass=False, cores=None, mask=True, compressed=False, nslice=None):
"""
Create a background and noise image from an input image.
Resulting images are written to `outbase_bkg.fits` and `outbase_rms.fits`
Parameters
----------
im_name : str or HDUList
Image to filter. Either a string filename or an astropy.io.fits.HDUList.
out_base : str
The output filename base. Will be modified to make _bkg and _rms files.
step_size : (int,int)
Tuple of the x,y step size in pixels
box_size : (int,int)
The size of the box in piexls
twopass : bool
Perform a second pass calculation to ensure that the noise is not contaminated by the background.
Default = False
cores : int
Number of CPU corse to use.
Default = all available
nslice : int
The image will be divided into this many horizontal stripes for processing.
Default = None = equal to cores
mask : bool
Mask the output array to contain np.nna wherever the input array is nan or not finite.
Default = true
compressed : bool
Return a compressed version of the background/noise images.
Default = False
Returns
-------
None
"""
header = fits.getheader(im_name)
shape = (header['NAXIS2'],header['NAXIS1'])
if step_size is None:
if 'BMAJ' in header and 'BMIN' in header:
beam_size = np.sqrt(abs(header['BMAJ']*header['BMIN']))
if 'CDELT1' in header:
pix_scale = np.sqrt(abs(header['CDELT1']*header['CDELT2']))
elif 'CD1_1' in header:
pix_scale = np.sqrt(abs(header['CD1_1']*header['CD2_2']))
if 'CD1_2' in header and 'CD2_1' in header:
if header['CD1_2'] != 0 or header['CD2_1']!=0:
logging.warning("CD1_2 and/or CD2_1 are non-zero and I don't know what to do with them")
logging.warning("Ingoring them")
else:
logging.warning("Cannot determine pixel scale, assuming 4 pixels per beam")
pix_scale = beam_size/4.
# default to 4x the synthesized beam width
step_size = int(np.ceil(4*beam_size/pix_scale))
else:
logging.info("BMAJ and/or BMIN not in fits header.")
logging.info("Assuming 4 pix/beam, so we have step_size = 16 pixels")
step_size = 16
step_size = (step_size, step_size)
if box_size is None:
# default to 6x the step size so we have ~ 30beams
box_size = (step_size[0]*6, step_size[1]*6)
if compressed:
if not step_size[0] == step_size[1]:
step_size = (min(step_size), min(step_size))
logging.info("Changing grid to be {0} so we can compress the output".format(step_size))
logging.info("using grid_size {0}, box_size {1}".format(step_size,box_size))
logging.info("on data shape {0}".format(shape))
bkg, rms = filter_mc_sharemem(im_name, step_size=step_size, box_size=box_size, cores=cores, shape=shape, nslice=nslice, domask=mask)
logging.info("done")
bkg_out = '_'.join([os.path.expanduser(out_base), 'bkg.fits'])
rms_out = '_'.join([os.path.expanduser(out_base), 'rms.fits'])
# add a comment to the fits header
header['HISTORY'] = 'BANE {0}-({1})'.format(__version__, __date__)
# compress
if compressed:
hdu = fits.PrimaryHDU(bkg)
hdu.header = copy.deepcopy(header)
hdulist = fits.HDUList([hdu])
compress(hdulist, step_size[0], bkg_out)
hdulist[0].header = copy.deepcopy(header)
hdulist[0].data = rms
compress(hdulist, step_size[0], rms_out)
return
write_fits(bkg, header, bkg_out)
write_fits(rms, header, rms_out) | [
"def",
"filter_image",
"(",
"im_name",
",",
"out_base",
",",
"step_size",
"=",
"None",
",",
"box_size",
"=",
"None",
",",
"twopass",
"=",
"False",
",",
"cores",
"=",
"None",
",",
"mask",
"=",
"True",
",",
"compressed",
"=",
"False",
",",
"nslice",
"=",... | Create a background and noise image from an input image.
Resulting images are written to `outbase_bkg.fits` and `outbase_rms.fits`
Parameters
----------
im_name : str or HDUList
Image to filter. Either a string filename or an astropy.io.fits.HDUList.
out_base : str
The output filename base. Will be modified to make _bkg and _rms files.
step_size : (int,int)
Tuple of the x,y step size in pixels
box_size : (int,int)
The size of the box in piexls
twopass : bool
Perform a second pass calculation to ensure that the noise is not contaminated by the background.
Default = False
cores : int
Number of CPU corse to use.
Default = all available
nslice : int
The image will be divided into this many horizontal stripes for processing.
Default = None = equal to cores
mask : bool
Mask the output array to contain np.nna wherever the input array is nan or not finite.
Default = true
compressed : bool
Return a compressed version of the background/noise images.
Default = False
Returns
-------
None | [
"Create",
"a",
"background",
"and",
"noise",
"image",
"from",
"an",
"input",
"image",
".",
"Resulting",
"images",
"are",
"written",
"to",
"outbase_bkg",
".",
"fits",
"and",
"outbase_rms",
".",
"fits"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L366-L461 |
PaulHancock/Aegean | AegeanTools/BANE.py | write_fits | def write_fits(data, header, file_name):
"""
Combine data and a fits header to write a fits file.
Parameters
----------
data : numpy.ndarray
The data to be written.
header : astropy.io.fits.hduheader
The header for the fits file.
file_name : string
The file to write
Returns
-------
None
"""
hdu = fits.PrimaryHDU(data)
hdu.header = header
hdulist = fits.HDUList([hdu])
hdulist.writeto(file_name, overwrite=True)
logging.info("Wrote {0}".format(file_name))
return | python | def write_fits(data, header, file_name):
"""
Combine data and a fits header to write a fits file.
Parameters
----------
data : numpy.ndarray
The data to be written.
header : astropy.io.fits.hduheader
The header for the fits file.
file_name : string
The file to write
Returns
-------
None
"""
hdu = fits.PrimaryHDU(data)
hdu.header = header
hdulist = fits.HDUList([hdu])
hdulist.writeto(file_name, overwrite=True)
logging.info("Wrote {0}".format(file_name))
return | [
"def",
"write_fits",
"(",
"data",
",",
"header",
",",
"file_name",
")",
":",
"hdu",
"=",
"fits",
".",
"PrimaryHDU",
"(",
"data",
")",
"hdu",
".",
"header",
"=",
"header",
"hdulist",
"=",
"fits",
".",
"HDUList",
"(",
"[",
"hdu",
"]",
")",
"hdulist",
... | Combine data and a fits header to write a fits file.
Parameters
----------
data : numpy.ndarray
The data to be written.
header : astropy.io.fits.hduheader
The header for the fits file.
file_name : string
The file to write
Returns
-------
None | [
"Combine",
"data",
"and",
"a",
"fits",
"header",
"to",
"write",
"a",
"fits",
"file",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/BANE.py#L467-L491 |
PaulHancock/Aegean | AegeanTools/angle_tools.py | dec2dec | def dec2dec(dec):
"""
Convert sexegessimal RA string into a float in degrees.
Parameters
----------
dec : string
A string separated representing the Dec.
Expected format is `[+- ]hh:mm[:ss.s]`
Colons can be replaced with any whit space character.
Returns
-------
dec : float
The Dec in degrees.
"""
d = dec.replace(':', ' ').split()
if len(d) == 2:
d.append(0.0)
if d[0].startswith('-') or float(d[0]) < 0:
return float(d[0]) - float(d[1]) / 60.0 - float(d[2]) / 3600.0
return float(d[0]) + float(d[1]) / 60.0 + float(d[2]) / 3600.0 | python | def dec2dec(dec):
"""
Convert sexegessimal RA string into a float in degrees.
Parameters
----------
dec : string
A string separated representing the Dec.
Expected format is `[+- ]hh:mm[:ss.s]`
Colons can be replaced with any whit space character.
Returns
-------
dec : float
The Dec in degrees.
"""
d = dec.replace(':', ' ').split()
if len(d) == 2:
d.append(0.0)
if d[0].startswith('-') or float(d[0]) < 0:
return float(d[0]) - float(d[1]) / 60.0 - float(d[2]) / 3600.0
return float(d[0]) + float(d[1]) / 60.0 + float(d[2]) / 3600.0 | [
"def",
"dec2dec",
"(",
"dec",
")",
":",
"d",
"=",
"dec",
".",
"replace",
"(",
"':'",
",",
"' '",
")",
".",
"split",
"(",
")",
"if",
"len",
"(",
"d",
")",
"==",
"2",
":",
"d",
".",
"append",
"(",
"0.0",
")",
"if",
"d",
"[",
"0",
"]",
".",
... | Convert sexegessimal RA string into a float in degrees.
Parameters
----------
dec : string
A string separated representing the Dec.
Expected format is `[+- ]hh:mm[:ss.s]`
Colons can be replaced with any whit space character.
Returns
-------
dec : float
The Dec in degrees. | [
"Convert",
"sexegessimal",
"RA",
"string",
"into",
"a",
"float",
"in",
"degrees",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L38-L59 |
PaulHancock/Aegean | AegeanTools/angle_tools.py | dec2dms | def dec2dms(x):
"""
Convert decimal degrees into a sexagessimal string in degrees.
Parameters
----------
x : float
Angle in degrees
Returns
-------
dms : string
String of format [+-]DD:MM:SS.SS
or XX:XX:XX.XX if x is not finite.
"""
if not np.isfinite(x):
return 'XX:XX:XX.XX'
if x < 0:
sign = '-'
else:
sign = '+'
x = abs(x)
d = int(math.floor(x))
m = int(math.floor((x - d) * 60))
s = float(( (x - d) * 60 - m) * 60)
return '{0}{1:02d}:{2:02d}:{3:05.2f}'.format(sign, d, m, s) | python | def dec2dms(x):
"""
Convert decimal degrees into a sexagessimal string in degrees.
Parameters
----------
x : float
Angle in degrees
Returns
-------
dms : string
String of format [+-]DD:MM:SS.SS
or XX:XX:XX.XX if x is not finite.
"""
if not np.isfinite(x):
return 'XX:XX:XX.XX'
if x < 0:
sign = '-'
else:
sign = '+'
x = abs(x)
d = int(math.floor(x))
m = int(math.floor((x - d) * 60))
s = float(( (x - d) * 60 - m) * 60)
return '{0}{1:02d}:{2:02d}:{3:05.2f}'.format(sign, d, m, s) | [
"def",
"dec2dms",
"(",
"x",
")",
":",
"if",
"not",
"np",
".",
"isfinite",
"(",
"x",
")",
":",
"return",
"'XX:XX:XX.XX'",
"if",
"x",
"<",
"0",
":",
"sign",
"=",
"'-'",
"else",
":",
"sign",
"=",
"'+'",
"x",
"=",
"abs",
"(",
"x",
")",
"d",
"=",
... | Convert decimal degrees into a sexagessimal string in degrees.
Parameters
----------
x : float
Angle in degrees
Returns
-------
dms : string
String of format [+-]DD:MM:SS.SS
or XX:XX:XX.XX if x is not finite. | [
"Convert",
"decimal",
"degrees",
"into",
"a",
"sexagessimal",
"string",
"in",
"degrees",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L62-L87 |
PaulHancock/Aegean | AegeanTools/angle_tools.py | dec2hms | def dec2hms(x):
"""
Convert decimal degrees into a sexagessimal string in hours.
Parameters
----------
x : float
Angle in degrees
Returns
-------
dms : string
String of format HH:MM:SS.SS
or XX:XX:XX.XX if x is not finite.
"""
if not np.isfinite(x):
return 'XX:XX:XX.XX'
# wrap negative RA's
if x < 0:
x += 360
x /= 15.0
h = int(x)
x = (x - h) * 60
m = int(x)
s = (x - m) * 60
return '{0:02d}:{1:02d}:{2:05.2f}'.format(h, m, s) | python | def dec2hms(x):
"""
Convert decimal degrees into a sexagessimal string in hours.
Parameters
----------
x : float
Angle in degrees
Returns
-------
dms : string
String of format HH:MM:SS.SS
or XX:XX:XX.XX if x is not finite.
"""
if not np.isfinite(x):
return 'XX:XX:XX.XX'
# wrap negative RA's
if x < 0:
x += 360
x /= 15.0
h = int(x)
x = (x - h) * 60
m = int(x)
s = (x - m) * 60
return '{0:02d}:{1:02d}:{2:05.2f}'.format(h, m, s) | [
"def",
"dec2hms",
"(",
"x",
")",
":",
"if",
"not",
"np",
".",
"isfinite",
"(",
"x",
")",
":",
"return",
"'XX:XX:XX.XX'",
"# wrap negative RA's",
"if",
"x",
"<",
"0",
":",
"x",
"+=",
"360",
"x",
"/=",
"15.0",
"h",
"=",
"int",
"(",
"x",
")",
"x",
... | Convert decimal degrees into a sexagessimal string in hours.
Parameters
----------
x : float
Angle in degrees
Returns
-------
dms : string
String of format HH:MM:SS.SS
or XX:XX:XX.XX if x is not finite. | [
"Convert",
"decimal",
"degrees",
"into",
"a",
"sexagessimal",
"string",
"in",
"hours",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L90-L115 |
PaulHancock/Aegean | AegeanTools/angle_tools.py | gcd | def gcd(ra1, dec1, ra2, dec2):
"""
Calculate the great circle distance between to points using the haversine formula [1]_.
Parameters
----------
ra1, dec1, ra2, dec2 : float
The coordinates of the two points of interest.
Units are in degrees.
Returns
-------
dist : float
The distance between the two points in degrees.
Notes
-----
This duplicates the functionality of astropy but is faster as there is no creation of SkyCoords objects.
.. [1] `Haversine formula <https://en.wikipedia.org/wiki/Haversine_formula>`_
"""
# TODO: Vincenty formula see - https://en.wikipedia.org/wiki/Great-circle_distance
dlon = ra2 - ra1
dlat = dec2 - dec1
a = np.sin(np.radians(dlat) / 2) ** 2
a += np.cos(np.radians(dec1)) * np.cos(np.radians(dec2)) * np.sin(np.radians(dlon) / 2) ** 2
sep = np.degrees(2 * np.arcsin(np.minimum(1, np.sqrt(a))))
return sep | python | def gcd(ra1, dec1, ra2, dec2):
"""
Calculate the great circle distance between to points using the haversine formula [1]_.
Parameters
----------
ra1, dec1, ra2, dec2 : float
The coordinates of the two points of interest.
Units are in degrees.
Returns
-------
dist : float
The distance between the two points in degrees.
Notes
-----
This duplicates the functionality of astropy but is faster as there is no creation of SkyCoords objects.
.. [1] `Haversine formula <https://en.wikipedia.org/wiki/Haversine_formula>`_
"""
# TODO: Vincenty formula see - https://en.wikipedia.org/wiki/Great-circle_distance
dlon = ra2 - ra1
dlat = dec2 - dec1
a = np.sin(np.radians(dlat) / 2) ** 2
a += np.cos(np.radians(dec1)) * np.cos(np.radians(dec2)) * np.sin(np.radians(dlon) / 2) ** 2
sep = np.degrees(2 * np.arcsin(np.minimum(1, np.sqrt(a))))
return sep | [
"def",
"gcd",
"(",
"ra1",
",",
"dec1",
",",
"ra2",
",",
"dec2",
")",
":",
"# TODO: Vincenty formula see - https://en.wikipedia.org/wiki/Great-circle_distance",
"dlon",
"=",
"ra2",
"-",
"ra1",
"dlat",
"=",
"dec2",
"-",
"dec1",
"a",
"=",
"np",
".",
"sin",
"(",
... | Calculate the great circle distance between to points using the haversine formula [1]_.
Parameters
----------
ra1, dec1, ra2, dec2 : float
The coordinates of the two points of interest.
Units are in degrees.
Returns
-------
dist : float
The distance between the two points in degrees.
Notes
-----
This duplicates the functionality of astropy but is faster as there is no creation of SkyCoords objects.
.. [1] `Haversine formula <https://en.wikipedia.org/wiki/Haversine_formula>`_ | [
"Calculate",
"the",
"great",
"circle",
"distance",
"between",
"to",
"points",
"using",
"the",
"haversine",
"formula",
"[",
"1",
"]",
"_",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L121-L149 |
PaulHancock/Aegean | AegeanTools/angle_tools.py | bear | def bear(ra1, dec1, ra2, dec2):
"""
Calculate the bearing of point 2 from point 1 along a great circle.
The bearing is East of North and is in [0, 360), whereas position angle is also East of North but (-180,180]
Parameters
----------
ra1, dec1, ra2, dec2 : float
The sky coordinates (degrees) of the two points.
Returns
-------
bear : float
The bearing of point 2 from point 1 (degrees).
"""
rdec1 = np.radians(dec1)
rdec2 = np.radians(dec2)
rdlon = np.radians(ra2-ra1)
y = np.sin(rdlon) * np.cos(rdec2)
x = np.cos(rdec1) * np.sin(rdec2)
x -= np.sin(rdec1) * np.cos(rdec2) * np.cos(rdlon)
return np.degrees(np.arctan2(y, x)) | python | def bear(ra1, dec1, ra2, dec2):
"""
Calculate the bearing of point 2 from point 1 along a great circle.
The bearing is East of North and is in [0, 360), whereas position angle is also East of North but (-180,180]
Parameters
----------
ra1, dec1, ra2, dec2 : float
The sky coordinates (degrees) of the two points.
Returns
-------
bear : float
The bearing of point 2 from point 1 (degrees).
"""
rdec1 = np.radians(dec1)
rdec2 = np.radians(dec2)
rdlon = np.radians(ra2-ra1)
y = np.sin(rdlon) * np.cos(rdec2)
x = np.cos(rdec1) * np.sin(rdec2)
x -= np.sin(rdec1) * np.cos(rdec2) * np.cos(rdlon)
return np.degrees(np.arctan2(y, x)) | [
"def",
"bear",
"(",
"ra1",
",",
"dec1",
",",
"ra2",
",",
"dec2",
")",
":",
"rdec1",
"=",
"np",
".",
"radians",
"(",
"dec1",
")",
"rdec2",
"=",
"np",
".",
"radians",
"(",
"dec2",
")",
"rdlon",
"=",
"np",
".",
"radians",
"(",
"ra2",
"-",
"ra1",
... | Calculate the bearing of point 2 from point 1 along a great circle.
The bearing is East of North and is in [0, 360), whereas position angle is also East of North but (-180,180]
Parameters
----------
ra1, dec1, ra2, dec2 : float
The sky coordinates (degrees) of the two points.
Returns
-------
bear : float
The bearing of point 2 from point 1 (degrees). | [
"Calculate",
"the",
"bearing",
"of",
"point",
"2",
"from",
"point",
"1",
"along",
"a",
"great",
"circle",
".",
"The",
"bearing",
"is",
"East",
"of",
"North",
"and",
"is",
"in",
"[",
"0",
"360",
")",
"whereas",
"position",
"angle",
"is",
"also",
"East",... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L152-L173 |
PaulHancock/Aegean | AegeanTools/angle_tools.py | translate | def translate(ra, dec, r, theta):
"""
Translate a given point a distance r in the (initial) direction theta, along a great circle.
Parameters
----------
ra, dec : float
The initial point of interest (degrees).
r, theta : float
The distance and initial direction to translate (degrees).
Returns
-------
ra, dec : float
The translated position (degrees).
"""
factor = np.sin(np.radians(dec)) * np.cos(np.radians(r))
factor += np.cos(np.radians(dec)) * np.sin(np.radians(r)) * np.cos(np.radians(theta))
dec_out = np.degrees(np.arcsin(factor))
y = np.sin(np.radians(theta)) * np.sin(np.radians(r)) * np.cos(np.radians(dec))
x = np.cos(np.radians(r)) - np.sin(np.radians(dec)) * np.sin(np.radians(dec_out))
ra_out = ra + np.degrees(np.arctan2(y, x))
return ra_out, dec_out | python | def translate(ra, dec, r, theta):
"""
Translate a given point a distance r in the (initial) direction theta, along a great circle.
Parameters
----------
ra, dec : float
The initial point of interest (degrees).
r, theta : float
The distance and initial direction to translate (degrees).
Returns
-------
ra, dec : float
The translated position (degrees).
"""
factor = np.sin(np.radians(dec)) * np.cos(np.radians(r))
factor += np.cos(np.radians(dec)) * np.sin(np.radians(r)) * np.cos(np.radians(theta))
dec_out = np.degrees(np.arcsin(factor))
y = np.sin(np.radians(theta)) * np.sin(np.radians(r)) * np.cos(np.radians(dec))
x = np.cos(np.radians(r)) - np.sin(np.radians(dec)) * np.sin(np.radians(dec_out))
ra_out = ra + np.degrees(np.arctan2(y, x))
return ra_out, dec_out | [
"def",
"translate",
"(",
"ra",
",",
"dec",
",",
"r",
",",
"theta",
")",
":",
"factor",
"=",
"np",
".",
"sin",
"(",
"np",
".",
"radians",
"(",
"dec",
")",
")",
"*",
"np",
".",
"cos",
"(",
"np",
".",
"radians",
"(",
"r",
")",
")",
"factor",
"... | Translate a given point a distance r in the (initial) direction theta, along a great circle.
Parameters
----------
ra, dec : float
The initial point of interest (degrees).
r, theta : float
The distance and initial direction to translate (degrees).
Returns
-------
ra, dec : float
The translated position (degrees). | [
"Translate",
"a",
"given",
"point",
"a",
"distance",
"r",
"in",
"the",
"(",
"initial",
")",
"direction",
"theta",
"along",
"a",
"great",
"circle",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L176-L200 |
PaulHancock/Aegean | AegeanTools/angle_tools.py | dist_rhumb | def dist_rhumb(ra1, dec1, ra2, dec2):
"""
Calculate the Rhumb line distance between two points [1]_.
A Rhumb line between two points is one which follows a constant bearing.
Parameters
----------
ra1, dec1, ra2, dec2 : float
The position of the two points (degrees).
Returns
-------
dist : float
The distance between the two points along a line of constant bearing.
Notes
-----
.. [1] `Rhumb line <https://en.wikipedia.org/wiki/Rhumb_line>`_
"""
# verified against website to give correct results
phi1 = np.radians(dec1)
phi2 = np.radians(dec2)
dphi = phi2 - phi1
lambda1 = np.radians(ra1)
lambda2 = np.radians(ra2)
dpsi = np.log(np.tan(np.pi / 4 + phi2 / 2) / np.tan(np.pi / 4 + phi1 / 2))
if dpsi < 1e-12:
q = np.cos(phi1)
else:
q = dpsi / dphi
dlambda = lambda2 - lambda1
if dlambda > np.pi:
dlambda -= 2 * np.pi
dist = np.hypot(dphi, q * dlambda)
return np.degrees(dist) | python | def dist_rhumb(ra1, dec1, ra2, dec2):
"""
Calculate the Rhumb line distance between two points [1]_.
A Rhumb line between two points is one which follows a constant bearing.
Parameters
----------
ra1, dec1, ra2, dec2 : float
The position of the two points (degrees).
Returns
-------
dist : float
The distance between the two points along a line of constant bearing.
Notes
-----
.. [1] `Rhumb line <https://en.wikipedia.org/wiki/Rhumb_line>`_
"""
# verified against website to give correct results
phi1 = np.radians(dec1)
phi2 = np.radians(dec2)
dphi = phi2 - phi1
lambda1 = np.radians(ra1)
lambda2 = np.radians(ra2)
dpsi = np.log(np.tan(np.pi / 4 + phi2 / 2) / np.tan(np.pi / 4 + phi1 / 2))
if dpsi < 1e-12:
q = np.cos(phi1)
else:
q = dpsi / dphi
dlambda = lambda2 - lambda1
if dlambda > np.pi:
dlambda -= 2 * np.pi
dist = np.hypot(dphi, q * dlambda)
return np.degrees(dist) | [
"def",
"dist_rhumb",
"(",
"ra1",
",",
"dec1",
",",
"ra2",
",",
"dec2",
")",
":",
"# verified against website to give correct results",
"phi1",
"=",
"np",
".",
"radians",
"(",
"dec1",
")",
"phi2",
"=",
"np",
".",
"radians",
"(",
"dec2",
")",
"dphi",
"=",
... | Calculate the Rhumb line distance between two points [1]_.
A Rhumb line between two points is one which follows a constant bearing.
Parameters
----------
ra1, dec1, ra2, dec2 : float
The position of the two points (degrees).
Returns
-------
dist : float
The distance between the two points along a line of constant bearing.
Notes
-----
.. [1] `Rhumb line <https://en.wikipedia.org/wiki/Rhumb_line>`_ | [
"Calculate",
"the",
"Rhumb",
"line",
"distance",
"between",
"two",
"points",
"[",
"1",
"]",
"_",
".",
"A",
"Rhumb",
"line",
"between",
"two",
"points",
"is",
"one",
"which",
"follows",
"a",
"constant",
"bearing",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L203-L237 |
PaulHancock/Aegean | AegeanTools/angle_tools.py | bear_rhumb | def bear_rhumb(ra1, dec1, ra2, dec2):
"""
Calculate the bearing of point 2 from point 1 along a Rhumb line.
The bearing is East of North and is in [0, 360), whereas position angle is also East of North but (-180,180]
Parameters
----------
ra1, dec1, ra2, dec2 : float
The sky coordinates (degrees) of the two points.
Returns
-------
dist : float
The bearing of point 2 from point 1 along a Rhumb line (degrees).
"""
# verified against website to give correct results
phi1 = np.radians(dec1)
phi2 = np.radians(dec2)
lambda1 = np.radians(ra1)
lambda2 = np.radians(ra2)
dlambda = lambda2 - lambda1
dpsi = np.log(np.tan(np.pi / 4 + phi2 / 2) / np.tan(np.pi / 4 + phi1 / 2))
theta = np.arctan2(dlambda, dpsi)
return np.degrees(theta) | python | def bear_rhumb(ra1, dec1, ra2, dec2):
"""
Calculate the bearing of point 2 from point 1 along a Rhumb line.
The bearing is East of North and is in [0, 360), whereas position angle is also East of North but (-180,180]
Parameters
----------
ra1, dec1, ra2, dec2 : float
The sky coordinates (degrees) of the two points.
Returns
-------
dist : float
The bearing of point 2 from point 1 along a Rhumb line (degrees).
"""
# verified against website to give correct results
phi1 = np.radians(dec1)
phi2 = np.radians(dec2)
lambda1 = np.radians(ra1)
lambda2 = np.radians(ra2)
dlambda = lambda2 - lambda1
dpsi = np.log(np.tan(np.pi / 4 + phi2 / 2) / np.tan(np.pi / 4 + phi1 / 2))
theta = np.arctan2(dlambda, dpsi)
return np.degrees(theta) | [
"def",
"bear_rhumb",
"(",
"ra1",
",",
"dec1",
",",
"ra2",
",",
"dec2",
")",
":",
"# verified against website to give correct results",
"phi1",
"=",
"np",
".",
"radians",
"(",
"dec1",
")",
"phi2",
"=",
"np",
".",
"radians",
"(",
"dec2",
")",
"lambda1",
"=",... | Calculate the bearing of point 2 from point 1 along a Rhumb line.
The bearing is East of North and is in [0, 360), whereas position angle is also East of North but (-180,180]
Parameters
----------
ra1, dec1, ra2, dec2 : float
The sky coordinates (degrees) of the two points.
Returns
-------
dist : float
The bearing of point 2 from point 1 along a Rhumb line (degrees). | [
"Calculate",
"the",
"bearing",
"of",
"point",
"2",
"from",
"point",
"1",
"along",
"a",
"Rhumb",
"line",
".",
"The",
"bearing",
"is",
"East",
"of",
"North",
"and",
"is",
"in",
"[",
"0",
"360",
")",
"whereas",
"position",
"angle",
"is",
"also",
"East",
... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L240-L265 |
PaulHancock/Aegean | AegeanTools/angle_tools.py | translate_rhumb | def translate_rhumb(ra, dec, r, theta):
"""
Translate a given point a distance r in the (initial) direction theta, along a Rhumb line.
Parameters
----------
ra, dec : float
The initial point of interest (degrees).
r, theta : float
The distance and initial direction to translate (degrees).
Returns
-------
ra, dec : float
The translated position (degrees).
"""
# verified against website to give correct results
# with the help of http://williams.best.vwh.net/avform.htm#Rhumb
delta = np.radians(r)
phi1 = np.radians(dec)
phi2 = phi1 + delta * np.cos(np.radians(theta))
dphi = phi2 - phi1
if abs(dphi) < 1e-9:
q = np.cos(phi1)
else:
dpsi = np.log(np.tan(np.pi / 4 + phi2 / 2) / np.tan(np.pi / 4 + phi1 / 2))
q = dphi / dpsi
lambda1 = np.radians(ra)
dlambda = delta * np.sin(np.radians(theta)) / q
lambda2 = lambda1 + dlambda
ra_out = np.degrees(lambda2)
dec_out = np.degrees(phi2)
return ra_out, dec_out | python | def translate_rhumb(ra, dec, r, theta):
"""
Translate a given point a distance r in the (initial) direction theta, along a Rhumb line.
Parameters
----------
ra, dec : float
The initial point of interest (degrees).
r, theta : float
The distance and initial direction to translate (degrees).
Returns
-------
ra, dec : float
The translated position (degrees).
"""
# verified against website to give correct results
# with the help of http://williams.best.vwh.net/avform.htm#Rhumb
delta = np.radians(r)
phi1 = np.radians(dec)
phi2 = phi1 + delta * np.cos(np.radians(theta))
dphi = phi2 - phi1
if abs(dphi) < 1e-9:
q = np.cos(phi1)
else:
dpsi = np.log(np.tan(np.pi / 4 + phi2 / 2) / np.tan(np.pi / 4 + phi1 / 2))
q = dphi / dpsi
lambda1 = np.radians(ra)
dlambda = delta * np.sin(np.radians(theta)) / q
lambda2 = lambda1 + dlambda
ra_out = np.degrees(lambda2)
dec_out = np.degrees(phi2)
return ra_out, dec_out | [
"def",
"translate_rhumb",
"(",
"ra",
",",
"dec",
",",
"r",
",",
"theta",
")",
":",
"# verified against website to give correct results",
"# with the help of http://williams.best.vwh.net/avform.htm#Rhumb",
"delta",
"=",
"np",
".",
"radians",
"(",
"r",
")",
"phi1",
"=",
... | Translate a given point a distance r in the (initial) direction theta, along a Rhumb line.
Parameters
----------
ra, dec : float
The initial point of interest (degrees).
r, theta : float
The distance and initial direction to translate (degrees).
Returns
-------
ra, dec : float
The translated position (degrees). | [
"Translate",
"a",
"given",
"point",
"a",
"distance",
"r",
"in",
"the",
"(",
"initial",
")",
"direction",
"theta",
"along",
"a",
"Rhumb",
"line",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/angle_tools.py#L268-L303 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | galactic2fk5 | def galactic2fk5(l, b):
"""
Convert galactic l/b to fk5 ra/dec
Parameters
----------
l, b : float
Galactic coordinates in radians.
Returns
-------
ra, dec : float
FK5 ecliptic coordinates in radians.
"""
a = SkyCoord(l, b, unit=(u.radian, u.radian), frame='galactic')
return a.fk5.ra.radian, a.fk5.dec.radian | python | def galactic2fk5(l, b):
"""
Convert galactic l/b to fk5 ra/dec
Parameters
----------
l, b : float
Galactic coordinates in radians.
Returns
-------
ra, dec : float
FK5 ecliptic coordinates in radians.
"""
a = SkyCoord(l, b, unit=(u.radian, u.radian), frame='galactic')
return a.fk5.ra.radian, a.fk5.dec.radian | [
"def",
"galactic2fk5",
"(",
"l",
",",
"b",
")",
":",
"a",
"=",
"SkyCoord",
"(",
"l",
",",
"b",
",",
"unit",
"=",
"(",
"u",
".",
"radian",
",",
"u",
".",
"radian",
")",
",",
"frame",
"=",
"'galactic'",
")",
"return",
"a",
".",
"fk5",
".",
"ra"... | Convert galactic l/b to fk5 ra/dec
Parameters
----------
l, b : float
Galactic coordinates in radians.
Returns
-------
ra, dec : float
FK5 ecliptic coordinates in radians. | [
"Convert",
"galactic",
"l",
"/",
"b",
"to",
"fk5",
"ra",
"/",
"dec"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L77-L92 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | mask_plane | def mask_plane(data, wcs, region, negate=False):
"""
Mask a 2d image (data) such that pixels within 'region' are set to nan.
Parameters
----------
data : 2d-array
Image array.
wcs : astropy.wcs.WCS
WCS for the image in question.
region : :class:`AegeanTools.regions.Region`
A region within which the image pixels will be masked.
negate : bool
If True then pixels *outside* the region are masked.
Default = False.
Returns
-------
masked : 2d-array
The original array, but masked as required.
"""
# create an array but don't set the values (they are random)
indexes = np.empty((data.shape[0]*data.shape[1], 2), dtype=int)
# since I know exactly what the index array needs to look like i can construct
# it faster than list comprehension would allow
# we do this only once and then recycle it
idx = np.array([(j, 0) for j in range(data.shape[1])])
j = data.shape[1]
for i in range(data.shape[0]):
idx[:, 1] = i
indexes[i*j:(i+1)*j] = idx
# put ALL the pixles into our vectorized functions and minimise our overheads
ra, dec = wcs.wcs_pix2world(indexes, 1).transpose()
bigmask = region.sky_within(ra, dec, degin=True)
if not negate:
bigmask = np.bitwise_not(bigmask)
# rework our 1d list into a 2d array
bigmask = bigmask.reshape(data.shape)
# and apply the mask
data[bigmask] = np.nan
return data | python | def mask_plane(data, wcs, region, negate=False):
"""
Mask a 2d image (data) such that pixels within 'region' are set to nan.
Parameters
----------
data : 2d-array
Image array.
wcs : astropy.wcs.WCS
WCS for the image in question.
region : :class:`AegeanTools.regions.Region`
A region within which the image pixels will be masked.
negate : bool
If True then pixels *outside* the region are masked.
Default = False.
Returns
-------
masked : 2d-array
The original array, but masked as required.
"""
# create an array but don't set the values (they are random)
indexes = np.empty((data.shape[0]*data.shape[1], 2), dtype=int)
# since I know exactly what the index array needs to look like i can construct
# it faster than list comprehension would allow
# we do this only once and then recycle it
idx = np.array([(j, 0) for j in range(data.shape[1])])
j = data.shape[1]
for i in range(data.shape[0]):
idx[:, 1] = i
indexes[i*j:(i+1)*j] = idx
# put ALL the pixles into our vectorized functions and minimise our overheads
ra, dec = wcs.wcs_pix2world(indexes, 1).transpose()
bigmask = region.sky_within(ra, dec, degin=True)
if not negate:
bigmask = np.bitwise_not(bigmask)
# rework our 1d list into a 2d array
bigmask = bigmask.reshape(data.shape)
# and apply the mask
data[bigmask] = np.nan
return data | [
"def",
"mask_plane",
"(",
"data",
",",
"wcs",
",",
"region",
",",
"negate",
"=",
"False",
")",
":",
"# create an array but don't set the values (they are random)",
"indexes",
"=",
"np",
".",
"empty",
"(",
"(",
"data",
".",
"shape",
"[",
"0",
"]",
"*",
"data"... | Mask a 2d image (data) such that pixels within 'region' are set to nan.
Parameters
----------
data : 2d-array
Image array.
wcs : astropy.wcs.WCS
WCS for the image in question.
region : :class:`AegeanTools.regions.Region`
A region within which the image pixels will be masked.
negate : bool
If True then pixels *outside* the region are masked.
Default = False.
Returns
-------
masked : 2d-array
The original array, but masked as required. | [
"Mask",
"a",
"2d",
"image",
"(",
"data",
")",
"such",
"that",
"pixels",
"within",
"region",
"are",
"set",
"to",
"nan",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L95-L139 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | mask_file | def mask_file(regionfile, infile, outfile, negate=False):
"""
Created a masked version of file, using a region.
Parameters
----------
regionfile : str
A file which can be loaded as a :class:`AegeanTools.regions.Region`.
The image will be masked according to this region.
infile : str
Input FITS image.
outfile : str
Output FITS image.
negate : bool
If True then pixels *outside* the region are masked.
Default = False.
See Also
--------
:func:`AegeanTools.MIMAS.mask_plane`
"""
# Check that the input file is accessible and then open it
if not os.path.exists(infile): raise AssertionError("Cannot locate fits file {0}".format(infile))
im = pyfits.open(infile)
if not os.path.exists(regionfile): raise AssertionError("Cannot locate region file {0}".format(regionfile))
region = Region.load(regionfile)
try:
wcs = pywcs.WCS(im[0].header, naxis=2)
except: # TODO: figure out what error is being thrown
wcs = pywcs.WCS(str(im[0].header), naxis=2)
if len(im[0].data.shape) > 2:
data = np.squeeze(im[0].data)
else:
data = im[0].data
print(data.shape)
if len(data.shape) == 3:
for plane in range(data.shape[0]):
mask_plane(data[plane], wcs, region, negate)
else:
mask_plane(data, wcs, region, negate)
im[0].data = data
im.writeto(outfile, overwrite=True)
logging.info("Wrote {0}".format(outfile))
return | python | def mask_file(regionfile, infile, outfile, negate=False):
"""
Created a masked version of file, using a region.
Parameters
----------
regionfile : str
A file which can be loaded as a :class:`AegeanTools.regions.Region`.
The image will be masked according to this region.
infile : str
Input FITS image.
outfile : str
Output FITS image.
negate : bool
If True then pixels *outside* the region are masked.
Default = False.
See Also
--------
:func:`AegeanTools.MIMAS.mask_plane`
"""
# Check that the input file is accessible and then open it
if not os.path.exists(infile): raise AssertionError("Cannot locate fits file {0}".format(infile))
im = pyfits.open(infile)
if not os.path.exists(regionfile): raise AssertionError("Cannot locate region file {0}".format(regionfile))
region = Region.load(regionfile)
try:
wcs = pywcs.WCS(im[0].header, naxis=2)
except: # TODO: figure out what error is being thrown
wcs = pywcs.WCS(str(im[0].header), naxis=2)
if len(im[0].data.shape) > 2:
data = np.squeeze(im[0].data)
else:
data = im[0].data
print(data.shape)
if len(data.shape) == 3:
for plane in range(data.shape[0]):
mask_plane(data[plane], wcs, region, negate)
else:
mask_plane(data, wcs, region, negate)
im[0].data = data
im.writeto(outfile, overwrite=True)
logging.info("Wrote {0}".format(outfile))
return | [
"def",
"mask_file",
"(",
"regionfile",
",",
"infile",
",",
"outfile",
",",
"negate",
"=",
"False",
")",
":",
"# Check that the input file is accessible and then open it",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"infile",
")",
":",
"raise",
"Assertion... | Created a masked version of file, using a region.
Parameters
----------
regionfile : str
A file which can be loaded as a :class:`AegeanTools.regions.Region`.
The image will be masked according to this region.
infile : str
Input FITS image.
outfile : str
Output FITS image.
negate : bool
If True then pixels *outside* the region are masked.
Default = False.
See Also
--------
:func:`AegeanTools.MIMAS.mask_plane` | [
"Created",
"a",
"masked",
"version",
"of",
"file",
"using",
"a",
"region",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L142-L191 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | mask_table | def mask_table(region, table, negate=False, racol='ra', deccol='dec'):
"""
Apply a given mask (region) to the table, removing all the rows with ra/dec inside the region
If negate=False then remove the rows with ra/dec outside the region.
Parameters
----------
region : :class:`AegeanTools.regions.Region`
Region to mask.
table : Astropy.table.Table
Table to be masked.
negate : bool
If True then pixels *outside* the region are masked.
Default = False.
racol, deccol : str
The name of the columns in `table` that should be interpreted as ra and dec.
Default = 'ra', 'dec'
Returns
-------
masked : Astropy.table.Table
A view of the given table which has been masked.
"""
inside = region.sky_within(table[racol], table[deccol], degin=True)
if not negate:
mask = np.bitwise_not(inside)
else:
mask = inside
return table[mask] | python | def mask_table(region, table, negate=False, racol='ra', deccol='dec'):
"""
Apply a given mask (region) to the table, removing all the rows with ra/dec inside the region
If negate=False then remove the rows with ra/dec outside the region.
Parameters
----------
region : :class:`AegeanTools.regions.Region`
Region to mask.
table : Astropy.table.Table
Table to be masked.
negate : bool
If True then pixels *outside* the region are masked.
Default = False.
racol, deccol : str
The name of the columns in `table` that should be interpreted as ra and dec.
Default = 'ra', 'dec'
Returns
-------
masked : Astropy.table.Table
A view of the given table which has been masked.
"""
inside = region.sky_within(table[racol], table[deccol], degin=True)
if not negate:
mask = np.bitwise_not(inside)
else:
mask = inside
return table[mask] | [
"def",
"mask_table",
"(",
"region",
",",
"table",
",",
"negate",
"=",
"False",
",",
"racol",
"=",
"'ra'",
",",
"deccol",
"=",
"'dec'",
")",
":",
"inside",
"=",
"region",
".",
"sky_within",
"(",
"table",
"[",
"racol",
"]",
",",
"table",
"[",
"deccol",... | Apply a given mask (region) to the table, removing all the rows with ra/dec inside the region
If negate=False then remove the rows with ra/dec outside the region.
Parameters
----------
region : :class:`AegeanTools.regions.Region`
Region to mask.
table : Astropy.table.Table
Table to be masked.
negate : bool
If True then pixels *outside* the region are masked.
Default = False.
racol, deccol : str
The name of the columns in `table` that should be interpreted as ra and dec.
Default = 'ra', 'dec'
Returns
-------
masked : Astropy.table.Table
A view of the given table which has been masked. | [
"Apply",
"a",
"given",
"mask",
"(",
"region",
")",
"to",
"the",
"table",
"removing",
"all",
"the",
"rows",
"with",
"ra",
"/",
"dec",
"inside",
"the",
"region",
"If",
"negate",
"=",
"False",
"then",
"remove",
"the",
"rows",
"with",
"ra",
"/",
"dec",
"... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L194-L226 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | mask_catalog | def mask_catalog(regionfile, infile, outfile, negate=False, racol='ra', deccol='dec'):
"""
Apply a region file as a mask to a catalog, removing all the rows with ra/dec inside the region
If negate=False then remove the rows with ra/dec outside the region.
Parameters
----------
regionfile : str
A file which can be loaded as a :class:`AegeanTools.regions.Region`.
The catalogue will be masked according to this region.
infile : str
Input catalogue.
outfile : str
Output catalogue.
negate : bool
If True then pixels *outside* the region are masked.
Default = False.
racol, deccol : str
The name of the columns in `table` that should be interpreted as ra and dec.
Default = 'ra', 'dec'
See Also
--------
:func:`AegeanTools.MIMAS.mask_table`
:func:`AegeanTools.catalogs.load_table`
"""
logging.info("Loading region from {0}".format(regionfile))
region = Region.load(regionfile)
logging.info("Loading catalog from {0}".format(infile))
table = load_table(infile)
masked_table = mask_table(region, table, negate=negate, racol=racol, deccol=deccol)
write_table(masked_table, outfile)
return | python | def mask_catalog(regionfile, infile, outfile, negate=False, racol='ra', deccol='dec'):
"""
Apply a region file as a mask to a catalog, removing all the rows with ra/dec inside the region
If negate=False then remove the rows with ra/dec outside the region.
Parameters
----------
regionfile : str
A file which can be loaded as a :class:`AegeanTools.regions.Region`.
The catalogue will be masked according to this region.
infile : str
Input catalogue.
outfile : str
Output catalogue.
negate : bool
If True then pixels *outside* the region are masked.
Default = False.
racol, deccol : str
The name of the columns in `table` that should be interpreted as ra and dec.
Default = 'ra', 'dec'
See Also
--------
:func:`AegeanTools.MIMAS.mask_table`
:func:`AegeanTools.catalogs.load_table`
"""
logging.info("Loading region from {0}".format(regionfile))
region = Region.load(regionfile)
logging.info("Loading catalog from {0}".format(infile))
table = load_table(infile)
masked_table = mask_table(region, table, negate=negate, racol=racol, deccol=deccol)
write_table(masked_table, outfile)
return | [
"def",
"mask_catalog",
"(",
"regionfile",
",",
"infile",
",",
"outfile",
",",
"negate",
"=",
"False",
",",
"racol",
"=",
"'ra'",
",",
"deccol",
"=",
"'dec'",
")",
":",
"logging",
".",
"info",
"(",
"\"Loading region from {0}\"",
".",
"format",
"(",
"regionf... | Apply a region file as a mask to a catalog, removing all the rows with ra/dec inside the region
If negate=False then remove the rows with ra/dec outside the region.
Parameters
----------
regionfile : str
A file which can be loaded as a :class:`AegeanTools.regions.Region`.
The catalogue will be masked according to this region.
infile : str
Input catalogue.
outfile : str
Output catalogue.
negate : bool
If True then pixels *outside* the region are masked.
Default = False.
racol, deccol : str
The name of the columns in `table` that should be interpreted as ra and dec.
Default = 'ra', 'dec'
See Also
--------
:func:`AegeanTools.MIMAS.mask_table`
:func:`AegeanTools.catalogs.load_table` | [
"Apply",
"a",
"region",
"file",
"as",
"a",
"mask",
"to",
"a",
"catalog",
"removing",
"all",
"the",
"rows",
"with",
"ra",
"/",
"dec",
"inside",
"the",
"region",
"If",
"negate",
"=",
"False",
"then",
"remove",
"the",
"rows",
"with",
"ra",
"/",
"dec",
"... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L229-L267 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | mim2reg | def mim2reg(mimfile, regfile):
"""
Convert a MIMAS region (.mim) file into a DS9 region (.reg) file.
Parameters
----------
mimfile : str
Input file in MIMAS format.
regfile : str
Output file.
"""
region = Region.load(mimfile)
region.write_reg(regfile)
logging.info("Converted {0} -> {1}".format(mimfile, regfile))
return | python | def mim2reg(mimfile, regfile):
"""
Convert a MIMAS region (.mim) file into a DS9 region (.reg) file.
Parameters
----------
mimfile : str
Input file in MIMAS format.
regfile : str
Output file.
"""
region = Region.load(mimfile)
region.write_reg(regfile)
logging.info("Converted {0} -> {1}".format(mimfile, regfile))
return | [
"def",
"mim2reg",
"(",
"mimfile",
",",
"regfile",
")",
":",
"region",
"=",
"Region",
".",
"load",
"(",
"mimfile",
")",
"region",
".",
"write_reg",
"(",
"regfile",
")",
"logging",
".",
"info",
"(",
"\"Converted {0} -> {1}\"",
".",
"format",
"(",
"mimfile",
... | Convert a MIMAS region (.mim) file into a DS9 region (.reg) file.
Parameters
----------
mimfile : str
Input file in MIMAS format.
regfile : str
Output file. | [
"Convert",
"a",
"MIMAS",
"region",
"(",
".",
"mim",
")",
"file",
"into",
"a",
"DS9",
"region",
"(",
".",
"reg",
")",
"file",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L270-L286 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | mim2fits | def mim2fits(mimfile, fitsfile):
"""
Convert a MIMAS region (.mim) file into a MOC region (.fits) file.
Parameters
----------
mimfile : str
Input file in MIMAS format.
fitsfile : str
Output file.
"""
region = Region.load(mimfile)
region.write_fits(fitsfile, moctool='MIMAS {0}-{1}'.format(__version__, __date__))
logging.info("Converted {0} -> {1}".format(mimfile, fitsfile))
return | python | def mim2fits(mimfile, fitsfile):
"""
Convert a MIMAS region (.mim) file into a MOC region (.fits) file.
Parameters
----------
mimfile : str
Input file in MIMAS format.
fitsfile : str
Output file.
"""
region = Region.load(mimfile)
region.write_fits(fitsfile, moctool='MIMAS {0}-{1}'.format(__version__, __date__))
logging.info("Converted {0} -> {1}".format(mimfile, fitsfile))
return | [
"def",
"mim2fits",
"(",
"mimfile",
",",
"fitsfile",
")",
":",
"region",
"=",
"Region",
".",
"load",
"(",
"mimfile",
")",
"region",
".",
"write_fits",
"(",
"fitsfile",
",",
"moctool",
"=",
"'MIMAS {0}-{1}'",
".",
"format",
"(",
"__version__",
",",
"__date__... | Convert a MIMAS region (.mim) file into a MOC region (.fits) file.
Parameters
----------
mimfile : str
Input file in MIMAS format.
fitsfile : str
Output file. | [
"Convert",
"a",
"MIMAS",
"region",
"(",
".",
"mim",
")",
"file",
"into",
"a",
"MOC",
"region",
"(",
".",
"fits",
")",
"file",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L289-L304 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | box2poly | def box2poly(line):
"""
Convert a string that describes a box in ds9 format, into a polygon that is given by the corners of the box
Parameters
----------
line : str
A string containing a DS9 region command for a box.
Returns
-------
poly : [ra, dec, ...]
The corners of the box in clockwise order from top left.
"""
words = re.split('[(\s,)]', line)
ra = words[1]
dec = words[2]
width = words[3]
height = words[4]
if ":" in ra:
ra = Angle(ra, unit=u.hour)
else:
ra = Angle(ra, unit=u.degree)
dec = Angle(dec, unit=u.degree)
width = Angle(float(width[:-1])/2, unit=u.arcsecond) # strip the "
height = Angle(float(height[:-1])/2, unit=u.arcsecond) # strip the "
center = SkyCoord(ra, dec)
tl = center.ra.degree+width.degree, center.dec.degree+height.degree
tr = center.ra.degree-width.degree, center.dec.degree+height.degree
bl = center.ra.degree+width.degree, center.dec.degree-height.degree
br = center.ra.degree-width.degree, center.dec.degree-height.degree
return np.ravel([tl, tr, br, bl]).tolist() | python | def box2poly(line):
"""
Convert a string that describes a box in ds9 format, into a polygon that is given by the corners of the box
Parameters
----------
line : str
A string containing a DS9 region command for a box.
Returns
-------
poly : [ra, dec, ...]
The corners of the box in clockwise order from top left.
"""
words = re.split('[(\s,)]', line)
ra = words[1]
dec = words[2]
width = words[3]
height = words[4]
if ":" in ra:
ra = Angle(ra, unit=u.hour)
else:
ra = Angle(ra, unit=u.degree)
dec = Angle(dec, unit=u.degree)
width = Angle(float(width[:-1])/2, unit=u.arcsecond) # strip the "
height = Angle(float(height[:-1])/2, unit=u.arcsecond) # strip the "
center = SkyCoord(ra, dec)
tl = center.ra.degree+width.degree, center.dec.degree+height.degree
tr = center.ra.degree-width.degree, center.dec.degree+height.degree
bl = center.ra.degree+width.degree, center.dec.degree-height.degree
br = center.ra.degree-width.degree, center.dec.degree-height.degree
return np.ravel([tl, tr, br, bl]).tolist() | [
"def",
"box2poly",
"(",
"line",
")",
":",
"words",
"=",
"re",
".",
"split",
"(",
"'[(\\s,)]'",
",",
"line",
")",
"ra",
"=",
"words",
"[",
"1",
"]",
"dec",
"=",
"words",
"[",
"2",
"]",
"width",
"=",
"words",
"[",
"3",
"]",
"height",
"=",
"words"... | Convert a string that describes a box in ds9 format, into a polygon that is given by the corners of the box
Parameters
----------
line : str
A string containing a DS9 region command for a box.
Returns
-------
poly : [ra, dec, ...]
The corners of the box in clockwise order from top left. | [
"Convert",
"a",
"string",
"that",
"describes",
"a",
"box",
"in",
"ds9",
"format",
"into",
"a",
"polygon",
"that",
"is",
"given",
"by",
"the",
"corners",
"of",
"the",
"box"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L307-L338 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | circle2circle | def circle2circle(line):
"""
Parse a string that describes a circle in ds9 format.
Parameters
----------
line : str
A string containing a DS9 region command for a circle.
Returns
-------
circle : [ra, dec, radius]
The center and radius of the circle.
"""
words = re.split('[(,\s)]', line)
ra = words[1]
dec = words[2]
radius = words[3][:-1] # strip the "
if ":" in ra:
ra = Angle(ra, unit=u.hour)
else:
ra = Angle(ra, unit=u.degree)
dec = Angle(dec, unit=u.degree)
radius = Angle(radius, unit=u.arcsecond)
return [ra.degree, dec.degree, radius.degree] | python | def circle2circle(line):
"""
Parse a string that describes a circle in ds9 format.
Parameters
----------
line : str
A string containing a DS9 region command for a circle.
Returns
-------
circle : [ra, dec, radius]
The center and radius of the circle.
"""
words = re.split('[(,\s)]', line)
ra = words[1]
dec = words[2]
radius = words[3][:-1] # strip the "
if ":" in ra:
ra = Angle(ra, unit=u.hour)
else:
ra = Angle(ra, unit=u.degree)
dec = Angle(dec, unit=u.degree)
radius = Angle(radius, unit=u.arcsecond)
return [ra.degree, dec.degree, radius.degree] | [
"def",
"circle2circle",
"(",
"line",
")",
":",
"words",
"=",
"re",
".",
"split",
"(",
"'[(,\\s)]'",
",",
"line",
")",
"ra",
"=",
"words",
"[",
"1",
"]",
"dec",
"=",
"words",
"[",
"2",
"]",
"radius",
"=",
"words",
"[",
"3",
"]",
"[",
":",
"-",
... | Parse a string that describes a circle in ds9 format.
Parameters
----------
line : str
A string containing a DS9 region command for a circle.
Returns
-------
circle : [ra, dec, radius]
The center and radius of the circle. | [
"Parse",
"a",
"string",
"that",
"describes",
"a",
"circle",
"in",
"ds9",
"format",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L341-L365 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | poly2poly | def poly2poly(line):
"""
Parse a string of text containing a DS9 description of a polygon.
This function works but is not very robust due to the constraints of healpy.
Parameters
----------
line : str
A string containing a DS9 region command for a polygon.
Returns
-------
poly : [ra, dec, ...]
The coordinates of the polygon.
"""
words = re.split('[(\s,)]', line)
ras = np.array(words[1::2])
decs = np.array(words[2::2])
coords = []
for ra, dec in zip(ras, decs):
if ra.strip() == '' or dec.strip() == '':
continue
if ":" in ra:
pos = SkyCoord(Angle(ra, unit=u.hour), Angle(dec, unit=u.degree))
else:
pos = SkyCoord(Angle(ra, unit=u.degree), Angle(dec, unit=u.degree))
# only add this point if it is some distance from the previous one
coords.extend([pos.ra.degree, pos.dec.degree])
return coords | python | def poly2poly(line):
"""
Parse a string of text containing a DS9 description of a polygon.
This function works but is not very robust due to the constraints of healpy.
Parameters
----------
line : str
A string containing a DS9 region command for a polygon.
Returns
-------
poly : [ra, dec, ...]
The coordinates of the polygon.
"""
words = re.split('[(\s,)]', line)
ras = np.array(words[1::2])
decs = np.array(words[2::2])
coords = []
for ra, dec in zip(ras, decs):
if ra.strip() == '' or dec.strip() == '':
continue
if ":" in ra:
pos = SkyCoord(Angle(ra, unit=u.hour), Angle(dec, unit=u.degree))
else:
pos = SkyCoord(Angle(ra, unit=u.degree), Angle(dec, unit=u.degree))
# only add this point if it is some distance from the previous one
coords.extend([pos.ra.degree, pos.dec.degree])
return coords | [
"def",
"poly2poly",
"(",
"line",
")",
":",
"words",
"=",
"re",
".",
"split",
"(",
"'[(\\s,)]'",
",",
"line",
")",
"ras",
"=",
"np",
".",
"array",
"(",
"words",
"[",
"1",
":",
":",
"2",
"]",
")",
"decs",
"=",
"np",
".",
"array",
"(",
"words",
... | Parse a string of text containing a DS9 description of a polygon.
This function works but is not very robust due to the constraints of healpy.
Parameters
----------
line : str
A string containing a DS9 region command for a polygon.
Returns
-------
poly : [ra, dec, ...]
The coordinates of the polygon. | [
"Parse",
"a",
"string",
"of",
"text",
"containing",
"a",
"DS9",
"description",
"of",
"a",
"polygon",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L368-L397 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | reg2mim | def reg2mim(regfile, mimfile, maxdepth):
"""
Parse a DS9 region file and write a MIMAS region (.mim) file.
Parameters
----------
regfile : str
DS9 region (.reg) file.
mimfile : str
MIMAS region (.mim) file.
maxdepth : str
Depth/resolution of the region file.
"""
logging.info("Reading regions from {0}".format(regfile))
lines = (l for l in open(regfile, 'r') if not l.startswith('#'))
poly = []
circles = []
for line in lines:
if line.startswith('box'):
poly.append(box2poly(line))
elif line.startswith('circle'):
circles.append(circle2circle(line))
elif line.startswith('polygon'):
logging.warning("Polygons break a lot, but I'll try this one anyway.")
poly.append(poly2poly(line))
else:
logging.warning("Not sure what to do with {0}".format(line[:-1]))
container = Dummy(maxdepth=maxdepth)
container.include_circles = circles
container.include_polygons = poly
region = combine_regions(container)
save_region(region, mimfile)
return | python | def reg2mim(regfile, mimfile, maxdepth):
"""
Parse a DS9 region file and write a MIMAS region (.mim) file.
Parameters
----------
regfile : str
DS9 region (.reg) file.
mimfile : str
MIMAS region (.mim) file.
maxdepth : str
Depth/resolution of the region file.
"""
logging.info("Reading regions from {0}".format(regfile))
lines = (l for l in open(regfile, 'r') if not l.startswith('#'))
poly = []
circles = []
for line in lines:
if line.startswith('box'):
poly.append(box2poly(line))
elif line.startswith('circle'):
circles.append(circle2circle(line))
elif line.startswith('polygon'):
logging.warning("Polygons break a lot, but I'll try this one anyway.")
poly.append(poly2poly(line))
else:
logging.warning("Not sure what to do with {0}".format(line[:-1]))
container = Dummy(maxdepth=maxdepth)
container.include_circles = circles
container.include_polygons = poly
region = combine_regions(container)
save_region(region, mimfile)
return | [
"def",
"reg2mim",
"(",
"regfile",
",",
"mimfile",
",",
"maxdepth",
")",
":",
"logging",
".",
"info",
"(",
"\"Reading regions from {0}\"",
".",
"format",
"(",
"regfile",
")",
")",
"lines",
"=",
"(",
"l",
"for",
"l",
"in",
"open",
"(",
"regfile",
",",
"'... | Parse a DS9 region file and write a MIMAS region (.mim) file.
Parameters
----------
regfile : str
DS9 region (.reg) file.
mimfile : str
MIMAS region (.mim) file.
maxdepth : str
Depth/resolution of the region file. | [
"Parse",
"a",
"DS9",
"region",
"file",
"and",
"write",
"a",
"MIMAS",
"region",
"(",
".",
"mim",
")",
"file",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L400-L436 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | combine_regions | def combine_regions(container):
"""
Return a region that is the combination of those specified in the container.
The container is typically a results instance that comes from argparse.
Order of construction is: add regions, subtract regions, add circles, subtract circles,
add polygons, subtract polygons.
Parameters
----------
container : :class:`AegeanTools.MIMAS.Dummy`
The regions to be combined.
Returns
-------
region : :class:`AegeanTools.regions.Region`
The constructed region.
"""
# create empty region
region = Region(container.maxdepth)
# add/rem all the regions from files
for r in container.add_region:
logging.info("adding region from {0}".format(r))
r2 = Region.load(r[0])
region.union(r2)
for r in container.rem_region:
logging.info("removing region from {0}".format(r))
r2 = Region.load(r[0])
region.without(r2)
# add circles
if len(container.include_circles) > 0:
for c in container.include_circles:
circles = np.radians(np.array(c))
if container.galactic:
l, b, radii = circles.reshape(3, circles.shape[0]//3)
ras, decs = galactic2fk5(l, b)
else:
ras, decs, radii = circles.reshape(3, circles.shape[0]//3)
region.add_circles(ras, decs, radii)
# remove circles
if len(container.exclude_circles) > 0:
for c in container.exclude_circles:
r2 = Region(container.maxdepth)
circles = np.radians(np.array(c))
if container.galactic:
l, b, radii = circles.reshape(3, circles.shape[0]//3)
ras, decs = galactic2fk5(l, b)
else:
ras, decs, radii = circles.reshape(3, circles.shape[0]//3)
r2.add_circles(ras, decs, radii)
region.without(r2)
# add polygons
if len(container.include_polygons) > 0:
for p in container.include_polygons:
poly = np.radians(np.array(p))
poly = poly.reshape((poly.shape[0]//2, 2))
region.add_poly(poly)
# remove polygons
if len(container.exclude_polygons) > 0:
for p in container.include_polygons:
poly = np.array(np.radians(p))
r2 = Region(container.maxdepth)
r2.add_poly(poly)
region.without(r2)
return region | python | def combine_regions(container):
"""
Return a region that is the combination of those specified in the container.
The container is typically a results instance that comes from argparse.
Order of construction is: add regions, subtract regions, add circles, subtract circles,
add polygons, subtract polygons.
Parameters
----------
container : :class:`AegeanTools.MIMAS.Dummy`
The regions to be combined.
Returns
-------
region : :class:`AegeanTools.regions.Region`
The constructed region.
"""
# create empty region
region = Region(container.maxdepth)
# add/rem all the regions from files
for r in container.add_region:
logging.info("adding region from {0}".format(r))
r2 = Region.load(r[0])
region.union(r2)
for r in container.rem_region:
logging.info("removing region from {0}".format(r))
r2 = Region.load(r[0])
region.without(r2)
# add circles
if len(container.include_circles) > 0:
for c in container.include_circles:
circles = np.radians(np.array(c))
if container.galactic:
l, b, radii = circles.reshape(3, circles.shape[0]//3)
ras, decs = galactic2fk5(l, b)
else:
ras, decs, radii = circles.reshape(3, circles.shape[0]//3)
region.add_circles(ras, decs, radii)
# remove circles
if len(container.exclude_circles) > 0:
for c in container.exclude_circles:
r2 = Region(container.maxdepth)
circles = np.radians(np.array(c))
if container.galactic:
l, b, radii = circles.reshape(3, circles.shape[0]//3)
ras, decs = galactic2fk5(l, b)
else:
ras, decs, radii = circles.reshape(3, circles.shape[0]//3)
r2.add_circles(ras, decs, radii)
region.without(r2)
# add polygons
if len(container.include_polygons) > 0:
for p in container.include_polygons:
poly = np.radians(np.array(p))
poly = poly.reshape((poly.shape[0]//2, 2))
region.add_poly(poly)
# remove polygons
if len(container.exclude_polygons) > 0:
for p in container.include_polygons:
poly = np.array(np.radians(p))
r2 = Region(container.maxdepth)
r2.add_poly(poly)
region.without(r2)
return region | [
"def",
"combine_regions",
"(",
"container",
")",
":",
"# create empty region",
"region",
"=",
"Region",
"(",
"container",
".",
"maxdepth",
")",
"# add/rem all the regions from files",
"for",
"r",
"in",
"container",
".",
"add_region",
":",
"logging",
".",
"info",
"... | Return a region that is the combination of those specified in the container.
The container is typically a results instance that comes from argparse.
Order of construction is: add regions, subtract regions, add circles, subtract circles,
add polygons, subtract polygons.
Parameters
----------
container : :class:`AegeanTools.MIMAS.Dummy`
The regions to be combined.
Returns
-------
region : :class:`AegeanTools.regions.Region`
The constructed region. | [
"Return",
"a",
"region",
"that",
"is",
"the",
"combination",
"of",
"those",
"specified",
"in",
"the",
"container",
".",
"The",
"container",
"is",
"typically",
"a",
"results",
"instance",
"that",
"comes",
"from",
"argparse",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L439-L511 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | intersect_regions | def intersect_regions(flist):
"""
Construct a region which is the intersection of all regions described in the given
list of file names.
Parameters
----------
flist : list
A list of region filenames.
Returns
-------
region : :class:`AegeanTools.regions.Region`
The intersection of all regions, possibly empty.
"""
if len(flist) < 2:
raise Exception("Require at least two regions to perform intersection")
a = Region.load(flist[0])
for b in [Region.load(f) for f in flist[1:]]:
a.intersect(b)
return a | python | def intersect_regions(flist):
"""
Construct a region which is the intersection of all regions described in the given
list of file names.
Parameters
----------
flist : list
A list of region filenames.
Returns
-------
region : :class:`AegeanTools.regions.Region`
The intersection of all regions, possibly empty.
"""
if len(flist) < 2:
raise Exception("Require at least two regions to perform intersection")
a = Region.load(flist[0])
for b in [Region.load(f) for f in flist[1:]]:
a.intersect(b)
return a | [
"def",
"intersect_regions",
"(",
"flist",
")",
":",
"if",
"len",
"(",
"flist",
")",
"<",
"2",
":",
"raise",
"Exception",
"(",
"\"Require at least two regions to perform intersection\"",
")",
"a",
"=",
"Region",
".",
"load",
"(",
"flist",
"[",
"0",
"]",
")",
... | Construct a region which is the intersection of all regions described in the given
list of file names.
Parameters
----------
flist : list
A list of region filenames.
Returns
-------
region : :class:`AegeanTools.regions.Region`
The intersection of all regions, possibly empty. | [
"Construct",
"a",
"region",
"which",
"is",
"the",
"intersection",
"of",
"all",
"regions",
"described",
"in",
"the",
"given",
"list",
"of",
"file",
"names",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L514-L534 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | save_region | def save_region(region, filename):
"""
Save the given region to a file
Parameters
----------
region : :class:`AegeanTools.regions.Region`
A region.
filename : str
Output file name.
"""
region.save(filename)
logging.info("Wrote {0}".format(filename))
return | python | def save_region(region, filename):
"""
Save the given region to a file
Parameters
----------
region : :class:`AegeanTools.regions.Region`
A region.
filename : str
Output file name.
"""
region.save(filename)
logging.info("Wrote {0}".format(filename))
return | [
"def",
"save_region",
"(",
"region",
",",
"filename",
")",
":",
"region",
".",
"save",
"(",
"filename",
")",
"logging",
".",
"info",
"(",
"\"Wrote {0}\"",
".",
"format",
"(",
"filename",
")",
")",
"return"
] | Save the given region to a file
Parameters
----------
region : :class:`AegeanTools.regions.Region`
A region.
filename : str
Output file name. | [
"Save",
"the",
"given",
"region",
"to",
"a",
"file"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L537-L551 |
PaulHancock/Aegean | AegeanTools/MIMAS.py | save_as_image | def save_as_image(region, filename):
"""
Convert a MIMAS region (.mim) file into a image (eg .png)
Parameters
----------
region : :class:`AegeanTools.regions.Region`
Region of interest.
filename : str
Output filename.
"""
import healpy as hp
pixels = list(region.get_demoted())
order = region.maxdepth
m = np.arange(hp.nside2npix(2**order))
m[:] = 0
m[pixels] = 1
hp.write_map(filename, m, nest=True, coord='C')
return | python | def save_as_image(region, filename):
"""
Convert a MIMAS region (.mim) file into a image (eg .png)
Parameters
----------
region : :class:`AegeanTools.regions.Region`
Region of interest.
filename : str
Output filename.
"""
import healpy as hp
pixels = list(region.get_demoted())
order = region.maxdepth
m = np.arange(hp.nside2npix(2**order))
m[:] = 0
m[pixels] = 1
hp.write_map(filename, m, nest=True, coord='C')
return | [
"def",
"save_as_image",
"(",
"region",
",",
"filename",
")",
":",
"import",
"healpy",
"as",
"hp",
"pixels",
"=",
"list",
"(",
"region",
".",
"get_demoted",
"(",
")",
")",
"order",
"=",
"region",
".",
"maxdepth",
"m",
"=",
"np",
".",
"arange",
"(",
"h... | Convert a MIMAS region (.mim) file into a image (eg .png)
Parameters
----------
region : :class:`AegeanTools.regions.Region`
Region of interest.
filename : str
Output filename. | [
"Convert",
"a",
"MIMAS",
"region",
"(",
".",
"mim",
")",
"file",
"into",
"a",
"image",
"(",
"eg",
".",
"png",
")"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/MIMAS.py#L554-L573 |
PaulHancock/Aegean | AegeanTools/fits_image.py | get_pixinfo | def get_pixinfo(header):
"""
Return some pixel information based on the given hdu header
pixarea - the area of a single pixel in deg2
pixscale - the side lengths of a pixel (assuming they are square)
Parameters
----------
header : HDUHeader or dict
FITS header information
Returns
-------
pixarea : float
The are of a single pixel at the reference location, in square degrees.
pixscale : (float, float)
The pixel scale in degrees, at the reference location.
Notes
-----
The reference location is not always at the image center, and the pixel scale/area may
change over the image, depending on the projection.
"""
if all(a in header for a in ["CDELT1", "CDELT2"]):
pixarea = abs(header["CDELT1"]*header["CDELT2"])
pixscale = (header["CDELT1"], header["CDELT2"])
elif all(a in header for a in ["CD1_1", "CD1_2", "CD2_1", "CD2_2"]):
pixarea = abs(header["CD1_1"]*header["CD2_2"]
- header["CD1_2"]*header["CD2_1"])
pixscale = (header["CD1_1"], header["CD2_2"])
if not (header["CD1_2"] == 0 and header["CD2_1"] == 0):
log.warning("Pixels don't appear to be square -> pixscale is wrong")
elif all(a in header for a in ["CD1_1", "CD2_2"]):
pixarea = abs(header["CD1_1"]*header["CD2_2"])
pixscale = (header["CD1_1"], header["CD2_2"])
else:
log.critical("cannot determine pixel area, using zero EVEN THOUGH THIS IS WRONG!")
pixarea = 0
pixscale = (0, 0)
return pixarea, pixscale | python | def get_pixinfo(header):
"""
Return some pixel information based on the given hdu header
pixarea - the area of a single pixel in deg2
pixscale - the side lengths of a pixel (assuming they are square)
Parameters
----------
header : HDUHeader or dict
FITS header information
Returns
-------
pixarea : float
The are of a single pixel at the reference location, in square degrees.
pixscale : (float, float)
The pixel scale in degrees, at the reference location.
Notes
-----
The reference location is not always at the image center, and the pixel scale/area may
change over the image, depending on the projection.
"""
if all(a in header for a in ["CDELT1", "CDELT2"]):
pixarea = abs(header["CDELT1"]*header["CDELT2"])
pixscale = (header["CDELT1"], header["CDELT2"])
elif all(a in header for a in ["CD1_1", "CD1_2", "CD2_1", "CD2_2"]):
pixarea = abs(header["CD1_1"]*header["CD2_2"]
- header["CD1_2"]*header["CD2_1"])
pixscale = (header["CD1_1"], header["CD2_2"])
if not (header["CD1_2"] == 0 and header["CD2_1"] == 0):
log.warning("Pixels don't appear to be square -> pixscale is wrong")
elif all(a in header for a in ["CD1_1", "CD2_2"]):
pixarea = abs(header["CD1_1"]*header["CD2_2"])
pixscale = (header["CD1_1"], header["CD2_2"])
else:
log.critical("cannot determine pixel area, using zero EVEN THOUGH THIS IS WRONG!")
pixarea = 0
pixscale = (0, 0)
return pixarea, pixscale | [
"def",
"get_pixinfo",
"(",
"header",
")",
":",
"if",
"all",
"(",
"a",
"in",
"header",
"for",
"a",
"in",
"[",
"\"CDELT1\"",
",",
"\"CDELT2\"",
"]",
")",
":",
"pixarea",
"=",
"abs",
"(",
"header",
"[",
"\"CDELT1\"",
"]",
"*",
"header",
"[",
"\"CDELT2\"... | Return some pixel information based on the given hdu header
pixarea - the area of a single pixel in deg2
pixscale - the side lengths of a pixel (assuming they are square)
Parameters
----------
header : HDUHeader or dict
FITS header information
Returns
-------
pixarea : float
The are of a single pixel at the reference location, in square degrees.
pixscale : (float, float)
The pixel scale in degrees, at the reference location.
Notes
-----
The reference location is not always at the image center, and the pixel scale/area may
change over the image, depending on the projection. | [
"Return",
"some",
"pixel",
"information",
"based",
"on",
"the",
"given",
"hdu",
"header",
"pixarea",
"-",
"the",
"area",
"of",
"a",
"single",
"pixel",
"in",
"deg2",
"pixscale",
"-",
"the",
"side",
"lengths",
"of",
"a",
"pixel",
"(",
"assuming",
"they",
"... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L20-L60 |
PaulHancock/Aegean | AegeanTools/fits_image.py | get_beam | def get_beam(header):
"""
Create a :class:`AegeanTools.fits_image.Beam` object from a fits header.
BPA may be missing but will be assumed to be zero.
if BMAJ or BMIN are missing then return None instead of a beam object.
Parameters
----------
header : HDUHeader
The fits header.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
Beam object, with a, b, and pa in degrees.
"""
if "BPA" not in header:
log.warning("BPA not present in fits header, using 0")
bpa = 0
else:
bpa = header["BPA"]
if "BMAJ" not in header:
log.warning("BMAJ not present in fits header.")
bmaj = None
else:
bmaj = header["BMAJ"]
if "BMIN" not in header:
log.warning("BMIN not present in fits header.")
bmin = None
else:
bmin = header["BMIN"]
if None in [bmaj, bmin, bpa]:
return None
beam = Beam(bmaj, bmin, bpa)
return beam | python | def get_beam(header):
"""
Create a :class:`AegeanTools.fits_image.Beam` object from a fits header.
BPA may be missing but will be assumed to be zero.
if BMAJ or BMIN are missing then return None instead of a beam object.
Parameters
----------
header : HDUHeader
The fits header.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
Beam object, with a, b, and pa in degrees.
"""
if "BPA" not in header:
log.warning("BPA not present in fits header, using 0")
bpa = 0
else:
bpa = header["BPA"]
if "BMAJ" not in header:
log.warning("BMAJ not present in fits header.")
bmaj = None
else:
bmaj = header["BMAJ"]
if "BMIN" not in header:
log.warning("BMIN not present in fits header.")
bmin = None
else:
bmin = header["BMIN"]
if None in [bmaj, bmin, bpa]:
return None
beam = Beam(bmaj, bmin, bpa)
return beam | [
"def",
"get_beam",
"(",
"header",
")",
":",
"if",
"\"BPA\"",
"not",
"in",
"header",
":",
"log",
".",
"warning",
"(",
"\"BPA not present in fits header, using 0\"",
")",
"bpa",
"=",
"0",
"else",
":",
"bpa",
"=",
"header",
"[",
"\"BPA\"",
"]",
"if",
"\"BMAJ\... | Create a :class:`AegeanTools.fits_image.Beam` object from a fits header.
BPA may be missing but will be assumed to be zero.
if BMAJ or BMIN are missing then return None instead of a beam object.
Parameters
----------
header : HDUHeader
The fits header.
Returns
-------
beam : :class:`AegeanTools.fits_image.Beam`
Beam object, with a, b, and pa in degrees. | [
"Create",
"a",
":",
"class",
":",
"AegeanTools",
".",
"fits_image",
".",
"Beam",
"object",
"from",
"a",
"fits",
"header",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L63-L102 |
PaulHancock/Aegean | AegeanTools/fits_image.py | fix_aips_header | def fix_aips_header(header):
"""
Search through an image header. If the keywords BMAJ/BMIN/BPA are not set,
but there are AIPS history cards, then we can populate the BMAJ/BMIN/BPA.
Fix the header if possible, otherwise don't. Either way, don't complain.
Parameters
----------
header : HDUHeader
Fits header which may or may not have AIPS history cards.
Returns
-------
header : HDUHeader
A header which has BMAJ, BMIN, and BPA keys, as well as a new HISTORY card.
"""
if 'BMAJ' in header and 'BMIN' in header and 'BPA' in header:
# The header already has the required keys so there is nothing to do
return header
aips_hist = [a for a in header['HISTORY'] if a.startswith("AIPS")]
if len(aips_hist) == 0:
# There are no AIPS history items to process
return header
for a in aips_hist:
if "BMAJ" in a:
# this line looks like
# 'AIPS CLEAN BMAJ= 1.2500E-02 BMIN= 1.2500E-02 BPA= 0.00'
words = a.split()
bmaj = float(words[3])
bmin = float(words[5])
bpa = float(words[7])
break
else:
# there are AIPS cards but there is no BMAJ/BMIN/BPA
return header
header['BMAJ'] = bmaj
header['BMIN'] = bmin
header['BPA'] = bpa
header['HISTORY'] = 'Beam information AIPS->fits by AegeanTools'
return header | python | def fix_aips_header(header):
"""
Search through an image header. If the keywords BMAJ/BMIN/BPA are not set,
but there are AIPS history cards, then we can populate the BMAJ/BMIN/BPA.
Fix the header if possible, otherwise don't. Either way, don't complain.
Parameters
----------
header : HDUHeader
Fits header which may or may not have AIPS history cards.
Returns
-------
header : HDUHeader
A header which has BMAJ, BMIN, and BPA keys, as well as a new HISTORY card.
"""
if 'BMAJ' in header and 'BMIN' in header and 'BPA' in header:
# The header already has the required keys so there is nothing to do
return header
aips_hist = [a for a in header['HISTORY'] if a.startswith("AIPS")]
if len(aips_hist) == 0:
# There are no AIPS history items to process
return header
for a in aips_hist:
if "BMAJ" in a:
# this line looks like
# 'AIPS CLEAN BMAJ= 1.2500E-02 BMIN= 1.2500E-02 BPA= 0.00'
words = a.split()
bmaj = float(words[3])
bmin = float(words[5])
bpa = float(words[7])
break
else:
# there are AIPS cards but there is no BMAJ/BMIN/BPA
return header
header['BMAJ'] = bmaj
header['BMIN'] = bmin
header['BPA'] = bpa
header['HISTORY'] = 'Beam information AIPS->fits by AegeanTools'
return header | [
"def",
"fix_aips_header",
"(",
"header",
")",
":",
"if",
"'BMAJ'",
"in",
"header",
"and",
"'BMIN'",
"in",
"header",
"and",
"'BPA'",
"in",
"header",
":",
"# The header already has the required keys so there is nothing to do",
"return",
"header",
"aips_hist",
"=",
"[",
... | Search through an image header. If the keywords BMAJ/BMIN/BPA are not set,
but there are AIPS history cards, then we can populate the BMAJ/BMIN/BPA.
Fix the header if possible, otherwise don't. Either way, don't complain.
Parameters
----------
header : HDUHeader
Fits header which may or may not have AIPS history cards.
Returns
-------
header : HDUHeader
A header which has BMAJ, BMIN, and BPA keys, as well as a new HISTORY card. | [
"Search",
"through",
"an",
"image",
"header",
".",
"If",
"the",
"keywords",
"BMAJ",
"/",
"BMIN",
"/",
"BPA",
"are",
"not",
"set",
"but",
"there",
"are",
"AIPS",
"history",
"cards",
"then",
"we",
"can",
"populate",
"the",
"BMAJ",
"/",
"BMIN",
"/",
"BPA"... | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L105-L145 |
PaulHancock/Aegean | AegeanTools/fits_image.py | FitsImage.set_pixels | def set_pixels(self, pixels):
"""
Set the image data.
Will not work if the new image has a different shape than the current image.
Parameters
----------
pixels : numpy.ndarray
New image data
Returns
-------
None
"""
if not (pixels.shape == self._pixels.shape):
raise AssertionError("Shape mismatch between pixels supplied {0} and existing image pixels {1}".format(pixels.shape,self._pixels.shape))
self._pixels = pixels
# reset this so that it is calculated next time the function is called
self._rms = None
return | python | def set_pixels(self, pixels):
"""
Set the image data.
Will not work if the new image has a different shape than the current image.
Parameters
----------
pixels : numpy.ndarray
New image data
Returns
-------
None
"""
if not (pixels.shape == self._pixels.shape):
raise AssertionError("Shape mismatch between pixels supplied {0} and existing image pixels {1}".format(pixels.shape,self._pixels.shape))
self._pixels = pixels
# reset this so that it is calculated next time the function is called
self._rms = None
return | [
"def",
"set_pixels",
"(",
"self",
",",
"pixels",
")",
":",
"if",
"not",
"(",
"pixels",
".",
"shape",
"==",
"self",
".",
"_pixels",
".",
"shape",
")",
":",
"raise",
"AssertionError",
"(",
"\"Shape mismatch between pixels supplied {0} and existing image pixels {1}\"",... | Set the image data.
Will not work if the new image has a different shape than the current image.
Parameters
----------
pixels : numpy.ndarray
New image data
Returns
-------
None | [
"Set",
"the",
"image",
"data",
".",
"Will",
"not",
"work",
"if",
"the",
"new",
"image",
"has",
"a",
"different",
"shape",
"than",
"the",
"current",
"image",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L235-L254 |
PaulHancock/Aegean | AegeanTools/fits_image.py | FitsImage.get_background_rms | def get_background_rms(self):
"""
Calculate the rms of the image. The rms is calculated from the interqurtile range (IQR), to
reduce bias from source pixels.
Returns
-------
rms : float
The image rms.
Notes
-----
The rms value is cached after first calculation.
"""
# TODO: return a proper background RMS ignoring the sources
# This is an approximate method suggested by PaulH.
# I have no idea where this magic 1.34896 number comes from...
if self._rms is None:
# Get the pixels values without the NaNs
data = numpy.extract(self.hdu.data > -9999999, self.hdu.data)
p25 = scipy.stats.scoreatpercentile(data, 25)
p75 = scipy.stats.scoreatpercentile(data, 75)
iqr = p75 - p25
self._rms = iqr / 1.34896
return self._rms | python | def get_background_rms(self):
"""
Calculate the rms of the image. The rms is calculated from the interqurtile range (IQR), to
reduce bias from source pixels.
Returns
-------
rms : float
The image rms.
Notes
-----
The rms value is cached after first calculation.
"""
# TODO: return a proper background RMS ignoring the sources
# This is an approximate method suggested by PaulH.
# I have no idea where this magic 1.34896 number comes from...
if self._rms is None:
# Get the pixels values without the NaNs
data = numpy.extract(self.hdu.data > -9999999, self.hdu.data)
p25 = scipy.stats.scoreatpercentile(data, 25)
p75 = scipy.stats.scoreatpercentile(data, 75)
iqr = p75 - p25
self._rms = iqr / 1.34896
return self._rms | [
"def",
"get_background_rms",
"(",
"self",
")",
":",
"# TODO: return a proper background RMS ignoring the sources",
"# This is an approximate method suggested by PaulH.",
"# I have no idea where this magic 1.34896 number comes from...",
"if",
"self",
".",
"_rms",
"is",
"None",
":",
"#... | Calculate the rms of the image. The rms is calculated from the interqurtile range (IQR), to
reduce bias from source pixels.
Returns
-------
rms : float
The image rms.
Notes
-----
The rms value is cached after first calculation. | [
"Calculate",
"the",
"rms",
"of",
"the",
"image",
".",
"The",
"rms",
"is",
"calculated",
"from",
"the",
"interqurtile",
"range",
"(",
"IQR",
")",
"to",
"reduce",
"bias",
"from",
"source",
"pixels",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L256-L280 |
PaulHancock/Aegean | AegeanTools/fits_image.py | FitsImage.pix2sky | def pix2sky(self, pixel):
"""
Get the sky coordinates for a given image pixel.
Parameters
----------
pixel : (float, float)
Image coordinates.
Returns
-------
ra,dec : float
Sky coordinates (degrees)
"""
pixbox = numpy.array([pixel, pixel])
skybox = self.wcs.all_pix2world(pixbox, 1)
return [float(skybox[0][0]), float(skybox[0][1])] | python | def pix2sky(self, pixel):
"""
Get the sky coordinates for a given image pixel.
Parameters
----------
pixel : (float, float)
Image coordinates.
Returns
-------
ra,dec : float
Sky coordinates (degrees)
"""
pixbox = numpy.array([pixel, pixel])
skybox = self.wcs.all_pix2world(pixbox, 1)
return [float(skybox[0][0]), float(skybox[0][1])] | [
"def",
"pix2sky",
"(",
"self",
",",
"pixel",
")",
":",
"pixbox",
"=",
"numpy",
".",
"array",
"(",
"[",
"pixel",
",",
"pixel",
"]",
")",
"skybox",
"=",
"self",
".",
"wcs",
".",
"all_pix2world",
"(",
"pixbox",
",",
"1",
")",
"return",
"[",
"float",
... | Get the sky coordinates for a given image pixel.
Parameters
----------
pixel : (float, float)
Image coordinates.
Returns
-------
ra,dec : float
Sky coordinates (degrees) | [
"Get",
"the",
"sky",
"coordinates",
"for",
"a",
"given",
"image",
"pixel",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L282-L299 |
PaulHancock/Aegean | AegeanTools/fits_image.py | FitsImage.sky2pix | def sky2pix(self, skypos):
"""
Get the pixel coordinates for a given sky position (degrees).
Parameters
----------
skypos : (float,float)
ra,dec position in degrees.
Returns
-------
x,y : float
Pixel coordinates.
"""
skybox = [skypos, skypos]
pixbox = self.wcs.all_world2pix(skybox, 1)
return [float(pixbox[0][0]), float(pixbox[0][1])] | python | def sky2pix(self, skypos):
"""
Get the pixel coordinates for a given sky position (degrees).
Parameters
----------
skypos : (float,float)
ra,dec position in degrees.
Returns
-------
x,y : float
Pixel coordinates.
"""
skybox = [skypos, skypos]
pixbox = self.wcs.all_world2pix(skybox, 1)
return [float(pixbox[0][0]), float(pixbox[0][1])] | [
"def",
"sky2pix",
"(",
"self",
",",
"skypos",
")",
":",
"skybox",
"=",
"[",
"skypos",
",",
"skypos",
"]",
"pixbox",
"=",
"self",
".",
"wcs",
".",
"all_world2pix",
"(",
"skybox",
",",
"1",
")",
"return",
"[",
"float",
"(",
"pixbox",
"[",
"0",
"]",
... | Get the pixel coordinates for a given sky position (degrees).
Parameters
----------
skypos : (float,float)
ra,dec position in degrees.
Returns
-------
x,y : float
Pixel coordinates. | [
"Get",
"the",
"pixel",
"coordinates",
"for",
"a",
"given",
"sky",
"position",
"(",
"degrees",
")",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/fits_image.py#L307-L324 |
PaulHancock/Aegean | AegeanTools/AeRes.py | load_sources | def load_sources(filename):
"""
Open a file, read contents, return a list of all the sources in that file.
@param filename:
@return: list of OutputSource objects
"""
catalog = catalogs.table_to_source_list(catalogs.load_table(filename))
logging.info("read {0} sources from {1}".format(len(catalog), filename))
return catalog | python | def load_sources(filename):
"""
Open a file, read contents, return a list of all the sources in that file.
@param filename:
@return: list of OutputSource objects
"""
catalog = catalogs.table_to_source_list(catalogs.load_table(filename))
logging.info("read {0} sources from {1}".format(len(catalog), filename))
return catalog | [
"def",
"load_sources",
"(",
"filename",
")",
":",
"catalog",
"=",
"catalogs",
".",
"table_to_source_list",
"(",
"catalogs",
".",
"load_table",
"(",
"filename",
")",
")",
"logging",
".",
"info",
"(",
"\"read {0} sources from {1}\"",
".",
"format",
"(",
"len",
"... | Open a file, read contents, return a list of all the sources in that file.
@param filename:
@return: list of OutputSource objects | [
"Open",
"a",
"file",
"read",
"contents",
"return",
"a",
"list",
"of",
"all",
"the",
"sources",
"in",
"that",
"file",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/AeRes.py#L19-L27 |
PaulHancock/Aegean | scripts/fix_beam.py | search_beam | def search_beam(hdulist):
"""
Will search the beam info from the HISTORY
:param hdulist:
:return:
"""
header = hdulist[0].header
history = header['HISTORY']
history_str = str(history)
#AIPS CLEAN BMAJ= 1.2500E-02 BMIN= 1.2500E-02 BPA= 0.00
if 'BMAJ' in history_str:
return True
else:
return False | python | def search_beam(hdulist):
"""
Will search the beam info from the HISTORY
:param hdulist:
:return:
"""
header = hdulist[0].header
history = header['HISTORY']
history_str = str(history)
#AIPS CLEAN BMAJ= 1.2500E-02 BMIN= 1.2500E-02 BPA= 0.00
if 'BMAJ' in history_str:
return True
else:
return False | [
"def",
"search_beam",
"(",
"hdulist",
")",
":",
"header",
"=",
"hdulist",
"[",
"0",
"]",
".",
"header",
"history",
"=",
"header",
"[",
"'HISTORY'",
"]",
"history_str",
"=",
"str",
"(",
"history",
")",
"#AIPS CLEAN BMAJ= 1.2500E-02 BMIN= 1.2500E-02 BPA= 0.00"... | Will search the beam info from the HISTORY
:param hdulist:
:return: | [
"Will",
"search",
"the",
"beam",
"info",
"from",
"the",
"HISTORY",
":",
"param",
"hdulist",
":",
":",
"return",
":"
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/scripts/fix_beam.py#L22-L35 |
PaulHancock/Aegean | AegeanTools/source_finder.py | fix_shape | def fix_shape(source):
"""
Ensure that a>=b for a given source object.
If a<b then swap a/b and increment pa by 90.
err_a/err_b are also swapped as needed.
Parameters
----------
source : object
any object with a/b/pa/err_a/err_b properties
"""
if source.a < source.b:
source.a, source.b = source.b, source.a
source.err_a, source.err_b = source.err_b, source.err_a
source.pa += 90
return | python | def fix_shape(source):
"""
Ensure that a>=b for a given source object.
If a<b then swap a/b and increment pa by 90.
err_a/err_b are also swapped as needed.
Parameters
----------
source : object
any object with a/b/pa/err_a/err_b properties
"""
if source.a < source.b:
source.a, source.b = source.b, source.a
source.err_a, source.err_b = source.err_b, source.err_a
source.pa += 90
return | [
"def",
"fix_shape",
"(",
"source",
")",
":",
"if",
"source",
".",
"a",
"<",
"source",
".",
"b",
":",
"source",
".",
"a",
",",
"source",
".",
"b",
"=",
"source",
".",
"b",
",",
"source",
".",
"a",
"source",
".",
"err_a",
",",
"source",
".",
"err... | Ensure that a>=b for a given source object.
If a<b then swap a/b and increment pa by 90.
err_a/err_b are also swapped as needed.
Parameters
----------
source : object
any object with a/b/pa/err_a/err_b properties | [
"Ensure",
"that",
"a",
">",
"=",
"b",
"for",
"a",
"given",
"source",
"object",
".",
"If",
"a<b",
"then",
"swap",
"a",
"/",
"b",
"and",
"increment",
"pa",
"by",
"90",
".",
"err_a",
"/",
"err_b",
"are",
"also",
"swapped",
"as",
"needed",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/source_finder.py#L1786-L1802 |
PaulHancock/Aegean | AegeanTools/source_finder.py | theta_limit | def theta_limit(theta):
"""
Angle theta is periodic with period pi.
Constrain theta such that -pi/2<theta<=pi/2.
Parameters
----------
theta : float
Input angle.
Returns
-------
theta : float
Rotate angle.
"""
while theta <= -1 * np.pi / 2:
theta += np.pi
while theta > np.pi / 2:
theta -= np.pi
return theta | python | def theta_limit(theta):
"""
Angle theta is periodic with period pi.
Constrain theta such that -pi/2<theta<=pi/2.
Parameters
----------
theta : float
Input angle.
Returns
-------
theta : float
Rotate angle.
"""
while theta <= -1 * np.pi / 2:
theta += np.pi
while theta > np.pi / 2:
theta -= np.pi
return theta | [
"def",
"theta_limit",
"(",
"theta",
")",
":",
"while",
"theta",
"<=",
"-",
"1",
"*",
"np",
".",
"pi",
"/",
"2",
":",
"theta",
"+=",
"np",
".",
"pi",
"while",
"theta",
">",
"np",
".",
"pi",
"/",
"2",
":",
"theta",
"-=",
"np",
".",
"pi",
"retur... | Angle theta is periodic with period pi.
Constrain theta such that -pi/2<theta<=pi/2.
Parameters
----------
theta : float
Input angle.
Returns
-------
theta : float
Rotate angle. | [
"Angle",
"theta",
"is",
"periodic",
"with",
"period",
"pi",
".",
"Constrain",
"theta",
"such",
"that",
"-",
"pi",
"/",
"2<theta<",
"=",
"pi",
"/",
"2",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/source_finder.py#L1827-L1846 |
PaulHancock/Aegean | AegeanTools/source_finder.py | scope2lat | def scope2lat(telescope):
"""
Convert a telescope name into a latitude
returns None when the telescope is unknown.
Parameters
----------
telescope : str
Acronym (name) of telescope, eg MWA.
Returns
-------
lat : float
The latitude of the telescope.
Notes
-----
These values were taken from wikipedia so have varying precision/accuracy
"""
scopes = {'MWA': -26.703319,
"ATCA": -30.3128,
"VLA": 34.0790,
"LOFAR": 52.9088,
"KAT7": -30.721,
"MEERKAT": -30.721,
"PAPER": -30.7224,
"GMRT": 19.096516666667,
"OOTY": 11.383404,
"ASKAP": -26.7,
"MOST": -35.3707,
"PARKES": -32.999944,
"WSRT": 52.914722,
"AMILA": 52.16977,
"AMISA": 52.164303,
"ATA": 40.817,
"CHIME": 49.321,
"CARMA": 37.28044,
"DRAO": 49.321,
"GBT": 38.433056,
"LWA": 34.07,
"ALMA": -23.019283,
"FAST": 25.6525
}
if telescope.upper() in scopes:
return scopes[telescope.upper()]
else:
log = logging.getLogger("Aegean")
log.warn("Telescope {0} is unknown".format(telescope))
log.warn("integrated fluxes may be incorrect")
return None | python | def scope2lat(telescope):
"""
Convert a telescope name into a latitude
returns None when the telescope is unknown.
Parameters
----------
telescope : str
Acronym (name) of telescope, eg MWA.
Returns
-------
lat : float
The latitude of the telescope.
Notes
-----
These values were taken from wikipedia so have varying precision/accuracy
"""
scopes = {'MWA': -26.703319,
"ATCA": -30.3128,
"VLA": 34.0790,
"LOFAR": 52.9088,
"KAT7": -30.721,
"MEERKAT": -30.721,
"PAPER": -30.7224,
"GMRT": 19.096516666667,
"OOTY": 11.383404,
"ASKAP": -26.7,
"MOST": -35.3707,
"PARKES": -32.999944,
"WSRT": 52.914722,
"AMILA": 52.16977,
"AMISA": 52.164303,
"ATA": 40.817,
"CHIME": 49.321,
"CARMA": 37.28044,
"DRAO": 49.321,
"GBT": 38.433056,
"LWA": 34.07,
"ALMA": -23.019283,
"FAST": 25.6525
}
if telescope.upper() in scopes:
return scopes[telescope.upper()]
else:
log = logging.getLogger("Aegean")
log.warn("Telescope {0} is unknown".format(telescope))
log.warn("integrated fluxes may be incorrect")
return None | [
"def",
"scope2lat",
"(",
"telescope",
")",
":",
"scopes",
"=",
"{",
"'MWA'",
":",
"-",
"26.703319",
",",
"\"ATCA\"",
":",
"-",
"30.3128",
",",
"\"VLA\"",
":",
"34.0790",
",",
"\"LOFAR\"",
":",
"52.9088",
",",
"\"KAT7\"",
":",
"-",
"30.721",
",",
"\"MEE... | Convert a telescope name into a latitude
returns None when the telescope is unknown.
Parameters
----------
telescope : str
Acronym (name) of telescope, eg MWA.
Returns
-------
lat : float
The latitude of the telescope.
Notes
-----
These values were taken from wikipedia so have varying precision/accuracy | [
"Convert",
"a",
"telescope",
"name",
"into",
"a",
"latitude",
"returns",
"None",
"when",
"the",
"telescope",
"is",
"unknown",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/source_finder.py#L1849-L1898 |
PaulHancock/Aegean | AegeanTools/source_finder.py | check_cores | def check_cores(cores):
"""
Determine how many cores we are able to use.
Return 1 if we are not able to make a queue via pprocess.
Parameters
----------
cores : int
The number of cores that are requested.
Returns
-------
cores : int
The number of cores available.
"""
cores = min(multiprocessing.cpu_count(), cores)
if six.PY3:
log = logging.getLogger("Aegean")
log.info("Multi-cores not supported in python 3+, using one core")
return 1
try:
queue = pprocess.Queue(limit=cores, reuse=1)
except: # TODO: figure out what error is being thrown
cores = 1
else:
try:
_ = queue.manage(pprocess.MakeReusable(fix_shape))
except:
cores = 1
return cores | python | def check_cores(cores):
"""
Determine how many cores we are able to use.
Return 1 if we are not able to make a queue via pprocess.
Parameters
----------
cores : int
The number of cores that are requested.
Returns
-------
cores : int
The number of cores available.
"""
cores = min(multiprocessing.cpu_count(), cores)
if six.PY3:
log = logging.getLogger("Aegean")
log.info("Multi-cores not supported in python 3+, using one core")
return 1
try:
queue = pprocess.Queue(limit=cores, reuse=1)
except: # TODO: figure out what error is being thrown
cores = 1
else:
try:
_ = queue.manage(pprocess.MakeReusable(fix_shape))
except:
cores = 1
return cores | [
"def",
"check_cores",
"(",
"cores",
")",
":",
"cores",
"=",
"min",
"(",
"multiprocessing",
".",
"cpu_count",
"(",
")",
",",
"cores",
")",
"if",
"six",
".",
"PY3",
":",
"log",
"=",
"logging",
".",
"getLogger",
"(",
"\"Aegean\"",
")",
"log",
".",
"info... | Determine how many cores we are able to use.
Return 1 if we are not able to make a queue via pprocess.
Parameters
----------
cores : int
The number of cores that are requested.
Returns
-------
cores : int
The number of cores available. | [
"Determine",
"how",
"many",
"cores",
"we",
"are",
"able",
"to",
"use",
".",
"Return",
"1",
"if",
"we",
"are",
"not",
"able",
"to",
"make",
"a",
"queue",
"via",
"pprocess",
"."
] | train | https://github.com/PaulHancock/Aegean/blob/185d2b4a51b48441a1df747efc9a5271c79399fd/AegeanTools/source_finder.py#L1901-L1931 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.