HistogramDockerWidget Class Reference

#include <histogramdockerwidget.h>

Inheritance diagram for HistogramDockerWidget:

Public Slots
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
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 23 of file histogramdockerwidget.cpp.

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

~HistogramDockerWidget()

HistogramDockerWidget::~HistogramDockerWidget ( )

override

Definition at line 30 of file histogramdockerwidget.cpp.

{
}

Member Function Documentation

clearCachedState()

void HistogramDockerWidget::clearCachedState ( )

overrideprivatevirtual

Implements KisWidgetWithIdleTask< QLabel >.

Definition at line 57 of file histogramdockerwidget.cpp.

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

References m_colorSpace, and m_histogramData.

paintEvent()

void HistogramDockerWidget::paintEvent ( QPaintEvent * event )

override

Definition at line 63 of file histogramdockerwidget.cpp.

{
    if (m_colorSpace && !m_histogramData.empty()) {
        int nBins = m_histogramData.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 NGRID = 4;
        for (int i = 0; i <= NGRID; ++i) {
            painter.drawLine(this->width()*i / NGRID, 0., this->width()*i / NGRID, this->height());
            painter.drawLine(0., this->height()*i / NGRID, this->width(), this->height()*i / NGRID);
        }
 
        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_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);
            }
        }
 
        painter.setWindow(QRect(-1, 0, nBins + 1, highest));
        painter.setCompositionMode(QPainter::CompositionMode_Plus);
 
        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, highest));
                    for (qint32 i = 0; i < nBins; ++i) {
                        float v = std::max((float)highest - m_histogramData[chan][i], 0.f);
                        path.lineTo(QPointF(i, v));
 
                    }
                    path.lineTo(QPointF(nBins + 1, highest));
                    path.closeSubpath();
                    painter.drawPath(path);
                } else {
                    pen.setWidth(1);
                    painter.setPen(pen);
                    for (qint32 i = 0; i < nBins; ++i) {
                        float v = std::max((float)highest - m_histogramData[chan][i], 0.f);
                        painter.drawLine(QPointF(i, highest), QPointF(i, v));
                    }
                }
            }
        }
    }
}

References KoChannelInfo::ALPHA, KoColorSpace::channelCount(), KoColorSpace::channels, KoColorSpace::colorChannelCount(), m_colorSpace, m_histogramData, m_smoothHistogram, palette, and v.

receiveNewHistogram

void HistogramDockerWidget::receiveNewHistogram ( HistogramData data )

slot

Definition at line 34 of file histogramdockerwidget.cpp.

{
    m_histogramData = data.bins;
    m_colorSpace = data.colorSpace;
    update();
}

References HistogramData::bins, HistogramData::colorSpace, m_colorSpace, and m_histogramData.

registerIdleTask()

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

overrideprivatevirtual

Implements KisWidgetWithIdleTask< QLabel >.

Definition at line 41 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 connect(), 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 38 of file histogramdockerwidget.h.

{0};

m_histogramData

HistVector HistogramDockerWidget::m_histogramData

private

Definition at line 37 of file histogramdockerwidget.h.

m_smoothHistogram

bool HistogramDockerWidget::m_smoothHistogram {false}

private

Definition at line 39 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