Ksetiwatch API Documentation
	Overview Class Hierarchy Classes Classes (annotated) Members Source Files Related Pages

loggedsigs.cpp

Go to the documentation of this file.

/***************************************************************************/
#include <qpushbutton.h>
#include <qlistview.h>
#include <qtabwidget.h>
#include <qtextview.h>
#include <qpainter.h>
#include <qlabel.h>

#include <klocale.h>
#include <kapp.h>
#include <kfiledialog.h>
#include <kmessagebox.h>
#include <ksimpleconfig.h>
#include <kiconloader.h>

#include "ksetiwatch.h"
#include "seticontainer.h"
#include "setiloc.h"
#include "loggedsigs.h"
#include "gaussianplot.h"
#include "pulseplot.h"
#include "tripletplot.h"

/*------------------------------------------------------------------------ */
QString SpikeListViewItem::key(int column, bool) const
{
// return value must be static
static QString ret;
QString val;
double tmp;

val = text(column);
tmp = val.toDouble();
val.sprintf("%f", tmp);
ret = val.rightJustify(32, '0');

return(ret);
}

/*------------------------------------------------------------------------ */
LoggedSigs::LoggedSigs(const QString& locName, const QString& wu,
                       QWidget* parent, const char* name)
          : LoggedSigsTmpl(parent, name, false, WDestructiveClose)
{
Ksetiwatch::TableColumn spcols[] =
  {
  {i18n("Power"), -1, AlignRight},
  {i18n("Resolution"), -1, AlignRight},
  {i18n("Signal Ratio"), -1, AlignRight},
  {i18n("RA"), 50, AlignRight},
  {i18n("Dec"), 50, AlignRight},
  {i18n("Frequency"), -1, AlignRight},
  {i18n("Chirp Rate"), -1, AlignRight}
  };

location = Ksetiwatch::getLocation(locName);
wuname   = wu;
setCaption(i18n("Work Unit %1: Logged Signals").arg(wuname));

SpikeListView->setShowSortIndicator(false);
SpikeListView->addColumn( i18n( "Power" ) );
SpikeListView->addColumn( i18n( "Resolution" ) );
SpikeListView->addColumn( i18n( "Signal Ratio" ) );
SpikeListView->addColumn( i18n( "RA" ) );
SpikeListView->addColumn( i18n( "Dec" ) );
SpikeListView->addColumn( i18n( "Frequency" ) );
SpikeListView->addColumn( i18n( "Chirp Rate" ) );

GaussianView->setName(wuname);
GaussianView->showInfoText(false);
PulseView->setName(wuname);
PulseView->showInfoText(false);
TripletView->setName(wuname);
TripletView->showInfoText(false);

// default size
resize(520, 300);

// set the pixmaps of the navigation buttons
FirstGaussianBtn->setPixmap(SmallIcon("start"));
PreviousGaussianBtn->setPixmap(SmallIcon("back"));
NextGaussianBtn->setPixmap(SmallIcon("forward"));
LastGaussianBtn->setPixmap(SmallIcon("finish"));
FirstPulseBtn->setPixmap(SmallIcon("start"));
PreviousPulseBtn->setPixmap(SmallIcon("back"));
NextPulseBtn->setPixmap(SmallIcon("forward"));
LastPulseBtn->setPixmap(SmallIcon("finish"));
FirstTripletBtn->setPixmap(SmallIcon("start"));
PreviousTripletBtn->setPixmap(SmallIcon("back"));
NextTripletBtn->setPixmap(SmallIcon("forward"));
LastTripletBtn->setPixmap(SmallIcon("finish"));

// right-align the columns in the spike list (Qt Designer can't handle
// this (yet))
for(int i=0; i<SpikeListView->columns(); i++)
  {
  if(spcols[i].width != -1)  SpikeListView->setColumnWidth(i, spcols[i].width);
  SpikeListView->setColumnAlignment(i, spcols[i].alignment);
  }

spikeList.setAutoDelete(true);
gaussianList.setAutoDelete(true);
pulseList.setAutoDelete(true);
tripletList.setAutoDelete(true);

readLoggedSigs();
slotFillSpikeTable();
slotShowFirstSignals();
}

/*------------------------------------------------------------------------ */
LoggedSigs::~LoggedSigs()
{
clearLists();
}

/*------------------------------------------------------------------------ */
void LoggedSigs::paintEvent(QPaintEvent* e)
{
SpikeListView->setGridEnabled(globalopts->DrawGrid);
QWidget::paintEvent(e);
}

/*------------------------------------------------------------------------ */
void LoggedSigs::slotShowHelp()
{
kapp->invokeHelp("logsigs_id");
}

/*------------------------------------------------------------------------ */
void LoggedSigs::clearLists()
{
spikeList.clear();
gaussianList.clear();
pulseList.clear();
tripletList.clear();
}

/*------------------------------------------------------------------------ */
bool LoggedSigs::readLoggedSigs()
{
bool status = false;
KSimpleConfig log(location->logDirectory() + "/" + ResultLogFileName, true);
QString sigId[4] = {"spike", "gaussian", "pulse", "triplet"};
enum sigIdNum {SigSpike=0, SigGaussian=1, SigPulse=2, SigTriplet=3};

if(!wuname.isNull() && !wuname.isEmpty())
  {
  log.setGroup(wuname);

  for(int i=0;i<4;i++)
    {
    QString sig, no;
    bool finished = false;
    int k = 1;
    while(!finished)
      {
      no.sprintf("%02d", k);
      sig = log.readEntry(sigId[i]+no);
      if(sig.isNull())
        finished = true;
      else
        {
        switch(i)
          {
          case SigSpike:
            {
            SpikeScore* spsc = new SpikeScore;
            *spsc = SetiLoc::loggedSpikeSignal(sig);
            spikeList.append(spsc);
            break;
            }
          case SigGaussian:
            {
            GaussianScore* gasc = new GaussianScore;
            *gasc = SetiLoc::loggedGaussianSignal(sig);
            gaussianList.append(gasc);
            break;
            }
          case SigPulse:
            {
            PulseScore* pusc = new PulseScore;
            *pusc = SetiLoc::loggedPulseSignal(sig);
            pulseList.append(pusc);
            break;
            }
          case SigTriplet:
            {
            TripletScore* trsc = new TripletScore;
            *trsc = SetiLoc::loggedTripletSignal(sig);
            tripletList.append(trsc);
            break;
            }
          }
        }
      k++;
      }
    }
  status = true;
  }
return(status);
}

/*------------------------------------------------------------------------ */
void LoggedSigs::slotFillSpikeTable()
{
SpikeListView->clear();

for(SpikeScore* sp=spikeList.first(); sp != 0; sp = spikeList.next())
  {
  SpikeListViewItem* it = new SpikeListViewItem(SpikeListView);
  it->setText(0, " " + ((sp->power > 1.0e6) ?
                 QString::number(sp->power, 'e', 6) :
                 QString::number(sp->power, 'f', 3)));
  it->setText(1, QString::number(SliceFrequency/sp->fft_len, 'f', 3));
  double ratio = (sp->power*MaxFFTLen)/(8*sp->fft_len);
  it->setText(2, " " + ((ratio > 1.0e6) ?
                 QString::number(ratio, 'e', 6) :
                 QString::number(ratio, 'f', 3)));
  it->setText(3, QString::number(sp->ra, 'f', 2));
  it->setText(4, QString::number(sp->dec, 'f', 2));
  it->setText(5, " " + QString::number(sp->frequency/1.0e9, 'f', 9));
  it->setText(6, QString::number(sp->chirprate, 'f', 4));
  }
}

/*------------------------------------------------------------------------ */
void LoggedSigs::slotShowFirstSignals()
{
if(gaussianList.count() > 0)
  {
  GaussianView->showNewGaussianData(*gaussianList.first());
  setGaussianText(gaussianList.at());
  }
if(pulseList.count() > 0)
  {
  PulseView->showNewPulseData(*pulseList.first());
  setPulseText(pulseList.at());
  }
if(tripletList.count() > 0)
  {
  TripletView->showNewTripletData(*tripletList.first());
  setTripletText(tripletList.at());
  }
changeGaussianBtnState();
changePulseBtnState();
changeTripletBtnState();
}

/*------------------------------------------------------------------------ */
void LoggedSigs::changeGaussianBtnState()
{
int curSig = gaussianList.at()+1;
int numSig = gaussianList.count();

if(curSig <= 1)
  {
  FirstGaussianBtn->setEnabled(false);
  PreviousGaussianBtn->setEnabled(false);
  }
else
  {
  FirstGaussianBtn->setEnabled(true);
  PreviousGaussianBtn->setEnabled(true);
  }
if(numSig > 1)
  {
  if(curSig == numSig)
    {
    LastGaussianBtn->setEnabled(false);
    NextGaussianBtn->setEnabled(false);
    }
  else
    {
    LastGaussianBtn->setEnabled(true);
    NextGaussianBtn->setEnabled(true);
    }
  }
else
  {
  LastGaussianBtn->setEnabled(false);
  NextGaussianBtn->setEnabled(false);
  }
GaussianLbl->setText(i18n("%1 of %2").arg(curSig).arg(numSig));
}

/*------------------------------------------------------------------------ */
void LoggedSigs::changePulseBtnState()
{
int curSig = pulseList.at()+1;
int numSig = pulseList.count();

if(curSig <= 1)
  {
  FirstPulseBtn->setEnabled(false);
  PreviousPulseBtn->setEnabled(false);
  }
else
  {
  FirstPulseBtn->setEnabled(true);
  PreviousPulseBtn->setEnabled(true);
  }
if(numSig > 1)
  {
  if(curSig == numSig)
    {
    LastPulseBtn->setEnabled(false);
    NextPulseBtn->setEnabled(false);
    }
  else
    {
    LastPulseBtn->setEnabled(true);
    NextPulseBtn->setEnabled(true);
    }
  }
else
  {
  LastPulseBtn->setEnabled(false);
  NextPulseBtn->setEnabled(false);
  }
PulseLbl->setText(i18n("%1 of %2").arg(curSig).arg(numSig));
}

/*------------------------------------------------------------------------ */
void LoggedSigs::changeTripletBtnState()
{
int curSig = tripletList.at()+1;
int numSig = tripletList.count();

if(curSig <= 1)
  {
  FirstTripletBtn->setEnabled(false);
  PreviousTripletBtn->setEnabled(false);
  }
else
  {
  FirstTripletBtn->setEnabled(true);
  PreviousTripletBtn->setEnabled(true);
  }
if(numSig > 1)
  {
  if(curSig == numSig)
    {
    LastTripletBtn->setEnabled(false);
    NextTripletBtn->setEnabled(false);
    }
  else
    {
    LastTripletBtn->setEnabled(true);
    NextTripletBtn->setEnabled(true);
    }
  }
else
  {
  LastTripletBtn->setEnabled(false);
  NextTripletBtn->setEnabled(false);
  }
TripletLbl->setText(i18n("%1 of %2").arg(curSig).arg(numSig));
}

/*------------------------------------------------------------------------ */
void LoggedSigs::slotNextSignal()
{
int tab = SigTabs->currentPageIndex();

switch(tab)
  {
  case 1: // Gaussian
    GaussianView->showNewGaussianData(*gaussianList.next());
    setGaussianText(gaussianList.at());
    changeGaussianBtnState();
    break;
  case 2: // Pulse
    PulseView->showNewPulseData(*pulseList.next());
    setPulseText(pulseList.at());
    changePulseBtnState();
    break;
  case 3: // Triplet
    TripletView->showNewTripletData(*tripletList.next());
    setTripletText(tripletList.at());
    changeTripletBtnState();
    break;
  }
}

/*------------------------------------------------------------------------ */
void LoggedSigs::slotPreviousSignal()
{
int tab = SigTabs->currentPageIndex();

switch(tab)
  {
  case 1: // Gaussian
    GaussianView->showNewGaussianData(*gaussianList.prev());
    setGaussianText(gaussianList.at());
    changeGaussianBtnState();
    break;
  case 2: // Pulse
    PulseView->showNewPulseData(*pulseList.prev());
    setPulseText(pulseList.at());
    changePulseBtnState();
    break;
  case 3: // Triplet
    TripletView->showNewTripletData(*tripletList.prev());
    setTripletText(tripletList.at());
    changeTripletBtnState();
    break;
  }
}

/*------------------------------------------------------------------------ */
void LoggedSigs::slotFirstSignal()
{
int tab = SigTabs->currentPageIndex();

switch(tab)
  {
  case 1: // Gaussian
    GaussianView->showNewGaussianData(*gaussianList.first());
    setGaussianText(gaussianList.at());
    changeGaussianBtnState();
    break;
  case 2: // Pulse
    PulseView->showNewPulseData(*pulseList.first());
    setPulseText(pulseList.at());
    changePulseBtnState();
    break;
  case 3: // Triplet
    TripletView->showNewTripletData(*tripletList.first());
    setTripletText(tripletList.at());
    changeTripletBtnState();
    break;
  }
}

/*------------------------------------------------------------------------ */
void LoggedSigs::slotLastSignal()
{
int tab = SigTabs->currentPageIndex();

switch(tab)
  {
  case 1: // Gaussian
    GaussianView->showNewGaussianData(*gaussianList.last());
    setGaussianText(gaussianList.at());
    changeGaussianBtnState();
    break;
  case 2: // Pulse
    PulseView->showNewPulseData(*pulseList.last());
    setPulseText(pulseList.at());
    changePulseBtnState();
    break;
  case 3: // Triplet
    TripletView->showNewTripletData(*tripletList.last());
    setTripletText(tripletList.at());
    changeTripletBtnState();
    break;
  }
}

/*------------------------------------------------------------------------ */
void LoggedSigs::setGaussianText(int idx)
{
QString txt;
GaussianScore* g = gaussianList.at(idx);

txt = i18n("<b><u>Gaussian Data:</u></b><br>"
           "<table>"
           "<tr><td>Power:</td><td>%1</td></tr>"
           "<tr><td>Mean:</td><td>%2</td></tr>"
           "<tr><td>Sigma:</td><td>%3</td></tr>"
           "<tr><td>Fit:</td><td>%4</td></tr>"
           "<tr><td><b>Score:</b></td><td><b>%5</b></td></tr>"
           "<tr><td>RA:</td><td>%6</td></tr>"
           "<tr><td>Dec:</td><td>%7</td></tr>"
           "<tr><td>Freq:</td><td>%8 GHz</td></tr>"
           "<tr><td>Chirp:</td><td>%9 Hz/s</td></tr>"
           "</table>")
           .arg(g->power)
           .arg(g->true_mean)
           .arg(g->sigma)
           .arg(g->chisq)
           .arg(g->score)
           .arg(SetiContainer::convertRAToString(g->ra))
           .arg(SetiContainer::convertDecToString(g->dec))
           .arg(g->frequency/1.0e9, 0, 'f', 9)
           .arg(g->chirprate, 0, 'f', 4);
GaussianInfo->setText(txt);
}

/*------------------------------------------------------------------------ */
void LoggedSigs::setPulseText(int idx)
{
QString txt;
PulseScore* p = pulseList.at(idx);

txt = i18n("<b><u>Pulse Data:</u></b><br>"
           "<table>"
           "<tr><td>Power:</td><td>%1</td></tr>"
           "<tr><td>Mean:</td><td>%2</td></tr>"
           "<tr><td>Period:</td><td>%3 s</td></tr>"
           "<tr><td><b>Score:</b></td><td><b>%4</b></td></tr>"
           "<tr><td>RA:</td><td>%5</td></tr>"
           "<tr><td>Dec:</td><td>%6</td></tr>"
           "<tr><td>Freq:</td><td>%7 GHz</td></tr>"
           "<tr><td>Chirp:</td><td>%8 Hz/s</td></tr>"
           "</table>")
           .arg(p->power)
           .arg(p->mean)
           .arg(p->period)
           .arg(p->score)
           .arg(SetiContainer::convertRAToString(p->ra))
           .arg(SetiContainer::convertDecToString(p->dec))
           .arg(p->frequency/1.0e9, 0, 'f', 9)
           .arg(p->chirprate, 0, 'f', 4);
PulseInfo->setText(txt);
}

/*------------------------------------------------------------------------ */
void LoggedSigs::setTripletText(int idx)
{
QString txt;
TripletScore* t = tripletList.at(idx);

txt = i18n("<b><u>Triplet Data:</u></b><br>"
           "<table>"
           "<tr><td>Power:</td><td>%1</td></tr>"
           "<tr><td>Mean:</td><td>%2</td></tr>"
           "<tr><td>Period:</td><td>%3 s</td></tr>"
           "<tr><td><b>Score:</b></td><td><b>%4</b></td></tr>"
           "<tr><td>RA:</td><td>%5</td></tr>"
           "<tr><td>Dec:</td><td>%6</td></tr>"
           "<tr><td>Freq:</td><td>%7 GHz</td></tr>"
           "<tr><td>Chirp:</td><td>%8 Hz/s</td></tr>"
           "</table>")
           .arg(t->power)
           .arg(t->mean)
           .arg(t->period)
           .arg(t->score)
           .arg(SetiContainer::convertRAToString(t->ra))
           .arg(SetiContainer::convertDecToString(t->dec))
           .arg(t->frequency/1.0e9, 0, 'f', 9)
           .arg(t->chirprate, 0, 'f', 4);
TripletInfo->setText(txt);
}

/*------------------------------------------------------------------------ */
void LoggedSigs::slotChangeSaveBtnState(QWidget*)
{
int idx = SigTabs->currentPageIndex();

switch(idx)
  {
  case 0: // spikes
    SaveBtn->setEnabled(false);
    break;
  case 1: // gaussians
    if(gaussianList.count() > 0)
      SaveBtn->setEnabled(true);
    else
      SaveBtn->setEnabled(false);
    break;
  case 2: // pulses
    if(pulseList.count() > 0)
      SaveBtn->setEnabled(true);
    else
      SaveBtn->setEnabled(false);
    break;
  case 3: // triplets
    if(tripletList.count() > 0)
      SaveBtn->setEnabled(true);
    else
      SaveBtn->setEnabled(false);
    break;
  }
}

/*------------------------------------------------------------------------ */
void LoggedSigs::slotSave()
{
int idx = SigTabs->currentPageIndex();
QPixmap pm;

switch(idx)
  {
  case 1: // gaussians
    {
    GaussianPlot* gp = new GaussianPlot();
    gp->showNewGaussianData(*gaussianList.current());
    gp->setName(wuName());
    pm = gp->createPixmap();
    gp->close(true);
    break;
    }
  case 2: // pulses
    {
    PulsePlot* pp = new PulsePlot();
    pp->showNewPulseData(*pulseList.current());
    pp->setName(wuName());
    pm = pp->createPixmap();
    pp->close(true);
    break;
    }
  case 3: // triplets
    {
    TripletPlot* tp = new TripletPlot();
    tp->showNewTripletData(*tripletList.current());
    tp->setName(wuName());
    pm = tp->createPixmap();
    tp->close(true);
    break;
    }
  }

QString fn;
fn = KFileDialog::getSaveFileName(location->directory(), "*.png *.PNG");
if(!fn.isEmpty())
    {
    if(strcmp((const char*)fn.right(4),".png") &&
       strcmp((const char*)fn.right(4),".PNG"))
      {
        fn.append(".png");
        }
    if(QFile::exists(fn))
        {
        int ret;
        ret = KMessageBox::warningYesNo(this,
                                        i18n("File already exists. Overwrite?"));
        if(ret == KMessageBox::No) return;  // <----- outta here
        }
    if(pm.save(fn, "PNG") == false)
        {
        KMessageBox::error(this, i18n("Could not save the image. Probably\n"
                                  "you don't have write permission."));
        }
    }
}

#include "loggedsigs.moc"

This file is part of the documentation for Ksetiwatch API Version 2.6.1.

Documentation copyright © 2000-2003 Gordon Machel.
Generated on Fri Jun 6 00:28:14 2003 by doxygen 1.2.18, written by Dimitri van Heesch, © 1997-2002