mirror of
https://github.com/jkriege2/JKQtPlotter.git
synced 2024-11-16 10:35:49 +08:00
979 lines
38 KiB
C++
979 lines
38 KiB
C++
/*
|
|
Copyright (c) 2008-2019 Jan W. Krieger (<jan@jkrieger.de>)
|
|
|
|
|
|
|
|
This software is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License (LGPL) as published by
|
|
the Free Software Foundation, either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License (LGPL) for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License (LGPL)
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
|
|
|
|
#include "jkqtplotter/jkqtpgraphsviolinplotstylingmixins.h"
|
|
#include "jkqtplotter/jkqtpbaseplotter.h"
|
|
#include <stdlib.h>
|
|
#include <QDebug>
|
|
#include <iostream>
|
|
#include "jkqtplotter/jkqtptools.h"
|
|
#include "jkqtplotter/jkqtpgraphsimage.h"
|
|
#include "jkqtplotter/jkqtpbaseelements.h"
|
|
#include "jkqtplotter/jkqtplotter.h"
|
|
|
|
|
|
|
|
JKQTPGraphViolinplotStyleMixin::JKQTPGraphViolinplotStyleMixin()
|
|
{
|
|
|
|
m_whiskerLinePen=QPen(getLineColor(), getLineWidth());
|
|
whiskerLineWidth=getLineWidth();
|
|
m_whiskerCapLinePen=QPen(getLineColor(), getLineWidth());
|
|
whiskerCapLineWidth=getLineWidth();
|
|
m_medianLinePen=QPen(getLineColor(), getLineWidth());
|
|
medianLineWidth=getLineWidth();
|
|
|
|
m_meanSymbolLinePen=QPen(getLineColor(), getLineWidth());
|
|
m_meanSymbolLineWidth=1;
|
|
m_meanSymbolType=JKQTPGraphSymbols::JKQTPDefaultSymbol;
|
|
m_meanSymbolSize=12;
|
|
m_meanSymbolFillColor=m_meanSymbolLinePen.color().lighter();
|
|
|
|
|
|
violinWidthAbsolute=m_meanSymbolSize*6.0;
|
|
relativeWhiskerWidth=0.5;
|
|
|
|
m_violinStyle=ViolinStyle::SmoothViolin;
|
|
m_violinPositionMode=ViolinPositionMode::ViolinBoth;
|
|
}
|
|
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::initViolinplotStyle(JKQTBasePlotter *parent, int &parentPlotStyle)
|
|
{
|
|
setFillStyle(Qt::SolidPattern);
|
|
setFillColor(parent->getCurrentPlotterStyle().plotBackgroundBrush.color());
|
|
initLineStyle(parent, parentPlotStyle);
|
|
if (parent) { // get style settings from parent object
|
|
if (parentPlotStyle<0) parentPlotStyle=parent->getNextStyle();
|
|
m_whiskerLinePen.setColor(parent->getPlotStyle(parentPlotStyle).color());
|
|
m_whiskerLinePen.setStyle(parent->getPlotStyle(parentPlotStyle).style());
|
|
whiskerLineWidth=parent->getPlotStyle(parentPlotStyle).widthF();
|
|
m_whiskerCapLinePen.setColor(parent->getPlotStyle(parentPlotStyle).color());
|
|
m_whiskerCapLinePen.setStyle(parent->getPlotStyle(parentPlotStyle).style());
|
|
whiskerCapLineWidth=parent->getPlotStyle(parentPlotStyle).widthF();
|
|
m_medianLinePen.setColor(parent->getPlotStyle(parentPlotStyle).color());
|
|
m_medianLinePen.setStyle(parent->getPlotStyle(parentPlotStyle).style());
|
|
medianLineWidth=parent->getPlotStyle(parentPlotStyle).widthF();
|
|
m_meanSymbolLinePen=QPen(parent->getPlotStyle(parentPlotStyle).color(), parent->getPlotStyle(parentPlotStyle).style());
|
|
m_meanSymbolSize=parent->getPlotStyle(parentPlotStyle).symbolSize();
|
|
m_meanSymbolLineWidth=parent->getPlotStyle(parentPlotStyle).symbolLineWidthF();
|
|
m_meanSymbolType=parent->getPlotStyle(parentPlotStyle).symbol();
|
|
m_meanSymbolFillColor=parent->getPlotStyle(parentPlotStyle).symbolFillColor();
|
|
}
|
|
|
|
setWhiskerLineColor(getLineColor());
|
|
setWhiskerCapLineColor(getLineColor());
|
|
setMedianLineColor(getLineColor());
|
|
setMeanSymbolType(JKQTPPlus);
|
|
|
|
if (m_meanSymbolSize>0) {
|
|
violinWidthAbsolute=m_meanSymbolSize*6.0;
|
|
}
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setViolinWidthAbsolute(double __value)
|
|
{
|
|
violinWidthAbsolute=__value;
|
|
}
|
|
|
|
double JKQTPGraphViolinplotStyleMixin::getViolinWidthAbsolute() const
|
|
{
|
|
return violinWidthAbsolute;
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setViolinplotColor(QColor c, JKQTBasePlotter *parent)
|
|
{
|
|
setLineColor(c);
|
|
setFillColor(JKQTPGetDerivedColor(parent->getCurrentPlotterStyle().graphFillColorDerivationMode, c));
|
|
setMeanColor(c);
|
|
setMeanFillColor(JKQTPGetDerivedColor(parent->getCurrentPlotterStyle().graphFillColorDerivationMode, c));
|
|
setWhiskerLineColor(getLineColor());
|
|
setWhiskerCapLineColor(getLineColor());
|
|
setMedianLineColor(getLineColor());
|
|
c.setAlphaF(0.5);
|
|
setHighlightingLineColor(c);
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setViolinplotColor(QColor c, QColor bc, JKQTBasePlotter *parent)
|
|
{
|
|
setViolinplotColor(c, parent);
|
|
setFillColor(bc);
|
|
setMeanFillColor(bc);
|
|
}
|
|
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setRelativeWhiskerWidth(double __value)
|
|
{
|
|
relativeWhiskerWidth=__value;
|
|
}
|
|
|
|
double JKQTPGraphViolinplotStyleMixin::getRelativeWhiskerWidth() const
|
|
{
|
|
return relativeWhiskerWidth;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMeanSymbolType(JKQTPGraphSymbols __value)
|
|
{
|
|
m_meanSymbolType=__value;
|
|
}
|
|
|
|
JKQTPGraphSymbols JKQTPGraphViolinplotStyleMixin::getMeanSymbolType() const
|
|
{
|
|
return m_meanSymbolType;
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMeanSize(double __value)
|
|
{
|
|
m_meanSymbolSize=__value;
|
|
}
|
|
|
|
double JKQTPGraphViolinplotStyleMixin::getMeanSize() const
|
|
{
|
|
return m_meanSymbolSize;
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMeanColor(const QColor &__value)
|
|
{
|
|
m_meanSymbolLinePen.setColor(__value);
|
|
}
|
|
|
|
QColor JKQTPGraphViolinplotStyleMixin::getMeanColor() const
|
|
{
|
|
return m_meanSymbolLinePen.color();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMeanFillColor(const QColor &__value)
|
|
{
|
|
m_meanSymbolFillColor=__value;
|
|
}
|
|
|
|
QColor JKQTPGraphViolinplotStyleMixin::getMeanFillColor() const
|
|
{
|
|
return m_meanSymbolFillColor;
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMeanLineWidth(double __value)
|
|
{
|
|
m_meanSymbolLineWidth=__value;
|
|
}
|
|
|
|
double JKQTPGraphViolinplotStyleMixin::getMeanLineWidth() const
|
|
{
|
|
return m_meanSymbolLineWidth;
|
|
}
|
|
|
|
JKQTPGraphViolinplotStyleMixin::ViolinStyle JKQTPGraphViolinplotStyleMixin::getViolinStyle() const
|
|
{
|
|
return m_violinStyle;
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setViolinStyle(JKQTPGraphViolinplotStyleMixin::ViolinStyle style)
|
|
{
|
|
m_violinStyle=style;
|
|
}
|
|
|
|
JKQTPGraphViolinplotStyleMixin::ViolinPositionMode JKQTPGraphViolinplotStyleMixin::getViolinPositionMode() const
|
|
{
|
|
return m_violinPositionMode;
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setViolinPositionMode(JKQTPGraphViolinplotStyleMixin::ViolinPositionMode positionMode)
|
|
{
|
|
m_violinPositionMode=positionMode;
|
|
}
|
|
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMeanLineStyle(Qt::PenStyle __value)
|
|
{
|
|
this->m_meanSymbolLinePen.setStyle(__value);
|
|
}
|
|
|
|
Qt::PenStyle JKQTPGraphViolinplotStyleMixin::getMeanLineStyle() const
|
|
{
|
|
return this->m_meanSymbolLinePen.style();
|
|
}
|
|
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMeanLineDashOffset(qreal offset)
|
|
{
|
|
m_meanSymbolLinePen.setDashOffset(offset);
|
|
}
|
|
|
|
qreal JKQTPGraphViolinplotStyleMixin::getMeanLineDashOffset() const
|
|
{
|
|
return m_meanSymbolLinePen.dashOffset();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMeanLineDashPattern(const QVector<qreal> &pattern)
|
|
{
|
|
m_meanSymbolLinePen.setDashPattern(pattern);
|
|
m_meanSymbolLinePen.setStyle(Qt::CustomDashLine);
|
|
}
|
|
|
|
QVector<qreal> JKQTPGraphViolinplotStyleMixin::getMeanLineDashPattern() const
|
|
{
|
|
return m_meanSymbolLinePen.dashPattern();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMedianLineWidth(double __value)
|
|
{
|
|
medianLineWidth=__value;
|
|
}
|
|
|
|
double JKQTPGraphViolinplotStyleMixin::getMedianLineWidth() const
|
|
{
|
|
return medianLineWidth;
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMedianLineColor(QColor __value)
|
|
{
|
|
m_medianLinePen.setColor(__value);
|
|
}
|
|
|
|
QColor JKQTPGraphViolinplotStyleMixin::getMedianLineColor() const
|
|
{
|
|
return m_medianLinePen.color();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMedianLineStyle(Qt::PenStyle __value)
|
|
{
|
|
this->m_medianLinePen.setStyle(__value);
|
|
}
|
|
|
|
Qt::PenStyle JKQTPGraphViolinplotStyleMixin::getMedianLineStyle() const
|
|
{
|
|
return this->m_medianLinePen.style();
|
|
}
|
|
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMedianLineDashOffset(qreal offset)
|
|
{
|
|
m_medianLinePen.setDashOffset(offset);
|
|
}
|
|
|
|
qreal JKQTPGraphViolinplotStyleMixin::getMedianLineDashOffset() const
|
|
{
|
|
return m_medianLinePen.dashOffset();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMedianLineDashPattern(const QVector<qreal> &pattern)
|
|
{
|
|
m_medianLinePen.setDashPattern(pattern);
|
|
m_medianLinePen.setStyle(Qt::CustomDashLine);
|
|
}
|
|
|
|
QVector<qreal> JKQTPGraphViolinplotStyleMixin::getMedianLineDashPattern() const
|
|
{
|
|
return m_medianLinePen.dashPattern();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMedianLineJoinStyle(Qt::PenJoinStyle style)
|
|
{
|
|
m_medianLinePen.setJoinStyle(style);
|
|
}
|
|
|
|
Qt::PenJoinStyle JKQTPGraphViolinplotStyleMixin::getMedianLineJoinStyle() const
|
|
{
|
|
return m_medianLinePen.joinStyle();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMedianLineCapStyle(Qt::PenCapStyle style)
|
|
{
|
|
m_medianLinePen.setCapStyle(style);
|
|
}
|
|
|
|
Qt::PenCapStyle JKQTPGraphViolinplotStyleMixin::getMedianLineCapStyle() const
|
|
{
|
|
return m_medianLinePen.capStyle();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setMedianLineBrush(const QBrush &style)
|
|
{
|
|
m_medianLinePen.setBrush(style);
|
|
}
|
|
|
|
QBrush JKQTPGraphViolinplotStyleMixin::getMedianLineBrush() const
|
|
{
|
|
return m_medianLinePen.brush();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerLineStyle(Qt::PenStyle __value)
|
|
{
|
|
this->m_whiskerLinePen.setStyle(__value);
|
|
}
|
|
|
|
Qt::PenStyle JKQTPGraphViolinplotStyleMixin::getWhiskerLineStyle() const
|
|
{
|
|
return this->m_whiskerLinePen.style();
|
|
}
|
|
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerLineWidth(double __value)
|
|
{
|
|
whiskerLineWidth=__value;
|
|
}
|
|
|
|
double JKQTPGraphViolinplotStyleMixin::getWhiskerLineWidth() const
|
|
{
|
|
return whiskerLineWidth;
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerLineColor(QColor __value)
|
|
{
|
|
m_whiskerLinePen.setColor(__value);
|
|
}
|
|
|
|
QColor JKQTPGraphViolinplotStyleMixin::getWhiskerLineColor() const
|
|
{
|
|
return m_whiskerLinePen.color();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerLineDashOffset(qreal offset)
|
|
{
|
|
m_whiskerLinePen.setDashOffset(offset);
|
|
}
|
|
|
|
qreal JKQTPGraphViolinplotStyleMixin::getWhiskerLineDashOffset() const
|
|
{
|
|
return m_whiskerLinePen.dashOffset();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerLineDashPattern(const QVector<qreal> &pattern)
|
|
{
|
|
m_whiskerLinePen.setDashPattern(pattern);
|
|
m_whiskerLinePen.setStyle(Qt::CustomDashLine);
|
|
}
|
|
|
|
QVector<qreal> JKQTPGraphViolinplotStyleMixin::getWhiskerLineDashPattern() const
|
|
{
|
|
return m_whiskerLinePen.dashPattern();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerLineJoinStyle(Qt::PenJoinStyle style)
|
|
{
|
|
m_whiskerLinePen.setJoinStyle(style);
|
|
}
|
|
|
|
Qt::PenJoinStyle JKQTPGraphViolinplotStyleMixin::getWhiskerLineJoinStyle() const
|
|
{
|
|
return m_whiskerLinePen.joinStyle();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerLineCapStyle(Qt::PenCapStyle style)
|
|
{
|
|
m_whiskerLinePen.setCapStyle(style);
|
|
}
|
|
|
|
Qt::PenCapStyle JKQTPGraphViolinplotStyleMixin::getWhiskerLineCapStyle() const
|
|
{
|
|
return m_whiskerLinePen.capStyle();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerLineBrush(const QBrush &style)
|
|
{
|
|
m_whiskerLinePen.setBrush(style);
|
|
}
|
|
|
|
QBrush JKQTPGraphViolinplotStyleMixin::getWhiskerLineBrush() const
|
|
{
|
|
return m_whiskerLinePen.brush();
|
|
}
|
|
|
|
QPen JKQTPGraphViolinplotStyleMixin::getWhiskerPen(JKQTPEnhancedPainter &painter, JKQTBasePlotter *parent) const
|
|
{
|
|
QPen pw=m_whiskerLinePen;
|
|
pw.setWidthF(qMax(JKQTPlotterDrawingTools::ABS_MIN_LINEWIDTH,parent->pt2px(painter, parent->getLineWidthMultiplier()*whiskerLineWidth)));
|
|
pw.setJoinStyle(Qt::MiterJoin);
|
|
pw.setCapStyle(Qt::FlatCap);
|
|
return pw;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerCapLineStyle(Qt::PenStyle __value)
|
|
{
|
|
this->m_whiskerCapLinePen.setStyle(__value);
|
|
}
|
|
|
|
Qt::PenStyle JKQTPGraphViolinplotStyleMixin::getWhiskerCapLineStyle() const
|
|
{
|
|
return this->m_whiskerCapLinePen.style();
|
|
}
|
|
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerCapLineWidth(double __value)
|
|
{
|
|
whiskerCapLineWidth=__value;
|
|
}
|
|
|
|
double JKQTPGraphViolinplotStyleMixin::getWhiskerCapLineWidth() const
|
|
{
|
|
return whiskerCapLineWidth;
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerCapLineColor(QColor __value)
|
|
{
|
|
m_whiskerCapLinePen.setColor(__value);
|
|
}
|
|
|
|
QColor JKQTPGraphViolinplotStyleMixin::getWhiskerCapLineColor() const
|
|
{
|
|
return m_whiskerCapLinePen.color();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerCapLineDashOffset(qreal offset)
|
|
{
|
|
m_whiskerCapLinePen.setDashOffset(offset);
|
|
}
|
|
|
|
qreal JKQTPGraphViolinplotStyleMixin::getWhiskerCapLineDashOffset() const
|
|
{
|
|
return m_whiskerCapLinePen.dashOffset();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerCapLineDashPattern(const QVector<qreal> &pattern)
|
|
{
|
|
m_whiskerCapLinePen.setDashPattern(pattern);
|
|
m_whiskerCapLinePen.setStyle(Qt::CustomDashLine);
|
|
}
|
|
|
|
QVector<qreal> JKQTPGraphViolinplotStyleMixin::getWhiskerCapLineDashPattern() const
|
|
{
|
|
return m_whiskerCapLinePen.dashPattern();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerCapLineJoinStyle(Qt::PenJoinStyle style)
|
|
{
|
|
m_whiskerCapLinePen.setJoinStyle(style);
|
|
}
|
|
|
|
Qt::PenJoinStyle JKQTPGraphViolinplotStyleMixin::getWhiskerCapLineJoinStyle() const
|
|
{
|
|
return m_whiskerCapLinePen.joinStyle();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerCapLineCapStyle(Qt::PenCapStyle style)
|
|
{
|
|
m_whiskerCapLinePen.setCapStyle(style);
|
|
}
|
|
|
|
Qt::PenCapStyle JKQTPGraphViolinplotStyleMixin::getWhiskerCapLineCapStyle() const
|
|
{
|
|
return m_whiskerCapLinePen.capStyle();
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::setWhiskerCapLineBrush(const QBrush &style)
|
|
{
|
|
m_whiskerCapLinePen.setBrush(style);
|
|
}
|
|
|
|
QBrush JKQTPGraphViolinplotStyleMixin::getWhiskerCapLineBrush() const
|
|
{
|
|
return m_whiskerCapLinePen.brush();
|
|
}
|
|
|
|
QPen JKQTPGraphViolinplotStyleMixin::getWhiskerCapPen(JKQTPEnhancedPainter &painter, JKQTBasePlotter *parent) const
|
|
{
|
|
QPen pw=m_whiskerCapLinePen;
|
|
pw.setWidthF(qMax(JKQTPlotterDrawingTools::ABS_MIN_LINEWIDTH,parent->pt2px(painter, parent->getLineWidthMultiplier()*whiskerCapLineWidth)));
|
|
pw.setJoinStyle(Qt::MiterJoin);
|
|
return pw;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
QPen JKQTPGraphViolinplotStyleMixin::getMedianPen(JKQTPEnhancedPainter &painter, JKQTBasePlotter *parent) const
|
|
{
|
|
QPen pw=m_medianLinePen;
|
|
pw.setWidthF(qMax(JKQTPlotterDrawingTools::ABS_MIN_LINEWIDTH,parent->pt2px(painter, parent->getLineWidthMultiplier()*medianLineWidth)));
|
|
pw.setJoinStyle(Qt::MiterJoin);
|
|
pw.setCapStyle(Qt::FlatCap);
|
|
return pw;
|
|
}
|
|
|
|
QPen JKQTPGraphViolinplotStyleMixin::getMeanSymbolPen(JKQTPEnhancedPainter& painter, JKQTBasePlotter* parent) const {
|
|
QPen p=m_meanSymbolLinePen;
|
|
p.setWidthF(qMax(JKQTPlotterDrawingTools::ABS_MIN_LINEWIDTH,parent->pt2px(painter, parent->getLineWidthMultiplier()*m_meanSymbolLineWidth)));
|
|
p.setStyle(Qt::SolidLine);
|
|
p.setJoinStyle(Qt::RoundJoin);
|
|
p.setCapStyle(Qt::RoundCap);
|
|
return p;
|
|
}
|
|
|
|
QPen JKQTPGraphViolinplotStyleMixin::getMeanLinePen(JKQTPEnhancedPainter& painter, JKQTBasePlotter* parent) const {
|
|
QPen p=m_meanSymbolLinePen;
|
|
p.setWidthF(qMax(JKQTPlotterDrawingTools::ABS_MIN_LINEWIDTH,parent->pt2px(painter, parent->getLineWidthMultiplier()*m_meanSymbolLineWidth)));
|
|
p.setJoinStyle(Qt::MiterJoin);
|
|
p.setCapStyle(Qt::FlatCap);
|
|
return p;
|
|
}
|
|
|
|
QBrush JKQTPGraphViolinplotStyleMixin::getMeanSymbolBrush(JKQTPEnhancedPainter& /*painter*/, JKQTBasePlotter* /*parent*/) const {
|
|
QBrush b;
|
|
b.setColor(m_meanSymbolFillColor);
|
|
return b;
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::plotStyledMeanSymbol(JKQTBasePlotter *parent, JKQTPEnhancedPainter &painter, double x, double y) const
|
|
{
|
|
JKQTPPlotSymbol(painter, x, y,m_meanSymbolType, parent->pt2px(painter, m_meanSymbolSize), parent->pt2px(painter, m_meanSymbolLineWidth*parent->getLineWidthMultiplier()), m_meanSymbolLinePen.color(), m_meanSymbolFillColor);
|
|
}
|
|
|
|
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::plotVerticalViolinplot(JKQTBasePlotter *parent, JKQTPEnhancedPainter &painter, double xp, double xpleft, double xpright, const QVector<double> &violin_cat, const QVector<double> &violin_freq, double minp, double medianp, double maxp, double meanp) const
|
|
{
|
|
if (JKQTPIsOKFloat(xp) ) {
|
|
painter.save(); auto __finalpaint=JKQTPFinally([&painter]() {painter.restore();});
|
|
painter.setBrush(Qt::NoBrush);
|
|
|
|
|
|
double minstop=medianp;
|
|
double maxstop=medianp;
|
|
if (!JKQTPIsOKFloat(minstop) && JKQTPIsOKFloat(meanp)) minstop=meanp;
|
|
else if (!JKQTPIsOKFloat(minstop) && JKQTPIsOKFloat(maxp)) minstop=maxp;
|
|
if (!JKQTPIsOKFloat(maxstop) && JKQTPIsOKFloat(meanp)) maxstop=meanp;
|
|
else if (!JKQTPIsOKFloat(maxstop) && JKQTPIsOKFloat(minp)) maxstop=minp;
|
|
const double wl=fabs(xpright-xp);
|
|
const double wr=fabs(xpleft-xp);
|
|
const double xprightWhisker=xp+wr*getRelativeWhiskerWidth();
|
|
const double xpleftWhisker=xp-wl*getRelativeWhiskerWidth();
|
|
|
|
|
|
// draw violin
|
|
const int NViol=std::min(violin_cat.size(), violin_freq.size());
|
|
double medianMin=xpleft;
|
|
double medianMax=xpright;
|
|
if (NViol>0) {
|
|
double fmin=violin_freq[0], fmax=violin_freq[0];
|
|
for (int i=1; i<NViol; i++) {
|
|
fmin=std::min(fmin, violin_freq[i]);
|
|
fmax=std::max(fmax, violin_freq[i]);
|
|
}
|
|
|
|
const double freqFactorr=1.0/fmax*fabs(xpright-xp);
|
|
const double freqFactorl=1.0/fmax*fabs(xpleft-xp);
|
|
|
|
if (m_violinStyle==ViolinStyle::BoxViolin && NViol>1) {
|
|
painter.save(); auto __finalpaint=JKQTPFinally([&painter]() {painter.restore();});
|
|
painter.setPen(getLinePen(painter, parent));
|
|
painter.setBrush(getFillBrush(painter, parent));
|
|
|
|
for (int i=0; i<NViol; i++) {
|
|
if (i==0) {
|
|
const double hl=(violin_cat[1]-violin_cat[0]);
|
|
if (m_violinPositionMode==ViolinBoth) {
|
|
painter.drawRect(QRectF(QPointF(xp-violin_freq[i]*freqFactorl, violin_cat.first()), QPointF(xp+violin_freq[i]*freqFactorr, violin_cat.first()+hl/2.0)));
|
|
} else if (m_violinPositionMode==ViolinLeft) {
|
|
painter.drawRect(QRectF(QPointF(xp-violin_freq[i]*freqFactorl, violin_cat.first()), QPointF(xp, violin_cat.first()+hl/2.0)));
|
|
} else if (m_violinPositionMode==ViolinRight) {
|
|
painter.drawRect(QRectF(QPointF(xp, violin_cat.first()), QPointF(xp+violin_freq[i]*freqFactorr, violin_cat.first()+hl/2.0)));
|
|
}
|
|
|
|
} else if (i>0 && i<NViol-1) {
|
|
const double hl=(violin_cat[i]-violin_cat[i-1]);
|
|
if (m_violinPositionMode==ViolinBoth) {
|
|
painter.drawRect(QRectF(QPointF(xp-violin_freq[i]*freqFactorl, violin_cat[i]-hl/2.0), QPointF(xp+violin_freq[i]*freqFactorr, violin_cat[i]+hl/2.0)));
|
|
} else if (m_violinPositionMode==ViolinLeft) {
|
|
painter.drawRect(QRectF(QPointF(xp-violin_freq[i]*freqFactorl, violin_cat[i]-hl/2.0), QPointF(xp, violin_cat[i]+hl/2.0)));
|
|
} else if (m_violinPositionMode==ViolinRight) {
|
|
painter.drawRect(QRectF(QPointF(xp, violin_cat[i]-hl/2.0), QPointF(xp+violin_freq[i]*freqFactorr, violin_cat[i]+hl/2.0)));
|
|
}
|
|
} else if (i==NViol-1) {
|
|
const double hl=(violin_cat[i]-violin_cat[i-1]);
|
|
if (m_violinPositionMode==ViolinBoth) {
|
|
painter.drawRect(QRectF(QPointF(xp-violin_freq[i]*freqFactorl, violin_cat[i]-hl/2.0), QPointF(xp+violin_freq[i]*freqFactorr, violin_cat[i])));
|
|
} else if (m_violinPositionMode==ViolinLeft) {
|
|
painter.drawRect(QRectF(QPointF(xp-violin_freq[i]*freqFactorl, violin_cat[i]-hl/2.0), QPointF(xp, violin_cat[i])));
|
|
} else if (m_violinPositionMode==ViolinRight) {
|
|
painter.drawRect(QRectF(QPointF(xp, violin_cat[i]-hl/2.0), QPointF(xp+violin_freq[i]*freqFactorr, violin_cat[i])));
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
} else if (m_violinStyle==ViolinStyle::SmoothViolin && NViol>1) {
|
|
QPolygonF pleft, pright;
|
|
pleft<<QPointF(xp, violin_cat.first());
|
|
pright<<QPointF(xp, violin_cat.last());
|
|
for (int i=0; i<NViol; i++) {
|
|
pleft<<QPointF(xp-violin_freq[i]*freqFactorl, violin_cat[i]);
|
|
pright<<QPointF(xp+violin_freq[NViol-1-i]*freqFactorr, violin_cat[NViol-1-i]);
|
|
}
|
|
pleft<<QPointF(xp, violin_cat.last());
|
|
pright<<QPointF(xp, violin_cat.first());
|
|
|
|
|
|
painter.save(); auto __finalpaint=JKQTPFinally([&painter]() {painter.restore();});
|
|
painter.setPen(getLinePen(painter, parent));
|
|
painter.setBrush(getFillBrush(painter, parent));
|
|
if (m_violinPositionMode==ViolinBoth) {
|
|
pleft.append(pright);
|
|
painter.drawPolygon(pleft);
|
|
} else if (m_violinPositionMode==ViolinLeft) {
|
|
painter.drawPolygon(pleft);
|
|
} else if (m_violinPositionMode==ViolinRight) {
|
|
painter.drawPolygon(pright);
|
|
}
|
|
} else if (m_violinStyle==ViolinStyle::StepViolin && NViol>1) {
|
|
QPolygonF pleft, pright;
|
|
for (int i=0; i<NViol; i++) {
|
|
if (i==0) {
|
|
const double hl=(violin_cat[1]-violin_cat[0]);
|
|
pleft<<QPointF(xp, violin_cat.first())
|
|
<<QPointF(xp-violin_freq[i]*freqFactorl, violin_cat.first())
|
|
<<QPointF(xp-violin_freq[i]*freqFactorl, violin_cat.first()+hl/2.0);
|
|
} else if (i>0 && i<NViol-1) {
|
|
const double hl=(violin_cat[i]-violin_cat[i-1]);
|
|
pleft<<QPointF(xp-violin_freq[i]*freqFactorl, violin_cat[i]-hl/2.0)
|
|
<<QPointF(xp-violin_freq[i]*freqFactorl, violin_cat[i]+hl/2.0);
|
|
} else if (i==NViol-1) {
|
|
const double hl=(violin_cat[i]-violin_cat[i-1]);
|
|
pleft<<QPointF(xp-violin_freq[i]*freqFactorl, violin_cat[i]-hl/2.0)
|
|
<<QPointF(xp-violin_freq[i]*freqFactorl, violin_cat[i])
|
|
<<QPointF(xp, violin_cat[i]);
|
|
|
|
}
|
|
if (i==0) {
|
|
const double hr=fabs(violin_cat[NViol-1]-violin_cat[NViol-2]);
|
|
pright<<QPointF(xp, violin_cat.last())
|
|
<<QPointF(xp+violin_freq.last()*freqFactorr, violin_cat.last())
|
|
<<QPointF(xp+violin_freq.last()*freqFactorr, violin_cat.last()+hr/2.0);
|
|
} else if (i>0 && i<NViol-1) {
|
|
const double hr=fabs(violin_cat[NViol-1-i]-violin_cat[NViol-1-i-1]);
|
|
pright<<QPointF(xp+violin_freq[NViol-1-i]*freqFactorr, violin_cat[NViol-1-i]-hr/2.0)
|
|
<<QPointF(xp+violin_freq[NViol-1-i]*freqFactorr, violin_cat[NViol-1-i]+hr/2.0);
|
|
} else if (i==NViol-1) {
|
|
const double hr=fabs(violin_cat[1]-violin_cat[0]);
|
|
pright<<QPointF(xp+violin_freq[0]*freqFactorr, violin_cat[0]-hr/2.0)
|
|
<<QPointF(xp+violin_freq[0]*freqFactorr, violin_cat[0])
|
|
<<QPointF(xp, violin_cat[0]);
|
|
}
|
|
}
|
|
|
|
painter.save(); auto __finalpaint=JKQTPFinally([&painter]() {painter.restore();});
|
|
painter.setPen(getLinePen(painter, parent));
|
|
painter.setBrush(getFillBrush(painter, parent));
|
|
if (m_violinPositionMode==ViolinBoth) {
|
|
pleft.append(pright);
|
|
painter.drawPolygon(pleft);
|
|
} else if (m_violinPositionMode==ViolinLeft) {
|
|
painter.drawPolygon(pleft);
|
|
} else if (m_violinPositionMode==ViolinRight) {
|
|
painter.drawPolygon(pright);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// whisker lines
|
|
painter.setPen(getWhiskerPen(painter, parent));
|
|
if (JKQTPIsOKFloat(minp) && JKQTPIsOKFloat(minstop)) {
|
|
painter.drawLine(QLineF(xp, minp, xp, minstop));
|
|
}
|
|
if (JKQTPIsOKFloat(maxp) && JKQTPIsOKFloat(maxstop)) {
|
|
painter.drawLine(QLineF(xp, maxp, xp, maxstop));
|
|
}
|
|
|
|
// whisker caps
|
|
if (JKQTPIsOKFloat(xpleftWhisker) && JKQTPIsOKFloat(xprightWhisker)){
|
|
painter.setPen(getWhiskerCapPen(painter, parent));
|
|
if (JKQTPIsOKFloat(minp)) {
|
|
painter.drawLine(QLineF(xpleftWhisker, minp, xprightWhisker, minp));
|
|
}
|
|
if (JKQTPIsOKFloat(maxp)) {
|
|
painter.drawLine(QLineF(xpleftWhisker, maxp, xprightWhisker, maxp));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// draw median
|
|
if (JKQTPIsOKFloat(medianp)) {
|
|
painter.setBrush(Qt::NoBrush);
|
|
painter.setPen(getMedianPen(painter, parent));
|
|
painter.drawLine(QLineF(medianMin, medianp, medianMax, medianp));
|
|
}
|
|
|
|
// draw mean
|
|
if (JKQTPIsOKFloat(meanp)) {
|
|
painter.setBrush(Qt::NoBrush);
|
|
plotStyledMeanSymbol(parent, painter,xp,meanp);
|
|
}
|
|
}
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::plotHorizontalViolinplot(JKQTBasePlotter *parent, JKQTPEnhancedPainter &painter, double yp, double ypbottom, double yptop, const QVector<double> &violin_cat, const QVector<double> &violin_freq, double minp, double medianp, double maxp, double meanp) const
|
|
{
|
|
if (JKQTPIsOKFloat(yp) ) {
|
|
painter.save(); auto __finalpaint=JKQTPFinally([&painter]() {painter.restore();});
|
|
painter.setBrush(Qt::NoBrush);
|
|
|
|
|
|
double minstop=medianp;
|
|
double maxstop=medianp;
|
|
if (!JKQTPIsOKFloat(minstop) && JKQTPIsOKFloat(meanp)) minstop=meanp;
|
|
else if (!JKQTPIsOKFloat(minstop) && JKQTPIsOKFloat(maxp)) minstop=maxp;
|
|
if (!JKQTPIsOKFloat(maxstop) && JKQTPIsOKFloat(meanp)) maxstop=meanp;
|
|
else if (!JKQTPIsOKFloat(maxstop) && JKQTPIsOKFloat(minp)) maxstop=minp;
|
|
const double wbot=fabs(ypbottom-yp);
|
|
const double wtop=fabs(yptop-yp);
|
|
const double xbottomWhisker=yp+wbot*getRelativeWhiskerWidth();
|
|
const double xptopWhisker=yp-wtop*getRelativeWhiskerWidth();
|
|
|
|
|
|
|
|
// draw violin
|
|
const int NViol=std::min(violin_cat.size(), violin_freq.size());
|
|
double medianMin=ypbottom;
|
|
double medianMax=yptop;
|
|
if (NViol>0) {
|
|
double fmin=violin_freq[0], fmax=violin_freq[0];
|
|
for (int i=1; i<NViol; i++) {
|
|
fmin=std::min(fmin, violin_freq[i]);
|
|
fmax=std::max(fmax, violin_freq[i]);
|
|
}
|
|
|
|
const double freqFactorr=1.0/fmax*fabs(yptop-yp);
|
|
const double freqFactorl=1.0/fmax*fabs(ypbottom-yp);
|
|
|
|
if (m_violinStyle==ViolinStyle::BoxViolin && NViol>1) {
|
|
painter.save(); auto __finalpaint=JKQTPFinally([&painter]() {painter.restore();});
|
|
painter.setPen(getLinePen(painter, parent));
|
|
painter.setBrush(getFillBrush(painter, parent));
|
|
|
|
for (int i=0; i<NViol; i++) {
|
|
if (i==0) {
|
|
const double hl=(violin_cat[1]-violin_cat[0]);
|
|
if (m_violinPositionMode==ViolinBoth) {
|
|
painter.drawRect(QRectF(QPointF(violin_cat.first(), yp+violin_freq[i]*freqFactorl), QPointF(violin_cat.first()+hl/2.0, yp-violin_freq[i]*freqFactorr)));
|
|
} else if (m_violinPositionMode==ViolinLeft) {
|
|
painter.drawRect(QRectF(QPointF(violin_cat.first(), yp+violin_freq[i]*freqFactorl), QPointF(violin_cat.first()+hl/2.0, yp)));
|
|
} else if (m_violinPositionMode==ViolinRight) {
|
|
painter.drawRect(QRectF(QPointF(violin_cat.first(), yp), QPointF(violin_cat.first()+hl/2.0, yp-violin_freq[i]*freqFactorr)));
|
|
}
|
|
|
|
} else if (i>0 && i<NViol-1) {
|
|
const double hl=(violin_cat[i]-violin_cat[i-1]);
|
|
if (m_violinPositionMode==ViolinBoth) {
|
|
painter.drawRect(QRectF(QPointF(violin_cat[i]-hl/2.0, yp+violin_freq[i]*freqFactorl), QPointF(violin_cat[i]+hl/2.0, yp-violin_freq[i]*freqFactorr)));
|
|
} else if (m_violinPositionMode==ViolinLeft) {
|
|
painter.drawRect(QRectF(QPointF(violin_cat[i]-hl/2.0, yp+violin_freq[i]*freqFactorl), QPointF(violin_cat[i]+hl/2.0, yp)));
|
|
} else if (m_violinPositionMode==ViolinRight) {
|
|
painter.drawRect(QRectF(QPointF(violin_cat[i]-hl/2.0, yp), QPointF(violin_cat[i]+hl/2.0, yp-violin_freq[i]*freqFactorr)));
|
|
}
|
|
} else if (i==NViol-1) {
|
|
const double hl=(violin_cat[i]-violin_cat[i-1]);
|
|
if (m_violinPositionMode==ViolinBoth) {
|
|
painter.drawRect(QRectF(QPointF(violin_cat[i]-hl/2.0, yp+violin_freq[i]*freqFactorl), QPointF(violin_cat[i], yp-violin_freq[i]*freqFactorr)));
|
|
} else if (m_violinPositionMode==ViolinLeft) {
|
|
painter.drawRect(QRectF(QPointF(violin_cat[i]-hl/2.0, yp+violin_freq[i]*freqFactorl), QPointF(violin_cat[i], yp)));
|
|
} else if (m_violinPositionMode==ViolinRight) {
|
|
painter.drawRect(QRectF(QPointF(violin_cat[i]-hl/2.0, yp), QPointF(violin_cat[i], yp-violin_freq[i]*freqFactorr)));
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
} else if (m_violinStyle==ViolinStyle::SmoothViolin && NViol>1) {
|
|
QPolygonF pleft, pright;
|
|
pleft<<QPointF(violin_cat.first(), yp);
|
|
pright<<QPointF(violin_cat.last(), yp);
|
|
for (int i=0; i<NViol; i++) {
|
|
pleft<<QPointF(violin_cat[i], yp+violin_freq[i]*freqFactorl);
|
|
pright<<QPointF(violin_cat[NViol-1-i], yp-violin_freq[NViol-1-i]*freqFactorr);
|
|
}
|
|
pleft<<QPointF(violin_cat.last(), yp);
|
|
pright<<QPointF(violin_cat.first(), yp);
|
|
|
|
|
|
painter.save(); auto __finalpaint=JKQTPFinally([&painter]() {painter.restore();});
|
|
painter.setPen(getLinePen(painter, parent));
|
|
painter.setBrush(getFillBrush(painter, parent));
|
|
if (m_violinPositionMode==ViolinBoth) {
|
|
pleft.append(pright);
|
|
painter.drawPolygon(pleft);
|
|
} else if (m_violinPositionMode==ViolinLeft) {
|
|
painter.drawPolygon(pleft);
|
|
} else if (m_violinPositionMode==ViolinRight) {
|
|
painter.drawPolygon(pright);
|
|
}
|
|
} else if (m_violinStyle==ViolinStyle::StepViolin && NViol>1) {
|
|
QPolygonF pleft, pright;
|
|
for (int i=0; i<NViol; i++) {
|
|
if (i==0) {
|
|
const double hl=(violin_cat[1]-violin_cat[0]);
|
|
pleft<<QPointF(violin_cat.first(), yp)
|
|
<<QPointF(violin_cat.first(), yp+violin_freq[i]*freqFactorl)
|
|
<<QPointF(violin_cat.first()+hl/2.0, yp+violin_freq[i]*freqFactorl);
|
|
} else if (i>0 && i<NViol-1) {
|
|
const double hl=(violin_cat[i]-violin_cat[i-1]);
|
|
pleft<<QPointF(violin_cat[i]-hl/2.0, yp+violin_freq[i]*freqFactorl)
|
|
<<QPointF(violin_cat[i]+hl/2.0, yp+violin_freq[i]*freqFactorl);
|
|
} else if (i==NViol-1) {
|
|
const double hl=(violin_cat[i]-violin_cat[i-1]);
|
|
pleft<<QPointF(violin_cat[i]-hl/2.0, yp+violin_freq[i]*freqFactorl)
|
|
<<QPointF(violin_cat[i], yp+violin_freq[i]*freqFactorl)
|
|
<<QPointF(violin_cat[i], yp);
|
|
|
|
}
|
|
if (i==0) {
|
|
const double hr=-fabs(violin_cat[NViol-1]-violin_cat[NViol-2]);
|
|
pright<<QPointF(violin_cat.last(), yp)
|
|
<<QPointF(violin_cat.last(), yp-violin_freq.last()*freqFactorr)
|
|
<<QPointF(violin_cat.last()+hr/2.0, yp-violin_freq.last()*freqFactorr);
|
|
} else if (i>0 && i<NViol-1) {
|
|
const double hr=-fabs(violin_cat[NViol-1-i]-violin_cat[NViol-1-i-1]);
|
|
pright<<QPointF(violin_cat[NViol-1-i]-hr/2.0, yp-violin_freq[NViol-1-i]*freqFactorr)
|
|
<<QPointF(violin_cat[NViol-1-i]+hr/2.0, yp-violin_freq[NViol-1-i]*freqFactorr);
|
|
} else if (i==NViol-1) {
|
|
const double hr=-fabs(violin_cat[1]-violin_cat[0]);
|
|
pright<<QPointF(violin_cat[0]-hr/2.0, yp-violin_freq[0]*freqFactorr)
|
|
<<QPointF(violin_cat[0], yp-violin_freq[0]*freqFactorr)
|
|
<<QPointF(violin_cat[0], yp);
|
|
}
|
|
}
|
|
|
|
painter.save(); auto __finalpaint=JKQTPFinally([&painter]() {painter.restore();});
|
|
painter.setPen(getLinePen(painter, parent));
|
|
painter.setBrush(getFillBrush(painter, parent));
|
|
if (m_violinPositionMode==ViolinBoth) {
|
|
pleft.append(pright);
|
|
painter.drawPolygon(pleft);
|
|
} else if (m_violinPositionMode==ViolinLeft) {
|
|
painter.drawPolygon(pleft);
|
|
} else if (m_violinPositionMode==ViolinRight) {
|
|
painter.drawPolygon(pright);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// whisker lines
|
|
painter.setPen(getWhiskerPen(painter, parent));
|
|
if (JKQTPIsOKFloat(minp) && JKQTPIsOKFloat(minstop)) {
|
|
painter.drawLine(QLineF(minp, yp, minstop, yp));
|
|
}
|
|
if (JKQTPIsOKFloat(maxp) && JKQTPIsOKFloat(maxstop)) {
|
|
painter.drawLine(QLineF(maxp, yp, maxstop, yp));
|
|
}
|
|
|
|
// whisker caps
|
|
if (JKQTPIsOKFloat(xptopWhisker) && JKQTPIsOKFloat(xbottomWhisker)){
|
|
painter.setPen(getWhiskerCapPen(painter, parent));
|
|
if (JKQTPIsOKFloat(minp)) {
|
|
painter.drawLine(QLineF(minp, xptopWhisker, minp, xbottomWhisker));
|
|
}
|
|
if (JKQTPIsOKFloat(maxp)) {
|
|
painter.drawLine(QLineF(maxp, xptopWhisker, maxp, xbottomWhisker));
|
|
}
|
|
}
|
|
|
|
// draw median
|
|
if (JKQTPIsOKFloat(medianp)) {
|
|
painter.setBrush(Qt::NoBrush);
|
|
painter.setPen(getMedianPen(painter, parent));
|
|
painter.drawLine(QLineF(medianp, medianMin, medianp, medianMax));
|
|
}
|
|
|
|
// draw mean
|
|
if (JKQTPIsOKFloat(meanp)) {
|
|
painter.setBrush(Qt::NoBrush);
|
|
plotStyledMeanSymbol(parent, painter,meanp,yp);
|
|
}
|
|
}
|
|
}
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::plotVerticalKeyMarker(JKQTBasePlotter *parent, JKQTPEnhancedPainter &painter, const QRectF &rect)
|
|
{
|
|
painter.save(); auto __finalpaint=JKQTPFinally([&painter]() {painter.restore();});
|
|
QPen p=getLinePenForRects(painter, parent);
|
|
QPen pw=getWhiskerPen(painter, parent);
|
|
QPen pm=getMedianPen(painter, parent);
|
|
QPen np(Qt::NoPen);
|
|
QBrush b=getFillBrush(painter, parent);
|
|
|
|
p.setWidthF(qMin(0.5, p.widthF()));
|
|
p.setStyle(Qt::SolidLine);
|
|
pw.setWidthF(qMin(0.5, pw.widthF()));
|
|
pw.setStyle(Qt::SolidLine);
|
|
pm.setWidthF(qMin(0.5, pm.widthF()));
|
|
pm.setStyle(Qt::SolidLine);
|
|
|
|
const double x=rect.left()+rect.width()/2.0;
|
|
const double xma=x+rect.width()/2.5;
|
|
const double xmi=x-rect.width()/2.5;
|
|
const double min=rect.bottom();
|
|
const double max=rect.top();
|
|
const double median=max+rect.height()/2.0;
|
|
|
|
QPainterPath path;
|
|
|
|
path.moveTo(x,max);
|
|
path.cubicTo(x,max+rect.height()/4.0,xma,median-rect.height()/4.0,xma,median);
|
|
path.cubicTo(xma,median+rect.height()/4.0,x,min-rect.height()/4.0,x,min);
|
|
path.cubicTo(x,min-rect.height()/4.0,xmi,median+rect.height()/4.0,xmi,median);
|
|
path.cubicTo(xmi,median-rect.height()/4.0,x,max+rect.height()/4.0,x,max);
|
|
|
|
|
|
painter.setPen(p);
|
|
{
|
|
painter.save(); auto __finalpaint=JKQTPFinally([&painter]() {painter.restore();});
|
|
painter.setBrush(b);
|
|
painter.drawPath(path);
|
|
}
|
|
|
|
painter.setPen(pm);
|
|
painter.drawLine(QLineF(xmi, median, xma, median));
|
|
painter.setPen(pw);
|
|
painter.drawLine(QLineF(x, max, x, min));
|
|
}
|
|
|
|
|
|
void JKQTPGraphViolinplotStyleMixin::plotHorizontalKeyMarker(JKQTBasePlotter *parent, JKQTPEnhancedPainter &painter, const QRectF &rect)
|
|
{
|
|
painter.save(); auto __finalpaint=JKQTPFinally([&painter]() {painter.restore();});
|
|
|
|
painter.translate(rect.center());
|
|
painter.rotate(90);
|
|
painter.translate(-1.0*rect.height()/2.0, -1.0*rect.width()/2.0);
|
|
plotVerticalKeyMarker(parent, painter, QRectF(0,0,rect.height(),rect.width()));
|
|
}
|