selectedpixelmodel.cpp

Go to the documentation of this file.
00001 //
00002 // C++ Implementation: selectedpixelmodel
00003 //
00004 // Description: 
00005 //
00006 //
00007 // Author: Nicholas Phillips <Nicholas.G.Phillips@nasa.gov>, (C) 2008
00008 //
00009 // Copyright: See COPYING file that comes with this distribution
00010 //
00011 //
00012 #include <iostream>
00013 #include <math.h>
00014 #include <QFile>
00015 #include <QTextStream>
00016 #include "selectedpixelmodel.h"
00017 #include "skymap.h"
00018 
00019 using namespace std;
00020 
00021 SelectedPixelModel::SelectedPixelModel(QObject *parent)
00022  : QAbstractTableModel(parent)
00023 {
00024         ncols = 0;
00025         nrows = 0;
00026         mode = list;
00027         data4stats = 0;
00028         n = 0;
00029 }
00030 
00031 int SelectedPixelModel::rowCount(const QModelIndex& /*parent*/) const
00032 {
00033         return pixs.size();
00034 }
00035 
00036 int SelectedPixelModel::columnCount(const QModelIndex& /*parent*/) const
00037 {
00038         return ncols;
00039 }
00040 
00041 QVariant SelectedPixelModel::data(const QModelIndex &index, int role) const
00042 {
00043         if( !index.isValid() )
00044                 return QVariant();
00045 
00046         if( role==Qt::TextAlignmentRole ) {
00047                 return int(Qt::AlignRight | Qt::AlignVCenter);
00048         }
00049         else if( role == Qt::DisplayRole ) {
00050                 switch( mode ) {
00051                         //----------------------------------------------------------------------
00052                         case list:
00053                                 if( index.column() == 0 ) {
00054                                         return pixs[index.row()].i;
00055                                 }
00056                                 return (*pixs[index.row()].p)[pidx[index.column()-1]];
00057                                 break;
00058                         //----------------------------------------------------------------------
00059                         case stats:
00060                                 if( index.column() == 0 ) {
00061                                         return statnames[index.row()];
00062                                 }
00063                                 // There are no stats
00064                                 if( n == 0)
00065                                         return QVariant();
00066                                 // No Std Dev for a single data point
00067                                 if( (index.row() == 1) && (n == 1) )
00068                                         return QVariant();
00069                                 return (*pixs[index.row()].p)[pidx[index.column()-1]];
00070                                 break;
00071                         //----------------------------------------------------------------------
00072                         case status:
00073                                 int v = (int)(*pixs[index.row()].p)[pidx[index.column()]];
00074                                 if( ! v )
00075                                         return QVariant();
00076                                 if( index.row() == 0 ) {
00077                                         return v == 1 ? QString("Present") : QString("Not Present");
00078                                 }
00079                                 else {
00080                                         return pidx[index.column()] != 4 ? QString("Loaded") : QString("Computed");
00081                                 }
00082                                 break;
00083                 }
00084         }
00085 
00086         return QVariant();
00087 }
00088 
00089 QVariant SelectedPixelModel::headerData(const int i, Qt::Orientation /*o*/, int role) const
00090 {
00091         if( role==Qt::TextAlignmentRole ) {
00092                 return int(Qt::AlignRight | Qt::AlignVCenter);
00093         }
00094         else if( role == Qt::DisplayRole ) {
00095                 return headers[i];
00096         }
00097         return QVariant();
00098 }
00099 
00100 void SelectedPixelModel::set(Skymap *map)
00101 {
00102         headers.clear();
00103         pidx.clear();
00104         ncols = 1;
00105         headers << "Pixel";
00106         if( map->has_Temperature( ) ) {
00107                 headers << "Temp";
00108                 pidx.push_back(0);
00109                 ncols += 1;
00110         }
00111         if( map->has_Polarization( ) ) {
00112                 headers << "Q Polar" << "U Polar" << "P Polar";
00113                 pidx.push_back(1);
00114                 pidx.push_back(2);
00115                 pidx.push_back(4);
00116                 ncols += 3;
00117         }
00118         if( map->has_Nobs( ) ) {
00119                 headers << "Nobs";
00120                 pidx.push_back(3);
00121                 ncols += 1;
00122         }
00123 
00124         nrows=0;
00125         pixs.clear();
00126 
00127         reset();
00128         return;
00129 }
00130 /*
00131         return:
00132                 true:   if pixel was set
00133                 false:  if pixel was de-selected
00134 */
00135 bool SelectedPixelModel::operator()(int i, BasePixel *pix)
00136 {
00137         for(PixList::iterator pi = pixs.begin();pi != pixs.end(); pi++) {
00138                 if( pi->i == i ) {
00139                         pixs.erase(pi);
00140                         reset();
00141                         return false;
00142                 }
00143         }
00144         SelectedPixel sp(i,pix);
00145         pixs.push_back(sp);
00146         reset();
00147         return true;
00148 }
00149 void SelectedPixelModel::clear()
00150 {
00151         pixs.clear();
00152         reset();
00153 }
00154 
00155 //============================================================================
00156 void SelectedPixelModel::asStats(SelectedPixelModel *data)
00157 {
00158         mode = stats;
00159         data4stats = data;
00160         // Copy Header and indexing info
00161         headers = data4stats->headers;
00162         headers[0] = "Stat";
00163         pidx = data4stats->pidx;
00164         ncols=data4stats->ncols;
00165         statnames << "Mean" << "Std Dev" << "Min" << "Max";
00166         pixs.clear();
00167         TPnobsPixel *dummy;
00168         for(int i = 0; i < 4; i++) {
00169                 dummy = new TPnobsPixel;
00170                 SelectedPixel sp(1,dummy);
00171                 pixs.push_back(sp);
00172         }
00173         nrows = 4;
00174         reset();
00175         //updateStats();
00176 }
00177 
00178 
00179 void SelectedPixelModel::updateStats()
00180 {
00181         if( ! data4stats )
00182                 return;
00183         n = data4stats->pixs.size();
00184         for(uint i = 0; i < pidx.size(); i++) {
00185                 int j = pidx[i];
00186                 (*pixs[2].p)[j] = (*data4stats->pixs[0].p)[j];
00187                 (*pixs[3].p)[j] = (*data4stats->pixs[0].p)[j];
00188                 double ttl = 0;
00189                 double ttlsqr = 0;
00190                 for(uint k = 0; k < (unsigned int) n; k++) {
00191                         double x = (*data4stats->pixs[k].p)[j];
00192                         if( x < (*pixs[2].p)[j]) (*pixs[2].p)[j] = x;
00193                         if( x > (*pixs[3].p)[j]) (*pixs[3].p)[j] = x;
00194                         ttl += x;
00195                         ttlsqr += x*x;
00196                 }
00197                 (*pixs[0].p)[j] = ttl/n;
00198                 if( n > 1 ) 
00199                         (*pixs[1].p)[j] = sqrt(ttlsqr/n - (ttl/n)*(ttl/n));
00200         }
00201         reset();
00202         return;
00203 }
00204 //============================================================================
00205 void SelectedPixelModel::asStatus()
00206 {
00207         if( mode != status ) {
00208                 headers.clear();
00209                 pidx.resize(5);
00210                 headers << "Temperature";
00211                 pidx[0] = 0;
00212                 headers << "Q Polar";
00213                 pidx[1] = 1;
00214                 headers << "U Polar";
00215                 pidx[2] = 2;
00216                 headers << "P Polar";
00217                 pidx[3] = 4;
00218                 headers << "Nobs";
00219                 pidx[4] = 3;
00220                 ncols = headers.size();
00221                 pixs.clear();
00222                 TPnobsPixel *dummy;
00223                 for(int i = 0; i < 2; i++) {
00224                         dummy = new TPnobsPixel;
00225                         SelectedPixel sp(1,dummy);
00226                         pixs.push_back(sp);
00227                 }
00228                 nrows = 2;
00229                 mode = status;
00230         }
00231         for(int i = 0; i < 2; i++) {
00232                 for(int k = 0; k <  ncols; k++)
00233                         (*pixs[i].p)[pidx[k]] = 0;
00234         }
00235         reset();
00236         
00237         return;
00238 }
00239 
00240 void SelectedPixelModel::hasField(Field f, bool b)
00241 {
00242         int i = 0;
00243         switch(f) {
00244                 case I: i = 0;
00245                         break;
00246                 case Q: i = 1;
00247                         break;
00248                 case U: i = 2;
00249                         break;
00250                 case P: i = 3;
00251                         break;
00252                 case Nobs: i = 4;
00253                         break;
00254         }
00255         (*pixs[0].p)[pidx[i]] = b ? 1 : -1;
00256         reset();
00257         return;
00258 }
00259 void SelectedPixelModel::loadField(Field f)
00260 {
00261         int i = 0;
00262         switch(f) {
00263                 case I: i = 0;
00264                         break;
00265                 case Q: i = 1;
00266                         break;
00267                 case U: i = 2;
00268                         break;
00269                 case P: i = 3;
00270                         break;
00271                 case Nobs: i = 4;
00272                         break;
00273         }
00274         (*pixs[1].p)[pidx[i]] = 1;
00275         reset();
00276         return;
00277 }
00278 void SelectedPixelModel::asStats(Skymap *map)
00279 {
00280         set(map);
00281         headers[0] = "Stat";
00282         statnames << "Mean" << "Std Dev" << "Min" << "Max";
00283         
00284         TPnobsPixel *dummy;
00285         for(int i = 0; i < 4; i++) {
00286                 dummy = new TPnobsPixel;
00287                 SelectedPixel sp(1,dummy);
00288                 pixs.push_back(sp);
00289         }
00290         nrows = 4;
00291         n = map->size();
00292         for(uint i = 0; i < pidx.size(); i++) {
00293                 int j = pidx[i];
00294                 (*pixs[2].p)[j] = (*map)[0][j];
00295                 (*pixs[3].p)[j] = (*map)[0][j];
00296                 double ttl = 0;
00297                 double ttlsqr = 0;
00298                 for(uint k = 0; k < (unsigned int) n; k++) {
00299                         double x = (*map)[k][j];
00300                         if( x < (*pixs[2].p)[j]) (*pixs[2].p)[j] = x;
00301                         if( x > (*pixs[3].p)[j]) (*pixs[3].p)[j] = x;
00302                         ttl += x;
00303                         ttlsqr += x*x;
00304                 }
00305                 (*pixs[0].p)[j] = ttl/n;
00306                 if( n > 1 ) 
00307                         (*pixs[1].p)[j] = sqrt(ttlsqr/n - (ttl/n)*(ttl/n));
00308         }
00309         
00310         mode = stats;
00311 
00312         reset();
00313 }
00314 //============================================================================
00315 void SelectedPixelModel::writeListToFile (const QString &dst)
00316 {
00317 /*
00318                 Open and configure the output stream.
00319 */
00320         int i, j, nr = pixs.size(), nc = ncols - 1;
00321         QFile file(dst);
00322         if (! file.open(QIODevice::WriteOnly))
00323         {
00324                 return;
00325         }
00326         QTextStream out(&file);
00327         out.setFieldAlignment(QTextStream::AlignRight);
00328         out.setFieldWidth(18);
00329         out.setRealNumberNotation(QTextStream::ScientificNotation);
00330         out.setRealNumberPrecision(8);
00331 /*
00332                 List...
00333 
00334                         Header.
00335 */
00336         out << "Pixel";
00337         for (i = 1; i < ncols; i++) out << headers[i];
00338         out << endl;
00339 /*
00340                         Pixels.
00341 */
00342         for (j = 0; j < nr; j++)
00343         {
00344                 out << pixs[j].i;
00345                 for (i = 0; i < nc; i++)
00346                 {
00347                         out << (*pixs[j].p)[pidx[i]];
00348                 }
00349                 out << endl;
00350         }
00351 /*
00352                         Done!
00353 */
00354         file.flush(); 
00355 }

Generated on Fri Feb 6 15:32:42 2009 for Skyviewer by  doxygen 1.4.7