EcgCh::EcgCh(QWidget *parent) :
QwtPlot(parent)
{
setMinimumHeight(10);
setMinimumWidth(10);
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->setMajPen(QPen(Qt::white, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(this);
setAxisTitle(QwtPlot::xBottom, "Czas [s]");
setAxisTitle(QwtPlot::yLeft, "Amplituda [mv]");
// picker = new QwtPlotPicker(QwtPlot::xBottom, QwtPlot::yLeft, QwtPlotPicker::CrossRubberBand, QwtPicker::AlwaysOn, canvas());
// picker->setStateMachine(new QwtPickerDragPointMachine());
// picker->setRubberBandPen(QColor(Qt::green));
// picker->setRubberBand(QwtPicker::CrossRubberBand);
// picker->setTrackerPen(QColor(Qt::white));
curve = new QwtPlotCurve("signal");
curve->setYAxis(QwtPlot::yLeft);
curve->attach(this);
peaksCurve = new QwtPlotCurve("signal");
peaksCurve->setYAxis(QwtPlot::yLeft);
peaksCurve->setStyle(QwtPlotCurve::CurveStyle::Dots);
peaksCurve->setPen(QPen(Qt::red, 5));
peaksCurve->attach(this);
samples = new QVector<QPointF>;
data = new QwtPointSeriesData;
peaksSamples = new QVector<QPointF>;
peaksData = new QwtPointSeriesData;
replot();
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QwtPlot plot;
plot.setCanvasBackground(QColor(Qt::white));
plot.setTitle("Bar Chart");
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableX(false);
grid->enableYMin(true);
grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(&plot);
BarChartItem *item = new BarChartItem();
item->attach(&plot);
QList< QPair<int, QString> > barHeights;
barHeights.append(QPair<int, QString>(10, ""));
barHeights.append(QPair<int, QString>(100, ""));
barHeights.append(QPair<int, QString>(20, ""));
item->setData(barHeights);
plot.enableAxis(QwtPlot::xBottom, false);
plot.resize(600, 400);
plot.show();
return app.exec();
}
SimDialog::SimDialog( QWidget * parent, Qt::WFlags f)
: QDialog(parent, f)
{
setupUi(this);
// setup the plot ...
m_plot->setTitle("Comparing Similarity Measures");
m_plot->insertLegend(new QwtLegend(), QwtPlot::BottomLegend);
// set up the axes ...
m_plot->setAxisTitle(QwtPlot::xBottom, "Variations");
m_plot->setAxisScale(QwtPlot::xBottom, -10, 10);
m_plot->setAxisTitle(QwtPlot::yLeft, "Similarity");
m_plot->setAxisScale(QwtPlot::yLeft, -1.5, 1.5);
// enable grid ...
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->enableYMin(true);
grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(m_plot);
// Insert zero line at y = 0
QwtPlotMarker *mY = new QwtPlotMarker();
mY->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
mY->setLineStyle(QwtPlotMarker::HLine);
mY->setYValue(0.0);
mY->attach(m_plot);
// Insert zero line at x = 0
QwtPlotMarker *mX = new QwtPlotMarker();
mX->setLabelAlignment(Qt::AlignRight|Qt::AlignTop);
mX->setLineStyle(QwtPlotMarker::VLine);
mX->setXValue(0.0);
mX->attach(m_plot);
// Insert new curves
cReg = new QwtPlotCurve("Regular Similarity Measure");
cReg->attach(m_plot);
cOct = new QwtPlotCurve("Octree based Similarity Measure");
cOct->attach(m_plot);
// Set curve styles
cReg->setPen(QPen(Qt::red, 2));
cOct->setPen(QPen(Qt::blue, 2));
// Populate the volume combos ...
MainWindow* _win = (MainWindow *)this->parent();
viewer3d * _view = (viewer3d *) _win->getViewer();
QList<Volume*> _vols = _view->getVolumes();
// append Volume names to combo boxes ...
// Need to modify Volume class so that it stored patient name ...
// More importantly modify PatientBrowser so that the data can be directly
// loaded.
}
StPlot::StPlot(QWidget* parent):
QwtPlot(parent),
viewFactor(-1.0)
{
setMinimumHeight(10);
setMinimumWidth(10);
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->setMajPen(QPen(Qt::white, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(this);
setAxisTitle(QwtPlot::xBottom, "Czas [s]");
setAxisTitle(QwtPlot::yLeft, "Amplituda [mv]");
curve = new QwtPlotCurve("Filtered signal");
curve->setYAxis(QwtPlot::yLeft);
curve->attach(this);
ISOPoints = new QwtPlotCurve("ISO");
ISOPoints->setStyle(QwtPlotCurve::NoCurve);
ISOPoints->setSymbol(new QwtSymbol(QwtSymbol::Ellipse,QColor(Qt::green), QColor(Qt::green), QSize(5, 5)));
ISOPoints->setYAxis(QwtPlot::yLeft);
ISOPoints->attach(this);
JPoints = new QwtPlotCurve("J");
JPoints->setStyle(QwtPlotCurve::NoCurve);
JPoints->setSymbol(new QwtSymbol(QwtSymbol::Ellipse,QColor(Qt::blue), QColor(Qt::blue), QSize(5, 5)));
JPoints->setYAxis(QwtPlot::yLeft);
JPoints->attach(this);
STPoints = new QwtPlotCurve("ST");
STPoints->setStyle(QwtPlotCurve::NoCurve);
STPoints->setSymbol(new QwtSymbol(QwtSymbol::Ellipse,QColor(Qt::red), QColor(Qt::red), QSize(5, 5)));
STPoints->setYAxis(QwtPlot::yLeft);
STPoints->attach(this);
RPoints = new QwtPlotCurve("R");
RPoints->setStyle(QwtPlotCurve::NoCurve);
RPoints->setSymbol(new QwtSymbol(QwtSymbol::Ellipse,QColor(Qt::yellow), QColor(Qt::yellow), QSize(5, 5)));
RPoints->setYAxis(QwtPlot::yLeft);
//RPoints->attach(this);
legend = new QwtLegend();
legend->setItemMode(QwtLegend::ReadOnlyItem);
legend->setWhatsThis("Click on an item to show/hide the plot");
this->insertLegend(legend, QwtPlot::RightLegend);
samples = new QVector<QPointF>;
data = new QwtPointSeriesData;
replot();
zoomer = new QwtPlotZoomer(QwtPlot::xBottom, QwtPlot::yLeft, canvas());
zoomer->setMousePattern(QwtEventPattern::MouseSelect1, Qt::NoButton);
zoomer->setMousePattern(QwtEventPattern::MouseSelect2, Qt::NoButton);
zoomer->setMousePattern(QwtEventPattern::MouseSelect3, Qt::NoButton);
zoomer->setMousePattern(QwtEventPattern::MouseSelect4, Qt::NoButton);
zoomer->setMousePattern(QwtEventPattern::MouseSelect5, Qt::NoButton);
zoomer->setMousePattern(QwtEventPattern::MouseSelect6, Qt::NoButton);
}
// Init X axis.
void DataPlot::setGridPlot()
{
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->enableYMin(true);
grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(this);
}
QmitkHistogramWidget::QmitkHistogramWidget(QWidget * parent, bool showreport)
: QDialog(parent)
{
QBoxLayout *layout = new QVBoxLayout(this);
//***histogram***
QGroupBox *hgroupbox = new QGroupBox("", this);
hgroupbox->setMinimumSize(900, 400);
m_Plot = new QwtPlot(hgroupbox);
m_Plot->setCanvasBackground(QColor(Qt::white));
m_Plot->setTitle("Histogram");
QwtText text = m_Plot->titleLabel()->text();
text.setFont(QFont("Helvetica", 12, QFont::Normal));
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->enableYMin(true);
grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(m_Plot);
layout->addWidget(hgroupbox);
layout->setSpacing(20);
if (showreport == true)
{
//***report***
QGroupBox *rgroupbox = new QGroupBox("", this);
rgroupbox->setMinimumSize(900, 400);
QLabel *label = new QLabel("Gray Value Analysis", rgroupbox);
label->setAlignment(Qt::AlignHCenter);
label->setFont(QFont("Helvetica", 14, QFont::Bold));
m_Textedit = new QTextEdit(rgroupbox);
m_Textedit->setFont(QFont("Helvetica", 12, QFont::Normal));
m_Textedit->setReadOnly(true);
layout->addWidget(rgroupbox);
}
m_Picker = new QwtPlotPicker(QwtPlot::xBottom, QwtPlot::yLeft,
QwtPicker::PointSelection,
QwtPlotPicker::NoRubberBand, QwtPicker::AlwaysOn,
m_Plot->canvas());
connect(m_Picker, SIGNAL(selected(const QwtDoublePoint &)),
SLOT(OnSelect(const QwtDoublePoint &)));
}
RTVTPlotWindow::RTVTPlotWindow(QWidget *parent) :
QWidget(parent),
ui(new Ui::RTVTPlotWindow)
{
ui->setupUi(this);
connect(ui->plotChannelListView, SIGNAL(clicked(QModelIndex)), this, SLOT(curveSelected(QModelIndex)));
// Setup curves
numberOfCurves = 10;
startColorIndex = 0;
channelListStringModel = new QStringListModel();
channelListStringModel->setStringList(channelStringList);
ui->plotChannelListView->setModel(channelListStringModel);
// Setup the plot view
ui->plotQwtView->setCanvasBackground(QColor(Qt::darkBlue));
ui->plotQwtView->setTitle("Frequency Response of Amplifier");
ui->plotQwtView->setTitle("Amplitude");
ui->plotQwtView->setAxisTitle(QwtPlot::yLeft,"dBm");
ui->plotQwtView->setAxisTitle(QwtPlot::xBottom,"Frequency (Hz)");
// grid
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->setMajPen(QPen(Qt::white, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(ui->plotQwtView);
ui->plotQwtView->setAxisMaxMajor(QwtPlot::xBottom, 6);
ui->plotQwtView->setAxisMaxMinor(QwtPlot::xBottom, 10);
ui->plotQwtView->setAxisScaleEngine(QwtPlot::xBottom, new QwtLog10ScaleEngine);
//QwtPlotGrid *gridy = new QwtPlotGrid();
//gridy->attach(ui->plotQwtView);
/*QwtLog10ScaleEngine * log10SE = new QwtLog10ScaleEngine();
double x1=0.0, x2=4.3, stepSize=0.1;
log10SE->autoScale(100, x1, x2, stepSize);
QwtLinearScaleEngine * yAxisEngine = new QwtLinearScaleEngine();
double y1=-100.0, y2 = 10.0, yStep = 10.0;
yAxisEngine->autoScale(10, y1, y2, yStep);*/
//ui->plotQwtView->setAxisScaleEngine(QwtPlot::xBottom,log10SE);
//ui->plotQwtView->setAxisScaleEngine(QwtPlot::yLeft,yAxisEngine);
//ui->plotQwtView->setAxis
ui->plotQwtView->replot();
}
MavPlot::MavPlot(QWidget *parent) : QwtPlot(parent), _havePrintColors(false) {
setAutoReplot(false);
setTitle("MAV System Data Plot");
setCanvasBackground(QColor(Qt::darkGray));
// legend
QwtLegend *legend = new QwtLegend;
insertLegend(legend, QwtPlot::BottomLegend);
#if (QWT_VERSION < QWT_VERSION_CHECK(6,1,0))
legend->setItemMode(QwtLegend::ClickableItem);
connect(this, SIGNAL(legendClicked(QwtPlotItem*)), SLOT(legendClicked(QwtPlotItem*)));
#else
legend->setDefaultItemMode(QwtLegendData::Clickable);
connect(legend, SIGNAL(clicked(const QVariant&, int)), SLOT(legendClickedNew(const QVariant&, int)));
#endif
// grid
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
#if (QWT_VERSION < QWT_VERSION_CHECK(6,1,0))
grid->setMajPen(QPen(Qt::gray, 0, Qt::DotLine));
grid->setMinPen(QPen(QColor(0x8, 0x8, 0x8), 0 , Qt::DotLine));
#else
grid->setMajorPen(QPen(Qt::gray, 0, Qt::DotLine));
grid->setMinorPen(QPen(QColor(0x8, 0x8, 0x8), 0 , Qt::DotLine));
#endif
grid->attach(this);
// axes
//enableAxis(QwtPlot::yRight);
setAxisTitle(QwtPlot::xBottom, "time");
setAxisScaleDraw(QwtPlot::xBottom, new HumanReadableTime()); // no need to de-alloc or store, plot does it
// A-B markers
for (int i=0; i<2; i++) {
_user_markers[i].setLineStyle(QwtPlotMarker::VLine);
_user_markers[i].setLabelAlignment(Qt::AlignRight | Qt::AlignBottom);
_user_markers[i].setLinePen(QPen(QColor(255, 140, 0), 0, Qt::SolidLine));
_user_markers_visible[i] = false;
}
_user_markers[0].setLabel(QwtText("A"));
_user_markers[1].setLabel(QwtText("B"));
// data marker
_data_marker.setLineStyle(QwtPlotMarker::VLine);
_data_marker.setLinePen(QPen(QColor(255, 160, 47), 2, Qt::SolidLine));
_data_marker.setLabel(QwtText("data"));
_data_marker.setLabelAlignment(Qt::AlignTop | Qt::AlignRight);
_data_marker_visible = false;
_data_marker.setZ(9999); // higher value -> paint on top of everything else
setAutoReplot(true);
}
int main(int argc, char **argv)
{
QApplication a(argc, argv);
QwtPlot plot;
plot.setCanvasBackground(QColor(Qt::white));
plot.setTitle("Histogram");
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->enableYMin(true);
grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(&plot);
HistogramItem *histogram = new HistogramItem();
histogram->setColor(Qt::darkCyan);
const int numValues = 20;
QwtArray<QwtDoubleInterval> intervals(numValues);
QwtArray<double> values(numValues);
double pos = 0.0;
for ( int i = 0; i < (int)intervals.size(); i++ )
{
const int width = 5 + rand() % 15;
const int value = rand() % 100;
intervals[i] = QwtDoubleInterval(pos, pos + double(width));
values[i] = value;
pos += width;
}
histogram->setData(QwtIntervalData(intervals, values));
histogram->attach(&plot);
plot.setAxisScale(QwtPlot::yLeft, 0.0, 100.0);
plot.setAxisScale(QwtPlot::xBottom, 0.0, pos);
plot.replot();
#if QT_VERSION < 0x040000
a.setMainWidget(&plot);
#endif
plot.resize(600,400);
plot.show();
return a.exec();
}
TempCompCurve::TempCompCurve(QWidget *parent) :
QwtPlot(parent), dataCurve(NULL), fitCurve(NULL)
{
setMouseTracking(true);
setMinimumSize(64, 64);
setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
setCanvasBackground(QColor(64, 64, 64));
//Add grid lines
QwtPlotGrid *grid = new QwtPlotGrid;
grid->setMajPen(QPen(Qt::gray, 0, Qt::DashLine));
grid->setMinPen(QPen(Qt::lightGray, 0, Qt::DotLine));
grid->setPen(QPen(Qt::darkGray, 1, Qt::DotLine));
grid->attach(this);
}
HarmPlot::HarmPlot(const QString& aDir, IRInfo anIi, QWidget *parent) throw (QLE) : QwtPlot(parent)
{
this->setAttribute(Qt::WA_DeleteOnClose);
this->dir = aDir;
this->ii = anIi;
this->data = (HarmData**) new char[sizeof(HarmData*) * (MAX_HARM - 1)];
this->setAutoReplot(false);
this->setCanvasBackground(BG_COLOR);
this->setAxisScale(QwtPlot::yLeft, -120.0, 20.0);
this->setAxisMaxMajor(QwtPlot::yLeft, 7);
this->setAxisMaxMinor(QwtPlot::yLeft, 10);
this->setAxisMaxMajor(QwtPlot::xBottom, 6);
this->setAxisMaxMinor(QwtPlot::xBottom, 10);
#if QWT_VERSION > 0x060000
QwtLogScaleEngine* logEngine = new QwtLogScaleEngine(10.0);
#else
QwtLog10ScaleEngine* logEngine = new QwtLog10ScaleEngine();
#endif
this->setAxisScaleEngine(QwtPlot::xBottom, logEngine);
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
#if QWT_VERSION > 0x060000
grid->setMajorPen(QPen(MAJ_PEN_COLOR, 0, Qt::DotLine));
grid->setMinorPen(QPen(MIN_PEN_COLOR, 0 , Qt::DotLine));
#else
grid->setMajPen(QPen(MAJ_PEN_COLOR, 0, Qt::DotLine));
grid->setMinPen(QPen(MIN_PEN_COLOR, 0 , Qt::DotLine));
#endif
grid->attach(this);
this->addCurves();
QwtPlotPanner* panner = new QwtPlotPanner(this->canvas());
panner->setMouseButton(Qt::MidButton);
panner->setEnabled(true);
this->setAutoReplot(true);
}
PowerBarHistoryPlot::PowerBarHistoryPlot(double defaultTime, double defaultPowerLevel, QWidget* parent)
: QWidget(parent)
, m_overalTime(0.0)
, m_lastSampleTime(0.0)
, m_firstTime(true)
, m_defaultTime(defaultTime)
, m_defaultPowerLevel(defaultPowerLevel)
, m_powerAxisMax(defaultPowerLevel)
, m_powerAxisMin(-1*defaultPowerLevel)
, m_timeAxisMax(defaultTime)
{
m_plot = new QwtPlot();
m_plot->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
m_plot->setAxisScale(QwtPlot::xBottom, 0, defaultTime, defaultTime/20.0);
m_plot->setAxisScale(QwtPlot::yLeft, -1 * defaultPowerLevel, defaultPowerLevel, defaultPowerLevel/2.0);
m_plot->setAxisAutoScale(QwtPlot::xBottom, false);
m_plot->setCanvasBackground(QBrush(Qt::white));
m_plot->setAxisTitle(QwtPlot::xBottom, tr(TIME_AXIS_NAME));
m_plot->setAxisTitle(QwtPlot::yLeft, tr(POWER_AXIS_NAME));
// legend
QwtLegend *legend = new QwtLegend;
legend->setFrameStyle(QFrame::Box|QFrame::Sunken);
m_plot->insertLegend(legend, QwtPlot::BottomLegend);
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableX(false);
grid->enableYMin(true);
grid->setMajPen(QPen(Qt::gray, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::transparent, 0 , Qt::NoPen));
grid->attach(m_plot);
setupCurves();
QHBoxLayout* historyPlotlayout = new QHBoxLayout;
historyPlotlayout->addWidget(m_plot);
historyPlotlayout->setSpacing(0);
setColors(Qt::blue, Qt::red);
setLayout(historyPlotlayout);
}
PlotHRT::PlotHRT(QWidget *parent) :
QwtPlot(parent)
{
setMinimumHeight(10);
setMinimumWidth(10);
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->setMajPen(QPen(Qt::white, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(this);
setAxisTitle(QwtPlot::xBottom, "relative interval number");
setAxisTitle(QwtPlot::yLeft, "RR [ms]");
rr = new QwtPlotCurve("RR");
ts = new QwtPlotCurve("TS");
ts->setPen(QPen(Qt::red, 2));
rr->setYAxis(QwtPlot::yLeft);
ts->setYAxis(QwtPlot::yLeft);
rr->attach(this);
ts->attach(this);
replot();
}
IRPlot::IRPlot(const QString& aDir, IRInfo anIi, QWidget *parent) throw (QLE) : QwtPlot(parent)
{
this->dir = aDir;
this->ii = anIi;
this->time = 0;
this->amps = 0;
this->setAutoReplot(false);
this->setCanvasBackground(BG_COLOR);
unsigned curveLength = this->calculate();
this->setAxisScale( xBottom, this->time[0], this->time[curveLength-1]);
this->setAxisAutoScale( xBottom);
this->setAxisScale( yLeft, -1.5, 1.5);
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
#if QWT_VERSION > 0x060000
grid->setMajorPen(QPen(MAJ_PEN_COLOR, 0, Qt::DotLine));
grid->setMinorPen(QPen(MIN_PEN_COLOR, 0 , Qt::DotLine));
#else
grid->setMajPen(QPen(MAJ_PEN_COLOR, 0, Qt::DotLine));
grid->setMinPen(QPen(MIN_PEN_COLOR, 0 , Qt::DotLine));
#endif
grid->attach(this);
QwtPlotCurve* ampCurve = new QwtPlotCurve("IR_Plot");
ampCurve->setPen(QPen(AMP_CURVE_COLOR));
ampCurve->setYAxis(QwtPlot::yLeft);
ampCurve->attach(this);
ampCurve->setSamples(this->time, this->amps, curveLength);
QwtPlotPanner* panner = new QwtPlotPanner(this->canvas());
panner->setMouseButton(Qt::MidButton);
panner->setEnabled(true);
this->setAutoReplot(true);
}
MainWindow::MainWindow():
PlotMatrix(3, 4)
{
enableAxis(QwtPlot::yLeft);
enableAxis(QwtPlot::yRight);
enableAxis(QwtPlot::xBottom);
for ( int row = 0; row < numRows(); row++ )
{
const double v = qPow(10.0, row);
setAxisScale(QwtPlot::yLeft, row, -v, v);
setAxisScale(QwtPlot::yRight, row, -v, v);
}
for ( int col = 0; col < numColumns(); col++ )
{
const double v = qPow(10.0, col);
setAxisScale(QwtPlot::xBottom, col, -v, v);
setAxisScale(QwtPlot::xTop, col, -v, v);
}
for ( int row = 0; row < numRows(); row++ )
{
for ( int col = 0; col < numColumns(); col++ )
{
QwtPlot *plt = plot(row, col);
plt->setCanvasBackground(QColor(Qt::darkBlue));
QwtPlotGrid *grid = new QwtPlotGrid();
grid->enableXMin(true);
grid->setMajPen(QPen(Qt::white, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(plt);
}
}
}
Plot::Plot( QWidget *parent ):
QwtPlot( parent )
{
setAutoReplot( false );
setTitle( "Frequency Response of a Second-Order System" );
setCanvasBackground( QColor( Qt::darkBlue ) );
// legend
QwtLegend *legend = new QwtLegend;
insertLegend( legend, QwtPlot::BottomLegend );
// grid
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin( true );
grid->setMajPen( QPen( Qt::white, 0, Qt::DotLine ) );
grid->setMinPen( QPen( Qt::gray, 0 , Qt::DotLine ) );
grid->attach( this );
// axes
enableAxis( QwtPlot::yRight );
setAxisTitle( QwtPlot::xBottom, "Normalized Frequency" );
setAxisTitle( QwtPlot::yLeft, "Amplitude [dB]" );
setAxisTitle( QwtPlot::yRight, "Phase [deg]" );
setAxisMaxMajor( QwtPlot::xBottom, 6 );
setAxisMaxMinor( QwtPlot::xBottom, 10 );
setAxisScaleEngine( QwtPlot::xBottom, new QwtLog10ScaleEngine );
// curves
d_curve1 = new QwtPlotCurve( "Amplitude" );
d_curve1->setRenderHint( QwtPlotItem::RenderAntialiased );
d_curve1->setPen( QPen( Qt::yellow ) );
d_curve1->setLegendAttribute( QwtPlotCurve::LegendShowLine );
d_curve1->setYAxis( QwtPlot::yLeft );
d_curve1->attach( this );
d_curve2 = new QwtPlotCurve( "Phase" );
d_curve2->setRenderHint( QwtPlotItem::RenderAntialiased );
d_curve2->setPen( QPen( Qt::cyan ) );
d_curve2->setLegendAttribute( QwtPlotCurve::LegendShowLine );
d_curve2->setYAxis( QwtPlot::yRight );
d_curve2->attach( this );
// marker
d_marker1 = new QwtPlotMarker();
d_marker1->setValue( 0.0, 0.0 );
d_marker1->setLineStyle( QwtPlotMarker::VLine );
d_marker1->setLabelAlignment( Qt::AlignRight | Qt::AlignBottom );
d_marker1->setLinePen( QPen( Qt::green, 0, Qt::DashDotLine ) );
d_marker1->attach( this );
d_marker2 = new QwtPlotMarker();
d_marker2->setLineStyle( QwtPlotMarker::HLine );
d_marker2->setLabelAlignment( Qt::AlignRight | Qt::AlignBottom );
d_marker2->setLinePen( QPen( QColor( 200, 150, 0 ), 0, Qt::DashDotLine ) );
d_marker2->setSymbol( new QwtSymbol( QwtSymbol::Diamond,
QColor( Qt::yellow ), QColor( Qt::green ), QSize( 7, 7 ) ) );
d_marker2->attach( this );
setDamp( 0.0 );
setAutoReplot( true );
}
signalForm::signalForm(dualVector<double>* gidroSignal){
log.open("signalForm.log");
log << "constructor call" << std::endl;
setupUi(this);
signal = gidroSignal;
qwtPlot_signal->setAutoReplot(false);
//plot
qwtPlot_signal->setCanvasBackground(QColor(Qt::darkBlue));
qwtPlot_signal->setTitle("Signal");
qwtPlot_signal->setAxisTitle(QwtPlot::xBottom, "Time points");
qwtPlot_signal->setAxisTitle(QwtPlot::yLeft, "Amplitude");
//legend
QwtLegend *legend = new QwtLegend;
qwtPlot_signal->insertLegend(legend, QwtPlot::BottomLegend);
//grid
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->setMajPen(QPen(Qt::white, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(qwtPlot_signal);
//curve
signalCurve = new QwtPlotCurve("Gidrophone 0 signal");
signalCurve->setPen(QPen(Qt::yellow));
signalCurve->attach(qwtPlot_signal);
//display signal curve
showSignalFromGidrophone(0);
// zoomer
signalZoomer = new ScrollZoomer( /*QwtPlot::xBottom, QwtPlot::yLeft, */
qwtPlot_signal->canvas());
signalZoomer->setRubberBand(QwtPicker::RectRubberBand);
signalZoomer->setRubberBandPen(QColor(Qt::green));
signalZoomer->setTrackerMode(QwtPicker::ActiveOnly);
signalZoomer->setTrackerPen(QColor(Qt::white));
// panner
signalPanner = new QwtPlotPanner(qwtPlot_signal->canvas());
signalPanner->setMouseButton(Qt::MidButton);
// picker
signalPicker = new QwtPlotPicker(QwtPlot::xBottom, QwtPlot::yLeft,
QwtPlotPicker::CrossRubberBand, QwtPicker::AlwaysOn,
qwtPlot_signal->canvas());
signalPicker->setStateMachine(new QwtPickerDragPointMachine());
signalPicker->setRubberBandPen(QColor(Qt::green));
signalPicker->setRubberBand(QwtPicker::CrossRubberBand);
signalPicker->setTrackerPen(QColor(Qt::white));
//setCentralWidget(qwtPlot_signal);
// toolbar
QToolBar *toolBar = new QToolBar(this);
// zoom button
QToolButton *btnZoom = new QToolButton(toolBar);
btnZoom->setText("Zoom");
btnZoom->setIcon(QIcon(zoom_xpm));
btnZoom->setCheckable(true);
btnZoom->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
toolBar->addWidget(btnZoom);
connect(btnZoom, SIGNAL(toggled(bool)), SLOT(enableZoomMode(bool)));
// adjust spinboxes and connect to showSignalFromGidrophone()
spinBox_gidrophonenumber->setMinimum(0);
spinBox_gidrophonenumber->setMaximum(signal->sizex() - 1);
connect(spinBox_gidrophonenumber, SIGNAL( valueChanged(int) ), this, SLOT( showSignalFromGidrophone(int) ) );
enableZoomMode(false);
qwtPlot_signal->setAutoReplot(true);
}
void QwtPlotPrintFilter::reset(QwtPlotItem *item) const
{
if ( d_data->cache == 0 )
return;
const PrivateData::Cache &cache = *d_data->cache;
switch(item->rtti())
{
case QwtPlotItem::Rtti_PlotGrid:
{
QwtPlotGrid *grid = (QwtPlotGrid *)item;
QPen pen = grid->majPen();
pen.setColor(cache.gridColors[0]);
grid->setMajPen(pen);
pen = grid->minPen();
pen.setColor(cache.gridColors[1]);
grid->setMinPen(pen);
break;
}
case QwtPlotItem::Rtti_PlotCurve:
{
QwtPlotCurve *c = (QwtPlotCurve *)item;
QwtSymbol symbol = c->symbol();
if ( cache.curveSymbolPenColors.contains(c) )
{
symbol.setPen(cache.curveSymbolPenColors[c]);
}
if ( cache.curveSymbolBrushColors.contains(c) )
{
QBrush brush = symbol.brush();
brush.setColor(cache.curveSymbolBrushColors[c]);
symbol.setBrush(brush);
}
c->setSymbol(symbol);
if ( cache.curveColors.contains(c) )
{
QPen pen = c->pen();
pen.setColor(cache.curveColors[c]);
c->setPen(pen);
}
break;
}
case QwtPlotItem::Rtti_PlotMarker:
{
QwtPlotMarker *m = (QwtPlotMarker *)item;
if ( cache.markerFonts.contains(m) )
{
QwtText label = m->label();
label.setFont(cache.markerFonts[m]);
m->setLabel(label);
}
if ( cache.markerLabelColors.contains(m) )
{
QwtText label = m->label();
label.setColor(cache.markerLabelColors[m]);
m->setLabel(label);
}
if ( cache.markerLineColors.contains(m) )
{
QPen pen = m->linePen();
pen.setColor(cache.markerLineColors[m]);
m->setLinePen(pen);
}
QwtSymbol symbol = m->symbol();
if ( cache.markerSymbolPenColors.contains(m) )
{
QPen pen = symbol.pen();
pen.setColor(cache.markerSymbolPenColors[m]);
symbol.setPen(pen);
}
if ( cache.markerSymbolBrushColors.contains(m) )
{
QBrush brush = symbol.brush();
brush.setColor(cache.markerSymbolBrushColors[m]);
symbol.setBrush(brush);
}
m->setSymbol(symbol);
break;
}
default:
break;
}
}
void QwtPlotPrintFilter::apply(QwtPlotItem *item) const
{
PrivateData::Cache &cache = *d_data->cache;
switch(item->rtti())
{
case QwtPlotItem::Rtti_PlotGrid:
{
QwtPlotGrid *grid = (QwtPlotGrid *)item;
QPen pen = grid->majPen();
cache.gridColors[0] = pen.color();
pen.setColor(color(pen.color(), MajorGrid));
grid->setMajPen(pen);
pen = grid->minPen();
cache.gridColors[1] = pen.color();
pen.setColor(color(pen.color(), MinorGrid));
grid->setMinPen(pen);
break;
}
case QwtPlotItem::Rtti_PlotCurve:
{
QwtPlotCurve *c = (QwtPlotCurve *)item;
QwtSymbol symbol = c->symbol();
QPen pen = symbol.pen();
cache.curveSymbolPenColors.insert(c, pen.color());
pen.setColor(color(pen.color(), CurveSymbol));
symbol.setPen(pen);
QBrush brush = symbol.brush();
cache.curveSymbolBrushColors.insert(c, brush.color());
brush.setColor(color(brush.color(), CurveSymbol));
symbol.setBrush(brush);
c->setSymbol(symbol);
pen = c->pen();
cache.curveColors.insert(c, pen.color());
pen.setColor(color(pen.color(), Curve));
c->setPen(pen);
break;
}
case QwtPlotItem::Rtti_PlotMarker:
{
QwtPlotMarker *m = (QwtPlotMarker *)item;
QwtText label = m->label();
cache.markerFonts.insert(m, label.font());
label.setFont(font(label.font(), Marker));
cache.markerLabelColors.insert(m, label.color());
label.setColor(color(label.color(), Marker));
m->setLabel(label);
QPen pen = m->linePen();
cache.markerLineColors.insert(m, pen.color());
pen.setColor(color(pen.color(), Marker));
m->setLinePen(pen);
QwtSymbol symbol = m->symbol();
pen = symbol.pen();
cache.markerSymbolPenColors.insert(m, pen.color());
pen.setColor(color(pen.color(), MarkerSymbol));
symbol.setPen(pen);
QBrush brush = symbol.brush();
cache.markerSymbolBrushColors.insert(m, brush.color());
brush.setColor(color(brush.color(), MarkerSymbol));
symbol.setBrush(brush);
m->setSymbol(symbol);
break;
}
default:
break;
}
}
EcgCh::EcgCh(QWidget *parent) :
QwtPlot(parent)
{
setMinimumHeight(10);
setMinimumWidth(10);
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->setMajPen(QPen(Qt::white, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(this);
setAxisTitle(QwtPlot::xBottom, "Czas [mm:ss.ms]");
setAxisTitle(QwtPlot::yLeft, "Amplituda [mV]");
signalCurve = new QwtPlotCurve("signal");
signalCurve->setYAxis(QwtPlot::yLeft);
signalCurve->attach(this);
peaksCurve = new QwtPlotCurve("r-peaks");
peaksCurve->setYAxis(QwtPlot::yLeft);
peaksCurve->setStyle(QwtPlotCurve::NoCurve);
peaksCurve->setSymbol(new QwtSymbol(QwtSymbol::Ellipse,QColor(Qt::red), QColor(Qt::red), QSize(6, 6)));
peaksCurve->setPen(QPen(Qt::red, 5));
peaksCurve->attach(this);
qrsOnSetCurve = new QwtPlotCurve("qrsOnSet");
qrsOnSetCurve->setYAxis(QwtPlot::yLeft);
qrsOnSetCurve->setStyle(QwtPlotCurve::NoCurve);
qrsOnSetCurve->setSymbol(new QwtSymbol(QwtSymbol::Ellipse,QColor(0,255,0), QColor(0,255,0), QSize(6, 6)));
qrsOnSetCurve->attach(this);
qrsEndSetCurve = new QwtPlotCurve("qrsEndSet");
qrsEndSetCurve->setYAxis(QwtPlot::yLeft);
qrsEndSetCurve->setStyle(QwtPlotCurve::NoCurve);
qrsEndSetCurve->setSymbol(new QwtSymbol(QwtSymbol::Ellipse,QColor(0,150,0), QColor(0,150,0), QSize(6, 6)));
qrsEndSetCurve->attach(this);
pOnSetCurve = new QwtPlotCurve("pOnSet");
pOnSetCurve->setYAxis(QwtPlot::yLeft);
pOnSetCurve->setStyle(QwtPlotCurve::NoCurve);
pOnSetCurve->setSymbol(new QwtSymbol(QwtSymbol::Ellipse,QColor(0,0,255), QColor(0,0,255), QSize(6, 6)));
pOnSetCurve->attach(this);
pEndSetCurve = new QwtPlotCurve("pEndSet");
pEndSetCurve->setYAxis(QwtPlot::yLeft);
pEndSetCurve->setStyle(QwtPlotCurve::NoCurve);
pEndSetCurve->setSymbol(new QwtSymbol(QwtSymbol::Ellipse,QColor(0,94,185), QColor(0,94,185), QSize(6, 6)));
pEndSetCurve->attach(this);
tEndSetCurve = new QwtPlotCurve("tEndSet");
tEndSetCurve->setYAxis(QwtPlot::yLeft);
tEndSetCurve->setStyle(QwtPlotCurve::NoCurve);
tEndSetCurve->setSymbol(new QwtSymbol(QwtSymbol::Ellipse,QColor(116,11,11), QColor(116,11,11), QSize(6, 6)));
tEndSetCurve->attach(this);
vCurve = new QwtPlotCurve("V");
vCurve->setYAxis(QwtPlot::yLeft);
vCurve->setStyle(QwtPlotCurve::NoCurve);
vCurve->setSymbol(new QwtSymbol(QwtSymbol::Triangle,QColor(Qt::red), QColor(Qt::red), QSize(6, 6)));
vCurve->attach(this);
vCurve->setVisible(false);
svCurve = new QwtPlotCurve("SV");
svCurve->setYAxis(QwtPlot::yLeft);
svCurve->setStyle(QwtPlotCurve::NoCurve);
svCurve->setSymbol(new QwtSymbol(QwtSymbol::Star1,QColor(Qt::red), QColor(Qt::red), QSize(6, 6)));
svCurve->attach(this);
svCurve->setVisible(false);
setAxisScaleDraw(QwtPlot::xBottom, new TimeScaleDraw(360.0));
replot();
}
//---------------------------------------------------------------------------
JrkPlotDialog::JrkPlotDialog(jrk_variables *indata, jrk_pid_variables *pid_indata, QWidget *parent) :
QDialog(parent),
ui(new Ui::JrkPlotDialog)
{
int i;
ui->setupUi(this);
setLayout(ui->mainLayout);
interval(200);
history(10);
setSamples();
data_ptr = indata;
pid_data_ptr = pid_indata;
timeData = (double *) malloc(SAMPLES * sizeof(double));
reset();
ui->jrkPlot->setAutoReplot(false);
ui->jrkPlot->canvas()->setBorderRadius(0);
ui->jrkPlot->plotLayout()->setAlignCanvasToScales(true);
ui->jrkPlot->setCanvasBackground(Qt::white);
QwtLegend *legend = new QwtLegend;
legend->setItemMode(QwtLegend::CheckableItem);
ui->jrkPlot->insertLegend(legend, QwtPlot::RightLegend);
ui->jrkPlot->setAxisTitle(QwtPlot::xBottom, "Seconds");
ui->jrkPlot->setAxisScale(QwtPlot::xBottom, timeData[0], timeData[SAMPLES - 1]);
// ui->jrkPlot->setAxisLabelRotation( QwtPlot::xBottom, -50.0 );
ui->jrkPlot->setAxisLabelAlignment( QwtPlot::xBottom, Qt::AlignLeft | Qt::AlignBottom );
QwtScaleWidget *scaleWidget = ui->jrkPlot->axisWidget(QwtPlot::xBottom);
i = QFontMetrics(scaleWidget->font()).height();
scaleWidget->setMinBorderDist(0, i / 2);
ui->jrkPlot->setAxisTitle(QwtPlot::yLeft, "%");
ui->jrkPlot->setAxisScale(QwtPlot::yLeft, -100, 100);
// picker, panner, zoomer
plot_picker = new QwtPlotPicker(QwtPlot::xBottom, QwtPlot::yLeft,
QwtPlotPicker::CrossRubberBand, QwtPicker::AlwaysOn,
ui->jrkPlot->canvas());
#if 0
plot_picker->setStateMachine(new QwtPickerDragPointMachine());
plot_picker->setRubberBandPen(QColor(Qt::black));
plot_picker->setRubberBand(QwtPicker::CrossRubberBand );
#endif
plot_picker->setTrackerPen(QColor(Qt::black));
// panning with the left mouse button
plot_panner = new QwtPlotPanner(ui->jrkPlot->canvas());
plot_panner->setUpdatesEnabled(true);
// zoom in/out with the wheel
plot_zoomer = new QwtPlotMagnifier(ui->jrkPlot->canvas());
// grid
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin( true );
grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::black, 0, Qt::DotLine));
grid->attach(ui->jrkPlot);
// curves, scale is in %
createCurve("Input", Qt::gray, false, 4095);
createCurve("Target", Qt::blue, false, 4095);
createCurve("Feedback", Qt::darkBlue, false, 4095);
createCurve("Scaled feedback", Qt::magenta, false, 4095);
createCurve("Error", Qt::red, true, 4095);
createCurve("Integral", Qt::darkGreen, false, 1000);
createCurve("Derivative", Qt::yellow, false, 1000);
createCurve("Duty cycle target", Qt::darkCyan, false, 0600);
createCurve("Duty cycle", Qt::darkRed, false, 0600);
createCurve("Current", Qt::black, true, 0050);
plot_timer = new QTimer(this);
plot_timer->setInterval(INTERVAL);
connect(plot_timer, SIGNAL(timeout()), this, SLOT(onUpdateGraph()));
connect(ui->jrkPlot, SIGNAL(legendChecked(QwtPlotItem *, bool)),
SLOT(showCurve(QwtPlotItem *, bool)));
#if 0
connect(plot_picker, SIGNAL(moved(const QPoint &)),
SLOT(picker_moved(const QPoint &)));
connect(plot_picker, SIGNAL(selected(const QPolygon &)),
SLOT(picker_selected(const QPolygon &)));
#endif
connect(this, SIGNAL(finished(int)), this, SLOT(onFinished(int)));
// plot_timer->start();
}
chooseCyclesForm::chooseCyclesForm(model* mainModelGiven, bool showAlreadyPrecalcedCycles){
// open log file
log.open("chooseCyclesForm.log");
log << "constructor call" << std::endl;
FFTSignal = NULL;
justDeletedMaker = NULL;
// attach ui form
setupUi(this);
mainModel = mainModelGiven;
peakSignal = mainModel->givePeakSignal();
// ask to evaluate peak signal
//askMainModelToEvaluate();
// and take it
//peakSignal = mainModel->givePeakSignal();
// peak signal plot
qwtPlot_peakSignal->setAutoReplot(false);
qwtPlot_peakSignal->setCanvasBackground(QColor(Qt::darkBlue));
qwtPlot_peakSignal->setTitle("peak signal");
qwtPlot_peakSignal->setAxisTitle(QwtPlot::xBottom, "FFT cycles");
qwtPlot_peakSignal->setAxisTitle(QwtPlot::yLeft, "Amplitude");
QwtLegend *legend = new QwtLegend;
qwtPlot_peakSignal->insertLegend(legend, QwtPlot::BottomLegend);
QwtPlotGrid *grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->setMajPen(QPen(Qt::white, 0, Qt::DotLine));
grid->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
grid->attach(qwtPlot_peakSignal);
peakSignalCurve1 = new QwtPlotCurve("Gidrophone 0 peakSignal");
peakSignalCurve1->setPen(QPen(Qt::cyan));
peakSignalCurve1->attach(qwtPlot_peakSignal);
peakSignalCurve2 = new QwtPlotCurve("Gidrophone 0 peakSignal");
peakSignalCurve2->setPen(QPen(Qt::yellow));
peakSignalCurve2->attach(qwtPlot_peakSignal);
showPeakSignal1(0);
showPeakSignal2(0);
qwtPlot_peakSignal->setAutoReplot(true);
// end of peak signal plot
//FFTSignal
qwtPlot_FFTCycle->setAutoReplot(false);
qwtPlot_FFTCycle->setCanvasBackground(QColor(Qt::darkBlue));
qwtPlot_FFTCycle->setTitle("FFT signal");
qwtPlot_FFTCycle->setAxisTitle(QwtPlot::xBottom, "FFT beans");
qwtPlot_FFTCycle->setAxisTitle(QwtPlot::yLeft, "Amplitude");
/*
qwtPlot_FFTCycle->setAxisTitle(QwtPlot::xTop, "FFT beans");
QwtInterval interval = qwtPlot_FFTCycle->axisInterval(QwtPlot::xBottom);
double left = interval.minValue();
double right = interval.maxValue();
qwtPlot_FFTCycle->setAxisScale(QwtPlot::xTop, left, right);
*/
QwtLegend *legendFFTSignal = new QwtLegend;
qwtPlot_FFTCycle->insertLegend(legendFFTSignal, QwtPlot::BottomLegend);
QwtPlotGrid *gridFFTSignal = new QwtPlotGrid;
gridFFTSignal->enableXMin(true);
gridFFTSignal->setMajPen(QPen(Qt::white, 0, Qt::DotLine));
gridFFTSignal->setMinPen(QPen(Qt::gray, 0 , Qt::DotLine));
gridFFTSignal->attach(qwtPlot_FFTCycle);
FFTSignalCurve1 = new QwtPlotCurve("Gidrophone 0 peakSignal");
FFTSignalCurve1->setPen(QPen(Qt::cyan));
FFTSignalCurve1->attach(qwtPlot_FFTCycle);
FFTSignalCurve2 = new QwtPlotCurve("Gidrophone 0 peakSignal");
FFTSignalCurve2->setPen(QPen(Qt::yellow));
FFTSignalCurve2->attach(qwtPlot_FFTCycle);
qwtPlot_FFTCycle->setAutoReplot(true);
// end of FFT signal plot
// zoomer and picker and smth else
// recreare zoomer each time we get new data in the plot
reCreateZoomer();
reCreateZoomer2nd();
// end of zoomer and picker and smth else
// toolbar
QToolBar *toolBar = new QToolBar(this);
// zoom button
btnZoom = new QToolButton(toolBar);
btnZoom->setText("Zoom");
btnZoom->setIcon(QIcon(zoom_xpm));
btnZoom->setCheckable(true);
btnZoom->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
toolBar->addWidget(btnZoom);
connect(btnZoom, SIGNAL(toggled(bool)), SLOT(enableZoomMode(bool)));
// end of zoom button
// zoom button 2nd
toolButton_zoom2nd->setText("Zoom");
toolButton_zoom2nd->setIcon(QIcon(zoom_xpm));
toolButton_zoom2nd->setCheckable(true);
toolButton_zoom2nd->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
connect(toolButton_zoom2nd, SIGNAL(toggled(bool)), SLOT(enableZoomMode2nd(bool)));
// end of zoom button 2nd
// marker
peakSignalMarker = new QwtPlotMarker();
peakSignalMarker->setValue(0.0, 0.0);
peakSignalMarker->setLineStyle(QwtPlotMarker::VLine);
peakSignalMarker->setLabelAlignment(Qt::AlignRight | Qt::AlignBottom);
peakSignalMarker->setLinePen(QPen(Qt::green, 0, Qt::DashDotLine));
peakSignalMarker->attach(qwtPlot_peakSignal);
// end of marker
// marker list
listOfMarkers = new markerList(listWidget_FFTCycles, qwtPlot_peakSignal, peakSignalMarker);
// end of marker list
// spin boxes
spinBox_gidrophone1->setMinimum(0);
spinBox_gidrophone1->setMaximum(peakSignal->sizex() - 1);
spinBox_gidrophone2->setMinimum(0);
spinBox_gidrophone2->setMaximum(peakSignal->sizex() - 1);
connect(spinBox_gidrophone1, SIGNAL( valueChanged(int) ), this, SLOT( showPeakSignal1(int) ) );
connect(spinBox_gidrophone2, SIGNAL( valueChanged(int) ), this, SLOT( showPeakSignal2(int) ) );
// end of spin boxes
// spin boxes 2
spinBox_FFTGidrophone1->setMinimum(0);
spinBox_FFTGidrophone1->setMaximum(0);
spinBox_FFTGidrophone2->setMinimum(0);
spinBox_FFTGidrophone2->setMaximum(0);
connect(spinBox_FFTGidrophone1, SIGNAL( valueChanged(int) ), this, SLOT( showFFTSignal1(int) ) );
connect(spinBox_FFTGidrophone2, SIGNAL( valueChanged(int) ), this, SLOT( showFFTSignal2(int) ) );
// end of spin boxes 2
// evaluate button
// (defined in ui form)
//connect( pushButton_evaluate, SIGNAL( clicked() ), this, SLOT( evaluatePeakSignal() ) );
// end of evaluate button
// signal picker
// (defined in function reCreateZoomer())
connect(peakSignalPicker, SIGNAL(moved(const QPoint &)), this, SLOT(showCurrentMarker(const QPoint &)));
connect(peakSignalPicker, SIGNAL(appended(const QPoint &)), this, SLOT(showCurrentMarker(const QPoint &)));
// end of signal picker
connect(pushButton_addFFTCycle, SIGNAL( clicked() ), listOfMarkers, SLOT( addMarker() ) );
connect(pushButton_removeCycle, SIGNAL( clicked() ), listOfMarkers, SLOT( removeMarker() ) );
connect(pushButton_FFTCycleShiftLeft, SIGNAL( clicked() ), listOfMarkers, SLOT( shiftCurrentMarkerLeft() ) );
connect(pushButton_FFTCycleShiftRight, SIGNAL( clicked() ), listOfMarkers, SLOT( shiftCurrentMarkerRight() ) );
connect(pushButton_calibrate, SIGNAL( clicked() ), this, SLOT( proceedCalibrate() ) );
//connect(listWidget_FFTCycles, SIGNAL( currentItemChanged( QListWidgetItem*, QListWidgetItem* ) ), this, SLOT( chooseCycleItem( QListWidgetItem*, QListWidgetItem* ) ) );
connect(listWidget_FFTCycles, SIGNAL( itemActivated( QListWidgetItem* ) ), listOfMarkers, SLOT( markerSelected( QListWidgetItem* ) ) );
if(showAlreadyPrecalcedCycles){
std::vector<double>* sourceFrequencies = mainModel->giveFrequencies();
std::vector<int>* alreadyPrecalcedCycles = mainModel->giveCycles();
int alreadyPrecalcedCyclesAmount = alreadyPrecalcedCycles->size();
for(int i = 0; i < alreadyPrecalcedCyclesAmount; i++){
listOfMarkers->addPrecalcedMarker((*alreadyPrecalcedCycles)[i], (*sourceFrequencies)[i]);
}
}
}