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();
}
/*! \brief Add a Graph to the current Plotter
\param index the index of the graph
\param title the title of the graph
\param color the color of the graph
\param type the type of the graph (bar, lines, points)
\param the tickness of the graph
\param graph_y_scale to multiply the all data points for a scale factor
*/
Graph * Plotter::addGraph(QString remotePort,QString localPort,int index, QString title, QString color, QString type, int size, double graph_y_scale)
{
Graph *graph = NULL;
graph = new Graph(index,title,color,type,size,graph_y_scale,this->size);
for(int i=0;i<graphList.count();i++) {
Graph *g = (Graph *)graphList.at(i);
Connection *con = g->getConnetion();
if(!con){
continue;
}
if(con->remotePortName == remotePort && con->localPortName == localPort){
graph->curr_connection = g->curr_connection;
graph->deleteConnection = false;
break;
}
}
graphList.append(graph);
QCPGraph *customGraph = customPlot.addGraph(); // line
customGraph->setPen(QPen(QColor(color),size));
customGraph->setAntialiased(false);
customGraph->setLineStyle(QCPGraph::lsLine);
if(type == "points"){
customGraph->setLineStyle(QCPGraph::lsNone);
customGraph->setScatterStyle(QCPScatterStyle::ssDot);
}
if(type == "bars"){
customGraph->setLineStyle(QCPGraph::lsImpulse);
customGraph->setScatterStyle(QCPScatterStyle::ssNone);
}
QCPGraph *customGraphPoint = customPlot.addGraph(); // dot
customGraphPoint->setPen(QPen(QColor(color)));
customGraphPoint->setLineStyle(QCPGraph::lsNone);
customGraphPoint->setScatterStyle(QCPScatterStyle::ssDisc);
graph->setCustomGraph(customGraph);
graph->setCustomGraphPoint(customGraphPoint);
customPlot.replot();
return graph;
}
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 ScatterWidget::setData(const std::vector<PointD> &data, string legend)
{
QCPGraph *graph = NULL;
int nG = ui->scatter->graphCount();
for(int i=0; i<nG; i++)
{
if(ui->scatter->graph(i)->name() == QString::fromStdString(legend))
{
graph = ui->scatter->graph(i);
break;
}
}
if(!graph)
{
graph = ui->scatter->addGraph();
// ----------------------- Scatter Configuration ---------------------------
graph->setName(QString::fromStdString(legend));
QColor color_ = colorManager.getNewDifferentColor();
graph->setPen(QPen(color_));
graph->setLineStyle(QCPGraph::lsNone);
graph->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssPlusCircle, 4));
ui->scatter->legend->setVisible(true);
}
double min_x = INFINITY, min_y = INFINITY;
double max_x = -INFINITY, max_y = -INFINITY;
QVector<QCPGraphData> q_data(data.size());
for(unsigned int i=0; i<data.size(); i++)
{
q_data[i] = QCPGraphData(data[i].x, data[i].y);
if(ui->recButton->isChecked())
{
vector<double> vec2_double(2);
vec2_double[0] = data[i].x;
vec2_double[1] = data[i].y;
vector<string> vec2_string(2);
vec2_string[0] = legend + "_x";
vec2_string[1] = legend + "_y";
logger.addLogCsv(graph->dataCount(), vec2_string, vec2_double);
}
max_x = qMax(data[i].x, ui->scatter->xAxis->range().upper);
min_x = qMin(data[i].x, ui->scatter->xAxis->range().lower);
max_y = qMax(data[i].y, ui->scatter->yAxis->range().upper);
min_y = qMin(data[i].y, ui->scatter->yAxis->range().lower);
}
graph->data()->set(q_data);
ui->scatter->xAxis->setRange(min_x, max_x);
ui->scatter->yAxis->setRange(min_y, max_y);
ui->scatter->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 RealTimePlot::updateChannel(int index)
{
Channel *chan = channels[index];
// Get parameters from channel
QCPGraph *line = chan->getPtrGraphLine();
QCPGraph *marker = chan->getPtrGraphMarker();
QColor color = chan->getGraphColor();
// Set parameters of line graph
line->setPen(QPen(color));
line->setLineStyle(QCPGraph::lsLine);
line->setVisible(chan->getVisible(LINE));
// Set parameters of marker graph
marker->setName(chan->getName());
marker->setPen(QPen(color));
marker->setLineStyle(QCPGraph::lsNone);
marker->setScatterStyle(chan->getMarkerStyle());
marker->setVisible(chan->getVisible(MARKER));
}
void ScatterWidget::addPacket(const ScatterPacket &packet)
{
QCPGraph *graph = NULL;
int nG = ui->scatter->graphCount();
for(int i=0; i<nG; i++)
{
if(ui->scatter->graph(i)->name() == QString::fromStdString(packet.legend))
{
graph = ui->scatter->graph(i);
break;
}
}
if(!graph)
{
graph = ui->scatter->addGraph();
// ----------------------- Scatter Configuration ---------------------------
graph->setName(QString::fromStdString(packet.legend));
QColor color_ = colorManager.getNewDifferentColor();
graph->setPen(QPen(color_));
graph->setLineStyle(QCPGraph::lsNone);
graph->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssPlusCircle, 4));
ui->scatter->legend->setVisible(true);
}
graph->addData(packet.point.x, packet.point.y);
//if(packet.point.x > ui->scatter->xAxis->max)
double max_x = qMax(packet.point.x, ui->scatter->xAxis->range().upper);
double min_x = qMin(packet.point.x, ui->scatter->xAxis->range().lower);
double max_y = qMax(packet.point.y, ui->scatter->yAxis->range().upper);
double min_y = qMin(packet.point.y, ui->scatter->yAxis->range().lower);
ui->scatter->xAxis->setRange(min_x, max_x);
ui->scatter->yAxis->setRange(min_y, max_y);
if(realTimePlot)
ui->scatter->replot();
else
ui->scatter->replot(QCustomPlot::rpQueuedReplot);
if(ui->recButton->isChecked())
{
vector<double> vec2_double(2);
vec2_double[0] = packet.point.x;
vec2_double[1] = packet.point.y;
vector<string> vec2_string(2);
vec2_string[0] = packet.legend + "_x";
vec2_string[1] = packet.legend + "_y";
logger.addLogCsv(graph->dataCount(), vec2_string, vec2_double);
}
}
QCPGraph* SensorDashboard::createGraph(const QString& name, const QColor& color)
{
QPen pen;
pen.setBrush(color);
QCPGraph *graph = mPlot->addGraph();
graph->setName(name);
graph->setLineStyle(QCPGraph::lsLine);
graph->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssNone));
graph->setPen(pen);
return graph;
}
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 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 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);
}
}
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 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 DataBrokerPlotter::createNewPlot() {
char text[50];
// create first curve
std::string cfgName = name;
std::string tmpString;
Plot *newPlot = new Plot;
QCPGraph *newCurve = qcPlot->addGraph();
newCurve->setAntialiasedFill(false);
newPlot->dpId = nextPlotId++;
sprintf(text, "graph%02d", newPlot->dpId);
newPlot->name = std::string(text);
cfgName.append("/");
cfgName.append(newPlot->name);
cfgName.append("/");
newCurve->setPen( QPen(colors[(newPlot->dpId-1) % 8], 0.5) );
newCurve->setLineStyle( QCPGraph::lsLine );
newPlot->curve = newCurve;
plots.push_back(newPlot);
// add datapackage for first plot
mars::data_broker::DataPackage dbPackageX;// = new mars::data_broker::DataPackage;
mars::data_broker::DataPackage dbPackageY;// = new mars::data_broker::DataPackage;
dbPackageX.add("xvalue", (double)0.0);
dbPackageY.add("yvalue", (double)0.0);
//dbPackage->add("yvalue", (double)0.0);
tmpString = name;
tmpString.append("/");
tmpString.append(text);
tmpString.append("/xvalue");
dataBroker->pushData("data_broker_plotter", tmpString,
dbPackageX, this,
mars::data_broker::DATA_PACKAGE_READ_WRITE_FLAG);
dataBroker->registerSyncReceiver(this, "data_broker_plotter",
tmpString, newPlot->dpId*10);
tmpString = name;
tmpString.append("/");
tmpString.append(text);
tmpString.append("/yvalue");
dataBroker->pushData("data_broker_plotter", tmpString,
dbPackageY, this,
mars::data_broker::DATA_PACKAGE_READ_WRITE_FLAG);
dataBroker->registerSyncReceiver(this, "data_broker_plotter",
tmpString, newPlot->dpId*10+1);
newPlot->gotData = 0;
tmpString = cfgName;
tmpString.append("sTime");
newPlot->sTime = cfg->getOrCreateProperty("DataBrokerPlotter",
tmpString.c_str(),
(double)0.0, this);
tmpString = cfgName;
tmpString.append("xRange");
newPlot->xRange = cfg->getOrCreateProperty("DataBrokerPlotter",
tmpString.c_str(),
(double)0.0, this);
tmpString = cfgName;
tmpString.append("yScale");
newPlot->yScale = cfg->getOrCreateProperty("DataBrokerPlotter",
tmpString.c_str(),
(double)1.0, this);
tmpString = cfgName;
tmpString.append("yOffset");
newPlot->yOffset = cfg->getOrCreateProperty("DataBrokerPlotter",
tmpString.c_str(),
(double)0.0, this);
cfgParamIdToPlot[newPlot->sTime.paramId] = newPlot;
cfgParamIdToPlot[newPlot->xRange.paramId] = newPlot;
cfgParamIdToPlot[newPlot->yScale.paramId] = newPlot;
cfgParamIdToPlot[newPlot->yOffset.paramId] = newPlot;
newPlot->cfgParamIdProp[newPlot->sTime.paramId] = &newPlot->sTime;
newPlot->cfgParamIdProp[newPlot->xRange.paramId] = &newPlot->xRange;
newPlot->cfgParamIdProp[newPlot->yScale.paramId] = &newPlot->yScale;
newPlot->cfgParamIdProp[newPlot->yOffset.paramId] = &newPlot->yOffset;
}
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 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);
}
}
Iax2AnalysisDialog::Iax2AnalysisDialog(QWidget &parent, CaptureFile &cf) :
WiresharkDialog(parent, cf),
ui(new Ui::Iax2AnalysisDialog),
port_src_fwd_(0),
port_dst_fwd_(0),
port_src_rev_(0),
port_dst_rev_(0)
{
ui->setupUi(this);
setWindowSubtitle(tr("IAX2 Stream Analysis"));
// XXX Use recent settings instead
resize(parent.width() * 4 / 5, parent.height() * 4 / 5);
ui->progressFrame->hide();
stream_ctx_menu_.addAction(ui->actionGoToPacket);
stream_ctx_menu_.addAction(ui->actionNextProblem);
stream_ctx_menu_.addSeparator();
stream_ctx_menu_.addAction(ui->actionSaveAudio);
stream_ctx_menu_.addAction(ui->actionSaveForwardAudio);
stream_ctx_menu_.addAction(ui->actionSaveReverseAudio);
stream_ctx_menu_.addSeparator();
stream_ctx_menu_.addAction(ui->actionSaveCsv);
stream_ctx_menu_.addAction(ui->actionSaveForwardCsv);
stream_ctx_menu_.addAction(ui->actionSaveReverseCsv);
stream_ctx_menu_.addSeparator();
stream_ctx_menu_.addAction(ui->actionSaveGraph);
ui->forwardTreeWidget->installEventFilter(this);
ui->forwardTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
connect(ui->forwardTreeWidget, SIGNAL(customContextMenuRequested(QPoint)),
SLOT(showStreamMenu(QPoint)));
ui->reverseTreeWidget->installEventFilter(this);
ui->reverseTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
connect(ui->reverseTreeWidget, SIGNAL(customContextMenuRequested(QPoint)),
SLOT(showStreamMenu(QPoint)));
connect(ui->streamGraph, SIGNAL(mousePress(QMouseEvent*)),
this, SLOT(graphClicked(QMouseEvent*)));
graph_ctx_menu_.addAction(ui->actionSaveGraph);
QStringList header_labels;
for (int i = 0; i < ui->forwardTreeWidget->columnCount(); i++) {
header_labels << ui->forwardTreeWidget->headerItem()->text(i);
}
ui->reverseTreeWidget->setHeaderLabels(header_labels);
memset(&src_fwd_, 0, sizeof(address));
memset(&dst_fwd_, 0, sizeof(address));
memset(&src_rev_, 0, sizeof(address));
memset(&dst_rev_, 0, sizeof(address));
QList<QCheckBox *> graph_cbs = QList<QCheckBox *>()
<< ui->fJitterCheckBox << ui->fDiffCheckBox
<< ui->rJitterCheckBox << ui->rDiffCheckBox;
for (int i = 0; i < num_graphs_; i++) {
QCPGraph *graph = ui->streamGraph->addGraph();
graph->setPen(QPen(ColorUtils::graph_colors_[i]));
graph->setName(graph_cbs[i]->text());
graphs_ << graph;
graph_cbs[i]->setChecked(true);
graph_cbs[i]->setIcon(StockIcon::colorIcon(ColorUtils::graph_colors_[i], QPalette::Text));
}
ui->streamGraph->xAxis->setLabel("Arrival Time");
ui->streamGraph->yAxis->setLabel("Value (ms)");
// We keep our temp files open for the lifetime of the dialog. The GTK+
// UI opens and closes at various points.
QString tempname = QString("%1/wireshark_iax2_f").arg(QDir::tempPath());
fwd_tempfile_ = new QTemporaryFile(tempname, this);
fwd_tempfile_->open();
tempname = QString("%1/wireshark_iax2_r").arg(QDir::tempPath());
rev_tempfile_ = new QTemporaryFile(tempname, this);
rev_tempfile_->open();
if (fwd_tempfile_->error() != QFile::NoError || rev_tempfile_->error() != QFile::NoError) {
err_str_ = tr("Unable to save RTP data.");
ui->actionSaveAudio->setEnabled(false);
ui->actionSaveForwardAudio->setEnabled(false);
ui->actionSaveReverseAudio->setEnabled(false);
}
QMenu *save_menu = new QMenu();
save_menu->addAction(ui->actionSaveAudio);
save_menu->addAction(ui->actionSaveForwardAudio);
save_menu->addAction(ui->actionSaveReverseAudio);
save_menu->addSeparator();
save_menu->addAction(ui->actionSaveCsv);
save_menu->addAction(ui->actionSaveForwardCsv);
save_menu->addAction(ui->actionSaveReverseCsv);
save_menu->addSeparator();
save_menu->addAction(ui->actionSaveGraph);
ui->buttonBox->button(QDialogButtonBox::Save)->setMenu(save_menu);
const gchar *filter_text = "iax2 && (ip || ipv6)";
dfilter_t *sfcode;
gchar *err_msg;
if (!dfilter_compile(filter_text, &sfcode, &err_msg)) {
QMessageBox::warning(this, tr("No IAX2 packets found"), QString("%1").arg(err_msg));
g_free(err_msg);
close();
}
if (!cap_file_.capFile() || !cap_file_.capFile()->current_frame) close();
frame_data *fdata = cap_file_.capFile()->current_frame;
if (!cf_read_record(cap_file_.capFile(), fdata)) close();
epan_dissect_t edt;
epan_dissect_init(&edt, cap_file_.capFile()->epan, TRUE, FALSE);
epan_dissect_prime_dfilter(&edt, sfcode);
epan_dissect_run(&edt, cap_file_.capFile()->cd_t, &cap_file_.capFile()->phdr,
frame_tvbuff_new_buffer(fdata, &cap_file_.capFile()->buf), fdata, NULL);
// This shouldn't happen (the menu item should be disabled) but check anyway
if (!dfilter_apply_edt(sfcode, &edt)) {
epan_dissect_cleanup(&edt);
dfilter_free(sfcode);
err_str_ = tr("Please select an IAX2 packet");
updateWidgets();
return;
}
dfilter_free(sfcode);
/* ok, it is a IAX2 frame, so let's get the ip and port values */
COPY_ADDRESS(&(src_fwd_), &(edt.pi.src));
COPY_ADDRESS(&(dst_fwd_), &(edt.pi.dst));
port_src_fwd_ = edt.pi.srcport;
port_dst_fwd_ = edt.pi.destport;
/* assume the inverse ip/port combination for the reverse direction */
COPY_ADDRESS(&(src_rev_), &(edt.pi.dst));
COPY_ADDRESS(&(dst_rev_), &(edt.pi.src));
port_src_rev_ = edt.pi.destport;
port_dst_rev_ = edt.pi.srcport;
#if 0
/* check if it is Voice or MiniPacket */
bool ok;
getIntFromProtoTree(edt.tree, "iax2", "iax2.call", &ok);
if (!ok) {
err_str_ = tr("Please select an IAX2 packet.");
updateWidgets();
return;
}
#endif
#ifdef IAX2_RTP_STREAM_CHECK
rtpstream_tapinfot tapinfo;
/* Register the tap listener */
memset(&tapinfo, 0, sizeof(rtpstream_tapinfot));
tapinfo.tap_data = this;
tapinfo.mode = TAP_ANALYSE;
// register_tap_listener_rtp_stream(&tapinfo, NULL);
/* Scan for RTP streams (redissect all packets) */
rtpstream_scan(&tapinfo, cap_file_.capFile(), NULL);
int num_streams = 0;
GList *filtered_list = NULL;
for (GList *strinfo_list = g_list_first(tapinfo.strinfo_list); strinfo_list; strinfo_list = g_list_next(strinfo_list)) {
rtp_stream_info_t * strinfo = (rtp_stream_info_t*)(strinfo_list->data);
<< address_to_qstring(&strinfo->dest_addr) << address_to_qstring(&src_rev_) << address_to_qstring(&dst_rev_);
if (ADDRESSES_EQUAL(&(strinfo->src_addr), &(src_fwd_))
&& (strinfo->src_port == port_src_fwd_)
&& (ADDRESSES_EQUAL(&(strinfo->dest_addr), &(dst_fwd_)))
&& (strinfo->dest_port == port_dst_fwd_))
{
++num_streams;
filtered_list = g_list_prepend(filtered_list, strinfo);
}
if (ADDRESSES_EQUAL(&(strinfo->src_addr), &(src_rev_))
&& (strinfo->src_port == port_src_rev_)
&& (ADDRESSES_EQUAL(&(strinfo->dest_addr), &(dst_rev_)))
&& (strinfo->dest_port == port_dst_rev_))
{
++num_streams;
filtered_list = g_list_append(filtered_list, strinfo);
}
}
