Main Page   Namespace List   Alphabetical List   Compound List   File List   Compound Members   File Members  

AIDA_DataPointSet.cpp

Go to the documentation of this file.
00001 #include "AIDA_DataPointSet.h"
00002 #include "AIDA_DataPoint.h"
00003 #include "AIDA/IAnnotation.h"
00004 #include "AIDA/IMeasurement.h"
00005 #include <set>
00006 
00007 // static const std::string titleKey = "Title"; // defined in aida
00008 static const std::string nameKey = "Name";
00009 static const std::string sizeKey = "Size";
00010 static const std::string emptyString = "";
00011 
00012 static const std::string g_userLevelClassType = "IDataPointSet";
00013 
00014 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::AIDA_DataPointSet( const std::string& title,
00015                                                                         int dimension,
00016                                                                         AIDA::IAnnotation* annotation ):
00017   m_annotation( annotation ),
00018   m_dimension( ( ( dimension > 0 ) ? dimension : 0  ) ),
00019   m_upToDate( false ),
00020   m_dataPoints()
00021 {
00022   m_annotation->addItem( titleKey, title, true );
00023   m_annotation->addItem( nameKey, emptyString, true );
00024   m_annotation->addItem( sizeKey, emptyString, false );
00025 }
00026 
00027 
00028 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::AIDA_DataPointSet( const Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet& dps,
00029                                                                         AIDA::IAnnotation* annotation ):
00030   m_annotation( annotation ),
00031   m_dimension( dps.dimension() ),
00032   m_upToDate( false ),
00033   m_dataPoints()
00034 {
00035   // Define the annotation items
00036   std::set< std::string > existingAnnotationItems;
00037   m_annotation->addItem( titleKey, dps.title(), true );
00038   existingAnnotationItems.insert( titleKey );
00039   m_annotation->addItem( nameKey, emptyString, true );
00040   existingAnnotationItems.insert( nameKey );
00041   m_annotation->addItem( sizeKey, emptyString, false );
00042   existingAnnotationItems.insert( sizeKey );
00043 
00044   // Copy other annotation items
00045   const AIDA::IAnnotation& otherAnnotation = dps.annotation();
00046   for ( int itemNew = 0; itemNew < otherAnnotation.size(); ++itemNew ) {
00047     const std::string& key = otherAnnotation.key( itemNew );
00048     if ( existingAnnotationItems.find( key ) == existingAnnotationItems.end() ) {
00049       m_annotation->addItem( key, otherAnnotation.value( itemNew ), false );
00050     }
00051   }
00052 
00053   // Copy over the data points
00054   for ( int i = 0; i < dps.size(); ++i ) {
00055     m_dataPoints.push_back( new Anaphe::AIDA_DataPointSet_native::AIDA_DataPoint( m_dimension ) );
00056     const AIDA::IDataPoint* originalPoint = dps.point( i );
00057     AIDA::IDataPoint* copyPoint = m_dataPoints.back();
00058     for ( int j = 0; j < m_dimension; ++j ) {
00059       copyPoint->coordinate( j )->setValue( originalPoint->coordinate( j )->value() );
00060       copyPoint->coordinate( j )->setErrorPlus( originalPoint->coordinate( j )->errorPlus() );
00061       copyPoint->coordinate( j )->setErrorMinus( originalPoint->coordinate( j )->errorMinus() );
00062     } 
00063   }
00064 }
00065 
00066 
00067 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::AIDA_DataPointSet( const AIDA::IDataPointSet& dps,
00068                                                                         AIDA::IAnnotation* annotation ):
00069   m_annotation( annotation ),
00070   m_dimension( dps.dimension() ),
00071   m_upToDate( false ),
00072   m_dataPoints()
00073 {
00074   // Define the annotation items
00075   std::set< std::string > existingAnnotationItems;
00076   m_annotation->addItem( titleKey, dps.title(), true );
00077   existingAnnotationItems.insert( titleKey );
00078   m_annotation->addItem( nameKey, emptyString, true );
00079   existingAnnotationItems.insert( nameKey );
00080   m_annotation->addItem( sizeKey, emptyString, false );
00081   existingAnnotationItems.insert( sizeKey );
00082 
00083   // Copy other annotation items
00084   const AIDA::IAnnotation& otherAnnotation = dps.annotation();
00085   for ( int itemNew = 0; itemNew < otherAnnotation.size(); ++itemNew ) {
00086     const std::string& key = otherAnnotation.key( itemNew );
00087     if ( existingAnnotationItems.find( key ) == existingAnnotationItems.end() ) {
00088       m_annotation->addItem( key, otherAnnotation.value( itemNew ), false );
00089     }
00090   }
00091 
00092   // Copy over the data points
00093   for ( int i = 0; i < dps.size(); ++i ) {
00094     m_dataPoints.push_back( new Anaphe::AIDA_DataPointSet_native::AIDA_DataPoint( m_dimension ) );
00095     const AIDA::IDataPoint* originalPoint = dps.point( i );
00096     AIDA::IDataPoint* copyPoint = m_dataPoints.back();
00097     for ( int j = 0; j < m_dimension; ++j ) {
00098       copyPoint->coordinate( j )->setValue( originalPoint->coordinate( j )->value() );
00099       copyPoint->coordinate( j )->setErrorPlus( originalPoint->coordinate( j )->errorPlus() );
00100       copyPoint->coordinate( j )->setErrorMinus( originalPoint->coordinate( j )->errorMinus() );
00101     } 
00102   }
00103 }
00104 
00105 
00106 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::~AIDA_DataPointSet()
00107 {
00108   delete m_annotation;
00109   for ( unsigned int i = 0; i < m_dataPoints.size(); ++i ) {
00110     delete m_dataPoints[i];
00111   }
00112 }
00113 
00114 
00115 const std::string&
00116 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::name() const
00117 {
00118   return m_annotation->value( nameKey );
00119 }
00120 
00121 
00122 bool
00123 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::isUpToDate() const
00124 {
00125   return m_upToDate;
00126 }
00127 
00128 
00129 void
00130 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::setUpToDate( bool isUpToDate )
00131 {
00132   m_upToDate = isUpToDate;
00133 }
00134 
00135 
00136 bool
00137 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::setName( const std::string& newName )
00138 {
00139   m_annotation->setValue( nameKey, newName );
00140   return true;
00141 }
00142 
00143 
00144 const std::string&
00145 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::userLevelClassType() const
00146 {
00147   return g_userLevelClassType;
00148 }
00149 
00150 
00151 AIDA::IAnnotation&
00152 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::annotation()
00153 {
00154   updateAnnotation();
00155   return *m_annotation;
00156 }
00157 
00158 
00159 const AIDA::IAnnotation&
00160 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::annotation() const
00161 {
00162   updateAnnotation();
00163   return *m_annotation;
00164 }
00165 
00166 
00167 const std::string&
00168 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::title() const
00169 {
00170   return m_annotation->value( titleKey );
00171 }
00172 
00173 
00174 bool
00175 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::setTitle( const std::string & newTitle )
00176 {
00177   m_annotation->setValue( titleKey, newTitle );
00178   return true;
00179 }
00180 
00181 
00182 int
00183 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::dimension() const
00184 {
00185   return m_dimension;
00186 }
00187 
00188 
00189 void
00190 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::clear()
00191 {
00192   for ( unsigned int i = 0; i < m_dataPoints.size(); ++i ) {
00193     delete m_dataPoints[i];
00194   }
00195   m_dataPoints.clear();
00196 }
00197 
00198 
00199 int
00200 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::size() const
00201 {
00202   return static_cast< int >( m_dataPoints.size() );
00203 }
00204 
00205 
00206 AIDA::IDataPoint*
00207 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::point( int index )
00208 {
00209   if ( index < 0 || index >= size() ) return 0;
00210   return m_dataPoints[ index ];
00211 }
00212 
00213 
00214 const AIDA::IDataPoint*
00215 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::point( int index ) const
00216 {
00217   if ( index < 0 || index >= size() ) return 0;
00218   return m_dataPoints[ index ];
00219 }
00220 
00221 
00222 bool
00223 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::addPoint()
00224 {
00225   m_dataPoints.push_back( new Anaphe::AIDA_DataPointSet_native::AIDA_DataPoint( m_dimension ) );
00226   return true;
00227 }
00228 
00229 
00230 bool
00231 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::addPoint(const AIDA::IDataPoint & other)
00232 {
00233   if ( other.dimension() != m_dimension ) return false;
00234   m_dataPoints.push_back( new Anaphe::AIDA_DataPointSet_native::AIDA_DataPoint( other ) );
00235   return true;
00236 }
00237 
00238 
00239 bool
00240 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::removePoint( int index )
00241 {
00242   if ( index < 0 || index >= size() ) return false;
00243   delete m_dataPoints[ index ];
00244   for ( unsigned int i = index + 1; i < m_dataPoints.size(); ++i ) {
00245     m_dataPoints[ i-1 ] = m_dataPoints[i];
00246   }
00247   m_dataPoints.pop_back();
00248   return true;
00249 }
00250 
00251 
00252 double
00253 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::lowerExtent( int coordinate ) const
00254 {
00255   if ( m_dataPoints.size() == 0 ) return 0;
00256   double low = m_dataPoints[0]->coordinate( coordinate )->value() - m_dataPoints[0]->coordinate( coordinate )->errorMinus();
00257   for ( unsigned int i = 1; i < m_dataPoints.size(); ++i ) {
00258     const double currentValue = m_dataPoints[i]->coordinate( coordinate )->value() - m_dataPoints[i]->coordinate( coordinate )->errorMinus();
00259     if ( currentValue < low ) low = currentValue;
00260   }
00261   return low;
00262 }
00263 
00264 
00265 double
00266 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::upperExtent( int coordinate ) const
00267 {
00268   if ( m_dataPoints.size() == 0 ) return 0;
00269   double high = m_dataPoints[0]->coordinate( coordinate )->value() + m_dataPoints[0]->coordinate( coordinate )->errorPlus();
00270   for ( unsigned int i = 1; i < m_dataPoints.size(); ++i ) {
00271     const double currentValue = m_dataPoints[i]->coordinate( coordinate )->value() + m_dataPoints[i]->coordinate( coordinate )->errorPlus();
00272     if ( currentValue > high ) high = currentValue;
00273   }
00274   return high;
00275 }
00276 
00277 
00278 bool
00279 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::scale( double scaleFactor )
00280 {
00281   for ( unsigned int i = 0; i < m_dataPoints.size(); ++i ) {
00282     AIDA::IDataPoint* point = m_dataPoints[i];
00283     for ( int iCoord = 0; iCoord < m_dimension; ++iCoord ) {
00284       AIDA::IMeasurement* measurement = point->coordinate( iCoord );
00285       measurement->setValue( measurement->value() * scaleFactor );
00286       measurement->setErrorPlus( measurement->errorPlus() * scaleFactor );
00287       measurement->setErrorMinus( measurement->errorMinus() * scaleFactor );
00288     }
00289   }
00290   return true;
00291 }
00292 
00293 
00294 bool
00295 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::scaleValues( double scaleFactor )
00296 {
00297   for ( unsigned int i = 0; i < m_dataPoints.size(); ++i ) {
00298     AIDA::IDataPoint* point = m_dataPoints[i];
00299     for ( int iCoord = 0; iCoord < m_dimension; ++iCoord ) {
00300       AIDA::IMeasurement* measurement = point->coordinate( iCoord );
00301       measurement->setValue( measurement->value() * scaleFactor );
00302     }
00303   }
00304   return true;
00305 }
00306 
00307 
00308 bool
00309 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::scaleErrors( double scaleFactor )
00310 {
00311   for ( unsigned int i = 0; i < m_dataPoints.size(); ++i ) {
00312     AIDA::IDataPoint* point = m_dataPoints[i];
00313     for ( int iCoord = 0; iCoord < m_dimension; ++iCoord ) {
00314       AIDA::IMeasurement* measurement = point->coordinate( iCoord );
00315       measurement->setErrorPlus( measurement->errorPlus() * scaleFactor );
00316       measurement->setErrorMinus( measurement->errorMinus() * scaleFactor );
00317     }
00318   }
00319   return true;
00320 }
00321 
00322 
00323 #ifdef OLDSTREAMS
00324 # include <strstream>
00325 # define ostringstream ostrstream
00326 #else
00327 # include <sstream>
00328 #endif
00329 
00330 void
00331 Anaphe::AIDA_DataPointSet_native::AIDA_DataPointSet::updateAnnotation() const
00332 {
00333   std::ostringstream osSize;
00334   osSize << size();
00335 #ifndef BADENDS
00336   osSize << std::ends;
00337 #endif
00338   m_annotation->setValue( sizeKey, osSize.str() );
00339 }

Generated on Tue Feb 18 17:50:27 2003 for AIDA_DataPointSet_native by doxygen1.2.16