KisHistogramPainter::Private Class Reference

Public Member Functions
QImage	paintChannels (const QSize &imageSize, const QVector< int > &channels={}, bool logarithmic=false)

Static Public Member Functions
static qreal	bestCutOffHeight (QPolygonF polygon)
static QPair< QColor, QPainter::CompositionMode >	computeChannelPaintingInfo (const KoColorSpace *colorSpace, int channel)
static QPair< QPolygonF, QPolygonF >	computeHistogramShape (KisHistogram *histogram, int channel, quint32 highest)
static qreal	orientationDeviation (const QPointF &A, const QPointF &B, const QPointF &C)
static void	paintHistogramShape (QImage &image, const QPolygonF &polygon, qreal scale, const QColor &color, QPainter::CompositionMode compositionMode)
static void	simplifyHistogramShape (QPolygonF &polygon)
static void	smoothHistogramShape (QPolygonF &polygon)

Public Attributes
QVector< int >	channelsToPaint
QColor	defaultColor
QHash< int, HistogramShapeInfo >	histogramChannelShapeInfo
bool	isLogarithmic {false}
qreal	scale {1.0}

Static Public Attributes
static constexpr qreal	histogramHeightFactor = 0.9
static constexpr qreal	maximumNeighborWeight = 0.33
static constexpr int	maximumNumberOfSimplifiedPoints = 3
static constexpr qreal	maximumOrientationDeviation = M_PI / 16.0
static constexpr qreal	percentageForPercentile = 0.98

Detailed Description

Definition at line 35 of file KisHistogramPainter.cpp.

Member Function Documentation

bestCutOffHeight()

qreal KisHistogramPainter::Private::bestCutOffHeight ( QPolygonF polygon )

static

Definition at line 115 of file KisHistogramPainter.cpp.

{
    const int binOfPercentile = static_cast<int>(std::round((1.0 - percentageForPercentile) * (polygon.size() - 4 - 1)));
    std::nth_element(polygon.begin() + 2,
                     polygon.begin() + 2 + binOfPercentile,
                     polygon.end() - 2,
                     [](const QPointF &p1, const QPointF &p2) ->bool
                     {
                         return p1.y() > p2.y();
                     });
    const qreal percentile = polygon[binOfPercentile + 2].y();
    return qFuzzyIsNull(percentile) ? 1.0 : percentile;
}

References p1, p2, and qFuzzyIsNull().

computeChannelPaintingInfo()

QPair< QColor, QPainter::CompositionMode > KisHistogramPainter::Private::computeChannelPaintingInfo ( const KoColorSpace * colorSpace, int channel )

static

Definition at line 171 of file KisHistogramPainter.cpp.

{
    Q_ASSERT(colorSpace);
    Q_ASSERT(channel >= 0);
 
    QColor color;
    QPainter::CompositionMode compositionMode = QPainter::CompositionMode_SourceOver;
 
    if (colorSpace->colorModelId() == RGBAColorModelID) {
        if (channel == 0) {
            color = Qt::blue;
        } else if (channel == 1) {
            color = Qt::green;
        } else if (channel == 2) {
            color = Qt::red;
        }
        compositionMode = QPainter::CompositionMode_Plus;
    } else if (colorSpace->colorModelId() == XYZAColorModelID) {
        if (channel == 0) {
            color = Qt::red;
        } else if (channel == 1) {
            color = Qt::green;
        } else if (channel == 2) {
            color = Qt::blue;
        }
        compositionMode = QPainter::CompositionMode_Plus;
    } else if (colorSpace->colorModelId() == CMYKAColorModelID) {
        if (channel == 0) {
            color = Qt::cyan;
        } else if (channel == 1) {
            color = Qt::magenta;
        } else if (channel == 2) {
            color = Qt::yellow;
        } else if (channel == 3) {
            color = Qt::black;
        }
        if (channel != 4) {
            color = KoColor(color, KoColorSpaceRegistry::instance()->rgb8())
                    .convertedTo(colorSpace,
                                KoColorConversionTransformation::IntentSaturation,
                                KoColorConversionTransformation::Empty)
                    .toQColor();
            compositionMode = QPainter::CompositionMode_Multiply;
        }
    }
 
    return {color, compositionMode};
}

References CMYKAColorModelID, KoColorSpace::colorModelId(), KoColor::convertedTo(), KoColorConversionTransformation::Empty, KoColorSpaceRegistry::instance(), KoColorConversionTransformation::IntentSaturation, RGBAColorModelID, KoColor::toQColor(), and XYZAColorModelID.

computeHistogramShape()

QPair< QPolygonF, QPolygonF > KisHistogramPainter::Private::computeHistogramShape ( KisHistogram * histogram, int channel, quint32 highest )

static

Definition at line 79 of file KisHistogramPainter.cpp.

{
    Q_ASSERT(histogram);
    Q_ASSERT(channel >= 0);
 
    QPolygonF linearHistogramShape, logarithmicHistogramShape;
    const int bins = histogram->producer()->numberOfBins();
    const qreal heightfactor = 1.0 / static_cast<qreal>(highest);
    const qreal logHeightFactor = 1.0 / std::log(static_cast<qreal>(highest + 1));
    const qreal widthFactor = 1.0 / static_cast<qreal>(bins);
 
    // Add extra points at the beginning and end so that the shape is a bit
    // hidden on the bottom (hides the pen line on the bottom when painting)
    linearHistogramShape.append(QPointF(0.0, -0.1));
    linearHistogramShape.append(QPointF(0.0, 0.0));
    logarithmicHistogramShape.append(QPointF(0.0, -0.1));
    logarithmicHistogramShape.append(QPointF(0.0, 0.0));
 
    for (int i = 0; i < bins; ++i) {
        const QPointF p = QPointF((static_cast<qreal>(i) + 0.5) * widthFactor,
                                  static_cast<qreal>(histogram->getValue(i)) * heightfactor);
        const QPointF logP = QPointF(p.x(), std::log(static_cast<qreal>(histogram->getValue(i) + 1)) * logHeightFactor);
        linearHistogramShape.append(p);
        logarithmicHistogramShape.append(logP);
    }
 
    linearHistogramShape.append(QPointF(1.0, 0.0));
    linearHistogramShape.append(QPointF(1.0, -0.1));
    logarithmicHistogramShape.append(QPointF(1.0, 0.0));
    logarithmicHistogramShape.append(QPointF(1.0, -0.1));
 
    return {linearHistogramShape, logarithmicHistogramShape};
}

References KisHistogram::getValue(), KoHistogramProducer::numberOfBins(), p, and KisHistogram::producer().

orientationDeviation()

qreal KisHistogramPainter::Private::orientationDeviation ( const QPointF & A, const QPointF & B, const QPointF & C )

static

Definition at line 68 of file KisHistogramPainter.cpp.

{
    const QPointF AB = B - A;
    const QPointF BC = C - B;
    const qreal angle =KisAlgebra2D::angleBetweenVectors(AB, BC);
    return angle < -M_PI ? angle + 2.0 * M_PI : (angle > M_PI ? angle - 2.0 * M_PI : angle);
}

References A, KisAlgebra2D::angleBetweenVectors(), B, C, and M_PI.

paintChannels()

QImage KisHistogramPainter::Private::paintChannels	(	const QSize &	imageSize,
		const QVector< int > &	channels = {},
		bool	logarithmic = false )

Definition at line 244 of file KisHistogramPainter.cpp.

{
    QImage image(imageSize, QImage::Format_ARGB32);
    image.fill(0);
 
    const int nChannels = histogramChannelShapeInfo.size();
 
    if (nChannels == 0 || channels.size() == 0) {
        return image;
    }
 
    qreal overallHighest = 0.0;
    for (int channel : channels) {
        if (!histogramChannelShapeInfo.contains(channel)) {
            continue;
        }
 
        const qreal channelHighest = static_cast<qreal>(histogramChannelShapeInfo[channel].highest);
        if (channelHighest > overallHighest) {
            overallHighest = channelHighest;
        }
    }
 
    for (int channel : channels) {
        if (!histogramChannelShapeInfo.contains(channel)) {
            continue;
        }
 
        const HistogramShapeInfo &info = histogramChannelShapeInfo[channel];
        Private::paintHistogramShape(
            image,
            logarithmic ? info.logarithmicHistogram : info.linearHistogram,
            logarithmic
                ? scale * std::log(info.highest + 1.0) / std::log(overallHighest + 1.0)
                : scale * info.highest / overallHighest,
            info.color.isValid() ? info.color : defaultColor,
            info.compositionMode
        );
    }
 
    return image;
}

References KisHistogramPainter::channels(), HistogramShapeInfo::color, HistogramShapeInfo::compositionMode, KisHistogramPainter::defaultColor(), HistogramShapeInfo::highest, HistogramShapeInfo::linearHistogram, HistogramShapeInfo::logarithmicHistogram, paintHistogramShape(), and KisHistogramPainter::scale().

paintHistogramShape()

void KisHistogramPainter::Private::paintHistogramShape ( QImage & image, const QPolygonF & polygon, qreal scale, const QColor & color, QPainter::CompositionMode compositionMode )

static

Definition at line 221 of file KisHistogramPainter.cpp.

{
    const qreal w = static_cast<qreal>(image.width());
    const qreal h = static_cast<qreal>(image.height());
    const qreal maxH = h * histogramHeightFactor;
 
    QPainter p(&image);
    p.setRenderHint(QPainter::Antialiasing);
    p.translate(0.0, h);
    p.scale(w, -scale * maxH);
    QPen pen(color, 2);
    pen.setCosmetic(true);
    QBrush brush(QColor(color.red(), color.green(), color.blue(), 200));
    p.setPen(pen);
    p.setBrush(brush);
    p.setCompositionMode(compositionMode);
    p.drawPolygon(polygon);
}

References p, and KisHistogramPainter::scale().

simplifyHistogramShape()

void KisHistogramPainter::Private::simplifyHistogramShape ( QPolygonF & polygon )

static

Definition at line 148 of file KisHistogramPainter.cpp.

{
    if (polygon.size() < 5) {
        return;
    }
 
    qreal accumulatedOrientationDeviation = 0.0;
    int numberOfSimplifiedPoints = 0;
 
    for (int i = polygon.size() - 3; i > 1; --i) {
        accumulatedOrientationDeviation += orientationDeviation(polygon[i + 1], polygon[i], polygon[i - 1]);
        ++numberOfSimplifiedPoints;
        if (std::abs(accumulatedOrientationDeviation) > maximumOrientationDeviation ||
            numberOfSimplifiedPoints > maximumNumberOfSimplifiedPoints) {
            accumulatedOrientationDeviation = 0.0;
            numberOfSimplifiedPoints = 0;
        } else {
            polygon.remove(i);
        }
    }
}

smoothHistogramShape()

void KisHistogramPainter::Private::smoothHistogramShape ( QPolygonF & polygon )

static

Definition at line 129 of file KisHistogramPainter.cpp.

{
    if (polygon.size() < 5) {
        return;
    }
 
    for (int i = 2; i < polygon.size() - 2; ++i) {
        const qreal leftValue = polygon[i - 1].y();
        const qreal centerValue = polygon[i].y();
        const qreal rightValue = polygon[i + 1].y();
        const qreal leftDelta = std::abs(centerValue - leftValue);
        const qreal rightDelta = std::abs(centerValue - rightValue);
        const qreal leftWeight = maximumNeighborWeight * std::exp(-pow2(10.0 * leftDelta));
        const qreal rightWeight = maximumNeighborWeight * std::exp(-pow2(10.0 * rightDelta));
        const qreal centerWeight = 1.0 - leftWeight - rightWeight;
        polygon[i].setY(leftValue * leftWeight + centerValue * centerWeight + rightValue * rightWeight);
    }
}

References pow2().

Member Data Documentation

channelsToPaint

QVector<int> KisHistogramPainter::Private::channelsToPaint

Definition at line 45 of file KisHistogramPainter.cpp.

defaultColor

QColor KisHistogramPainter::Private::defaultColor

Definition at line 46 of file KisHistogramPainter.cpp.

histogramChannelShapeInfo

QHash<int, HistogramShapeInfo> KisHistogramPainter::Private::histogramChannelShapeInfo

Definition at line 44 of file KisHistogramPainter.cpp.

histogramHeightFactor

constexpr qreal KisHistogramPainter::Private::histogramHeightFactor = 0.9

staticconstexpr

Definition at line 40 of file KisHistogramPainter.cpp.

isLogarithmic

bool KisHistogramPainter::Private::isLogarithmic {false}

Definition at line 48 of file KisHistogramPainter.cpp.

{false};

maximumNeighborWeight

constexpr qreal KisHistogramPainter::Private::maximumNeighborWeight = 0.33

staticconstexpr

Definition at line 41 of file KisHistogramPainter.cpp.

maximumNumberOfSimplifiedPoints

constexpr int KisHistogramPainter::Private::maximumNumberOfSimplifiedPoints = 3

staticconstexpr

Definition at line 39 of file KisHistogramPainter.cpp.

maximumOrientationDeviation

constexpr qreal KisHistogramPainter::Private::maximumOrientationDeviation = M_PI / 16.0

staticconstexpr

Definition at line 38 of file KisHistogramPainter.cpp.

percentageForPercentile

constexpr qreal KisHistogramPainter::Private::percentageForPercentile = 0.98

staticconstexpr

Definition at line 42 of file KisHistogramPainter.cpp.

scale

qreal KisHistogramPainter::Private::scale {1.0}

Definition at line 47 of file KisHistogramPainter.cpp.

{1.0};

---

The documentation for this class was generated from the following file:

• libs/ui/widgets/KisHistogramPainter.cpp