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
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
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
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
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
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
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
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 }