/*!
\brief Draw symbols
\param painter Painter
\param symbol Curve symbol
\param xMap x map
\param yMap y map
\param from index of the first point to be painted
\param to index of the last point to be painted
\sa setSymbol(), draw(), drawCurve()
*/
void PlotCurve::drawSymbols(QPainter *painter, const QwtSymbol &symbol, const QwtScaleMap &xMap,
const QwtScaleMap &yMap, int from, int to) const
{
painter->translate(d_x_offset,-d_y_offset); // For waterfall plots (will be zero otherwise)
// Don't really know why you'd want symbols on a waterfall plot, but just in case...
if (d_skip_symbols < 2)
{
QwtPlotCurve::drawSymbols(painter, symbol, xMap, yMap, from, to);
return;
}
painter->setBrush(symbol.brush());
//QtiPlot has added method to QwtPainter: painter->setPen(QwtPainter::scaledPen(symbol.pen()));
painter->setPen(symbol.pen());
const QwtMetricsMap &metricsMap = QwtPainter::metricsMap();
QRect rect;
rect.setSize(metricsMap.screenToLayout(symbol.size()));
for (int i = from; i <= to; i += d_skip_symbols)
{
const int xi = xMap.transform(x(i));
const int yi = yMap.transform(y(i));
rect.moveCenter(QPoint(xi, yi));
symbol.draw(painter, rect);
}
}
static inline void qwtDrawSvgSymbols( QPainter *painter,
const QPointF *points, int numPoints,
QSvgRenderer *renderer, const QwtSymbol &symbol )
{
if ( renderer == NULL || !renderer->isValid() )
return;
const QRectF viewBox = renderer->viewBoxF();
if ( viewBox.isEmpty() )
return;
QSizeF sz = symbol.size();
if ( !sz.isValid() )
sz = viewBox.size();
const double sx = sz.width() / viewBox.width();
const double sy = sz.height() / viewBox.height();
QPointF pinPoint = viewBox.center();
if ( symbol.isPinPointEnabled() )
pinPoint = symbol.pinPoint();
const double dx = sx * ( pinPoint.x() - viewBox.left() );
const double dy = sy * ( pinPoint.y() - viewBox.top() );
for ( int i = 0; i < numPoints; i++ )
{
const double x = points[i].x() - dx;
const double y = points[i].y() - dy;
renderer->render( painter,
QRectF( x, y, sz.width(), sz.height() ) );
}
}
static inline void qwtDrawPixmapSymbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
QSize size = symbol.size();
if ( size.isEmpty() )
size = symbol.pixmap().size();
const QTransform transform = painter->transform();
if ( transform.isScaling() )
{
const QRect r( 0, 0, size.width(), size.height() );
size = transform.mapRect( r ).size();
}
QPixmap pm = symbol.pixmap();
if ( pm.size() != size )
pm = pm.scaled( size );
QPointF pinPoint( 0.5 * size.width(), 0.5 * size.height() );
if ( symbol.isPinPointEnabled() )
pinPoint = symbol.pinPoint();
painter->resetTransform();
for ( int i = 0; i < numPoints; i++ )
{
const QPointF pos = transform.map( points[i] ) - pinPoint;
QwtPainter::drawPixmap( painter,
QRect( pos.toPoint(), pm.size() ), pm );
}
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
config(),
configUI(&config),
experiment(&config, this),
qwtPlotCurveHallU("Hall U"),
qwtPlotCurveResistivity("Resistivity"),
ui(new Ui::MainWindow)
{
experiment.setObjectName("experiment");
ui->setupUi(this);
QObject::connect(&configUI, SIGNAL(accepted()), this, SLOT(show()));
QObject::connect(&experiment, SIGNAL(coilBMeasured(double)),
ui->coilBDoubleSpinBox, SLOT(setValue(double)));
QObject::connect(&experiment, SIGNAL(coilIMeasured(double)),
ui->coilCurrMeasDoubleSpinBox, SLOT(setValue(double)));
QObject::connect(&experiment, SIGNAL(coilUMeasured(double)),
ui->coilVoltMeasDoubleSpinBox, SLOT(setValue(double)));
ui->qwtPlot->enableAxis(QwtPlot::yRight, true);
QString titleTpl("<html><body><span style=\"font-family:'Sans Serif'; font-size:14pt; font-weight:600; font-style:bold;\"><span style=\"%1\">%2</span> %3</span></body></html>");
QwtText titleHall(titleTpl.arg("color: red;").arg("×").arg("hall U [V]"));
QwtText titleR(titleTpl.arg("color: lime;").arg("*").arg("Resistivity [Ω]"));
ui->qwtPlot->setAxisTitle(QwtPlot::yLeft, titleHall);
ui->qwtPlot->setAxisTitle(QwtPlot::yRight, titleR);
ui->qwtPlot->setAxisTitle(QwtPlot::xBottom, "B [T]");
qwtPlotCurveHallU.attach(ui->qwtPlot);
qwtPlotCurveResistivity.attach(ui->qwtPlot);
qwtPlotCurveHallU.setStyle(QwtPlotCurve::NoCurve);
qwtPlotCurveResistivity.setStyle(QwtPlotCurve::NoCurve);
QwtSymbol *qwtPlotHallUSymbol = new QwtSymbol(QwtSymbol::XCross);
QwtSymbol *qwtPlotResistivitySymbol = new QwtSymbol(QwtSymbol::Star1);
qwtPlotHallUSymbol->setColor(QColor(255, 0, 0));
qwtPlotResistivitySymbol->setColor(QColor(0, 255, 0));
qwtPlotHallUSymbol->setSize(QSize(12, 12));
qwtPlotResistivitySymbol->setSize(QSize(12, 12));
QPen hallSymbolPen(qwtPlotHallUSymbol->pen());
QPen resistivitySymbolPen(qwtPlotResistivitySymbol->pen());
hallSymbolPen.setWidth(2);
resistivitySymbolPen.setWidth(2);
qwtPlotHallUSymbol->setPen(hallSymbolPen);
qwtPlotResistivitySymbol->setPen(resistivitySymbolPen);
qwtPlotCurveResistivity.setYAxis(QwtPlot::yRight);
qwtPlotCurveHallU.setSymbol(qwtPlotHallUSymbol);
qwtPlotCurveResistivity.setSymbol(qwtPlotResistivitySymbol);
ui->dataTableWidget->resizeColumnsToContents();
}
void VectorPlot::addDotPlot(const MarkupQwtAdapter&adapter,
QColor color,
const QString &name,
bool addToLegend) {
QwtPlotCurve *curve = new QwtPlotCurve(name);
QwtSymbol sym;
sym.setPen(QColor(color));
sym.setBrush(QColor(color));
sym.setStyle(QwtSymbol::Rect);
sym.setSize(
QSize(1, 20)
);
curve->setSymbol(sym);
curve->setStyle(QwtPlotCurve::NoCurve);
if(adapter.size() > 0) {
setupPlot(adapter.boundingRect());
curve->setData(adapter);
curve->attach(plot);
}
if(!legend) {
return;
}
// Добавляем кривую в легенду
QwtLegendItem *item = new QwtLegendItem(0);
item->setText(curve->title());
item->setSymbol(sym);
item->setIdentifierMode(QwtLegendItem::ShowLine | QwtLegendItem::ShowSymbol | QwtLegendItem::ShowText);
legend->insert(curve, item);
}
/*!
Draw symbols
\param painter Painter
\param symbol Curve symbol
\param azimuthMap Maps azimuth values to values related to 0.0, M_2PI
\param radialMap Maps radius values into painter coordinates.
\param pole Position of the pole in painter coordinates
\param from index of the first point to be painted
\param to index of the last point to be painted.
\sa setSymbol(), draw(), drawCurve()
*/
void QwtPolarCurve::drawSymbols( QPainter *painter, const QwtSymbol &symbol,
const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,
const QPointF &pole, int from, int to ) const
{
painter->setBrush( symbol.brush() );
painter->setPen( symbol.pen() );
const int chunkSize = 500;
for ( int i = from; i <= to; i += chunkSize )
{
const int n = qMin( chunkSize, to - i + 1 );
QPolygonF points;
for ( int j = 0; j < n; j++ )
{
const QwtPointPolar point = sample( i + j );
if ( !qwtInsidePole( radialMap, point.radius() ) )
{
const double r = radialMap.transform( point.radius() );
const double a = azimuthMap.transform( point.azimuth() );
points += qwtPolar2Pos( pole, r, a );
}
else
{
points += pole;
}
}
if ( points.size() > 0 )
symbol.drawSymbols( painter, points );
}
}
void
PfPvPlot::configChanged()
{
setCanvasBackground(GColor(CPLOTBACKGROUND));
// frame with inverse of background
QwtSymbol *sym = new QwtSymbol;
sym->setStyle(QwtSymbol::Ellipse);
sym->setSize(4);
sym->setPen(QPen(Qt::red));
sym->setBrush(QBrush(Qt::red));
curve->setSymbol(sym);
curve->setStyle(QwtPlotCurve::Dots);
curve->setRenderHint(QwtPlotItem::RenderAntialiased);
QPalette palette;
palette.setBrush(QPalette::Window, QBrush(GColor(CPLOTBACKGROUND)));
palette.setColor(QPalette::WindowText, GColor(CPLOTMARKER));
palette.setColor(QPalette::Text, GColor(CPLOTMARKER));
setPalette(palette);
axisWidget(QwtPlot::xBottom)->setPalette(palette);
axisWidget(QwtPlot::yLeft)->setPalette(palette);
// use grid line color for mX, mY and CPcurve
QPen marker = GColor(CPLOTMARKER);
QPen cp = GColor(CCP);
mX->setLinePen(marker);
mY->setLinePen(marker);
cpCurve->setPen(cp);
setCL(appsettings->value(this, GC_CRANKLENGTH).toDouble() / 1000.0);
replot();
}
/*!
\brief Draw symbols
\param painter Painter
\param symbol Curve symbol
\param xMap x map
\param yMap y map
\param from index of the first point to be painted
\param to index of the last point to be painted
\sa setSymbol(), draw(), drawCurve()
*/
void PlotCurve::drawSymbols(QPainter *painter, const QwtSymbol &symbol,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
int from, int to) const {
if (d_skip_symbols < 2) {
QwtPlotCurve::drawSymbols(painter, symbol, xMap, yMap, from, to);
return;
}
painter->setBrush(symbol.brush());
// QtiPlot has added method to QwtPainter:
// painter->setPen(QwtPainter::scaledPen(symbol.pen()));
painter->setPen(symbol.pen());
const QwtMetricsMap &metricsMap = QwtPainter::metricsMap();
QRect rect;
rect.setSize(metricsMap.screenToLayout(symbol.size()));
for (int i = from; i <= to; i += d_skip_symbols) {
const int xi = xMap.transform(x(i));
const int yi = yMap.transform(y(i));
rect.moveCenter(QPoint(xi, yi));
symbol.draw(painter, rect);
}
}
static inline void qwtDrawXCrossSymbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
const QSize size = symbol.size();
int off = 0;
QPen pen = symbol.pen();
if ( pen.width() > 1 )
{
pen.setCapStyle( Qt::FlatCap );
off = 1;
}
painter->setPen( pen );
if ( QwtPainter::roundingAlignment( painter ) )
{
const int sw = size.width();
const int sh = size.height();
const int sw2 = size.width() / 2;
const int sh2 = size.height() / 2;
for ( int i = 0; i < numPoints; i++ )
{
const QPointF &pos = points[i];
const int x = qRound( pos.x() );
const int y = qRound( pos.y() );
const int x1 = x - sw2;
const int x2 = x1 + sw + off;
const int y1 = y - sh2;
const int y2 = y1 + sh + off;
QwtPainter::drawLine( painter, x1, y1, x2, y2 );
QwtPainter::drawLine( painter, x2, y1, x1, y2 );
}
}
else
{
const double sw = size.width();
const double sh = size.height();
const double sw2 = 0.5 * size.width();
const double sh2 = 0.5 * size.height();
for ( int i = 0; i < numPoints; i++ )
{
const QPointF &pos = points[i];
const double x1 = pos.x() - sw2;
const double x2 = x1 + sw;
const double y1 = pos.y() - sh2;
const double y2 = y1 + sh;
QwtPainter::drawLine( painter, x1, y1, x2, y2 );
QwtPainter::drawLine( painter, x1, y2, x2, y1 );
}
}
}
void QwtErrorPlotCurve::drawErrorBars(QPainter *painter,
const QwtScaleMap &xMap, const QwtScaleMap &yMap, int from, int to) const
{
int sh = 0, sw =0;
const QwtSymbol symbol = d_master_curve->symbol();
if (symbol.style() != QwtSymbol::NoSymbol){
sh = symbol.size().height();
sw = symbol.size().width();
}
double d_xOffset = 0.0;
double d_yOffset = 0.0;
if (d_master_curve->type() == Graph::VerticalBars)
d_xOffset = ((QwtBarCurve *)d_master_curve)->dataOffset();
else if (d_master_curve->type() == Graph::HorizontalBars)
d_yOffset = ((QwtBarCurve *)d_master_curve)->dataOffset();
ScaleEngine *yScaleEngine = (ScaleEngine *)plot()->axisScaleEngine(yAxis());
bool logYScale = (yScaleEngine->type() == QwtScaleTransformation::Log10) ? true : false;
for (int i = from; i <= to; i++){
const int xi = xMap.transform(x(i) + d_xOffset);
const int yi = yMap.transform(y(i) + d_yOffset);
if (type == Vertical){
const int yh = yMap.transform(y(i) + err[i]);
const int yl = yMap.transform(y(i) - err[i]);
const int yhl = yi - sh/2;
const int ylh = yi + sh/2;
if (plus){
QwtPainter::drawLine(painter, xi, yhl, xi, yh);
QwtPainter::drawLine(painter, xi - cap/2, yh, xi + cap/2, yh);
}
if (minus && (!logYScale || (logYScale && yl > 0))){
QwtPainter::drawLine(painter, xi, ylh, xi, yl);
QwtPainter::drawLine(painter, xi - cap/2, yl, xi + cap/2, yl);
}
if (through)
QwtPainter::drawLine(painter, xi, yhl, xi, ylh);
} else if (type == Horizontal) {
const int xp = xMap.transform(x(i) + err[i]);
const int xm = xMap.transform(x(i) - err[i]);
const int xpm = xi + sw/2;
const int xmp = xi - sw/2;
if (plus){
QwtPainter::drawLine(painter, xp, yi, xpm, yi);
QwtPainter::drawLine(painter, xp, yi - cap/2, xp, yi + cap/2);
}
if (minus){
QwtPainter::drawLine(painter, xm, yi, xmp, yi);
QwtPainter::drawLine(painter, xm, yi - cap/2, xm, yi + cap/2);
}
if (through)
QwtPainter::drawLine(painter, xmp, yi, xpm, yi);
}
}
}
void SAQwtPlotCurveItemSetWidget::onSymbolSetMenuHide()
{
if(m_symbolSetWidget)
{
const QwtSymbol& s = m_symbolSetWidget->getSymbol();
QwtSymbol* symbol = new QwtSymbol(s.style(),s.brush(),s.pen(),s.size());
m_curveItem->setSymbol(symbol);
m_symbolComboBox->setStyle(symbol->style());
}
}
static inline void qwtDrawDiamondSymbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
const QSize size = symbol.size();
QPen pen = symbol.pen();
pen.setJoinStyle( Qt::MiterJoin );
painter->setPen( pen );
painter->setBrush( symbol.brush() );
if ( QwtPainter::roundingAlignment( painter ) )
{
for ( int i = 0; i < numPoints; i++ )
{
const int x = qRound( points[i].x() );
const int y = qRound( points[i].y() );
const int x1 = x - size.width() / 2;
const int y1 = y - size.height() / 2;
const int x2 = x1 + size.width();
const int y2 = y1 + size.height();
QPolygonF polygon;
polygon += QPointF( x, y1 );
polygon += QPointF( x1, y );
polygon += QPointF( x, y2 );
polygon += QPointF( x2, y );
QwtPainter::drawPolygon( painter, polygon );
}
}
else
{
for ( int i = 0; i < numPoints; i++ )
{
const QPointF &pos = points[i];
const double x1 = pos.x() - 0.5 * size.width();
const double y1 = pos.y() - 0.5 * size.height();
const double x2 = x1 + size.width();
const double y2 = y1 + size.height();
QPolygonF polygon;
polygon += QPointF( pos.x(), y1 );
polygon += QPointF( x2, pos.y() );
polygon += QPointF( pos.x(), y2 );
polygon += QPointF( x1, pos.y() );
QwtPainter::drawPolygon( painter, polygon );
}
}
}
void specCanvasItem::setSymbolSize(const QSize& s)
{
if(oldSymbol)
{
oldSymbol->setSize(s) ;
}
else
{
QwtSymbol* newSymbol = symbol() ? cloneSymbol(symbol()) : (new QwtSymbol) ;
newSymbol->setSize(s) ;
setSymbol(newSymbol) ;
}
}
Graph::Graph(QWidget *parent) : QWidget(parent){
ui.setupUi(this);
// Задаём положение окна по центру
/*QDesktopWidget desktop;
QRect rect = desktop.availableGeometry(desktop.primaryScreen());
QPoint center = rect.center();
center.setX(center.x() - (this->width()/2));
center.setY(center.y() - (this->height()/2));
move(center);*/
// Создаём окно
this->setWindowTitle(QString::fromUtf8("График"));
// Файл с настройками
settings_read = new QSettings("settings.conf",QSettings::IniFormat);
settings_write = new QSettings("settings.conf",QSettings::IniFormat);
// Настройка отрисовки графика
grid = new QwtPlotGrid;
grid->enableXMin(true);
grid->setMajPen(QPen(Qt::black,0,Qt::DotLine));
grid->setMinPen(QPen(Qt::gray,0,Qt::DotLine));
grid->attach(ui.qwtGraph);
curveTimeForce = new QwtPlotCurve();
curveTimeForce->attach(ui.qwtGraph);
QPen curvePen;
curvePen.setStyle(Qt::DashLine);
curvePen.setBrush(Qt::blue);
curveTimeForce->setPen(curvePen);
QwtSymbol symbolPoint;
symbolPoint.setStyle(QwtSymbol::Rect);
symbolPoint.setPen(QColor(Qt::blue));
symbolPoint.setSize(5);
curveTimeForce->setSymbol(symbolPoint);
// Установка единиц измерения силы
connect( this->ui.rbAdc, SIGNAL( clicked() ), this, SLOT( rbAdcSet() ) );
connect( this->ui.rbNewton, SIGNAL( clicked() ), this, SLOT( rbNewtonSet() ) );
connect( this->ui.rbKgf, SIGNAL( clicked() ), this, SLOT( rbKgfSet() ) );
nPoints = 0;
ui.rbAdc->setChecked(1);
ui.qwtGraph->setAxisTitle(QwtPlot::yLeft,QString::fromUtf8("F, ед. ацп"));
ui.qwtGraph->setAxisTitle(QwtPlot::xBottom,QString::fromUtf8("t, секунды"));
// Загрузка настроек
loadSettings();
}
void VectorPlot::addLinePlot(const VectorQwtAdapter &adapter) {
setupPlot(adapter.boundingRect());
QwtPlotCurve *curve = new QwtPlotCurve();
QwtSymbol sym;
sym.setStyle(QwtSymbol::Cross);
sym.setPen(QColor(Qt::black));
sym.setSize(2);
curve->setSymbol(sym);
curve->setPen(QColor(Qt::darkGreen));
curve->setData(adapter);
curve->attach(plot);
}
void PlotPropertiesGUI::symbolSizeValue(int value)
{
QwtPlotCurve *plotCurve = internalCurves.value(currentCurve)->plotCurve;
// Changes only the symbol width
QwtSymbol symbol = plotCurve->symbol();
symbol.setStyle((QwtSymbol::Style) (ui->curveSymbolCombo->currentIndex() - 1)); // starts in -1
if (symbol.brush().style() != Qt::NoBrush)
symbol.setBrush(QBrush(plotCurve->pen().color()));
symbol.setSize(value);
plotCurve->setSymbol(symbol);
plotter->replot();
}
void specCanvasItem::setSymbolBrushColor(const QColor& newColor)
{
if(oldSymbol)
{
QBrush brush(oldSymbol->brush()) ;
brush.setColor(newColor) ;
oldSymbol->setBrush(brush) ;
}
else
{
QwtSymbol* newSymbol = symbol() ? cloneSymbol(symbol()) : (new QwtSymbol) ;
newSymbol->setBrush(newColor) ;
setSymbol(newSymbol) ;
}
}
QString PlotCurve::saveCurveLayout()
{
Plot *plot = static_cast<Plot *>(this->plot());
Graph *g = static_cast<Graph *>(plot->parent());
int index = g->curveIndex(static_cast<QwtPlotCurve *>(this));
int style = g->curveType(index);
QString s = "<Style>" + QString::number(style) + "</Style>\n";
if (style == Graph::Spline)
s += "<LineStyle>5</LineStyle>\n";
else if (style == Graph::VerticalSteps)
s += "<LineStyle>6</LineStyle>\n";
else
s += "<LineStyle>" + QString::number(this->style()) + "</LineStyle>\n";
QPen pen = this->pen();
if (pen.style() != Qt::NoPen){
s += "<Pen>\n";
s += "\t<Color>" + pen.color().name() + "</Color>\n";
s += "\t<Style>" + QString::number(pen.style()-1) + "</Style>\n";
s += "\t<Width>" + QString::number(pen.widthF()) + "</Width>\n";
s += "</Pen>\n";
}
QBrush brush = this->brush();
if (brush.style() != Qt::NoBrush){
s += "<Brush>\n";
s += "\t<Color>" + brush.color().name() + "</Color>\n";
s += "\t<Style>" + QString::number(PatternBox::patternIndex(brush.style())) + "</Style>\n";
s += "</Brush>\n";
}
const QwtSymbol symbol = this->symbol();
if (symbol.style() != QwtSymbol::NoSymbol){
s += "<Symbol>\n";
s += "\t<Style>" + QString::number(SymbolBox::symbolIndex(symbol.style())) + "</Style>\n";
s += "\t<Size>" + QString::number(symbol.size().width()) + "</Size>\n";
s += "\t<SymbolPen>\n";
s += "\t\t<Color>" + symbol.pen().color().name() + "</Color>\n";
s += "\t\t<Width>" + QString::number(symbol.pen().widthF()) + "</Width>\n";
s += "\t</SymbolPen>\n";
brush = this->brush();
if (brush.style() != Qt::NoBrush){
s += "\t<SymbolBrush>\n";
s += "\t\t<Color>" + symbol.brush().color().name() + "</Color>\n";
s += "\t\t<Style>" + QString::number(PatternBox::patternIndex(symbol.brush().style())) + "</Style>\n";
s += "\t</SymbolBrush>\n";
}
s += "</Symbol>\n";
}
s += "<xAxis>" + QString::number(xAxis()) + "</xAxis>\n";
s += "<yAxis>" + QString::number(yAxis()) + "</yAxis>\n";
s += "<Visible>" + QString::number(isVisible()) + "</Visible>\n";
return s;
}
void Plot::insertCurve( const QString& title,
const QVector<QPointF>& samples, const QColor &color )
{
d_curve = new QwtPlotCurve( title );
d_curve->setRenderHint( QwtPlotItem::RenderAntialiased );
d_curve->setStyle( QwtPlotCurve::NoCurve );
d_curve->setLegendAttribute( QwtPlotCurve::LegendShowSymbol );
QwtSymbol *symbol = new QwtSymbol( QwtSymbol::XCross );
symbol->setSize( 4 );
symbol->setPen( QPen( color ) );
d_curve->setSymbol( symbol );
d_curve->setSamples( samples );
d_curve->attach( this );
}
/*!
Draw symbols
\param painter Painter
\param symbol Curve symbol
\param xMap x map
\param yMap y map
\param canvasRect Contents rectangle of the canvas
\param from Index of the first point to be painted
\param to Index of the last point to be painted
\sa setSymbol(), drawSeries(), drawCurve()
*/
void QwtPlotCurve::drawSymbols( QPainter *painter, const QwtSymbol &symbol,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
const QRectF &canvasRect, int from, int to ) const
{
QwtPointMapper mapper;
mapper.setFlag( QwtPointMapper::RoundPoints,
QwtPainter::roundingAlignment( painter ) );
mapper.setFlag( QwtPointMapper::WeedOutPoints,
testPaintAttribute( QwtPlotCurve::FilterPoints ) );
const QRectF clipRect = qwtIntersectedClipRect( canvasRect, painter );
mapper.setBoundingRect( clipRect );
const int chunkSize = 500;
for ( int i = from; i <= to; i += chunkSize )
{
const int n = qMin( chunkSize, to - i + 1 );
const QPolygonF points = mapper.toPointsF( xMap, yMap,
data(), i, i + n - 1 );
if ( points.size() > 0 )
symbol.drawSymbols( painter, points );
}
}
// Hightlight the selected point
void CanvasPicker::showCursor( bool showIt )
{
if ( !d_selectedCurve )
return;
QwtSymbol *symbol = const_cast<QwtSymbol *>( d_selectedCurve->symbol() );
const QBrush brush = symbol->brush();
if ( showIt )
symbol->setBrush( symbol->brush().color().dark( 180 ) );
QwtPlotDirectPainter directPainter;
directPainter.drawSeries( d_selectedCurve, d_selectedPoint, d_selectedPoint );
if ( showIt )
symbol->setBrush( brush ); // reset brush
}
void specCanvasItem::setSymbolPenColor(const QColor& newColor)
{
if(oldSymbol)
{
QPen newPen(oldSymbol->pen()) ;
newPen.setColor(newColor) ;
oldSymbol->setPen(newPen) ;
}
else
{
QwtSymbol* newSymbol = symbol() ? cloneSymbol(symbol()) : (new QwtSymbol) ;
QPen newPen = newSymbol->pen() ;
newPen.setColor(newColor) ;
newSymbol->setPen(newPen) ;
setSymbol(newSymbol) ;
}
}
void LegendWidget::drawSymbol(PlotCurve *c, int point, QPainter *p, int x, int y, int l)
{
if (!c || c->rtti() == QwtPlotItem::Rtti_PlotSpectrogram)
return;
if (c->type() == Graph::VectXYXY || c->type() == Graph::VectXYAM){
drawVector(c, p, x, y, l);
return;
}
if (c->type() == Graph::Pie){
QwtPieCurve *pie = (QwtPieCurve *)c;
const QBrush br = QBrush(pie->color(point), pie->pattern());
QPen pen = pie->pen();
p->save();
p->setPen (QPen(pen.color(), pen.widthF(), Qt::SolidLine));
QRect lr = QRect(x, y - 4, l, 10);
p->setBrush(br);
QwtPainter::drawRect(p, lr);
p->restore();
return;
}
QwtSymbol symb = c->symbol();
const QBrush br = c->brush();
QPen pen = c->pen();
p->save();
if (c->style()!=0){
p->setPen (pen);
if (br.style() != Qt::NoBrush || c->type() == Graph::Box){
QRect lr = QRect(x, y-4, l, 10);
p->setBrush(br);
QwtPainter::drawRect(p, lr);
} else
QwtPainter::drawLine(p, x, y, x + l, y);
}
int symb_size = symb.size().width();
if (symb_size > 15)
symb_size = 15;
else if (symb_size < 3)
symb_size = 3;
symb.setSize(symb_size);
symb.draw(p, x + l/2, y);
p->restore();
}
QwtSymbol *SAQwtPlotCurveItemSetWidget::makeSymbol(QwtSymbol::Style style)
{
if(nullptr == m_curveItem)
{
return nullptr;
}
const QwtSymbol* oldSymbol = m_curveItem->symbol();
QwtSymbol* newSymbol = nullptr;
if(QwtSymbol::NoSymbol != style)
{
newSymbol = new QwtSymbol(style);
if(nullptr == oldSymbol)
{
//初始没有符号，第一次设置
QColor penColor = m_curveItem->pen().color();
newSymbol->setPen(penColor);
penColor.setAlpha(80);
newSymbol->setBrush(QBrush(penColor));
newSymbol->setSize(6,6);
}
else
{
newSymbol->setPen(oldSymbol->pen());
newSymbol->setBrush(oldSymbol->brush());
newSymbol->setSize(oldSymbol->size());
}
}
return newSymbol;
}
void PlotPropertiesGUI::consistCurveTab(const QString &name)
{
QwtPlotCurve *plotCurve = internalCurves.value(name)->plotCurve;
QwtSymbol symbol = plotCurve->symbol();
ui->symbolSizeSpinBox->setValue( symbol.size().width() );
ui->curveSymbolCombo->setCurrentIndex( (int)symbol.style() + 1); // Starts in -1
// Fixes bug built when used 'plotCurve->symbol()'
plotCurve->setSymbol(symbol);
ui->curveWidthSpinBox->setValue( plotCurve->pen().width() );
ui->curveStyleCombo->setCurrentIndex( (int)plotCurve->style() );
ui->lineStylecombo->setCurrentIndex( (int)plotCurve->pen().style() );
ui->curveColorButton->setStyleSheet(QString(" border-radius: 4px; "
"border: 1px solid rgb(0, 0, 0); background-color: %1")
.arg(plotCurve->pen().color().name()));
}
/*!
\brief Draw symbols
\param painter Painter
\param symbol Curve symbol
\param xMap x map
\param yMap y map
\param from index of the first point to be painted
\param to index of the last point to be painted
*/
void QwtCurve::drawSymbols(QPainter *painter, QwtSymbol &symbol,
const QwtDiMap &xMap, const QwtDiMap &yMap, int from, int to)
{
painter->setBrush(symbol.brush());
painter->setPen(symbol.pen());
QRect rect;
rect.setSize(QwtPainter::metricsMap().screenToLayout(symbol.size()));
for (int i = from; i <= to; i++)
{
const int xi = xMap.transform(x(i));
const int yi = yMap.transform(y(i));
rect.moveCenter(QPoint(xi, yi));
symbol.draw(painter, rect);
}
}
PfPvPlot::PfPvPlot()
: rideItem (NULL),
cp_ (0),
cad_ (85),
cl_ (0.175),
shade_zones(true)
{
setCanvasBackground(Qt::white);
setAxisTitle(yLeft, "Average Effective Pedal Force (N)");
setAxisScale(yLeft, 0, 600);
setAxisTitle(xBottom, "Circumferential Pedal Velocity (m/s)");
setAxisScale(xBottom, 0, 3);
mX = new QwtPlotMarker();
mX->setLineStyle(QwtPlotMarker::VLine);
mX->attach(this);
mY = new QwtPlotMarker();
mY->setLineStyle(QwtPlotMarker::HLine);
mY->attach(this);
cpCurve = new QwtPlotCurve();
cpCurve->setRenderHint(QwtPlotItem::RenderAntialiased);
cpCurve->attach(this);
curve = new QwtPlotCurve();
QwtSymbol sym;
sym.setStyle(QwtSymbol::Ellipse);
sym.setSize(6);
sym.setPen(QPen(Qt::red));
sym.setBrush(QBrush(Qt::NoBrush));
curve->setSymbol(sym);
curve->setStyle(QwtPlotCurve::Dots);
curve->setRenderHint(QwtPlotItem::RenderAntialiased);
curve->attach(this);
boost::shared_ptr<QSettings> settings = GetApplicationSettings();
cl_ = settings->value(GC_CRANKLENGTH).toDouble() / 1000.0;
recalc();
}
static inline void qwtDrawRectSymbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
const QSize size = symbol.size();
QPen pen = symbol.pen();
pen.setJoinStyle( Qt::MiterJoin );
painter->setPen( pen );
painter->setBrush( symbol.brush() );
painter->setRenderHint( QPainter::Antialiasing, false );
if ( QwtPainter::roundingAlignment( painter ) )
{
const int sw = size.width();
const int sh = size.height();
const int sw2 = size.width() / 2;
const int sh2 = size.height() / 2;
for ( int i = 0; i < numPoints; i++ )
{
const int x = qRound( points[i].x() );
const int y = qRound( points[i].y() );
const QRect r( x - sw2, y - sh2, sw, sh );
QwtPainter::drawRect( painter, r );
}
}
else
{
const double sw = size.width();
const double sh = size.height();
const double sw2 = 0.5 * size.width();
const double sh2 = 0.5 * size.height();
for ( int i = 0; i < numPoints; i++ )
{
const double x = points[i].x();
const double y = points[i].y();
const QRectF r( x - sw2, y - sh2, sw, sh );
QwtPainter::drawRect( painter, r );
}
}
}
/*!
\brief Draw symbols
\param painter Painter
\param symbol Curve symbol
\param xMap x map
\param yMap y map
\param from index of the first point to be painted
\param to index of the last point to be painted
\sa setSymbol(), draw(), drawCurve()
*/
void QwtPlotCurve::drawSymbols(QPainter *painter, const QwtSymbol &symbol,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
int from, int to) const
{
painter->setBrush(symbol.brush());
painter->setPen(QwtPainter::scaledPen(symbol.pen()));
const QwtMetricsMap &metricsMap = QwtPainter::metricsMap();
QRect rect;
rect.setSize(metricsMap.screenToLayout(symbol.size()));
if ( to > from && d_data->paintAttributes & PaintFiltered )
{
const QRect window = painter->window();
if ( window.isEmpty() )
return;
PrivateData::PixelMatrix pixelMatrix(window);
for (int i = from; i <= to; i++)
{
const QPoint pi( xMap.transform(x(i)),
yMap.transform(y(i)) );
if ( pixelMatrix.testPixel(pi) )
{
rect.moveCenter(pi);
symbol.draw(painter, rect);
}
}
}
else
{
for (int i = from; i <= to; i++)
{
const int xi = xMap.transform(x(i));
const int yi = yMap.transform(y(i));
rect.moveCenter(QPoint(xi, yi));
symbol.draw(painter, rect);
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPlotCurve::updateCurveAppearance()
{
CVF_ASSERT(m_qwtPlotCurve);
QColor curveColor(m_curveColor.value().rByte(), m_curveColor.value().gByte(), m_curveColor.value().bByte());
QwtSymbol* symbol = nullptr;
if (m_pointSymbol() != RiuQwtSymbol::SYMBOL_NONE)
{
// QwtPlotCurve will take ownership of the symbol
symbol = new RiuQwtSymbol(m_pointSymbol(), m_symbolLabel, m_symbolLabelPosition);
symbol->setSize(m_symbolSize, m_symbolSize);
symbol->setColor(curveColor);
QColor symbolEdgeColor(m_symbolEdgeColor.value().rByte(), m_symbolEdgeColor.value().gByte(), m_symbolEdgeColor.value().bByte());
symbol->setPen(symbolEdgeColor);
}
m_qwtPlotCurve->setAppearance(m_lineStyle(), m_curveInterpolation(), m_curveThickness(), curveColor);
m_qwtPlotCurve->setSymbol(symbol);
m_qwtPlotCurve->setSymbolSkipPixelDistance(m_symbolSkipPixelDistance());
m_qwtPlotCurve->setErrorBarsColor(curveColor);
// Make sure the legend lines are long enough to distinguish between line types.
// Standard width in Qwt is 8 which is too short.
// Use 10 and scale this by curve thickness + add space for displaying symbol.
if (m_lineStyle() != RiuQwtPlotCurve::STYLE_NONE)
{
QSize legendIconSize = m_qwtPlotCurve->legendIconSize();
int symbolWidth = 0;
if (symbol)
{
symbolWidth = symbol->boundingRect().size().width() + 2;
}
int width = std::max(10 * m_curveThickness, (symbolWidth * 3) / 2);
legendIconSize.setWidth(width);
m_qwtPlotCurve->setLegendIconSize(legendIconSize);
}
}
