All pixels coordinates are zero relative.
Double restfreq = 1.420405752E9;
Double crpix = 10.0;
Double crval = 1.4e9;
Double cdelt = 1.0e6;
SpectralCoordinate sc(MFrequency::TOPO, crval, cdelt, crpix, restfreq);
Double world, pixel;
pixel = 12.1;
if (!sc.toWorld(world, pixel)) {
cerr << "Error : " << sc.errorMessage() << endl;
} else {
cerr << "pixel, world = " << pixel << ", " << world << endl;
}
Vector<Double> freqs(5);
freqs(0) = 1.4e9; freqs(1) = 1.41e9;
freqs(2) = 1.43e9; freqs(3) = 1.44e9;
freqs(4) = 1.47e9;
SpectralCoordinate sc(MFrequency::LSRK, freqs, restfreq);
Double world, pixel;
world = 1.42e9;
if (!sc.toPixel(pixel, world)) {
cerr << "Error : " << sc.errorMessage() << endl;
} else {
cerr << "world, pixel = " << world << ", " << pixel << endl;
}
Create a linear frequency axis SpectralCoordinate f0 is the frequency of the reference pixel, inc is the pixel increment, refPix is the reference pixel. You can optionally store the rest frequency for later use in calculating radial velocities. Use 0 for restFrequency if continuum.
Frequencies and increments initially in Hz.
Create linear frequency axis SpectralCoordinate with Quantum-based interface. Parameters are the same as above. Regardless of the units of the Quanta, the initial units of the SpectralCoordinate will be Hz. You can change it to something else with the setWorldAxisUnits method later if you want. Use 0 for restFrequency if continuum.
Construct a SpectralCoordinate with the specified frequencies (in Hz). This axis can be nonlinear; the increments and related functions return the average values (calculated from the first and last pixel's frequencies).
A linear interpolation/extrapolation is used for pixels which are not supplied. The reference pixel is chosen to be 0. The frequencies must increase or decrease monotonically (otherwise the toPixel lookup would not be possible). Use 0 for restFrequency if continuum.
Construct a SpectralCoordinate with the specified frequencies with Quantum-based interface. Parameters are the same as above. Regardless of the units of the Quanta, the initial units of the SpectralCoordinate will be Hz. Use 0 for restFrequency if continuum.
Construct a SpectralCoordinate with the specified velocities (in km/s). They will be converted to Hz and the SpectralCoordinate constructed. This axis can be nonlinear; the increments and related functions return the average values (calculated from the first and last pixel's frequencies).
A linear interpolation/extrapolation is used for pixels which are not supplied. The reference pixel is chosen to be 0. The velocities must increase or decrease monotonically (otherwise the toPixel lookup would not be possible).
Copy constructor (copy semantics).
Assignment (copy semantics).
Destructor.
Always returns Coordinate::SPECTRAL.
Always returns the String "Spectral".
Always returns 1.
Set extra conversion layer. Whenever a conversion from pixel to world is done, the world value is then further converted to this MFrequency::Types value. For example, your SpectralCoordinate may be defined in LSRK. You can use this to get the world values out in say BARY. You must specify the position on earth, the epoch and the direction for the conversions and it is your responsibility to ensure they are viable. Similarly, whenever you convert from world to pixel, the world value is assumed to be that appropriate to the setReferenceConversion type. It is first converted to the MFrequency::Types with which the SpectralCoordinate was constructed and from there to pixel. If you don't call this function, or you set the same type for which the SpectralCoordinate was constructed, no extra conversions occur. Some conversions will fail. These are the ones that require extra frame information (radial velocity) such as to REST. This will be added later. In this case this function returns False (and the conversion parameters are all left as they were), else it returns True.
Convert a pixel to a world coordinate or vice versa. Returns True if the conversion succeeds, otherwise it returns False and errorMessage() contains an error message. The input vectors must be of length one and the output vectors are resized if they are not already of length one.
Convert a pixel (channel number) into an MFrequency or MVFrequency and vice versa. Usually you will do this for calculating velocities or converting frequencies from one frame to another.
Batch up a lot of transformations. The first (most rapidly varying) axis of the matrices contain the coordinates. Returns False if any conversion failed and errorMessage() will hold a message. The failures array (True for fail, False for success) is the length of the number of conversions and holds an error status for each conversion.
Make absolute coordinates relative and vice-versa (with respect to the reference value). Vectors must be length nPixelAxes() or nWorldAxes() or memory access errors will occur
Set the state that is used for conversions from pixel and frequency to velocity. The SpectralCoordinate is constructed with MDoppler::RADIO and km/s as the velocity conversion state. The functions in this class which use this state are those that convert to or from velocity. Also, function format uses the Doppler state set here. If the function returns False it means the unit was not valid. There will be an error message in function errorMessage
Functions to convert to velocity (uses the current active rest frequency). There is no reference frame change but you can specify the velocity Doppler and the output units of the velocity with function setVelocity. When the input is a frequency stored as a Double it must be in the current units of the SpectralCoordinate.
Note that the extra conversion layer (see function setReferenceConversion) is active in the pixelToVelocity functions (because internally the use toWorld) but not in the frequencyToVelocity functions.
Functions to convert from velocity (uses the current active rest frequency). There is no reference frame change but you can specify the velocity Doppler and the output units of the velocity with function setVelocity. When the input is a frequency stored as a Double it must be in the current units of the SpectralCoordinate.
Note that the extra conversion layer (see function setReferenceConversion) is active in the pixelToVelocity functions (because internally the use toPixel) but not in the frequencyToVelocity functions.
The SpectralCoordinate can maintain a list of rest frequencies (e.g. multiple lines within a band). However, only one of them is active (e.g. for velocity conversions) at any one time. Function restFrequency returns that frequency. Function restFrequencies returns all of the possible restfrequencies.
When you construct the SpectralCoordinate, you give it one rest frequency and it is the active one. Thereafter you can add a new restfrequency with function setRestFrequency (append=True) and that frequency will become the active one. With this function and append=False, the current active restfrequency will be replaced by the one you give.
You can change the list of restfrequencies with function setRestFrequencies. When you do so, you can either replace the list of rest frequencies or append to it. You specify which frequency of the new (appended) list becomes active.
You can also select the active rest frequency either by an index into the current list (exception if out of range) given by restFrequencies() or by the value in the list nearest to the frequency you give.
Whenever you change the active rest frequency, the class internals are adjusted (e.g. the velocity machine is updated).
Retrieve/set the frequency system. Note that setting the frequency system just changes the internal value of the frequency system. In addition, it will reset the internal conversion frequency system to the new type and delete any conversion machines.
Report the value of the requested attribute.
Set the value of the requested attribute. Note that these just change the internal values, they do not cause any recomputation.
Get the table, i.e. the pixel and world values. The length of these Vectors will be zero if this axis is pure linear (i.e. if the channel and frequencies are related through an increment and offset).
Set/get the unit. Adjust the increment and reference value by the ratio of the old and new units. The unit must be compatible with frequency.
Set the world min and max ranges, for use in function toMix, for a lattice of the given shape (for this coordinate). The implementation here gives world coordinates dangling 25% off the edges of the image. The output vectors are resized. Returns False if fails (and then setDefaultWorldMixRanges generates the ranges) with a reason in errorMessage(). The setDefaultWorldMixRanges function gives you [-1e99->1e99].
Comparison function. Any private Double data members are compared with the specified fractional tolerance. Don't compare on the specified axes in the Coordinate. If the comparison returns False, errorMessage() contains a message about why.
Find the Coordinate for when we Fourier Transform ourselves. This pointer must be deleted by the caller. Axes specifies which axes of the Coordinate you wish to transform. Shape specifies the shape of the image associated with all the axes of the Coordinate. Currently the output reference pixel is always shape/2.
Format a SpectralCoordinate coordinate world value nicely through the common format interface. See Coordinate for basics.
The world value must always be given in native frequency units. Use argument unit to determine what it will be converted to for formatting. If unit is given, it must be dimensionally consistent with Hz or m/s. If you give a unit consistent with m/s then the appropriate velocity Doppler type is taken from that set by function setVelocity. There is no frame conversion. If unit is empty, the unit given by setFormatUnit is used. If this is turn empty, then native units are used.
Set the default formatter unit (which is initialized to empty). Must be consistent with Hz or km/s. If the given unit is illegal, False is returned and the internal state unchanged. This unit is used by the function format when the given unit is empty.
Convert to and from a FITS header record. When writing the FITS record, the fields "ctype, crval, crpix", and "cdelt" must already be created. Other header words are created as needed. Use oneRelative=True to convert zero-relative SpectralCoordinate pixel coordinates to one-relative FITS coordinates, and vice-versa. If preferVelocity=False the primary axis type will be Frequency, else velocity. For a velocity axis, if opticalVelDef=False, the radio velocity definition will be used, else optical definition.
Save the SpectralCoordinate into the supplied record using the supplied field name. The field must not exist, otherwise False is returned.
Recover the SpectralCoordinate from a record. A null pointer means that the restoration did not succeed.
Make a copy of the SpectralCoordinate using new. The caller is responsible for calling delete.
Set up pixel<->world conversion machines Returns: 3 (machines were noOPs, machines deleted) 2 (types the same, machines deleted), 1 (machines created and functioning) -1 (machines could not make trial conversion, machines deleted)
Create velocity<->frequency machine
Deletes and sets pointer to 0
Deletes and sets pointers to 0
Format checker
Convert to and from conversion type
Update Velocity Machine