"""
Runs commands from the Starlink ATOOLS package.
Autogenerated from the starlink .hlp and .ifl files,
by starlink-pywrapper/helperscripts/generate_functions.py.
Starlink version: 2018A
b6ca36bf8884802759017298539489d11795861e (2018-07-06 09:36:39)
"""
from . import wrapper
[docs]def astaddframe(this, **kwargs):
"""
Add a Frame to a FrameSet to define a new coordinate system.
Runs the command: $ATOOLS_DIR/astaddframe .
Arguments
---------
this : str
The input FrameSet
Keyword Arguments
-----------------
iframe : str
The index or Domain of the basis Frame within the FrameSet [!]
map : str,filename
The Mapping from the basis Frame to the new Frame
frame : str,filename
The Frame to add to the FrameSet
result : str
The modified FrameSet
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astaddframe", "astaddframe", this, **kwargs)
[docs]def astaddvariant(this, map, name, result, **kwargs):
"""
Store a new variant Mapping for the current Frame in a FrameSet.
Runs the command: $ATOOLS_DIR/astaddvariant .
Arguments
---------
this : str
The input FrameSet
map : str,filename
The Mapping from current Frame to new variant Frame
name : str
The name for the new variant Mapping
result : str
The modified FrameSet
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astaddvariant", "astaddvariant", this, map, name, result, **kwargs)
[docs]def astangle(this, a, b, c, **kwargs):
"""
Calculate the angle subtended by two points at a third point
Runs the command: $ATOOLS_DIR/astangle .
Arguments
---------
this : str
The input Frame
a : List[float]
Coords at first point
b : List[float]
Coords at second point
c : List[float]
Coords at third point
Keyword Arguments
-----------------
degs : bool
Report answer in degrees? [FALSE]
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astangle", "astangle", this, a, b, c, **kwargs)
[docs]def astbox(frame, form, point1, point2, unc, **kwargs):
"""
Create a Box.
Runs the command: $ATOOLS_DIR/astbox .
Arguments
---------
frame : str,filename
The Frame in which the Box is defined
form : int
Specify the Box by opposite corners?
point1 : str
Centre or corner axis values
point2 : str
Corner axis values
unc : str
The uncertainty Region
Keyword Arguments
-----------------
options : str
Options for the Box [!]
result : str
Name of file in which to store the Box
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astbox", "astbox", frame, form, point1, point2, unc, **kwargs)
[docs]def astchebydomain(this, **kwargs):
"""
Returns the bounding box of the domain of a ChebyMap.
Runs the command: $ATOOLS_DIR/astchebydomain .
Arguments
---------
this : str
The input ChebyMap
Keyword Arguments
-----------------
forward : bool
Use the forward transformation? [TRUE]
fmt : str
Format for output text file [AST]
Returns
-------
lbnd : List[float]
ubnd : List[float]
"""
return wrapper.starcomm("$ATOOLS_DIR/astchebydomain", "astchebydomain", this, **kwargs)
[docs]def astchebymap(*args, **kwargs):
"""
Create a ChebyMap.
Runs the command: $ATOOLS_DIR/astchebymap .
Keyword Arguments
-----------------
nin : int
Number of input coordinates [1]
nout : int
Number of output coordinates [1]
coeff_f : str
Group of coefficients for the forward transformation
coeff_i : str
Group of coefficients for the inverse transformation
lbndf : float
Lower bounds of input box
ubndf : float
Upper bounds of input box
lbndi : float
Lower bounds of output box
ubndi : float
Upper bounds of output box
options : str
Options for the ChebyMap [!]
result : str
Name of file in which to store the ChebyMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astchebymap", "astchebymap", *args, **kwargs)
[docs]def astcircle(frame, form, centre, point, unc, **kwargs):
"""
Create a Circle.
Runs the command: $ATOOLS_DIR/astcircle .
Arguments
---------
frame : str,filename
The Frame in which the Circle is defined
form : int
Parameter form
centre : List[float]
Centre coords
point : List[float]
Circumference position or radius
unc : str
The uncertainty Region
Keyword Arguments
-----------------
options : str
Options for the Circle [!]
result : str
Name of file in which to store the Circle
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astcircle", "astcircle", frame, form, centre, point, unc, **kwargs)
[docs]def astclear(this, attrib, result, **kwargs):
"""
Clear attribute values for an Object.
Runs the command: $ATOOLS_DIR/astclear .
Arguments
---------
this : str
The input Object
attrib : str
The attribute to clear
result : str
Name of file or NDF in which to store the modified Object
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astclear", "astclear", this, attrib, result, **kwargs)
[docs]def astcmpframe(frame1, frame2, **kwargs):
"""
Create a CmpFrame.
Runs the command: $ATOOLS_DIR/astcmpframe .
Arguments
---------
frame1 : str
The first component Frame
frame2 : str
The second component Frame
Keyword Arguments
-----------------
options : str
Options for the CmpFrame [!]
result : str
Name of file in which to store the CmpFrame
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astcmpframe", "astcmpframe", frame1, frame2, **kwargs)
[docs]def astcmpmap(map1, map2, series, **kwargs):
"""
Create a CmpMap.
Runs the command: $ATOOLS_DIR/astcmpmap .
Arguments
---------
map1 : str
The first component Mapping
map2 : str
The second component Mapping
series : bool
Combine the Mappings in series?
Keyword Arguments
-----------------
options : str
Options for the CmpMap [!]
result : str
Name of file in which to store the CmpMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astcmpmap", "astcmpmap", map1, map2, series, **kwargs)
[docs]def astcmpregion(region1, region2, oper, **kwargs):
"""
Create a CmpRegion.
Runs the command: $ATOOLS_DIR/astcmpregion .
Arguments
---------
region1 : str
The first component Region
region2 : str
The second component Region
oper : str
The boolean operator
Keyword Arguments
-----------------
options : str
Options for the CmpRegion [!]
result : str
Name of file in which to store the CmpRegion
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astcmpregion", "astcmpregion", region1, region2, oper, **kwargs)
[docs]def astconvert(from_, to, **kwargs):
"""
Determine how to convert between two coordinate systems.
Runs the command: $ATOOLS_DIR/astconvert .
Arguments
---------
`from_` : str
The source Frame or FrameSet
to : str
The destination Frame or FrameSet
Keyword Arguments
-----------------
domainlist : str
A comma-separated search list of domains [!]
result : str
Name of file in which to store the FrameSet
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astconvert", "astconvert", from_, to, **kwargs)
[docs]def astconvex(*args, **kwargs):
"""
Create a new Polygon representing the convex hull of a 2D data grid.
Runs the command: $ATOOLS_DIR/astconvex .
Keyword Arguments
-----------------
value : str
The value that defines the pixels to be included [BAD]
oper : str
Operation defining the pixels to be included [EQ]
array : str,filename
The input NDF
result : str
Name of file in which to store the Polygon
current : bool
Map the Polygon into current Frame of the NDF? [FALSE]
fmt : str
Format for output text file ["AST"]
Returns
-------
nvert : int
"""
return wrapper.starcomm("$ATOOLS_DIR/astconvex", "astconvex", *args, **kwargs)
[docs]def astcopy(this, result, **kwargs):
"""
Copy an AST Object.
Runs the command: $ATOOLS_DIR/astcopy .
Arguments
---------
this : str
The input Object
result : str
The output Object
Keyword Arguments
-----------------
`class_` : str
Class of output object ["Object"]
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astcopy", "astcopy", this, result, **kwargs)
[docs]def astdistance(this, point1, point2, **kwargs):
"""
Calculate the distance between two points in a Frame
Runs the command: $ATOOLS_DIR/astdistance .
Arguments
---------
this : str
The input Frame
point1 : List[float]
Coords at first point
point2 : List[float]
Coords at second point
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
Returns
-------
distance : float
"""
return wrapper.starcomm("$ATOOLS_DIR/astdistance", "astdistance", this, point1, point2, **kwargs)
[docs]def astdownsize(this, maxerr, maxvert, result, **kwargs):
"""
Reduce the number of vertices in a Polygon.
Runs the command: $ATOOLS_DIR/astdownsize .
Arguments
---------
this : str
The input Polygon
maxerr : float
Maximum error between old and new Polygons
maxvert : int
Maximum number of vertices in new Polygon
result : str
The new Polygon
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astdownsize", "astdownsize", this, maxerr, maxvert, result, **kwargs)
[docs]def astdsbframe(*args, **kwargs):
"""
Create a DSBSpecFrame.
Runs the command: $ATOOLS_DIR/astdsbframe .
Keyword Arguments
-----------------
options : str
Options for the DSBSpecFrame [!]
result : str
Name of file in which to store the DSBSpecFrame
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astdsbframe", "astdsbframe", *args, **kwargs)
[docs]def astellipse(frame, form, centre, point1, point2, unc, **kwargs):
"""
Create a Ellipse.
Runs the command: $ATOOLS_DIR/astellipse .
Arguments
---------
frame : str,filename
The Frame in which the Ellipse is defined
form : int
Parameter form
centre : List[float]
Centre coords
point1 : List[float]
Coords at axis end or axis lengths
point2 : List[float]
Coords at a point on ellipse of position angle
unc : str
The uncertainty Region
Keyword Arguments
-----------------
options : str
Options for the Ellipse [!]
result : str
Name of file in which to store the Ellipse
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astellipse", "astellipse", frame, form, centre, point1, point2, unc, **kwargs)
[docs]def astfindframe(target, template, **kwargs):
"""
Find a coordinate system with specified characteristics.
Runs the command: $ATOOLS_DIR/astfindframe .
Arguments
---------
target : str
The target Frame or FrameSet
template : str
The template Frame
Keyword Arguments
-----------------
domainlist : str
A comma-separated search list of domains [!]
result : str
Name of file in which to store the FrameSet
fmt : str
Format for output text file ["AST"]
Returns
-------
iframe : int
"""
return wrapper.starcomm("$ATOOLS_DIR/astfindframe", "astfindframe", target, template, **kwargs)
[docs]def astfluxframe(*args, **kwargs):
"""
Create a FluxFrame.
Runs the command: $ATOOLS_DIR/astfluxframe .
Keyword Arguments
-----------------
specval : DOUBLE
The spectral position at which flux values are measured [!]
specfrm : str
The SpecFrame to which SPECVAL refers
options : str
Options for the FluxFrame [!]
result : str
Name of file in which to store the FluxFrame
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astfluxframe", "astfluxframe", *args, **kwargs)
[docs]def astframe(*args, **kwargs):
"""
Create a Frame.
Runs the command: $ATOOLS_DIR/astframe .
Keyword Arguments
-----------------
naxes : int
The number of axes in the Frame [2]
options : str
Options for the Frame [!]
result : str
Name of file in which to store the Frame
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astframe", "astframe", *args, **kwargs)
[docs]def astframeset(frame, **kwargs):
"""
Create a FrameSet.
Runs the command: $ATOOLS_DIR/astframeset .
Arguments
---------
frame : str,filename
A Frame to store in the FrameSet
Keyword Arguments
-----------------
options : str
Options for the FrameSet [!]
result : str
Name of file or NDF in which to store the FrameSet
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astframeset", "astframeset", frame, **kwargs)
[docs]def astfromhds(object, keymap, **kwargs):
"""
Create a KeyMap containing the contents of an HDS object.
Runs the command: $ATOOLS_DIR/astfromhds .
Arguments
---------
object : UNIV
Input HDS object
keymap : str
The new KeyMap
Keyword Arguments
-----------------
fmt : str
Format for output text file [AST]
"""
return wrapper.starcomm("$ATOOLS_DIR/astfromhds", "astfromhds", object, keymap, **kwargs)
[docs]def astget(this, attrib, **kwargs):
"""
Get an attribute value for an Object.
Runs the command: $ATOOLS_DIR/astget .
Arguments
---------
this : str
The input Object
attrib : str
The attribute to examine
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
Returns
-------
value : str
"""
return wrapper.starcomm("$ATOOLS_DIR/astget", "astget", this, attrib, **kwargs)
[docs]def astgetactunit(this, **kwargs):
"""
Get the value of the ActiveUnit flag for a rame.
Runs the command: $ATOOLS_DIR/astgetactunit .
Arguments
---------
this : str
The input Frame
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
Returns
-------
value : bool
"""
return wrapper.starcomm("$ATOOLS_DIR/astgetactunit", "astgetactunit", this, **kwargs)
[docs]def astgetframe(this, **kwargs):
"""
Obtain a specified Frame in a FrameSet
Runs the command: $ATOOLS_DIR/astgetframe .
Arguments
---------
this : str
The input FrameSet
Keyword Arguments
-----------------
iframe : str
The index or Domain of the required Frame [!]
result : str
Name of file in which to store the Frame
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astgetframe", "astgetframe", this, **kwargs)
[docs]def astgetmapping(this, **kwargs):
"""
Obtain a Mapping that converts between two Frames in a FrameSet.
Runs the command: $ATOOLS_DIR/astgetmapping .
Arguments
---------
this : str
The input FrameSet
Keyword Arguments
-----------------
iframe1 : str
The index or Domain of the input-end Frame [!]
iframe2 : str
The index or Domain of the output-end Frame [!]
result : str
Name of file in which to store the Mapping
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astgetmapping", "astgetmapping", this, **kwargs)
[docs]def astgetrefpos(this, **kwargs):
"""
Get the reference position for a SpecFrame.
Runs the command: $ATOOLS_DIR/astgetrefpos .
Arguments
---------
this : str
The input SpecFrame
Keyword Arguments
-----------------
frm : str
The input SkyFrame [!]
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astgetrefpos", "astgetrefpos", this, **kwargs)
[docs]def astgetregbounds(this, **kwargs):
"""
Returns the bounding box of Region.
Runs the command: $ATOOLS_DIR/astgetregbounds .
Arguments
---------
this : str
The input Region
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
Returns
-------
lbnd : List[float]
ubnd : List[float]
"""
return wrapper.starcomm("$ATOOLS_DIR/astgetregbounds", "astgetregbounds", this, **kwargs)
[docs]def astgetregframe(this, result, **kwargs):
"""
Obtain the Frame represented by a Region.
Runs the command: $ATOOLS_DIR/astgetregframe .
Arguments
---------
this : str
The input Region
result : str
Name of file in which to store the Frame
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astgetregframe", "astgetregframe", this, result, **kwargs)
[docs]def astgetunc(this, **kwargs):
"""
Obtain uncertainty information from a Region.
Runs the command: $ATOOLS_DIR/astgetunc .
Arguments
---------
this : str
The input Region
Keyword Arguments
-----------------
`def_` : bool
Return default uncertainty if non defined? [TRUE]
result : str
The uncertainty Region
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astgetunc", "astgetunc", this, **kwargs)
[docs]def astinterval(frame, lbnd, ubnd, unc, **kwargs):
"""
Create a Interval.
Runs the command: $ATOOLS_DIR/astinterval .
Arguments
---------
frame : str,filename
The Frame in which the Interval is defined
lbnd : str
Lower axis bounds
ubnd : str
Upper axis bounds
unc : str
The uncertainty Region
Keyword Arguments
-----------------
options : str
Options for the Interval [!]
result : str
Name of file in which to store the Interval
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astinterval", "astinterval", frame, lbnd, ubnd, unc, **kwargs)
[docs]def astinvert(this, result, **kwargs):
"""
Invert a Mapping.
Runs the command: $ATOOLS_DIR/astinvert .
Arguments
---------
this : str
The input Mapping
result : str
Name of file in which to store the inverted Mapping
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astinvert", "astinvert", this, result, **kwargs)
[docs]def astlinearapprox(this, lbndin, ubndin, **kwargs):
"""
Find a linear approximation to a mapping
Runs the command: $ATOOLS_DIR/astlinearapprox .
Arguments
---------
this : str
The input Mapping
lbndin : List[float]
Lower bounds of input region
ubndin : List[float]
Upper bounds of input region
Keyword Arguments
-----------------
tol : float
Deviation from linearity [1]
fmt : str
Format for output text file ["AST"]
Returns
-------
fit : List[float]
"""
return wrapper.starcomm("$ATOOLS_DIR/astlinearapprox", "astlinearapprox", this, lbndin, ubndin, **kwargs)
[docs]def astlutmap(lut, **kwargs):
"""
Create a LutMap.
Runs the command: $ATOOLS_DIR/astlutmap .
Arguments
---------
lut : str
Group of numerical look up table values
Keyword Arguments
-----------------
start : float
Input coordinate value for first LUT entry [0.0]
inc : float
Increment in input coordinate value between LUT entries [1.0]
options : str
Options for the LutMap [!]
result : str
Name of file in which to store the LutMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astlutmap", "astlutmap", lut, **kwargs)
[docs]def astmapbox(this, lbndin, ubndin, **kwargs):
"""
Find a bounding box for a Mapping.
Runs the command: $ATOOLS_DIR/astmapbox .
Arguments
---------
this : str
The input Mapping
lbndin : List[float]
Lower bounds of input box
ubndin : List[float]
Upper bounds of input box
Keyword Arguments
-----------------
forward : bool
Use the forward transformation? [TRUE]
coordout : int
Index of output axis for which bounds are required
fmt : str
Format for output text file ["AST"]
Returns
-------
lbndout : float
ubndout : float
xl : List[float]
xu : List[float]
"""
return wrapper.starcomm("$ATOOLS_DIR/astmapbox", "astmapbox", this, lbndin, ubndin, **kwargs)
[docs]def astmapregion(this, map, frame, result, **kwargs):
"""
Transform a Region into a new Frame using a given Mapping
Runs the command: $ATOOLS_DIR/astmapregion .
Arguments
---------
this : str
The input Region
map : str,filename
The Mapping from the original Frame to the new Frame
frame : str,filename
The Frame for the new Region
result : str
The mapped Region
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astmapregion", "astmapregion", this, map, frame, result, **kwargs)
[docs]def astmapsplit(this, in_, **kwargs):
"""
Split a Mapping up into parallel component Mappings.
Runs the command: $ATOOLS_DIR/astmapsplit .
Arguments
---------
this : str
The input Mapping
`in_` : List[int]
The indices of the required inputs
Keyword Arguments
-----------------
map : str
Name of file in which to store the output Mapping
fmt : str
Format for output text file ["AST"]
Returns
-------
out : List[int]
"""
return wrapper.starcomm("$ATOOLS_DIR/astmapsplit", "astmapsplit", this, in_, **kwargs)
[docs]def astmask(this, map, **kwargs):
"""
Mask a region of a data grid.
Runs the command: $ATOOLS_DIR/astmask .
Arguments
---------
this : str
The input Region
map : str
The Mapping from pixel coords to Region coords
Keyword Arguments
-----------------
inside : bool
Modify pixels inside the supplied Region? [TRUE]
val : str
The value used to flag values in the output NDF [BAD]
`in_` : str,filename
The input NDF
out : str,filename
The output NDF
fmt : str
Format for output text file ["AST"]
Returns
-------
result : int
"""
return wrapper.starcomm("$ATOOLS_DIR/astmask", "astmask", this, map, **kwargs)
[docs]def astmatchaxes(frm1, frm2, **kwargs):
"""
Find any corresponding axes in two Frames.
Runs the command: $ATOOLS_DIR/astmatchaxes .
Arguments
---------
frm1 : str
The first Frame
frm2 : str
The second Frame
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
Returns
-------
axes : List[int]
"""
return wrapper.starcomm("$ATOOLS_DIR/astmatchaxes", "astmatchaxes", frm1, frm2, **kwargs)
[docs]def astmathmap(*args, **kwargs):
"""
Create a MathMap.
Runs the command: $ATOOLS_DIR/astmathmap .
Keyword Arguments
-----------------
nin : int
The number of input coordinates in the MathMap [2]
nout : int
The number of output coordinates in the MathMap [2]
fwd : str
Group of forward expressions
inv : str
Group of inverse expressions
options : str
Options for the MathMap [!]
result : str
Name of file in which to store the MathMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astmathmap", "astmathmap", *args, **kwargs)
[docs]def astmatrixmap(*args, **kwargs):
"""
Create a MatrixMap.
Runs the command: $ATOOLS_DIR/astmatrixmap .
Keyword Arguments
-----------------
nin : int
The number of input coordinates (columns) in the MatrixMap [2]
nout : int
The number of output coordinates (rows) in the MatrixMap [2]
form : int
The form of the MatrixMap [0]
matrix : List[float]
The matrix elements [0]
options : str
Options for the MatrixMap [!]
result : str
Name of file in which to store the MatrixMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astmatrixmap", "astmatrixmap", *args, **kwargs)
[docs]def astmirrorvars(this, **kwargs):
"""
Make the current Frame in a FrameSet mirror the variant Mappings
Runs the command: $ATOOLS_DIR/astmirrorvars .
Arguments
---------
this : str
The input FrameSet
Keyword Arguments
-----------------
iframe : str
The index or Domain of the variant Frame to mirror [!]
result : str
The modified FrameSet
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astmirrorvars", "astmirrorvars", this, **kwargs)
[docs]def astnegate(this, result, **kwargs):
"""
Negate the area represented by a Region.
Runs the command: $ATOOLS_DIR/astnegate .
Arguments
---------
this : str
The input Region
result : str
Name of file in which to store the negated Region
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astnegate", "astnegate", this, result, **kwargs)
[docs]def astoutline(*args, **kwargs):
"""
Create a new Polygon outling values in a 2D NDF.
Runs the command: $ATOOLS_DIR/astoutline .
Keyword Arguments
-----------------
value : str
The value that defines the pixels to be outlined [BAD]
oper : str
Operation defining the pixels to be outlined [EQ]
array : str,filename
The input NDF
maxerr : float
The maximum allowed positional error in the polygon [0.0]
maxvert : int
The maximum number of vertices in the polygon [10]
inside : List[int]
Pixel indices of a point in the polygon [!]
result : str
Name of file in which to store the Polygon
current : bool
Map the Polygon into current Frame of the NDF? [FALSE]
fmt : str
Format for output text file ["AST"]
Returns
-------
nvert : int
"""
return wrapper.starcomm("$ATOOLS_DIR/astoutline", "astoutline", *args, **kwargs)
[docs]def astoverlap(this, that, **kwargs):
"""
Test if two regions overlap each other.
Runs the command: $ATOOLS_DIR/astoverlap .
Arguments
---------
this : str
The first Region
that : str
The second Region
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
Returns
-------
result : int
"""
return wrapper.starcomm("$ATOOLS_DIR/astoverlap", "astoverlap", this, that, **kwargs)
[docs]def astpcdmap(disco, pcdcen, **kwargs):
"""
Create a PcdMap.
Runs the command: $ATOOLS_DIR/astpcdmap .
Arguments
---------
disco : float
The distortion coefficient
pcdcen : List[float]
The coordinates of the centre of the distortion
Keyword Arguments
-----------------
options : str
Options for the PcdMap [!]
result : str
Name of file in which to store the PcdMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astpcdmap", "astpcdmap", disco, pcdcen, **kwargs)
[docs]def astpermaxes(this, perm, result, **kwargs):
"""
Permute the axis order in a Frame.
Runs the command: $ATOOLS_DIR/astpermaxes .
Arguments
---------
this : str
The input Frame or FrameSet
perm : List[int]
The new axis order
result : str
The modified Frame or FrameSet
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astpermaxes", "astpermaxes", this, perm, result, **kwargs)
[docs]def astpermmap(inperm, outperm, constants, **kwargs):
"""
Create a PermMap.
Runs the command: $ATOOLS_DIR/astpermmap .
Arguments
---------
inperm : List[int]
Output axes for each input axis
outperm : List[int]
Input axes for each output axis
constants : float
Constant values for unattached axes
Keyword Arguments
-----------------
options : str
Options for the PermMap [!]
result : str
Name of file in which to store the PermMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astpermmap", "astpermmap", inperm, outperm, constants, **kwargs)
[docs]def astpickaxes(this, axes, **kwargs):
"""
Create a new Frame by picking axes from an existing one.
Runs the command: $ATOOLS_DIR/astpickaxes .
Arguments
---------
this : str
The input Frame or FrameSet
axes : List[int]
The indices of the required axes
Keyword Arguments
-----------------
map : str
The Mapping from old to new Frame [!]
result : str
The new Frame
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astpickaxes", "astpickaxes", this, axes, **kwargs)
[docs]def astpolygon(frame, xin, yin, unc, **kwargs):
"""
Create a Polygon.
Runs the command: $ATOOLS_DIR/astpolygon .
Arguments
---------
frame : str,filename
The Frame in which the Polygon is defined
xin : str
Group of numerical X axis values
yin : str
Group of numerical Y axis values
unc : str
The uncertainty Region
Keyword Arguments
-----------------
options : str
Options for the Polygon [!]
result : str
Name of file in which to store the Polygon
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astpolygon", "astpolygon", frame, xin, yin, unc, **kwargs)
[docs]def astpolymap(*args, **kwargs):
"""
Create a PolyMap.
Runs the command: $ATOOLS_DIR/astpolymap .
Keyword Arguments
-----------------
nin : int
Number of input coordinates [1]
nout : int
Number of output coordinates [1]
coeff_f : str
Group of coefficients for the forward transformation
coeff_i : str
Group of coefficients for the inverse transformation
options : str
Options for the PolyMap [!]
result : str
Name of file in which to store the PolyMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astpolymap", "astpolymap", *args, **kwargs)
[docs]def astpolytran(this, forward, acc, maxacc, maxorder, lbnd, ubnd, result, **kwargs):
"""
Fit a PolyMap inverse or forward transformation.
Runs the command: $ATOOLS_DIR/astpolytran .
Arguments
---------
this : str
The input PolyMap
forward : bool
Replace the forward transformation?
acc : float
The target accuracy
maxacc : float
The maximum allowed accuracy
maxorder : int
The maximum polynomial order
lbnd : List[float]
Lower bounds of fitting box
ubnd : List[float]
Upper bounds of fitting box
result : str
Name of file in which to store the new PolyMap
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astpolytran", "astpolytran", this, forward, acc, maxacc, maxorder, lbnd, ubnd, result, **kwargs)
[docs]def astprism(region1, region2, **kwargs):
"""
Create a Prism.
Runs the command: $ATOOLS_DIR/astprism .
Arguments
---------
region1 : str
The Region to be extruded
region2 : str
The Region defining the extent of the extrusion
Keyword Arguments
-----------------
options : str
Options for the Prism [!]
result : str
Name of file in which to store the Prism
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astprism", "astprism", region1, region2, **kwargs)
[docs]def astquadapprox(this, lbnd, ubnd, **kwargs):
"""
Obtain a quadratic approximation to a 2D Mapping.
Runs the command: $ATOOLS_DIR/astquadapprox .
Arguments
---------
this : str
The input Mapping
lbnd : List[float]
Lower bounds of input region
ubnd : List[float]
Upper bounds of input region
Keyword Arguments
-----------------
nx : int
Number of points to place along the first input axis [10]
ny : int
Number of points to place along the second input axis [10]
fmt : str
Format for output text file ["AST"]
Returns
-------
fit : List[float]
rms : float
"""
return wrapper.starcomm("$ATOOLS_DIR/astquadapprox", "astquadapprox", this, lbnd, ubnd, **kwargs)
[docs]def astrate(this, at, ax1, ax2, **kwargs):
"""
Calculate the rate of change of a Mapping output
Runs the command: $ATOOLS_DIR/astrate .
Arguments
---------
this : str
The input Mapping
at : List[float]
Input position at which rate of change is to be determined
ax1 : int
Index of output axis for which rate of change is required
ax2 : int
Index of input axis for which is to be varied
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
Returns
-------
rate : float
"""
return wrapper.starcomm("$ATOOLS_DIR/astrate", "astrate", this, at, ax1, ax2, **kwargs)
[docs]def astratemap(map, ax1, ax2, **kwargs):
"""
Create a RateMap.
Runs the command: $ATOOLS_DIR/astratemap .
Arguments
---------
map : str
The encapsulated Mapping
ax1 : int
Mapping output for which rate of change is required
ax2 : int
Mapping input to be varied
Keyword Arguments
-----------------
options : str
Options for the RateMap [!]
result : str
Name of file in which to store the RateMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astratemap", "astratemap", map, ax1, ax2, **kwargs)
[docs]def astremapframe(this, **kwargs):
"""
Modify a Frame's relationship to other Frames in a FrameSet.
Runs the command: $ATOOLS_DIR/astremapframe .
Arguments
---------
this : str
The input FrameSet
Keyword Arguments
-----------------
iframe : str
The index or Domain of the Frame to be re-mapped [!]
map : str,filename
The Mapping from the original to the new Frame
result : str
The modified FrameSet
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astremapframe", "astremapframe", this, **kwargs)
[docs]def astremoveframe(this, **kwargs):
"""
Remove a Frame from a FrameSet.
Runs the command: $ATOOLS_DIR/astremoveframe .
Arguments
---------
this : str
The input FrameSet
Keyword Arguments
-----------------
iframe : str
The index or Domain of the Frame to be removed [!]
result : str
The modified FrameSet
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astremoveframe", "astremoveframe", this, **kwargs)
[docs]def astremoveregion(this, result, **kwargs):
"""
Remove any Regions from a Mapping.
Runs the command: $ATOOLS_DIR/astremoveregion .
Arguments
---------
this : str
The input Mapping
result : str
Name of file in which to store the modified Mapping
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astremoveregion", "astremoveregion", this, result, **kwargs)
[docs]def astselectormap(reg1, reg2, **kwargs):
"""
Create a SelectorMap.
Runs the command: $ATOOLS_DIR/astselectormap .
Arguments
---------
reg1 : str
The first Region
reg2 : str
The second Region
Keyword Arguments
-----------------
options : str
Options for the SelectorMap [!]
result : str
Name of file in which to store the SelectorMap
badval : str
Output value to use for bad input values
fmt : str
Format for output text file ["AST"]
reg10 : str
Region number 10 [!]
reg11 : str
Region number 11 [!]
reg12 : str
Region number 12 [!]
reg13 : str
Region number 13 [!]
reg14 : str
Region number 14 [!]
reg15 : str
Region number 15 [!]
reg16 : str
Region number 16 [!]
reg17 : str
Region number 17 [!]
reg18 : str
Region number 18 [!]
reg19 : str
Region number 19 [!]
reg20 : str
Region number 20 [!]
reg21 : str
Region number 21 [!]
reg22 : str
Region number 22 [!]
reg23 : str
Region number 23 [!]
reg24 : str
Region number 24 [!]
reg25 : str
Region number 25 [!]
reg3 : str
Region number 3 [!]
reg4 : str
Region number 4 [!]
reg5 : str
Region number 5 [!]
reg6 : str
Region number 6 [!]
reg7 : str
Region number 7 [!]
reg8 : str
Region number 8 [!]
reg9 : str
Region number 9 [!]
"""
return wrapper.starcomm("$ATOOLS_DIR/astselectormap", "astselectormap", reg1, reg2, **kwargs)
[docs]def astset(this, attrib, value, result, **kwargs):
"""
Set an attribute value for an Object.
Runs the command: $ATOOLS_DIR/astset .
Arguments
---------
this : str
The input Object
attrib : str
The attribute to set
value : str
The new attribute value
result : str
Name of file or NDF in which to store the modified Object
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astset", "astset", this, attrib, value, result, **kwargs)
[docs]def astsetactunit(this, value, result, **kwargs):
"""
Set the ActiveUnit flag for a Frame.
Runs the command: $ATOOLS_DIR/astsetactunit .
Arguments
---------
this : str
The input Frame
value : bool
The new ActiveUnit value
result : str
Name of file or NDF in which to store the modified Frame
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astsetactunit", "astsetactunit", this, value, result, **kwargs)
[docs]def astsetrefpos(this, **kwargs):
"""
Set the reference position for a SpecFrame.
Runs the command: $ATOOLS_DIR/astsetrefpos .
Arguments
---------
this : str
The input SpecFrame
Keyword Arguments
-----------------
frm : str
The input SkyFrame [!]
lon : str
The formatted celestial longitude [0 0 0]
lat : str
The formatted celestial latitude [0 0 0]
result : str
Name of file in which to store the modified SpecFrame
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astsetrefpos", "astsetrefpos", this, **kwargs)
[docs]def astsfluxframe(frame1, frame2, **kwargs):
"""
Create a SpecFluxFrame.
Runs the command: $ATOOLS_DIR/astsfluxframe .
Arguments
---------
frame1 : str
The SpecFrame
frame2 : str
The FluxFrame
Keyword Arguments
-----------------
options : str
Options for the SpecFluxFrame [!]
result : str
Name of file in which to store the SpecFluxFrame
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astsfluxframe", "astsfluxframe", frame1, frame2, **kwargs)
[docs]def astshiftmap(*args, **kwargs):
"""
Create a ShiftMap.
Runs the command: $ATOOLS_DIR/astshiftmap .
Keyword Arguments
-----------------
ncoord : int
The number of coordinates for the ShiftMap [2]
shift : List[float]
Values to add onto each coordinate axis
options : str
Options for the ShiftMap [!]
result : str
Name of file in which to store the ShiftMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astshiftmap", "astshiftmap", *args, **kwargs)
[docs]def astshow(*args, **kwargs):
"""
Runs the command: $ATOOLS_DIR/astshow.tcl .
"""
return wrapper.starcomm("$ATOOLS_DIR/astshow.tcl", "astshow", *args, **kwargs)
[docs]def astshowmesh(this, format, ttl, **kwargs):
"""
Display a mesh of points covering the surface of a Region.
Runs the command: $ATOOLS_DIR/astshowmesh .
Arguments
---------
this : str
The Region
format : bool
Format the displayed axis values?
ttl : str
Title to display before the table of axis values
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astshowmesh", "astshowmesh", this, format, ttl, **kwargs)
[docs]def astsimplify(this, result, **kwargs):
"""
Simplify a Mapping.
Runs the command: $ATOOLS_DIR/astsimplify .
Arguments
---------
this : str
The input Mapping
result : str
Name of file in which to store the simplified Mapping
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astsimplify", "astsimplify", this, result, **kwargs)
[docs]def astskyframe(*args, **kwargs):
"""
Create a SkyFrame.
Runs the command: $ATOOLS_DIR/astskyframe .
Keyword Arguments
-----------------
options : str
Options for the SkyFrame [!]
result : str
Name of file in which to store the SkyFrame
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astskyframe", "astskyframe", *args, **kwargs)
[docs]def astspecframe(*args, **kwargs):
"""
Create a SpecFrame.
Runs the command: $ATOOLS_DIR/astspecframe .
Keyword Arguments
-----------------
options : str
Options for the SpecFrame [!]
result : str
Name of file in which to store the SpecFrame
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astspecframe", "astspecframe", *args, **kwargs)
[docs]def astsphmap(*args, **kwargs):
"""
Create a SphMap.
Runs the command: $ATOOLS_DIR/astsphmap .
Keyword Arguments
-----------------
options : str
Options for the SphMap [!]
result : str
Name of file in which to store the SphMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astsphmap", "astsphmap", *args, **kwargs)
[docs]def astswitchmap(fsmap, ismap, routemap1, routemap2, **kwargs):
"""
Create a SwitchMap.
Runs the command: $ATOOLS_DIR/astswitchmap .
Arguments
---------
fsmap : str
The forward selector Mapping
ismap : str
The inverse selector Mapping
routemap1 : str
The first route Mapping
routemap2 : str
The second route Mapping
Keyword Arguments
-----------------
options : str
Options for the SwitchMap [!]
result : str
Name of file in which to store the SwitchMap
fmt : str
Format for output text file ["AST"]
iarcfile : str
IARC output file [!]
routemap10 : str
Route Mapping number 10 [!]
routemap11 : str
Route Mapping number 11 [!]
routemap12 : str
Route Mapping number 12 [!]
routemap13 : str
Route Mapping number 13 [!]
routemap14 : str
Route Mapping number 14 [!]
routemap15 : str
Route Mapping number 15 [!]
routemap16 : str
Route Mapping number 16 [!]
routemap17 : str
Route Mapping number 17 [!]
routemap18 : str
Route Mapping number 18 [!]
routemap19 : str
Route Mapping number 19 [!]
routemap20 : str
Route Mapping number 20 [!]
routemap21 : str
Route Mapping number 21 [!]
routemap22 : str
Route Mapping number 22 [!]
routemap23 : str
Route Mapping number 23 [!]
routemap24 : str
Route Mapping number 24 [!]
routemap25 : str
Route Mapping number 25 [!]
routemap3 : str
Route Mapping number 3 [!]
routemap4 : str
Route Mapping number 4 [!]
routemap5 : str
Route Mapping number 5 [!]
routemap6 : str
Route Mapping number 6 [!]
routemap7 : str
Route Mapping number 7 [!]
routemap8 : str
Route Mapping number 8 [!]
routemap9 : str
Route Mapping number 9 [!]
"""
return wrapper.starcomm("$ATOOLS_DIR/astswitchmap", "astswitchmap", fsmap, ismap, routemap1, routemap2, **kwargs)
[docs]def asttest(this, attrib, **kwargs):
"""
Test if an Object attribute value is set.
Runs the command: $ATOOLS_DIR/asttest .
Arguments
---------
this : str
The input Object
attrib : str
The attribute to test
Keyword Arguments
-----------------
fmt : str
Format for output text file ["AST"]
Returns
-------
value : bool
"""
return wrapper.starcomm("$ATOOLS_DIR/asttest", "asttest", this, attrib, **kwargs)
[docs]def asttimeframe(*args, **kwargs):
"""
Create a TimeFrame.
Runs the command: $ATOOLS_DIR/asttimeframe .
Keyword Arguments
-----------------
options : str
Options for the TimeFrame [!]
result : str
Name of file in which to store the TimeFrame
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/asttimeframe", "asttimeframe", *args, **kwargs)
[docs]def asttohds(keymap, object, **kwargs):
"""
Copy the contents of a KeyMap to a new HDS object.
Runs the command: $ATOOLS_DIR/asttohds .
Arguments
---------
keymap : str
The input KeyMap
object : UNIV
HDS object to create
"""
return wrapper.starcomm("$ATOOLS_DIR/asttohds", "asttohds", keymap, object, **kwargs)
[docs]def asttran1(this, xin, **kwargs):
"""
Use a Mapping to transform a set of position in one dimension.
Runs the command: $ATOOLS_DIR/asttran1 .
Arguments
---------
this : str
The input Mapping
xin : str
Group of numerical axis values
Keyword Arguments
-----------------
forward : bool
Use the forward transformation? [TRUE]
xout : str
Name of output text file to hold axis values [!]
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/asttran1", "asttran1", this, xin, **kwargs)
[docs]def asttran2(this, xin, yin, **kwargs):
"""
Use a Mapping to transform a set of position in two dimensions.
Runs the command: $ATOOLS_DIR/asttran2 .
Arguments
---------
this : str
The input Mapping
xin : str
Group of numerical X axis values
yin : str
Group of numerical Y axis values
Keyword Arguments
-----------------
forward : bool
Use the forward transformation? [TRUE]
xout : str
Name of output text file to hold X axis values [!]
yout : str
Name of output text file to hold Y axis values [!]
fmt : str
Format for output text file ["AST"]
Returns
-------
xval : float
yval : float
"""
return wrapper.starcomm("$ATOOLS_DIR/asttran2", "asttran2", this, xin, yin, **kwargs)
[docs]def asttrangrid(this, lbnd, ubnd, **kwargs):
"""
Transform a grid of positions
Runs the command: $ATOOLS_DIR/asttrangrid .
Arguments
---------
this : str
The input Mapping
lbnd : List[int]
Lower pixel index bounds of output NDF
ubnd : List[int]
Upper pixel index bounds of output NDF
Keyword Arguments
-----------------
tol : float
Maximum tolerable geometrical distortion [0.0]
maxpix : int
Initial scale size in input grid points [100]
forward : bool
Use the forward transformation? [TRUE]
result : str,filename
The NDF containing the transformed positions
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/asttrangrid", "asttrangrid", this, lbnd, ubnd, **kwargs)
[docs]def asttranmap(map1, map2, **kwargs):
"""
Create a TranMap.
Runs the command: $ATOOLS_DIR/asttranmap .
Arguments
---------
map1 : str
The first component Mapping
map2 : str
The second component Mapping
Keyword Arguments
-----------------
options : str
Options for the TranMap [!]
result : str
Name of file in which to store the TranMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/asttranmap", "asttranmap", map1, map2, **kwargs)
[docs]def asttrann(this, **kwargs):
"""
Transform N-dimensional coordinates.
Runs the command: $ATOOLS_DIR/asttrann .
Arguments
---------
this : str
The input Mapping
Keyword Arguments
-----------------
incols : List[int]
The columns containing the input axis values [!]
`in_` : str,filename
The NDF containing the input positions
forward : bool
Use the forward transformation? [TRUE]
outcols : List[int]
The columns to receive the output axis values [dyn.]
out : str,filename
The NDF containing the transformed positions
fmt : str
Format for output text file ["AST"]
posin : str
Group of numerical input axis values [!]
posout : str
Name of output text file to hold axis values [!]
"""
return wrapper.starcomm("$ATOOLS_DIR/asttrann", "asttrann", this, **kwargs)
[docs]def astunitmap(*args, **kwargs):
"""
Create a UnitMap.
Runs the command: $ATOOLS_DIR/astunitmap .
Keyword Arguments
-----------------
ncoord : int
The number of input and output coordinates in the UnitMap [2]
options : str
Options for the UnitMap [!]
result : str
Name of file in which to store the UnitMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astunitmap", "astunitmap", *args, **kwargs)
[docs]def astwcsmap(ncoord, type, lonax, latax, **kwargs):
"""
Create a WcsMap.
Runs the command: $ATOOLS_DIR/astwcsmap .
Arguments
---------
ncoord : int
The number of inputs and outputs
type : str
The FITS-WCS projection code
lonax : int
The index of the longitude axis
latax : int
The index of the latitude axis
Keyword Arguments
-----------------
options : str
Options for the WcsMap [!]
result : str
Name of file in which to store the WcsMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astwcsmap", "astwcsmap", ncoord, type, lonax, latax, **kwargs)
[docs]def astwinmap(*args, **kwargs):
"""
Create a WinMap.
Runs the command: $ATOOLS_DIR/astwinmap .
Keyword Arguments
-----------------
ncoord : int
The number of coordinates for the WinMap [2]
ina : List[float]
Coords of corner A in input coordinate system
inb : List[float]
Coords of corner B in input coordinate system
outa : List[float]
Coords of corner A in output coordinate system
outb : List[float]
Coords of corner B in output coordinate system
options : str
Options for the WinMap [!]
result : str
Name of file in which to store the WinMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astwinmap", "astwinmap", *args, **kwargs)
[docs]def astzoommap(*args, **kwargs):
"""
Create a ZoomMap.
Runs the command: $ATOOLS_DIR/astzoommap .
Keyword Arguments
-----------------
ncoord : int
The number of coordinates for the ZoomMap [2]
zoom : float
Zoom factor
options : str
Options for the ZoomMap [!]
result : str
Name of file in which to store the ZoomMap
fmt : str
Format for output text file ["AST"]
"""
return wrapper.starcomm("$ATOOLS_DIR/astzoommap", "astzoommap", *args, **kwargs)
[docs]def atlhelp(*args, **kwargs):
"""
Display information about ATOOLS.
Runs the command: $ATOOLS_DIR/atlhelp .
Keyword Arguments
-----------------
topic : str
Help topic [" "]
subtopic : str
Help subtopic [" "]
subsubtopic : str
Help subsubtopic [" "]
subsubsubtopic : str
Help subsubsubtopic [" "]
fmt : str
Format for output text file [AST]
"""
return wrapper.starcomm("$ATOOLS_DIR/atlhelp", "atlhelp", *args, **kwargs)