void WindPlot::updatePlot() { clearPlottables(); clearItems(); // Return now if plot empty if (mMainWindow->dataSize() == 0) return; double lower = mMainWindow->rangeLower(); double upper = mMainWindow->rangeUpper(); QVector< double > t, x, y; double xMin, xMax; double yMin, yMax; int start = mMainWindow->findIndexBelowT(lower) + 1; int end = mMainWindow->findIndexAboveT(upper); bool first = true; for (int i = start; i < end; ++i) { const DataPoint &dp = mMainWindow->dataPoint(i); t.append(dp.t); if (mMainWindow->units() == PlotValue::Metric) { x.append(dp.velE * MPS_TO_KMH); y.append(dp.velN * MPS_TO_KMH); } else { x.append(dp.velE * MPS_TO_MPH); y.append(dp.velN * MPS_TO_MPH); } if (first) { xMin = xMax = x.back(); yMin = yMax = y.back(); first = false; } else { if (x.back() < xMin) xMin = x.back(); if (x.back() > xMax) xMax = x.back(); if (y.back() < yMin) yMin = y.back(); if (y.back() > yMax) yMax = y.back(); } } QCPCurve *curve = new QCPCurve(xAxis, yAxis); curve->setData(t, x, y); curve->setPen(QPen(Qt::lightGray, mMainWindow->lineThickness())); setViewRange(xMin, xMax, yMin, yMax); if (mMainWindow->markActive()) { const DataPoint &dpEnd = mMainWindow->interpolateDataT(mMainWindow->markEnd()); t.clear(); x.clear(); y.clear(); QVector< double > xMark, yMark; if (mMainWindow->units() == PlotValue::Metric) { xMark.append(dpEnd.velE * MPS_TO_KMH); yMark.append(dpEnd.velN * MPS_TO_KMH); } else { xMark.append(dpEnd.velE * MPS_TO_MPH); yMark.append(dpEnd.velN * MPS_TO_MPH); } QCPGraph *graph = addGraph(); graph->setData(xMark, yMark); graph->setPen(QPen(Qt::black, mMainWindow->lineThickness())); graph->setLineStyle(QCPGraph::lsNone); graph->setScatterStyle(QCPScatterStyle::ssDisc); } updateWind(start, end); QVector< double > xMark, yMark; if (mMainWindow->units() == PlotValue::Metric) { xMark.append(mWindE * MPS_TO_KMH); yMark.append(mWindN * MPS_TO_KMH); } else { xMark.append(mWindE * MPS_TO_MPH); yMark.append(mWindN * MPS_TO_MPH); } QCPGraph *graph = addGraph(); graph->setData(xMark, yMark); graph->setPen(QPen(Qt::red, mMainWindow->lineThickness())); graph->setLineStyle(QCPGraph::lsNone); graph->setScatterStyle(QCPScatterStyle::ssDisc); const double x0 = mWindE; const double y0 = mWindN; const double r = mVelAircraft; QVector< double > tCircle, xCircle, yCircle; for (int i = 0; i <= 100; ++i) { tCircle.append(i); const double x = x0 + r * cos((double) i / 100 * 2 * M_PI); const double y = y0 + r * sin((double) i / 100 * 2 * M_PI); if (mMainWindow->units() == PlotValue::Metric) { xCircle.append(x * MPS_TO_KMH); yCircle.append(y * MPS_TO_KMH); } else { xCircle.append(x * MPS_TO_MPH); yCircle.append(y * MPS_TO_MPH); } } curve = new QCPCurve(xAxis, yAxis); curve->setData(tCircle, xCircle, yCircle); curve->setPen(QPen(Qt::red, mMainWindow->lineThickness())); // Add label to show best fit QCPItemText *textLabel = new QCPItemText(this); const double factor = (mMainWindow->units() == PlotValue::Metric) ? MPS_TO_KMH : MPS_TO_MPH; const QString units = (mMainWindow->units() == PlotValue::Metric) ? "km/h" : "mph"; double direction = atan2(-mWindE, -mWindN) / M_PI * 180.0; if (direction < 0) direction += 360.0; QPainter painter(this); double mmPerPix = (double) painter.device()->widthMM() / painter.device()->width(); double xRatioPerPix = 1.0 / axisRect()->width(); double xRatioPerMM = xRatioPerPix / mmPerPix; double yRatioPerPix = 1.0 / axisRect()->height(); double yRatioPerMM = yRatioPerPix / mmPerPix; textLabel->setPositionAlignment(Qt::AlignBottom|Qt::AlignRight); textLabel->setTextAlignment(Qt::AlignRight); textLabel->position->setType(QCPItemPosition::ptAxisRectRatio); textLabel->position->setCoords(1 - 5 * xRatioPerMM, 1 - 5 * yRatioPerMM); textLabel->setText( QString("Wind speed = %1 %2\nWind direction = %3 deg\nAircraft speed = %4 %5") .arg(sqrt(mWindE * mWindE + mWindN * mWindN) * factor) .arg(units) .arg(direction) .arg(mVelAircraft * factor) .arg(units)); replot(); }
void ScatterWidget::addBaseLine(const PointD &p1, const PointD &p2, string legend) { QCPGraph *graph = NULL; int nG = ui->scatter->graphCount(); for(int j=0; j<nG; j++) { if(ui->scatter->graph(j)->name() == QString::fromStdString(legend)) { graph = ui->scatter->graph(j); break; } } if(!graph) { graph = ui->scatter->addGraph(); // ----------------------- Scatter Configuration --------------------------- graph->setName(QString::fromStdString(legend)); QColor color_ = colorManager.getNewDifferentColor(); graph->setPen(QPen(color_)); } QVector<double> keys, vals; keys << p1.x << p2.x; vals << p1.y << p2.y; graph->setData(keys, vals); }
void OdroidReader::updateCurve(int row, int col) { if (col != 0) return; bool enable = ui->sensors->item(row,col)->checkState() == Qt::Checked; if (enable && graphs.at(row) == nullptr) { if (origcols.count() == 0) { ui->sensors->item(row,col)->setCheckState(Qt::Unchecked); return; } QColor color = origcols.takeFirst(); QCPGraph* graph = ui->globalPlot->addGraph(); DataSeries* series = data[rowMap[row]]; graph->setName(series->descriptor->name()); graph->setProperty("unit",series->descriptor->unit()); graph->setPen(color); graph->setData(series->getTimestamps(), series->getValues()); connect(series,&DataSeries::newValue,[graph,this](double time, double value) { graph->addData(time,value); ui->globalPlot->rescaleAxes(); ui->globalPlot->yAxis->scaleRange(1.2,ui->globalPlot->yAxis->range().center()); ui->globalPlot->replot(); }); graphs[row] = graph; ui->sensors->item(row,col)->setBackgroundColor(color); } else if (!enable && graphs.at(row) != nullptr){ disconnect(data.at(rowMap[row]),SIGNAL(newValue(double,double)),0,0); origcols.push_front(graphs.at(row)->pen().color()); ui->globalPlot->removeGraph(graphs.at(row)); graphs[row] = nullptr; ui->sensors->item(row,col)->setBackgroundColor(Qt::white); }
static void createGraph(QCustomPlot *plot, QVector<double> &steps, QVector<double> &data, const Qt::GlobalColor &color, const Qt::PenStyle &style, const int width) { QCPGraph *graph = plot->addGraph(); QPen pen(color); pen.setStyle(style); pen.setWidth(width); graph->setPen(pen); graph->setData(steps, data); }
void MainWindow::on_listView_clicked(const QModelIndex &index) { //QModelIndex a = ui->listView->selectedIndexes().back(); QVariant selected = dataModel->compNameList->data(index,Qt::DisplayRole); dataModel->dataViewComp = selected.toString(); QVector<double> dataViewPrice = dataModel->priceBuff.value(selected.toString()); QVector<double> xval; QVector<double> baseVal; if(dataViewPrice.empty()) return; double min = dataViewPrice[0]; for(auto &i : dataViewPrice) min = std::fmin(min,i); for(int i = 0; i<dataViewPrice.size(); i++){ xval<<i; baseVal<<min; } QCustomPlot* p = ui->qcpDataView;; p->clearGraphs(); QCPGraph* timeline = new QCPGraph(p->xAxis,p->yAxis); timeline->addData(xval,dataViewPrice); QCPGraph* base = new QCPGraph(p->xAxis,p->yAxis); base->setData(xval,baseVal); p->addPlottable(timeline); p->addPlottable(base); timeline->setChannelFillGraph(base); timeline->setPen(QPen(QColor(0,0,0,0))); timeline->setBrush(QColor(0,0,255,100)); //QVector<double> ticks; QVector<QString> labels; int L = this->dataModel->dateBuff.values()[0].size()-1; int len = 6; float step = (float)L/(float)len; for(int i = 0; i<= len; i++){ labels<<this->dataModel->dateBuff.values()[0][i*step].toString("MM/yy"); } p->xAxis->setTickVectorLabels(labels); p->xAxis->setAutoTicks(true); p->xAxis->setAutoTickLabels(false); p->xAxis->setTickLabelRotation(-60); //p->xAxis->setSubTickCount(0); //p->xAxis->setTickLength(0, len-1); p->xAxis->grid()->setVisible(true); //p->xAxis->setRange(0, len-2); //p->xAxis->setTickVector(ticks); p->rescaleAxes(); p->replot(); }
void Record::createWaveFormPic(Ffmpeg_t *ffmpeg, QString recortPath) { std::pair<std::vector<double>, std::vector<double> > dataWaveForm = ffmpeg->getSamplesForWaveformPlotting(recortPath + "/" + m_Name); QCustomPlot Plotter; Plotter.setBackground(QBrush(Qt::transparent) ); Plotter.xAxis->setVisible(false); Plotter.yAxis->setVisible(false); Plotter.axisRect()->setAutoMargins(QCP::msNone); Plotter.axisRect()->setMargins(QMargins(0, 5, 0, 5)); QCPGraph *Waveform = Plotter.addGraph(); Waveform->setPen(QPen(Qt::green) ); if (!Waveform) { qDebug("addGraph failed\n"); } QVector<double> Amplitudes(QVector<double>::fromStdVector(dataWaveForm.first) ); QVector<double> Time; double CurrentTime = 0; auto TimeSlotCount = Amplitudes.size(); for (int64_t i = 1; i < TimeSlotCount; i++) { Time.append(CurrentTime); CurrentTime += 0.5; } Waveform->setData(Time, Amplitudes); Plotter.xAxis->setRange(0, Time.back() ); Plotter.yAxis->setRange(SHRT_MIN, SHRT_MAX); QByteArray ByteArray; QBuffer Buffer(&ByteArray); Buffer.open(QBuffer::WriteOnly); uint32_t time = m_EndTime - m_StartTime; for (int i = 1; i < 10000; i*=10) { Plotter.toPixmap(time/(i), this->height()).save(&Buffer, "PNG", 0); //Plotter.saveJpg(recortPath + "/plot" + QString::number(m_Id) + QString::number(i) + ".jpg", time/(i), this->height()); QPixmap Pixmap; Pixmap.loadFromData(ByteArray, "PNG"); v_PixWaves.append(Pixmap); ByteArray.clear(); Buffer.reset(); } Buffer.close(); qDebug() << m_WavePic->margin(); // místo 2 podle toho jaký zoom m_WavePic->setPixmap(v_PixWaves[2]); }
void DataExplorer::updateDetails() { //qDebug() << "SELECT!"; ui->runPlot->clearPlottables(); QVector<QString> labels; QVector<double> ticks; int colid = 0; switch (ui->detailType->currentIndex()) { case 0: ui->runPlot->xAxis->setAutoTicks(true); ui->runPlot->xAxis->setAutoTickLabels(true); for (QCPAbstractPlottable *p : ui->selectEnvironment->selectedPlottables()) { int unitid = p->property("UID").toInt(); int envid = p->property("EID").toInt(); DataSeries v = exp->runs.keys().at(envid)->run(unitid,ui->runNo->value(),exp); QCPGraph *g = ui->runPlot->addGraph(); g->setName(v.descriptor->name()+" @ "+exp->runs.keys().at(envid)->label); g->setProperty("Unit",v.descriptor->unit()); g->setPen(origcols[colid++%origcols.size()]); g->setData(v.getTimestamps(),v.getValues()); } break; case 1: for (QCPAbstractPlottable *p : ui->selectEnvironment->selectedPlottables()) { int unitid = p->property("UID").toInt(); int envid = p->property("EID").toInt(); StatisticalSet vals = exp->runs.keys().at(envid)->integral(unitid,exp); QCPStatisticalBox* b = new QCPStatisticalBox(ui->runPlot->xAxis,ui->runPlot->yAxis); b->setData(colid,vals.min(),vals.quantile(0.25),vals.median(),vals.quantile(0.75),vals.max()); b->setProperty("StdDev",vals.getStdDev()); b->setProperty("avg",vals.avg()); b->setProperty("avgTime",vals.avgTime()); qWarning() << exp->data.at(unitid)->descriptor->name() << exp->runs.keys().at(envid)->label << vals.avg() << vals.avgTime() << vals.getStdDev(); ui->runPlot->addPlottable(b); labels.append(QString("%1 @ %2").arg(exp->data.at(unitid)->descriptor->name(),exp->runs.keys().at(envid)->label)); ticks.append(colid++); ui->runPlot->xAxis->setAutoTicks(false); ui->runPlot->xAxis->setAutoTickLabels(false); ui->runPlot->xAxis->setSubTickCount(0); ui->runPlot->xAxis->setTickLength(0, 4); ui->runPlot->xAxis->setTickLabelRotation(90); ui->runPlot->xAxis->setTickVector(ticks); ui->runPlot->xAxis->setTickVectorLabels(labels); } break; case 2: break; } ui->runPlot->rescaleAxes(); if (ui->axisFromZero->isChecked()) ui->runPlot->yAxis->setRangeLower(0); ui->runPlot->replot(); }
void BodeWidget::addBodePlot(BodeData *data, const QString& name){ QCPGraph* dbGraph = dbPlot->addGraph(); QCPGraph* paGraph = paPlot->addGraph(); dbGraph->setData(data->at(0), data->at(1)); paGraph->setData(data->at(0), data->at(2)); dbGraph->setName(name); paGraph->setName(name); dbGraph->setPen(QPen(QColor::fromHsv(hue, 255, 255, 192))); paGraph->setPen(QPen(QColor::fromHsv(hue, 255, 255, 192))); paGraph->setVisible(false); dbGraph->rescaleAxes(); paGraph->rescaleAxes(); hue += 17; hue %= 360; this->paGraphMap[dbGraph] = paGraph; }
void MainWindow::setupItemTracerTest_MyTest_addGrap(QCustomPlot *customPlot, QCPAxisRect* pAxisRect) { QCPGraph *graph = customPlot->addGraph(pAxisRect->axis(QCPAxis::atBottom), pAxisRect->axis(QCPAxis::atLeft)); int n = 200; QVector<double> x(n), y(n); for (int nIndex=0; nIndex<n; ++nIndex) { //x[i] = 0.5+i/(double)n*4; unsigned int nTimeNow = 0; double xValue = 0.5 + nIndex/(double)n*4; nTimeNow = QDateTime::currentDateTime().toTime_t() + nIndex; x[nIndex] = nTimeNow; //y[nIndex] = qSin(x[nIndex])+1.5;// y[nIndex] = qSin(xValue)+1.5;// } graph->setData(x, y); }
void ConvertProfile(TProfile* prof, QCPGraph &graph){ //how we put the profile histogram in Qt. //passing the graph to alter is just easier :) QVector<double> xvals,yvals,xerrs, yerrs; int nbins = prof->GetNbinsX(); //get the values for(int i=0; i<nbins;++i){ xvals.push_back(prof->GetBinCenter(i+1)); yvals.push_back(prof->GetBinContent(i+1)); xerrs.push_back(prof->GetBinWidth(i+1)/2.); yerrs.push_back(prof->GetBinError(i+1)); } graph.setData(xvals, yvals); graph.setDataValueError(xvals, yvals, yerrs);//symmetric errors, only in y. graph.setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssCircle, QPen(Qt::black, 1.5), QBrush(Qt::white), 9)); graph.setPen(QPen(QColor(120, 120, 120), 2)); graph.setLineStyle(QCPGraph::LineStyle::lsNone); return; }
void MainWindow::setupAdaptiveSamplingTest(QCustomPlot *customPlot) { qsrand(1); QCPGraph *g = customPlot->addGraph(); int n = 200000; QVector<double> x, y; x << -6; y << 2; for (int i=0; i<n/2; ++i) { x << i/(double)(n/2-1)*4-5; if (qrand()%(n/25) == 0) y << qrand()/(double)RAND_MAX*7; // generate outliers (must be preserved in adaptive-sampling-algorithm) else y << qCos(qrand()/(double)RAND_MAX*2*M_PI)*qSqrt(-2*qLn(qrand()/(double)RAND_MAX)) + 5*qSin(x[i]); } x << 0.5; y << 2; for (int i=0; i<n/2; ++i) { x << i/(double)(n/2-1)*4+1; if (qrand()%(n/25) == 0) y << qrand()/(double)RAND_MAX*7; // generate outliers (must be preserved in adaptive-sampling-algorithm) else y << qCos(qrand()/(double)RAND_MAX*2*M_PI)*qSqrt(-2*qLn(qrand()/(double)RAND_MAX)) + qSin(5*x[i]); } x << 6; y << -1; g->setData(x, y); //g->setScatterStyle(QCPScatterStyle::ssPlus); //g->setLineStyle(QCPGraph::lsNone); g->setAdaptiveSampling(true); customPlot->setPlottingHint(QCP::phFastPolylines, true); customPlot->rescaleAxes(); customPlot->xAxis->scaleRange(1, customPlot->xAxis->range().center()); customPlot->yAxis->scaleRange(1, customPlot->yAxis->range().center()); }
QCPGraph* tva::postProc::vec2Chart( const postProc::policyChart& policy, const tva::opVecReal& opVx, const tva::vecReal& vy, QCustomPlot *plot ) { if (policy.needClear) { /*int n=*/ plot->clearGraphs(); } size_t size = vy.size(); tva::vecReal vx; // generate data: if (opVx.isSettled()) { vx = opVx.get(); } else { for (size_t i=0; i<size; ++i) { vx.push_back(i);//index } } //const auto& mx = vx_vy.first; //const auto& my = vx_vy.second; QVector<double> x, y; for (size_t i=0; i<size; ++i) { x.push_back(vx[i]);//index y.push_back(vy[i]);//value } // create graph and assign data to it: QCPGraph * graph; if (policy.leftAxis) { graph = plot->addGraph(); } else { graph = plot->addGraph(plot->xAxis, plot->yAxis2); plot->yAxis2->setVisible(true); } //auto * graph = plot->addPlottable(); {//set graph QPen graphPen; if (policy.lStyle.isSettled()) { graph->setLineStyle(policy.lStyle.get().style); graph->setScatterStyle(policy.lStyle.get().scatter); if (policy.lStyle.get().name.isSettled()) { graph->setName(policy.lStyle.get().name.get()); } if (policy.lStyle.get().color.isSettled()) { graphPen.setColor(policy.lStyle.get().color.get()); } else { graphPen.setColor(QColor(rand()%245+10, rand()%245+10, rand()%245+10)); } //graphPen.setWidthF(rand()/(double)RAND_MAX*2+1); } else { tva::chartSetup::lineStyle ls; graph->setLineStyle(ls.style); } graph->setPen(graphPen); } graph->setData(x, y); QCPAxis* xAxis= plot->xAxis; QCPAxis* yAxis;// = plot->yAxis; if (policy.leftAxis) { yAxis = plot->yAxis; } else { yAxis = plot->yAxis2; } if (policy.style.isSettled()) { plot->setTitle(policy.style.get().title); } tva::chartSetup::setupAxisesStyle(policy.style, xAxis, yAxis); // plot->replot(); return graph; }
void ScatterPlotWidget::updatePlot(){ ui->customPlot->clearGraphs();//clearPlottables(); if(selectedTrips == NULL) return; // ExtraField field; switch(attrib1){ case(FARE_AMOUNT): ui->customPlot->xAxis->setLabel(QString::fromStdString("Fare Amount (US$)")); break; case(TIP_AMOUNT): ui->customPlot->xAxis->setLabel(QString::fromStdString("Tip Amount (US$)")); break; case(DURATION): ui->customPlot->xAxis->setLabel(QString::fromStdString("Duration (min)")); break; case(DISTANCE): ui->customPlot->xAxis->setLabel(QString::fromStdString("Distance (mi)")); break; case(TOLL_AMOUNT): ui->customPlot->xAxis->setLabel(QString::fromStdString("Toll Amount (US$)")); break; case(AVG_SPEED): ui->customPlot->xAxis->setLabel(QString::fromStdString("Avg Speed (mi/h)")); break; case(TIME_OF_DAY): ui->customPlot->xAxis->setLabel(QString::fromStdString("Hour of day")); break; case(FIELD1): field = Global::getInstance()->getExtraField(0); ui->customPlot->xAxis->setLabel(field.axisLabel); break; case(FIELD2): field = Global::getInstance()->getExtraField(1); ui->customPlot->xAxis->setLabel(field.axisLabel); break; case(FIELD3): field = Global::getInstance()->getExtraField(2); ui->customPlot->xAxis->setLabel(field.axisLabel); break; case(FIELD4): field = Global::getInstance()->getExtraField(3); ui->customPlot->xAxis->setLabel(field.axisLabel); break; default: assert(false); break; } // switch(attrib2){ case(FARE_AMOUNT): ui->customPlot->yAxis->setLabel(QString::fromStdString("Fare Amount (US$)")); break; case(TIP_AMOUNT): ui->customPlot->yAxis->setLabel(QString::fromStdString("Tip Amount (US$)")); break; case(DURATION): ui->customPlot->yAxis->setLabel(QString::fromStdString("Duration (min)")); break; case(DISTANCE): ui->customPlot->yAxis->setLabel(QString::fromStdString("Distance (mi)")); break; case(TOLL_AMOUNT): ui->customPlot->yAxis->setLabel(QString::fromStdString("Toll Amount (US$)")); break; case(AVG_SPEED): ui->customPlot->yAxis->setLabel(QString::fromStdString("Avg Speed (mi/h)")); break; case(TIME_OF_DAY): ui->customPlot->yAxis->setLabel(QString::fromStdString("Hour of day")); break; case(FIELD1): field = Global::getInstance()->getExtraField(0); ui->customPlot->yAxis->setLabel(field.axisLabel); break; case(FIELD2): field = Global::getInstance()->getExtraField(1); ui->customPlot->yAxis->setLabel(field.axisLabel); break; case(FIELD3): field = Global::getInstance()->getExtraField(2); ui->customPlot->yAxis->setLabel(field.axisLabel); break; case(FIELD4): field = Global::getInstance()->getExtraField(3); ui->customPlot->yAxis->setLabel(field.axisLabel); break; default: assert(false); break; } // bool buildGlobalPlot = (selectionGraph->isEmpty()); set<Group> groups; map<Group,vector<SelectionGraphNode*> > mapGroupToNodes; map<Group,vector<SelectionGraphEdge*> > mapGroupToEdges; set<Group>::iterator groupIterator; selectionGraph->groupNodesAndEdgeByColor(groups,mapGroupToNodes,mapGroupToEdges); map<Group,QCPGraph*> mapGroupGraph; // set<Group> notEmptyGroups; map<Group,vector<SelectionGraphNode*> > tempMapGroupToNodes; if(buildGlobalPlot){ QPen pen; QCPGraph* graph = ui->customPlot->addGraph(); QColor color(0,0,0); mapGroupGraph[Group(color)] = graph; color.setAlphaF(0.05); pen.setColor(color); graph->setPen(pen); graph->setLineStyle(QCPGraph::lsNone); graph->setScatterStyle(QCP::ssDisc); graph->setScatterSize(10); } else{ // for(groupIterator = groups.begin() ; groupIterator != groups.end() ; ++groupIterator){ vector<SelectionGraphNode*> &groupNodes = mapGroupToNodes[*groupIterator]; vector<SelectionGraphNode*> validGroupNodes; int numGroupNodes = groupNodes.size(); for(int i = 0 ; i < numGroupNodes ; ++i){ SelectionGraphNode* node = groupNodes.at(i); if(node->inDegree() + node->outDegree() == 0) validGroupNodes.push_back(node); } vector<SelectionGraphEdge*> &groupEdges = mapGroupToEdges[*groupIterator]; if(groupEdges.size() + validGroupNodes.size() > 0){ notEmptyGroups.insert(*groupIterator); tempMapGroupToNodes[*groupIterator] = validGroupNodes; } } groups.clear(); groups = notEmptyGroups; mapGroupToNodes.clear(); mapGroupToNodes = tempMapGroupToNodes; // for(groupIterator = groups.begin() ; groupIterator != groups.end() ; ++groupIterator){ QPen pen; QCPGraph* graph = ui->customPlot->addGraph(); graph->setLineStyle(QCPGraph::lsNone); graph->setScatterStyle(QCP::ssDisc); graph->setScatterSize(10); Group group = *groupIterator; QColor color = group.getColor(); mapGroupGraph[group] = graph; color.setAlphaF(0.3); pen.setColor(color); graph->setPen(pen); } } //int numberOfTrip = selectedTrips->size(); map<Group,pair<QVector<double>,QVector<double> > > mapGroupData; if(buildGlobalPlot){ int numberOfTrips = selectedTrips->size(); //QVector<double> x(numberOfTrips), y(numberOfTrips); QVector<double> x, y; mapGroupData[QColor(0,0,0)] = make_pair(x,y); } else{ QVector<double> x, y; for(groupIterator = groups.begin() ; groupIterator != groups.end() ; ++groupIterator){ Group group = *groupIterator; mapGroupData[group.getColor()] = make_pair(x,y); } } // add graphs with different scatter styles: KdTrip::TripSet::iterator it = selectedTrips->begin(); for (; it != selectedTrips->end(); ++it) { const KdTrip::Trip * trip = *it; QPointF coords = getCoords(trip); if(buildGlobalPlot){ pair<QVector<double>,QVector<double> > &data = mapGroupData[QColor(0,0,0)]; QVector<double> &x = data.first; QVector<double> &y = data.second; x << coords.x(); y << coords.y(); } else{ for(groupIterator = groups.begin() ; groupIterator != groups.end() ; ++groupIterator){ Group currentGroup = *groupIterator; assert(mapGroupToNodes.count(currentGroup) > 0 && mapGroupToEdges.count(currentGroup) > 0); if(tripSatisfiesConstraints(trip, mapGroupToNodes[currentGroup],mapGroupToEdges[currentGroup])){ pair<QVector<double>,QVector<double> > &data = mapGroupData[currentGroup.getColor()]; QVector<double> &x = data.first; QVector<double> &y = data.second; x << coords.x(); y << coords.y(); continue; // make sure the point is only added once } } } } if(buildGlobalPlot){ pair<QVector<double>,QVector<double> > &data = mapGroupData[QColor(0,0,0)]; QVector<double> &x = data.first; QVector<double> &y = data.second; QCPGraph* graph = mapGroupGraph[QColor(0,0,0)]; graph->setData(x, y); graph->rescaleAxes(true); } else{ for(groupIterator = groups.begin() ; groupIterator != groups.end() ; ++groupIterator){ Group currentGroup = *groupIterator; pair<QVector<double>,QVector<double> > &data = mapGroupData[currentGroup.getColor()]; QVector<double> &x = data.first; QVector<double> &y = data.second; QCPGraph* graph = mapGroupGraph[currentGroup.getColor()]; graph->setData(x, y); graph->rescaleAxes(true); } } // int numGraphs = ui->customPlot->graphCount(); for(int i = 0 ; i < numGraphs ; ++i){ ui->customPlot->graph(i)->rescaleAxes(false,true); } //ui->customPlot->yAxis->scaleRange(1.1, ui->customPlot->yAxis->range().center()); ui->customPlot->setRangeDrag(Qt::Horizontal|Qt::Vertical); ui->customPlot->setRangeZoom(Qt::Horizontal|Qt::Vertical); ui->customPlot->setInteractions(QCustomPlot::iRangeDrag | QCustomPlot::iRangeZoom | QCustomPlot::iSelectAxes | QCustomPlot::iSelectLegend | QCustomPlot::iSelectPlottables | QCustomPlot::iSelectTitle); // ui->customPlot->replot(); }
void Dialog::mkSensorModel() { QCPGraph * gr; QPen pn; double simTime = 60.0; double simStepTime = 0.1; double tempStart = 25.0; double tempCurrent = tempStart; double tempSet = 35.0; double tempDeltaPrev = 0.0; int normalFixDeep = 5; int steps = simTime / simStepTime; QVector<double> xTime(steps), yTemp(steps), yTempSet(steps); QVector<double> normalValues(normalFixDeep); normalValues.fill(0); QVector<double> tempLabels; for (int x=10; x<=50; x+=5) tempLabels.push_back(x); QVector<double> timeLabels; for (int x=0; x<=simTime; x+=5) timeLabels.push_back(x); for (int x=0; x<steps; x++) { // Calc new temp value double tempApply = 0.0; // No change double tempDelta = std::abs(tempCurrent - tempSet); double stepDir = (tempCurrent < tempSet) ? 1.0 : -1.0; if (0.1 < tempDelta) { if (tempDelta > 10) { tempApply = 0.19 * 1.0; } else { tempApply = 0.2 * (1.0 * (tempDelta/10.0) ); } // if (tempApply < 0.01) tempApply = 0.01; // qDebug() << tempApply; tempApply = tempApply * stepDir; // Calc normalzied value double lastSum = 0; for (int x=0; x<normalFixDeep; x++) lastSum += normalValues[x]; tempApply = (lastSum + tempApply) / ((double)normalFixDeep + 1.0); tempDeltaPrev = tempApply; tempCurrent = tempCurrent + tempApply; qDebug() << tempCurrent; } normalValues.push_back(tempApply); normalValues.pop_front(); xTime[x] = (double)x * simStepTime; if (10.0 == xTime[x]) tempSet = 40.0; if (40.0 == xTime[x]) tempSet = 30.0; yTempSet[x] = tempSet; yTemp[x] = tempCurrent; } gr = ui->plot->addGraph(); gr->setData(xTime, yTemp); pn.setColor(Qt::red); pn.setWidth(3); gr->setPen(pn); gr->setName("Реальное значение"); gr = ui->plot->addGraph(); gr->setData(xTime, yTempSet); pn.setColor(0x008080); pn.setWidth(1); pn.setStyle(Qt::DashLine); gr->setPen(pn); gr->setName("Конечное значение"); ui->plot->xAxis->setLabel("Время, сек"); ui->plot->xAxis->setRange(0, simTime); ui->plot->xAxis->setAutoTicks(false); ui->plot->xAxis->setTickVector(timeLabels); ui->plot->yAxis->setLabel("Температура, °C"); ui->plot->yAxis->setRange(20, 50); ui->plot->yAxis->setAutoTicks(false); ui->plot->yAxis->setTickVector(tempLabels); ui->plot->legend->setVisible(true); ui->plot->replot(); ui->plot->savePdf("graph-boiler.pdf", false, 800, 400); }
void Dialog::mkGraph() { QCPGraph * gr; QPen pn; QVector<double> timeLabels, tempLabels, drosselLabels; for (int x=0; x<mdl.simTime; x+=10) timeLabels.push_back(x); for (int x=0; x<=80; x+=5) tempLabels.push_back(x); for (int x=0; x<=120; x+=10) drosselLabels.push_back(x); gr = ui->plot->addGraph(); gr->setData(mdl.xTime, mdl.yTempOutput); pn.setColor(Qt::red); pn.setWidth(3); gr->setPen(pn); gr->setName("Реальное значение, °C"); gr = ui->plot->addGraph(); gr->setData(mdl.xTime, mdl.yTempSet); pn.setColor(0x0000FF); pn.setWidth(2); pn.setStyle(Qt::DotLine); gr->setPen(pn); gr->setName("Конечное значение, °C"); gr = ui->plot->addGraph(); gr->setData(mdl.xTime, mdl.yTempCurrent); pn.setColor(0x808000); pn.setWidth(2); pn.setStyle(Qt::SolidLine); gr->setPen(pn); gr->setName("Желаемая температура, °C"); gr = ui->plot->addGraph(0, ui->plot->yAxis2); gr->setData(mdl.xTime, mdl.yServoPos); pn.setColor(0x006600); pn.setWidth(2); pn.setStyle(Qt::DotLine); gr->setPen(pn); gr->setName("Дроссель, %"); gr = ui->plot->addGraph(0, ui->plot->yAxis2); gr->setData(mdl.xTime, mdl.yPressure); pn.setColor(0x800080); pn.setWidth(2); pn.setStyle(Qt::SolidLine); gr->setPen(pn); gr->setName("Сила нагрева, %"); ui->plot->xAxis->setLabel("Время, сек"); ui->plot->xAxis->setRange(0, mdl.simTime); ui->plot->xAxis->setAutoTicks(false); ui->plot->xAxis->setTickVector(timeLabels); //ui->plot->xAxis->setAutoTickCount(15); ui->plot->xAxis->setSubTickCount(10); ui->plot->yAxis->setLabel("Температура, °C"); ui->plot->yAxis->setRange(20, 80); ui->plot->yAxis->setAutoTicks(false); ui->plot->yAxis->setTickVector(tempLabels); ui->plot->yAxis->setSubTickCount(5); ui->plot->yAxis2->setLabel("Параметры, %"); ui->plot->yAxis2->setRange(0, 150); ui->plot->yAxis2->setVisible(true); ui->plot->yAxis2->setAutoTicks(false); ui->plot->yAxis2->setTickVector(drosselLabels); ui->plot->axisRect()->insetLayout()->setInsetAlignment(0, Qt::AlignLeft|Qt::AlignTop); ui->plot->legend->setVisible(true); mdl.reset(); mdl.tempCurrent = 40; mdl.pressureCoef = 1.0; repaintGraph("ideal"); /* mdl.reset(); mdl.simTime = 180; mdl.tempCurrent = 35; mdl.pressureCoef = 1.2; mdl.paramsChanged.push_back(ParamChange(20.0, 0, 40)); repaintGraph("hotrun"); mdl.reset(); mdl.tempCurrent = 35; mdl.pressureCoef = 1.2; mdl.paramsChanged.push_back(ParamChange(20.0, 0, 30)); repaintGraph("hotrun-low"); // return; mdl.reset(); mdl.tempCurrent = 45; mdl.pressureCoef = 0.5; mdl.paramsChanged.push_back(ParamChange(20.0, 0, 40)); mdl.paramsChanged.push_back(ParamChange(30.0, 1.2, 0)); repaintGraph("plow-hi"); mdl.reset(); mdl.tempCurrent = 45; mdl.pressureCoef = 0.5; mdl.paramsChanged.push_back(ParamChange(30.0, 0.8, 0)); repaintGraph("plow"); mdl.reset(); mdl.tempOutput = 40; mdl.tempCurrent = 30; mdl.paramsChanged.push_back(ParamChange(50.0, 0.8, 0)); repaintGraph("hotstart"); mdl.reset(); mdl.simTime = 180; mdl.tempCurrent = 30; mdl.paramsChanged.push_back(ParamChange(20.0, 0.8, 0)); mdl.paramsChanged.push_back(ParamChange(40.0, 0, 40)); mdl.paramsChanged.push_back(ParamChange(50.0, 0.9, 0)); mdl.paramsChanged.push_back(ParamChange(90.0, 1.1, 0)); mdl.paramsChanged.push_back(ParamChange(130.0, 1.0, 0)); repaintGraph("longrun"); // ui->plot->savePdf("graph-test.pdf", false, 800, 600); // qDebug() << QImageWriter::supportedImageFormats(); */ }
void Dialog::mkSensor() { QCPGraph * gr; QPen pn; int steps = (20) + 1; double stepTemp = 0.47; QVector<double> xLabels; QVector<double> yLabels; QVector<double> xD(steps), yD(steps),yDlin(steps); for (int x=0; x<steps; x++) { //xD[x] = 30.0 + (stepTemp * (double)x) + 0.5 * ((double)(100 - qrand()%200) / 100.0); xD[x] = 30.0 + x; yD[x] = 158 + floor( ((double)x / 0.47) + 1.5 * ((double)(100 - qrand()%200) / 100.0) ); yDlin[x] = 158.0 + ((double)x / 0.47); //if (((int)yD[x])%50 == 0) yLabels.push_back(yD[x]); //if (((int)xD[x])%10 == 0) xLabels.push_back(xD[x]); } for (int x=150; x<=210; x+=10) { yLabels.push_back(x); } for (int x=30; x<=50; x+=1) { xLabels.push_back(x); } qDebug() << yD; qDebug() << xD; gr = ui->plot->addGraph(); gr->setData(xD, yD); pn.setColor(Qt::red); pn.setWidth(3); gr->setPen(pn); gr = ui->plot->addGraph(); gr->setData(xD, yDlin); pn.setColor(0x008080); pn.setWidth(1); pn.setStyle(Qt::DashLine); gr->setPen(pn); ui->plot->xAxis->setLabel("Температура, °C"); ui->plot->xAxis->setRange(30, 50); ui->plot->xAxis->setAutoTicks(false); ui->plot->xAxis->setTickVector(xLabels); ui->plot->yAxis->setLabel("Сигнал АЦП"); ui->plot->yAxis->setRange(145, 215); ui->plot->yAxis->setAutoTicks(false); ui->plot->yAxis->setTickVector(yLabels); ui->plot->replot(); ui->plot->savePdf("graph-sensor.pdf", false, 800, 400); }
void LiftDragPlot::updatePlot() { clearPlottables(); clearItems(); xAxis->setLabel(tr("Drag Coefficient")); yAxis->setLabel(tr("Lift Coefficient")); double lower = mMainWindow->rangeLower(); double upper = mMainWindow->rangeUpper(); QVector< double > t, x, y; double xMin, xMax; double yMin, yMax; int start = mMainWindow->findIndexBelowT(lower) + 1; int end = mMainWindow->findIndexAboveT(upper); double s10 = 0, s01 = 0, s20 = 0, s11 = 0; double s21 = 0, s30 = 0, s40 = 0; bool first = true; for (int i = start; i < end; ++i) { const DataPoint &dp = mMainWindow->dataPoint(i); t.append(dp.t); x.append(dp.drag); y.append(dp.lift); if (first) { xMax = x.back(); yMax = y.back(); first = false; } else { if (x.back() > xMax) xMax = x.back(); if (y.back() > yMax) yMax = y.back(); } s10 += dp.lift; s01 += dp.drag; s20 += dp.lift * dp.lift; s11 += dp.lift * dp.drag; s21 += dp.lift * dp.lift * dp.drag; s30 += dp.lift * dp.lift * dp.lift; s40 += dp.lift * dp.lift * dp.lift * dp.lift; } QCPCurve *curve = new QCPCurve(xAxis, yAxis); curve->setData(t, x, y); curve->setPen(QPen(Qt::lightGray, mMainWindow->lineThickness())); curve->setLineStyle(QCPCurve::lsNone); curve->setScatterStyle(QCPScatterStyle::ssDisc); addPlottable(curve); setViewRange(xMax, yMax); // Update plot limits xMin = xAxis->range().lower; xMax = xAxis->range().upper; yMin = yAxis->range().lower; yMax = yAxis->range().upper; if (mMainWindow->markActive()) { int i1 = mMainWindow->findIndexBelowT(mMainWindow->markEnd()) + 1; int i2 = mMainWindow->findIndexAboveT(mMainWindow->markEnd()) - 1; const DataPoint &dp1 = mMainWindow->dataPoint(i1); const DataPoint &dp2 = mMainWindow->dataPoint(i2); QVector< double > xMark, yMark; if (mMainWindow->markEnd() - dp1.t < dp2.t - mMainWindow->markEnd()) { xMark.append(dp1.drag); yMark.append(dp1.lift); } else { xMark.append(dp2.drag); yMark.append(dp2.lift); } QCPGraph *graph = addGraph(); graph->setData(xMark, yMark); graph->setPen(QPen(Qt::black, mMainWindow->lineThickness())); graph->setLineStyle(QCPGraph::lsNone); graph->setScatterStyle(QCPScatterStyle::ssDisc); } // x = ay^2 + c const double m = 1 / mMainWindow->maxLD(); const double c = mMainWindow->minDrag(); const double a = m * m / (4 * c); // Draw tangent line const double yt = sqrt(c / a); if (a != 0) { x.clear(); y.clear(); x << m * yMin << m * yMax; y << yMin << yMax; QCPGraph *graph = addGraph(); graph->setData(x, y); graph->setPen(QPen(Qt::blue, mMainWindow->lineThickness(), Qt::DashLine)); } // Draw minimum drag x.clear(); y.clear(); x << mMainWindow->minDrag() << mMainWindow->minDrag(); y << yMin << yMax; QCPGraph *graph = addGraph(); graph->setData(x, y); graph->setPen(QPen(Qt::blue, mMainWindow->lineThickness(), Qt::DashLine)); // Draw maximum lift x.clear(); y.clear(); x << xMin << xMax; y << mMainWindow->maxLift() << mMainWindow->maxLift(); graph = addGraph(); graph->setData(x, y); graph->setPen(QPen(Qt::blue, mMainWindow->lineThickness(), Qt::DashLine)); // Draw saved curve t.clear(); x.clear(); y.clear(); for (int i = 0; i <= 100; ++i) { const double yy = yMin + (yMax - yMin) / 100 * i; t.append(yy); x.append(a * yy * yy + c); y.append(yy); } curve = new QCPCurve(xAxis, yAxis); curve->setData(t, x, y); curve->setPen(QPen(Qt::red, mMainWindow->lineThickness())); addPlottable(curve); // Draw dot at maximum L/D x.clear(); y.clear(); x << a * yt * yt + c; y << yt; graph = addGraph(); graph->setData(x, y); graph->setPen(QPen(Qt::red, mMainWindow->lineThickness())); graph->setLineStyle(QCPGraph::lsNone); graph->setScatterStyle(QCPScatterStyle::ssDisc); // Add label to show equation for saved curve QCPItemText *textLabel = new QCPItemText(this); addItem(textLabel); QPainter painter(this); double mmPerPix = (double) painter.device()->widthMM() / painter.device()->width(); double xRatioPerPix = 1.0 / axisRect()->width(); double xRatioPerMM = xRatioPerPix / mmPerPix; double yRatioPerPix = 1.0 / axisRect()->height(); double yRatioPerMM = yRatioPerPix / mmPerPix; textLabel->setPositionAlignment(Qt::AlignBottom|Qt::AlignRight); textLabel->setTextAlignment(Qt::AlignRight); textLabel->position->setType(QCPItemPosition::ptAxisRectRatio); textLabel->position->setCoords(1 - 5 * xRatioPerMM, 1 - 5 * yRatioPerMM); textLabel->setText( QString("Minimum drag = %1\nMaximum lift = %2\nMaximum L/D = %3") .arg(fabs(c)) .arg(mMainWindow->maxLift()) .arg(1/ m)); replot(); }
void MainWindow::setupItemTracerTest(QCustomPlot *customPlot) { QCPItemTracer *tracer1 = new QCPItemTracer(customPlot); customPlot->addItem(tracer1); tracer1->position->setCoords(1, 3); tracer1->setStyle(QCPItemTracer::tsCircle); tracer1->setSize(20); QCPItemTracer *tracer2 = new QCPItemTracer(customPlot); customPlot->addItem(tracer2); tracer2->position->setCoords(2, 2.5); tracer2->setStyle(QCPItemTracer::tsCrosshair); QCPItemTracer *tracer3 = new QCPItemTracer(customPlot); customPlot->addItem(tracer3); tracer3->position->setCoords(3, 2); tracer3->setStyle(QCPItemTracer::tsPlus); tracer3->setSize(20); QCPItemTracer *tracer4 = new QCPItemTracer(customPlot); customPlot->addItem(tracer4); tracer4->position->setCoords(4, 1.5); tracer4->setStyle(QCPItemTracer::tsSquare); tracer4->setSize(20); QCPGraph *graph = customPlot->addGraph(); int n = 20; QVector<double> x(n), y(n); for (int i=0; i<n; ++i) { x[i] = 0.5+i/(double)n*4; y[i] = qSin(x[i])+1.5; } graph->setData(x, y); QCPItemTracer *graphTracer = new QCPItemTracer(customPlot); customPlot->addItem(graphTracer); graphTracer->setGraph(graph); graphTracer->setGraphKey(2.3); graphTracer->setStyle(QCPItemTracer::tsNone); graphTracer->setInterpolating(true); tracerTestTracer = graphTracer; connect(customPlot, SIGNAL(mouseMove(QMouseEvent*)), this, SLOT(tracerTestMouseMove(QMouseEvent*))); graphTracer->setStyle(QCPItemTracer::tsSquare); QCPItemText *text = new QCPItemText(customPlot); customPlot->addItem(text); text->setText("Tracer"); text->setPositionAlignment(Qt::AlignBottom|Qt::AlignHCenter); text->position->setType(QCPItemPosition::ptAxisRectRatio); text->position->setCoords(0.5, 0.05); text->setPen(QPen()); QCPItemCurve *curve = new QCPItemCurve(customPlot); customPlot->addItem(curve); curve->start->setParentAnchor(text->bottom); curve->startDir->setParentAnchor(curve->start); curve->startDir->setCoords(0, 100); curve->end->setParentAnchor(tracerTestTracer->position); curve->end->setCoords(0, -5); curve->endDir->setParentAnchor(curve->end); curve->endDir->setCoords(0, -100); curve->setHead(QCPLineEnding::esSpikeArrow); }
void MainWindow::setupExportTest(QCustomPlot *customPlot) { QDir dir("./"); dir.mkdir("export-test"); dir.cd("export-test"); // test cosmetic/non-cosmetic pen and scaling of export functions: int n = 10; for (int penWidth=0; penWidth<5; ++penWidth) { QVector<double> x(n), y(n); for (int i=0; i<n; ++i) { x[i] = i; y[i] = qSin(i/2.0)+penWidth; } customPlot->addGraph(); customPlot->graph()->setData(x, y); customPlot->graph()->setPen(QPen(Qt::blue, penWidth)); } customPlot->rescaleAxes(); qDebug() << customPlot->savePdf(dir.filePath("exportTest_cosmetic.pdf"), false, 500, 400); qDebug() << customPlot->savePdf(dir.filePath("exportTest_noncosmetic.pdf"), true, 500, 400); qDebug() << customPlot->savePng(dir.filePath("exportTest_1x.png"), 500, 400); qDebug() << customPlot->savePng(dir.filePath("exportTest_2x.png"), 500, 400, 2); qDebug() << customPlot->saveJpg(dir.filePath("exportTest_1x.jpg"), 500, 400); qDebug() << customPlot->saveJpg(dir.filePath("exportTest_2x.jpg"), 500, 400, 2); customPlot->clearPlottables(); // test floating-point precision of vectorized (pdf) export: QCPGraph *graph = customPlot->addGraph(); QVector<double> x, y; for (int i=1; i<100; ++i) { x << 1.0 - 1.0/(double)i; y << i; } x << 0.3 << 0.6; // point that should perfectly match grid y << 15 << 45; // point that should perfectly match grid graph->setData(x, y); graph->setLineStyle(QCPGraph::lsNone); graph->setScatterStyle(QCPScatterStyle::ssPlus); customPlot->xAxis->setRange(0, 1.1); customPlot->yAxis->setRange(0, 101); //customPlot->setAntialiasedElements(QCP::aeAll); qDebug() << customPlot->savePng(dir.filePath("float-precision-raster0.2x.png"), 500, 400, 0.2); qDebug() << customPlot->savePng(dir.filePath("float-precision-raster1x.png"), 500, 400); qDebug() << customPlot->savePng(dir.filePath("float-precision-raster5x.png"), 500, 400, 5); qDebug() << customPlot->savePdf(dir.filePath("float-precision-vector.pdf"), false, 500, 400); customPlot->clearPlottables(); // test transparent/colored background: customPlot->addGraph(); x.clear(); y.clear(); for (int i=0; i<100; ++i) { x << i; y << qSin(i/20.0); } customPlot->graph()->setData(x, y); customPlot->rescaleAxes(); customPlot->setBackground(Qt::transparent); qDebug() << customPlot->savePng(dir.filePath("exportTest_bg_transparent.png"), 500, 400); qDebug() << customPlot->savePdf(dir.filePath("exportTest_bg_transparent.pdf"), true, 500, 400); customPlot->setBackground(QColor(100, 100, 155)); qDebug() << customPlot->savePng(dir.filePath("exportTest_bg_color.png"), 500, 400); qDebug() << customPlot->savePdf(dir.filePath("exportTest_bg_color.pdf"), true, 500, 400); customPlot->clearPlottables(); QTimer::singleShot(100, qApp, SLOT(quit())); }
void Widget::on_pushButtonLagra_clicked() { ui->widget->clearGraphs(); // Graphf* gf = new Graphf(); gf->setStartX(ui->lineEditLagraStart->text().toDouble()); gf->setFinishX(ui->lineEditLagraFinish->text().toDouble()); gf->setPointsCount((gf->finishX - gf->startX) * 10 + 1); gf->setStepY((gf->finishX - gf->startX) / (gf->points_count - 1)); gf->calcf(); QCPGraph *graph = ui->widget->addGraph(); graph->setData(gf->fX, gf->fY); graph->setPen(QPen(Qt::red, 1)); graph->setName("f(x)"); // // Lagra* l = new Lagra(ui->lineEditLagraPointsCount->text().toInt() + 1); l->calcF(gf); graph = ui->widget->addGraph(); graph->setData(gf->fX, l->result); graph->setPen(QPen(Qt::blue, 1)); graph->setName("L(x)"); // // QVector<double> Rt(gf->points_count); for (int i = 0; i < Rt.size(); i++) Rt[i] = qFabs(gf->fY[i] - l->result[i]); qDebug() << Rt; graph = ui->widget->addGraph(); graph->setData(gf->fX, Rt); graph->setPen(QPen(Qt::black, 1)); graph->setName("R(x)"); // // LagraRp* lrp = NULL; int unit_points = l->lX.size(); if (unit_points - 1 == 5) { lrp = new LagraRp(); lrp->calcRp(gf, l); graph = ui->widget->addGraph(); graph->setData(gf->fX, lrp->result); graph->setPen(QPen(Qt::green, 1)); graph->setName("Теоретическая погрешность"); } // ui->widget->xAxis->setRange(gf->startX, gf->finishX); ui->widget->yAxis->setRange(0, 10); ui->widget->replot(); /* Рисуем */ if (lrp != NULL) delete lrp; delete l; delete gf; }
void MainWindow::setupItemTracerTest_MyTest_1(QCustomPlot *customPlot) { QCPAxisRect* pAxisRectTop = NULL; QCPAxisRect* pAxisRectBottom = NULL; QCPLayoutGrid *pLayoutGrid = NULL; QCPMarginGroup *pMarginGroup = NULL; QCPItemTracerCrossHair *pTracerTop = NULL; QCPItemTracerCrossHair *pTracerBottom = NULL; customPlot->clearGraphs(); customPlot->plotLayout()->clear(); // clear default axis rect so we can start from scratch pAxisRectTop = new QCPAxisRect(customPlot); pAxisRectTop->setupFullAxesBox(true); //pAxisRectTop->axis(QCPAxis::atLeft)->setLabel(QObject::tr("Y-value")); //pAxisRectTop->axis(QCPAxis::atBottom)->setLabel(QObject::tr("X-time")); //pAxisRectTop->axis(QCPAxis::atBottom)->setTickLabelType(QCPAxis::ltDateTime); //pAxisRectTop->axis(QCPAxis::atBottom)->setDateTimeFormat("yyyy-MM-dd hh-mm-ss");//DEF_STRING_FORMAT_TIME pAxisRectBottom = new QCPAxisRect(customPlot); pAxisRectBottom->setupFullAxesBox(true); //pAxisRectBottom->axis(QCPAxis::atLeft)->setLabel(QObject::tr("Y-value")); //pAxisRectBottom->axis(QCPAxis::atBottom)->setLabel(QObject::tr("X-time")); //pAxisRectBottom->axis(QCPAxis::atBottom)->setTickLabelType(QCPAxis::ltDateTime); //pAxisRectBottom->axis(QCPAxis::atBottom)->setDateTimeFormat("yyyy-MM-dd hh-mm-ss");//DEF_STRING_FORMAT_TIME customPlot->plotLayout()->addElement(0, 0, pAxisRectTop); // insert axis rect in first row customPlot->plotLayout()->addElement(1, 0, pAxisRectBottom); // insert axis rect in first row pLayoutGrid = customPlot->plotLayout(); pMarginGroup = new QCPMarginGroup(customPlot); pLayoutGrid->element(0, 0)->setMarginGroup(QCP::msAll, pMarginGroup); pLayoutGrid->element(1, 0)->setMarginGroup(QCP::msAll, pMarginGroup); QCPGraph *graph = customPlot->addGraph(pAxisRectTop->axis(QCPAxis::atBottom), pAxisRectTop->axis(QCPAxis::atLeft)); int n = 200; QVector<double> x(n), y(n); for (int i=0; i<n; ++i) { x[i] = 0.5+i/(double)n*4; y[i] = qSin(x[i])+1.5; } graph->setData(x, y); pTracerTop = NULL; pTracerTop = new QCPItemTracerCrossHair(customPlot); customPlot->addItem(pTracerTop); pTracerTop->setTracerAxisRect(pAxisRectTop); pTracerTop->setStyle(QCPItemTracerCrossHair::tsCrosshair); m_pQCPItemTracerCrossHairTop = pTracerTop; pTracerBottom = NULL; pTracerBottom = new QCPItemTracerCrossHair(customPlot); customPlot->addItem(pTracerBottom); pTracerBottom->setTracerAxisRect(pAxisRectBottom); pTracerBottom->setStyle(QCPItemTracerCrossHair::tsCrosshair); m_pQCPItemTracerCrossHairBottom = pTracerBottom; connect(customPlot, SIGNAL(mouseMove(QMouseEvent*)), this, SLOT(QCPItemTracerCrossHairMouseMove(QMouseEvent*))); customPlot->rescaleAxes(); customPlot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom); customPlot->replot();//draw again }
void FlareScoring::prepareDataPlot( DataPlot *plot) { // Return now if plot empty if (mMainWindow->dataSize() == 0) return; DataPoint dpBottom, dpTop; bool success; switch (mMainWindow->windowMode()) { case MainWindow::Actual: success = getWindowBounds(mMainWindow->data(), dpBottom, dpTop); break; case MainWindow::Optimal: success = getWindowBounds(mMainWindow->optimal(), dpBottom, dpTop); break; } // Add shading for scoring window if (success && plot->yValue(DataPlot::Elevation)->visible()) { DataPoint dpLower = mMainWindow->interpolateDataT(mMainWindow->rangeLower()); DataPoint dpUpper = mMainWindow->interpolateDataT(mMainWindow->rangeUpper()); const double xMin = plot->xValue()->value(dpLower, mMainWindow->units()); const double xMax = plot->xValue()->value(dpUpper, mMainWindow->units()); QVector< double > xElev, yElev; xElev << xMin << xMax; yElev << plot->yValue(DataPlot::Elevation)->value(dpBottom, mMainWindow->units()) << plot->yValue(DataPlot::Elevation)->value(dpBottom, mMainWindow->units()); QCPGraph *graph = plot->addGraph( plot->axisRect()->axis(QCPAxis::atBottom), plot->yValue(DataPlot::Elevation)->axis()); graph->setData(xElev, yElev); graph->setPen(QPen(QBrush(Qt::lightGray), mMainWindow->lineThickness(), Qt::DashLine)); yElev.clear(); yElev << plot->yValue(DataPlot::Elevation)->value(dpTop, mMainWindow->units()) << plot->yValue(DataPlot::Elevation)->value(dpTop, mMainWindow->units()); graph = plot->addGraph( plot->axisRect()->axis(QCPAxis::atBottom), plot->yValue(DataPlot::Elevation)->axis()); graph->setData(xElev, yElev); graph->setPen(QPen(QBrush(Qt::lightGray), mMainWindow->lineThickness(), Qt::DashLine)); QCPItemRect *rect = new QCPItemRect(plot); plot->addItem(rect); rect->setPen(QPen(QBrush(Qt::lightGray), mMainWindow->lineThickness(), Qt::DashLine)); rect->setBrush(QColor(0, 0, 0, 8)); rect->topLeft->setType(QCPItemPosition::ptAxisRectRatio); rect->topLeft->setAxes(plot->xAxis, plot->yValue(DataPlot::Elevation)->axis()); rect->topLeft->setCoords(-0.1, -0.1); rect->bottomRight->setType(QCPItemPosition::ptAxisRectRatio); rect->bottomRight->setAxes(plot->xAxis, plot->yValue(DataPlot::Elevation)->axis()); rect->bottomRight->setCoords( (plot->xValue()->value(dpBottom, mMainWindow->units()) - xMin) / (xMax - xMin), 1.1); rect = new QCPItemRect(plot); plot->addItem(rect); rect->setPen(QPen(QBrush(Qt::lightGray), mMainWindow->lineThickness(), Qt::DashLine)); rect->setBrush(QColor(0, 0, 0, 8)); rect->topLeft->setType(QCPItemPosition::ptAxisRectRatio); rect->topLeft->setAxes(plot->xAxis, plot->yValue(DataPlot::Elevation)->axis()); rect->topLeft->setCoords( (plot->xValue()->value(dpTop, mMainWindow->units()) - xMin) / (xMax - xMin), -0.1); rect->bottomRight->setType(QCPItemPosition::ptAxisRectRatio); rect->bottomRight->setAxes(plot->xAxis, plot->yValue(DataPlot::Elevation)->axis()); rect->bottomRight->setCoords(1.1, 1.1); } }
void PerformanceScoring::prepareDataPlot( DataPlot *plot) { // Return now if plot empty if (mMainWindow->dataSize() == 0) return; DataPoint dpStart = mMainWindow->interpolateDataT(mStartTime); DataPoint dpEnd = mMainWindow->interpolateDataT(mEndTime); // Add shading for scoring window if (plot->yValue(DataPlot::Elevation)->visible()) { DataPoint dpLower = mMainWindow->interpolateDataT(mMainWindow->rangeLower()); DataPoint dpUpper = mMainWindow->interpolateDataT(mMainWindow->rangeUpper()); const double xMin = plot->xValue()->value(dpLower, mMainWindow->units()); const double xMax = plot->xValue()->value(dpUpper, mMainWindow->units()); QVector< double > xElev, yElev; xElev << xMin << xMax; yElev << plot->yValue(DataPlot::Elevation)->value(dpStart, mMainWindow->units()) << plot->yValue(DataPlot::Elevation)->value(dpStart, mMainWindow->units()); QCPGraph *graph = plot->addGraph( plot->axisRect()->axis(QCPAxis::atBottom), plot->yValue(DataPlot::Elevation)->axis()); graph->setData(xElev, yElev); graph->setPen(QPen(QBrush(Qt::lightGray), mMainWindow->lineThickness(), Qt::DashLine)); yElev.clear(); yElev << plot->yValue(DataPlot::Elevation)->value(dpEnd, mMainWindow->units()) << plot->yValue(DataPlot::Elevation)->value(dpEnd, mMainWindow->units()); graph = plot->addGraph( plot->axisRect()->axis(QCPAxis::atBottom), plot->yValue(DataPlot::Elevation)->axis()); graph->setData(xElev, yElev); graph->setPen(QPen(QBrush(Qt::lightGray), mMainWindow->lineThickness(), Qt::DashLine)); QCPItemRect *rect = new QCPItemRect(plot); rect->setPen(QPen(QBrush(Qt::lightGray), mMainWindow->lineThickness(), Qt::DashLine)); rect->setBrush(QColor(0, 0, 0, 8)); rect->topLeft->setType(QCPItemPosition::ptAxisRectRatio); rect->topLeft->setAxes(plot->xAxis, plot->yValue(DataPlot::Elevation)->axis()); rect->topLeft->setCoords(-0.1, -0.1); rect->bottomRight->setType(QCPItemPosition::ptAxisRectRatio); rect->bottomRight->setAxes(plot->xAxis, plot->yValue(DataPlot::Elevation)->axis()); rect->bottomRight->setCoords( (plot->xValue()->value(dpStart, mMainWindow->units()) - xMin) / (xMax - xMin), 1.1); rect = new QCPItemRect(plot); rect->setPen(QPen(QBrush(Qt::lightGray), mMainWindow->lineThickness(), Qt::DashLine)); rect->setBrush(QColor(0, 0, 0, 8)); rect->topLeft->setType(QCPItemPosition::ptAxisRectRatio); rect->topLeft->setAxes(plot->xAxis, plot->yValue(DataPlot::Elevation)->axis()); rect->topLeft->setCoords( (plot->xValue()->value(dpEnd, mMainWindow->units()) - xMin) / (xMax - xMin), -0.1); rect->bottomRight->setType(QCPItemPosition::ptAxisRectRatio); rect->bottomRight->setAxes(plot->xAxis, plot->yValue(DataPlot::Elevation)->axis()); rect->bottomRight->setCoords(1.1, 1.1); } }