00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #ifndef DISPLAY_COORDINATESYSTEM_H_
00030 #define DISPLAY_COORDINATESYSTEM_H_
00031
00032 #include <coordinates/Coordinates/CoordinateSystem.h>
00033 #include <coordinates/Coordinates/CoordinateUtil.h>
00034 #include <components/ComponentModels/SkyComponentFactory.h>
00035
00036 namespace casa {
00037
00038 class DisplayCoordinateSystem {
00039 public:
00040
00041 DisplayCoordinateSystem ( ) { }
00042 DisplayCoordinateSystem( const DisplayCoordinateSystem &o ) :
00043 cs_(o.cs_), transposition_log(o.transposition_log) { }
00044 DisplayCoordinateSystem( const CoordinateSystem &c ) : cs_(c) { }
00045 virtual ~DisplayCoordinateSystem( );
00046
00047 operator const CoordinateSystem &( ) const { return cs_; }
00048
00049 const DisplayCoordinateSystem &operator =(const DisplayCoordinateSystem &o) {
00050 transposition_log = o.transposition_log;
00051 cs_ = o.cs_;
00052 return *this;
00053 }
00054 const DisplayCoordinateSystem &operator =(const CoordinateSystem &o) {
00055 transposition_log.clear( );
00056 cs_ = o;
00057 return *this;
00058 }
00059
00060 String showType(uInt whichCoordinate) const
00061 { return cs_.showType(whichCoordinate); }
00062
00063 uInt nCoordinates() const { return cs_.nCoordinates( ); }
00064 unsigned int nPixelAxes() const { return cs_.nPixelAxes( ); }
00065 unsigned int nWorldAxes() const { return cs_.nWorldAxes( ); }
00066
00067
00068 bool isDirectionAbscissaLongitude( ) const
00069 { return cs_.isDirectionAbscissaLongitude( ); }
00070
00071 ObsInfo obsInfo() const
00072 { return cs_.obsInfo( ); }
00073 void setObsInfo(const ObsInfo &obsinfo)
00074 { cs_.setObsInfo(obsinfo); }
00075
00076 Vector<String> worldAxisUnits() const;
00077 Vector<String> worldAxisNames() const;
00078 bool setWorldAxisUnits(const Vector<String> &units);
00079 bool setWorldAxisNames( const Vector<String> &names);
00080 Vector<int> worldAxes(uInt whichCoord) const;
00081 Vector<int> pixelAxes(uInt whichCoord) const;
00082
00083 Vector<double> worldMixMin () const
00084 { return cs_.worldMixMin( ); }
00085 Vector<double> worldMixMax () const
00086 { return cs_.worldMixMax( ); }
00087 bool setWorldMixRanges (const IPosition& shape)
00088 { return cs_.setWorldMixRanges(shape); }
00089
00090 bool near( const Coordinate& other, Double tol=1e-6 ) const
00091 { return cs_.near(other,tol); }
00092 bool near(const Coordinate& other, const Vector<Int>& excludePixelAxes, Double tol=1e-6) const
00093 { return cs_.near(other,excludePixelAxes,tol); }
00094
00095 void makePixelRelative( Vector<double>& pixel ) const;
00096 void makePixelAbsolute( Vector<double>& pixel ) const;
00097 void makeWorldAbsolute (Vector<double>& world) const;
00098 void makeWorldRelative (Vector<double>& world) const;
00099
00100 Vector<double> referencePixel() const
00101 { return cs_.referencePixel( ); }
00102 bool setReferencePixel( const Vector<double> &refPix)
00103 { return cs_.setReferencePixel( Vector<double>(refPix) ); }
00104 Vector<double> referenceValue() const
00105 { return cs_.referenceValue( ); }
00106 bool setReferenceValue( const Vector<double> &refval )
00107 { return cs_.setReferenceValue(refval); }
00108 bool setIncrement( const Vector<double> &inc )
00109 { return cs_.setIncrement(inc); }
00110
00111
00112 Coordinate::Type type(unsigned int whichCoordinate) const { return cs_.type(whichCoordinate); }
00113
00114 bool hasDirectionCoordinate( ) const { return cs_.hasDirectionCoordinate( ); }
00115 const DirectionCoordinate &directionCoordinate( int which = -1 ) const
00116 { return which < 0 ? cs_.directionCoordinate( ) : cs_.directionCoordinate(which); }
00117 Vector<int> directionAxesNumbers() const;
00118
00119 bool hasSpectralAxis() const { return cs_.hasSpectralAxis( ); }
00120 const SpectralCoordinate &spectralCoordinate( int which = -1 ) const
00121 { return which < 0 ? cs_.spectralCoordinate( ) : cs_.spectralCoordinate(which); }
00122 int spectralAxisNumber(bool doWorld=false) const { return cs_.spectralAxisNumber(doWorld); }
00123
00124 const LinearCoordinate &linearCoordinate( unsigned int which ) const
00125 { return cs_.linearCoordinate(which); }
00126 bool hasPolarizationCoordinate() const { return cs_.hasPolarizationCoordinate(); }
00127
00128 Int polarizationAxisNumber(Bool doWorld=False) const {
00129 return cs_.polarizationAxisNumber(doWorld);
00130 }
00131 const StokesCoordinate &stokesCoordinate( int which = -1 ) const
00132 { return which < 0 ? cs_.stokesCoordinate( ) : cs_.stokesCoordinate(which); }
00133
00134 const TabularCoordinate &tabularCoordinate( unsigned int which ) const
00135 { return cs_.tabularCoordinate(which); }
00136
00137 const QualityCoordinate &qualityCoordinate(unsigned int which) const
00138 { return cs_.qualityCoordinate(which); }
00139 int qualityAxisNumber() const
00140 { return cs_.qualityAxisNumber( ); }
00141
00142 int worldAxisToPixelAxis(unsigned int worldAxis) const
00143 { return cs_.worldAxisToPixelAxis(worldAxis); }
00144 int pixelAxisToWorldAxis(unsigned int pixelAxis) const
00145 { return cs_.pixelAxisToWorldAxis(pixelAxis); }
00146
00147 void findWorldAxis( int &coordinate, int &axisInCoordinate, unsigned int axisInCoordinateSystem) const
00148 { cs_.findWorldAxis( coordinate, axisInCoordinate, axisInCoordinateSystem ); }
00149 void findPixelAxis( int &coordinate, int &axisInCoordinate, unsigned int axisInCoordinateSystem) const
00150 { cs_.findPixelAxis( coordinate, axisInCoordinate, axisInCoordinateSystem ); }
00151
00152 const Coordinate& coordinate(unsigned int which) const
00153 { return cs_.coordinate(which); }
00154 int findCoordinate( Coordinate::Type type, int afterCoord = -1 ) const
00155 { return cs_.findCoordinate(type,afterCoord); }
00156 bool replaceCoordinate( const Coordinate &newCoordinate, unsigned int whichCoordinate )
00157 { return cs_.replaceCoordinate( newCoordinate, whichCoordinate ); }
00158
00159 void addCoordinate(const Coordinate &coord)
00160 { cs_.addCoordinate(coord); }
00161 bool removeWorldAxis(unsigned int axis, double replacement)
00162 { return cs_.removeWorldAxis(axis,replacement); }
00163 bool removePixelAxis(unsigned int axis, double replacement)
00164 { return cs_.removePixelAxis(axis,replacement); }
00165 void transpose(const Vector<int> &newWorldOrder, const Vector<int> &newPixelOrder);
00166
00167 String format( String& units, Coordinate::formatType format, double worldValue, unsigned int worldAxis,
00168 bool isAbsolute=true, bool showAsAbsolute=true, int precision=-1, bool usePrecForMixed=false ) const;
00169
00170
00171 const String& errorMessage() const { return cs_.errorMessage( ); }
00172
00173 bool toWorld( Vector<double> &world, const Vector<double> &pixel ) const;
00174 bool toPixel(Vector<double> &pixel, const Vector<double> &world) const;
00175
00176 #if 0
00177 bool toWorld( Vector<double> &world, const Vector<double> &pixel ) const;
00178 bool toPixel(Vector<double> &pixel, const Vector<double> &world) const;
00179 #endif
00180 bool toMix( Vector<double>& worldOut, Vector<double>& pixelOut,
00181 const Vector<double>& worldIn, const Vector<double>& pixelIn,
00182 const Vector<bool>& worldAxes, const Vector<bool>& pixelAxes,
00183 const Vector<double>& worldMin, const Vector<double>& worldMax) const;
00184
00185 void subImageInSitu( const Vector<float> &originShift, const Vector<float> &incrFac, const Vector<int>& newShape)
00186 { cs_.subImageInSitu( originShift, incrFac, newShape ); }
00187
00188
00189 Vector<double> increment( ) const
00190 { return cs_.increment( ); }
00191
00192 bool save( RecordInterface &container, const String &fieldName ) const
00193 { return cs_.save(container,fieldName); }
00194 static DisplayCoordinateSystem restore( const RecordInterface &container,const String &fieldName );
00195
00196
00197 bool setRestFrequency( String& errorMsg, const String& unit, const Double& value )
00198 { return cs_.setRestFrequency( errorMsg, Quantity(value, unit) ); }
00199 bool setSpectralState( String& errorMsg,const String& unit, const String& spcquant)
00200 { return CoordinateUtil::setSpectralState( errorMsg, cs_, unit, spcquant ); }
00201 bool setSpectralConversion( String& errorMsg, const String frequencySystem )
00202 { return cs_.setSpectralConversion( errorMsg, frequencySystem); }
00203 bool setSpectralFormatting( String& errorMsg, const String& unit, const String& spcquant )
00204 { return CoordinateUtil::setSpectralFormatting( errorMsg, cs_, unit, spcquant ); }
00205 bool setDirectionUnit( const string& unit, Int which=-1)
00206 { return CoordinateUtil::setDirectionUnit( cs_, unit, which ); }
00207 void setNiceAxisLabelUnits( )
00208 { CoordinateUtil::setNiceAxisLabelUnits( cs_ ); }
00209 bool setVelocityState( String& errorMsg, const String& unit, const String& spcquant)
00210 { return CoordinateUtil::setVelocityState( errorMsg, cs_, unit, spcquant ); }
00211 bool removePixelAxes( Vector<Double>& pixelReplacement, const Vector<Int>& pixelAxes, const Bool remove)
00212 { return CoordinateUtil::removePixelAxes( cs_, pixelReplacement,pixelAxes,remove ); }
00213 bool removeAxes( Vector<double>& worldReplacement, const Vector<int>& worldAxes, bool remove)
00214 { return CoordinateUtil::removeAxes( cs_, worldReplacement, worldAxes, remove); }
00215
00216
00217
00218
00219 void worldWidthsToPixel( LogIO& , Vector<double>& dParameters, const Vector<Quantum<Double> >& parameters,
00220 const IPosition& pixelAxes, bool doRef=false ) const {
00221 SkyComponentFactory::worldWidthsToPixel(dParameters, parameters, cs_, pixelAxes, doRef );
00222 }
00223
00224
00225 void match( const DisplayCoordinateSystem &other );
00226 Vector<int> transposeShape( const Vector<int> &original_shape, bool world=true );
00227
00228 private:
00229 CoordinateSystem cs_;
00230 typedef vector<pair<Vector<int>,Vector<int> > > transposition_log_t;
00231 transposition_log_t transposition_log;
00232 };
00233
00234 }
00235
00236 #endif
1.6.1
