HistogramDockerWidget Class Reference

#include <histogramdockerwidget.h>

Inheritance diagram for HistogramDockerWidget:

Public Slots
void	enableLogarithmic (bool enable)
void	receiveNewHistogram (HistogramData data)

Public Member Functions
	HistogramDockerWidget (QWidget *parent=0, const char *name=0, Qt::WindowFlags f=Qt::WindowFlags())
void	paintEvent (QPaintEvent *event) override
	~HistogramDockerWidget () override
Public Member Functions inherited from KisWidgetWithIdleTask< QLabel >
void	hideEvent (QHideEvent *event) override
	KisWidgetWithIdleTask (QWidget *parent=0, Qt::WindowFlags flags=Qt::WindowFlags())
virtual void	setCanvas (KisCanvas2 *canvas)
void	showEvent (QShowEvent *event) override
void	triggerCacheUpdate ()
	~KisWidgetWithIdleTask () override=default

Private Member Functions
void	clearCachedState () override
KisIdleTasksManager::TaskGuard	registerIdleTask (KisCanvas2 *canvas) override

Private Attributes
const KoColorSpace *	m_colorSpace {0}
HistVector	m_histogramData
HistVector	m_histogramDataLog
bool	m_logarithmic {false}
float	m_maximumValue {1.0}
bool	m_smoothHistogram {false}

Additional Inherited Members
Protected Attributes inherited from KisWidgetWithIdleTask< QLabel >
KisCanvas2 *	m_canvas
KisIdleTasksManager::TaskGuard	m_idleTaskGuard
bool	m_isVisibleState

Detailed Description

Definition at line 20 of file histogramdockerwidget.h.

Constructor & Destructor Documentation

HistogramDockerWidget()

HistogramDockerWidget::HistogramDockerWidget	(	QWidget *	parent = 0,
		const char *	name = 0,
		Qt::WindowFlags	f = Qt::WindowFlags() )

Definition at line 24 of file histogramdockerwidget.cpp.

    : KisWidgetWithIdleTask<QLabel>(parent, f)
{
    setObjectName(name);
    qRegisterMetaType<HistogramData>();
}

~HistogramDockerWidget()

HistogramDockerWidget::~HistogramDockerWidget ( )

override

Definition at line 31 of file histogramdockerwidget.cpp.

{
}

Member Function Documentation

clearCachedState()

void HistogramDockerWidget::clearCachedState ( )

overrideprivatevirtual

Implements KisWidgetWithIdleTask< QLabel >.

Definition at line 67 of file histogramdockerwidget.cpp.

{
    m_colorSpace = 0;
    m_histogramData.clear();
    m_histogramDataLog.clear();
}

References m_colorSpace, m_histogramData, and m_histogramDataLog.

enableLogarithmic

void HistogramDockerWidget::enableLogarithmic ( bool enable )

slot

Definition at line 44 of file histogramdockerwidget.cpp.

{
    if (m_logarithmic == enable) return;
    m_logarithmic = enable;
    update();
}

References m_logarithmic.

paintEvent()

void HistogramDockerWidget::paintEvent ( QPaintEvent * event )

override

Definition at line 118 of file histogramdockerwidget.cpp.

{
    if (m_colorSpace && !m_histogramData.empty()) {
        int nBins = m_logarithmic? m_histogramData.at(0).size(): m_histogramDataLog.at(0).size();
        const KoColorSpace* cs = m_colorSpace;
 
        QLabel::paintEvent(event);
        QPainter painter(this);
        painter.fillRect(0, 0, this->width(), this->height(), this->palette().dark().color());
        painter.setPen(this->palette().light().color());
 
        const int gridHeight = this->height() - painter.fontMetrics().height();
 
        painter.save();
 
        QMap<float, float> horGrid = m_logarithmic? calculateLogGridLines(this->width(), m_maximumValue): calculateLinearGridLines(this->width(), m_maximumValue);
        Q_FOREACH (float k, horGrid.keys()) {
            float i = horGrid.value(k);
            painter.drawLine(qRound(i), 0, qRound(i), gridHeight);
            painter.drawText(QPointF(qRound(i), this->height()-2), QString::number(k));
        }
 
        unsigned int nChannels = cs->channelCount();
        const QList<KoChannelInfo *> channels = cs->channels();
        unsigned int highest = 0;
        //find the most populous bin in the histogram to scale it properly
        for (int chan = 0; chan < channels.size(); chan++) {
            if (channels.at(chan)->channelType() != KoChannelInfo::ALPHA) {
                std::vector<quint32> histogramTemp = m_logarithmic? m_histogramDataLog.at(chan): m_histogramData.at(chan);
                //use 98th percentile, rather than max for better visual appearance
                int nthPercentile = 2 * histogramTemp.size() / 100;
                //unsigned int max = *std::max_element(m_histogramData.at(chan).begin(),m_histogramData.at(chan).end());
                std::nth_element(histogramTemp.begin(),
                                 histogramTemp.begin() + nthPercentile, histogramTemp.end(), std::greater<int>());
                unsigned int max = *(histogramTemp.begin() + nthPercentile);
 
                highest = std::max(max, highest);
            }
        }
 
        QMap<float, float> vertGrid = m_logarithmic? calculateLogGridLines(gridHeight, highest): calculateLinearGridLines(gridHeight, highest);
        Q_FOREACH (float k, vertGrid.keys()) {
            float i = vertGrid.value(k);
            painter.drawLine(0., gridHeight -i, this->width(), gridHeight -i);
        }
 
        painter.restore();
 
        painter.setCompositionMode(QPainter::CompositionMode_Plus);
        const float barWidth = float(this->width()-1) / float(nBins);
        float logVerticalMax = std::log10(vertGrid.keys().last()*10)*0.1;
 
        for (int chan = 0; chan < (int)nChannels; chan++) {
            if (channels.at(chan)->channelType() != KoChannelInfo::ALPHA) {
                QColor color = channels.at(chan)->color();
 
                //special handling of grayscale color spaces. can't use color returned above.
                if(cs->colorChannelCount()==1){
                    color = QColor(Qt::gray);
                }
 
                QColor fill_color = color;
                fill_color.setAlphaF(.25);
                painter.setBrush(fill_color);
                QPen pen = QPen(color);
                pen.setWidth(0);
                painter.setPen(pen);
 
                if (m_smoothHistogram) {
                    QPainterPath path;
                    path.moveTo(QPointF(1, gridHeight));
                    for (qint32 i = 0; i < nBins; ++i) {
                        const float curBinVertical = !m_logarithmic? m_histogramData[chan][i]
                                                                    : std::log(m_histogramDataLog[chan][i]+1);
                        const float maxBin = !m_logarithmic? highest: logVerticalMax;
                        const float v = curBinVertical > 0? ((std::max((float)maxBin - curBinVertical, 0.f))/maxBin)*gridHeight: 0;
                        path.lineTo(QPointF((i*barWidth) - (barWidth*0.5), v));
 
                    }
                    path.lineTo(QPointF(this->width(), gridHeight));
                    path.closeSubpath();
                    painter.drawPath(path);
                } else {
                    painter.setBrush(color);
                    painter.setPen(Qt::transparent);
                    float start = 1.0;
                    for (qint32 i = 0; i < nBins; ++i) {
 
                        const float curBinEnd = 1.0+(i*barWidth)+barWidth;
                        const float curBinVertical = m_logarithmic? std::log10(m_histogramDataLog[chan][i] *10)*0.1: m_histogramData[chan][i];
                        const float maxBin = m_logarithmic? logVerticalMax: highest;
                        if (curBinVertical > 0) {
                            const int v = std::max(qRound((curBinVertical/maxBin)*gridHeight), 1);
                            const QRect bar(QPoint(qRound(start), std::max(gridHeight - v, 0)),
                                            QPoint(qRound(curBinEnd), gridHeight));
                            painter.drawRect(bar);
                        }
                        start = curBinEnd;
                    }
                }
            }
        }
    }
}

References KoChannelInfo::ALPHA, calculateLinearGridLines(), calculateLogGridLines(), KoColorSpace::channelCount(), KoColorSpace::channels, KoColorSpace::colorChannelCount(), m_colorSpace, m_histogramData, m_histogramDataLog, m_logarithmic, m_maximumValue, m_smoothHistogram, palette, and v.

receiveNewHistogram

void HistogramDockerWidget::receiveNewHistogram ( HistogramData data )

slot

Definition at line 35 of file histogramdockerwidget.cpp.

{
    m_histogramData = data.bins;
    m_histogramDataLog = data.binsLog;
    m_colorSpace = data.colorSpace;
    m_maximumValue = data.maximumValue;
    update();
}

References HistogramData::bins, HistogramData::binsLog, HistogramData::colorSpace, m_colorSpace, m_histogramData, m_histogramDataLog, m_maximumValue, and HistogramData::maximumValue.

registerIdleTask()

KisIdleTasksManager::TaskGuard HistogramDockerWidget::registerIdleTask ( KisCanvas2 * canvas )

overrideprivatevirtual

Implements KisWidgetWithIdleTask< QLabel >.

Definition at line 51 of file histogramdockerwidget.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(canvas, KisIdleTasksManager::TaskGuard());
 
    return
        canvas->viewManager()->idleTasksManager()->
        addIdleTaskWithGuard([this](KisImageSP image) {
            HistogramComputationStrokeStrategy* strategy =
                new HistogramComputationStrokeStrategy(image);
 
            connect(strategy, SIGNAL(computationResultReady(HistogramData)), this, SLOT(receiveNewHistogram(HistogramData)));
 
            return strategy;
        });
}

References KisViewManager::idleTasksManager(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, receiveNewHistogram(), and KisCanvas2::viewManager().

Member Data Documentation

m_colorSpace

const KoColorSpace* HistogramDockerWidget::m_colorSpace {0}

private

Definition at line 40 of file histogramdockerwidget.h.

{0};

m_histogramData

HistVector HistogramDockerWidget::m_histogramData

private

Definition at line 38 of file histogramdockerwidget.h.

m_histogramDataLog

HistVector HistogramDockerWidget::m_histogramDataLog

private

Definition at line 39 of file histogramdockerwidget.h.

m_logarithmic

bool HistogramDockerWidget::m_logarithmic {false}

private

Definition at line 42 of file histogramdockerwidget.h.

{false};

m_maximumValue

float HistogramDockerWidget::m_maximumValue {1.0}

private

Definition at line 43 of file histogramdockerwidget.h.

{1.0};

m_smoothHistogram

bool HistogramDockerWidget::m_smoothHistogram {false}

private

Definition at line 41 of file histogramdockerwidget.h.

{false};

---

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

• plugins/dockers/histogram/histogramdockerwidget.h
• plugins/dockers/histogram/histogramdockerwidget.cpp