KisHistogram Class Reference

#include <kis_histogram.h>

Inheritance diagram for KisHistogram:

Classes
class	Calculations

Public Member Functions
Calculations	calculations ()
qint32	channel ()
void	computeHistogram ()
enumHistogramType	getHistogramType ()
quint32	getValue (quint8 i)
bool	hasSelection ()
	KisHistogram (KisPaintDeviceSP paintdev, const QRect &bounds, KoHistogramProducer *producer, const enumHistogramType type)
	KisHistogram (KisPaintLayerSP layer, KoHistogramProducer *producer, const enumHistogramType type)
KoHistogramProducer *	producer ()
Calculations	selectionCalculations ()
double	selectionFrom ()
double	selectionTo ()
void	setChannel (qint32 channel)
void	setHistogramType (enumHistogramType type)
void	setNoSelection ()
void	setProducer (KoHistogramProducer *producer)
void	setSelection (double from, double to)
void	updateHistogram ()
virtual	~KisHistogram ()
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Private Member Functions
QVector< Calculations >	calculateForRange (double from, double to)
Calculations	calculateSingleRange (int channel, double from, double to)
void	dump ()

Private Attributes
QRect	m_bounds
qint32	m_channel {0}
QVector< Calculations >	m_completeCalculations
const KisPaintDeviceSP	m_paintDevice
KoHistogramProducer *	m_producer {nullptr}
bool	m_selection {false}
QVector< Calculations >	m_selectionCalculations
double	m_selFrom {0.0}
double	m_selTo {0.0}
enumHistogramType	m_type {LINEAR}

Additional Inherited Members
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Detailed Description

The histogram class computes the histogram data from the specified layer for the specified channel, through the use of a KoHistogramProducer. This class is only for layers and paintdevices. KisImages are not supported, but you can use the mergedImage function to create a paintdevice and feed that to this class.

A Histogram also can have a selection: this is a specific range in the current histogram that will get calculations done on it as well. If the range's begin and end are the same, it is supposed to specify a single bin in the histogram.

The calculations are done in the range 0 - 1, instead of the native range that a pixel might have, so it's not always as precise as it could be. But you can't have it all...

Definition at line 36 of file kis_histogram.h.

Constructor & Destructor Documentation

KisHistogram() [1/2]

KisHistogram::KisHistogram	(	KisPaintLayerSP	layer,
		KoHistogramProducer *	producer,
		const enumHistogramType	type )

Definition at line 19 of file kis_histogram.cc.

    : m_paintDevice(layer->projection())
{
    Q_ASSERT(producer);
 
    KisImageSP imageSP = layer->image().toStrongRef();
    if (imageSP) {
        m_bounds = imageSP->bounds();
    }
    m_type = type;
    m_producer = producer;
    m_selection = false;
    m_channel = 0;
 
    updateHistogram();
}

References KisImage::bounds(), KisBaseNode::image, m_bounds, m_channel, m_producer, m_selection, m_type, producer(), KisWeakSharedPtr< T >::toStrongRef(), and updateHistogram().

KisHistogram() [2/2]

KisHistogram::KisHistogram	(	KisPaintDeviceSP	paintdev,
		const QRect &	bounds,
		KoHistogramProducer *	producer,
		const enumHistogramType	type )

Definition at line 38 of file kis_histogram.cc.

    : m_paintDevice(paintdev)
{
    Q_ASSERT(producer);
 
    m_bounds = bounds;
    m_producer = producer;
    m_type = type;
 
    m_selection = false;
    m_channel = 0;
 
    // TODO: Why does Krita crash when updateHistogram() is *not* called here?
    updateHistogram();
}

References bounds, m_bounds, m_channel, m_producer, m_selection, m_type, producer(), and updateHistogram().

~KisHistogram()

KisHistogram::~KisHistogram ( )

virtual

Definition at line 57 of file kis_histogram.cc.

{
    delete m_producer;
}

References m_producer.

Member Function Documentation

calculateForRange()

QVector< KisHistogram::Calculations > KisHistogram::calculateForRange ( double from, double to )

private

Definition at line 126 of file kis_histogram.cc.

{
    QVector<Calculations> calculations;
    if (m_producer) {
        uint count = m_producer->channels().count();
 
        for (uint i = 0; i < count; i++) {
            calculations.append(calculateSingleRange(i, from, to));
        }
    }
    return calculations;
}

References calculateSingleRange(), calculations(), KoHistogramProducer::channels(), and m_producer.

calculateSingleRange()

KisHistogram::Calculations KisHistogram::calculateSingleRange ( int channel, double from, double to )

private

Definition at line 139 of file kis_histogram.cc.

{
    Calculations c;
 
    // XXX If from == to, we only want a specific bin, handle that properly!
 
    double max = from, min = to, total = 0.0, mean = 0.0; //, median = 0.0, stddev = 0.0;
    quint32 high = 0, low = (quint32) - 1, count = 0;
 
    if (m_producer->count() == 0) {
        // We won't get anything, even if a range is specified
        // XXX make sure all initial '0' values are correct here!
        return c;
    }
 
    qint32 totbins = m_producer->numberOfBins();
    quint32 current;
 
    // convert the double range into actual bins:
    double factor = static_cast<double>(totbins) / m_producer->viewWidth();
 
    qint32 fromBin = static_cast<qint32>((from - m_producer->viewFrom()) * factor);
    qint32 toBin = fromBin + static_cast<qint32>((to - from) * factor);
 
    // Min, max, count, low, high
    for (qint32 i = fromBin; i < toBin; i++) {
        current = m_producer->getBinAt(channel, i);
        double pos = static_cast<double>(i) / factor + from;
        if (current > high)
            high = current;
        if (current < low)
            low = current;
        if (current > 0) {
            if (pos < min)
                min = pos;
            if (pos > max)
                max = pos;
        }
        // We do the count here as well.
        // we can't use m_producer->count() for this, because of the range
        count += current;
        total += current * pos;
    }
 
    if (count > 0)
        mean = total / count;
 
    c.m_high = high;
    c.m_low = low;
    c.m_count = count;
    c.m_min = min;
    c.m_max = max;
    c.m_mean = mean;
    c.m_total = total;
 
    return c;
}

References channel(), KoHistogramProducer::count(), KoHistogramProducer::getBinAt(), KisHistogram::Calculations::m_count, KisHistogram::Calculations::m_high, KisHistogram::Calculations::m_low, KisHistogram::Calculations::m_max, KisHistogram::Calculations::m_mean, KisHistogram::Calculations::m_min, m_producer, KisHistogram::Calculations::m_total, KoHistogramProducer::numberOfBins(), KoHistogramProducer::viewFrom(), and KoHistogramProducer::viewWidth().

calculations()

KisHistogram::Calculations KisHistogram::calculations

(

)

The information on the entire view for the current channel

Definition at line 116 of file kis_histogram.cc.

{
    return m_completeCalculations.at(m_channel);
}

References m_channel, and m_completeCalculations.

channel()

qint32 KisHistogram::channel ( )

inline

Definition at line 148 of file kis_histogram.h.

                            {
        return m_channel;
    }

computeHistogram()

void KisHistogram::computeHistogram

(

)

(Re)computes the mathematical information from the information currently in the producer. Needs to be called when you change the selection and want to get that information

Definition at line 98 of file kis_histogram.cc.

{
    if (!m_producer) return;
 
    m_completeCalculations = calculateForRange(m_producer->viewFrom(),
                             m_producer->viewFrom() + m_producer->viewWidth());
 
    if (m_selection) {
        m_selectionCalculations = calculateForRange(m_selFrom, m_selTo);
    } else {
        m_selectionCalculations.clear();
    }
 
#if 1
    dump();
#endif
}

References calculateForRange(), dump(), m_completeCalculations, m_producer, m_selection, m_selectionCalculations, m_selFrom, m_selTo, KoHistogramProducer::viewFrom(), and KoHistogramProducer::viewWidth().

dump()

void KisHistogram::dump ( )

private

Definition at line 198 of file kis_histogram.cc.

{
    dbgMath << "Histogram";
 
    switch (m_type) {
    case LINEAR:
        dbgMath << "Linear histogram";
        break;
    case LOGARITHMIC:
        dbgMath << "Logarithmic histogram";
    }
 
    dbgMath << "Dumping channel" << m_channel;
    Calculations c = calculations();
 
    /*        for( int i = 0; i <256; ++i ) {
            dbgMath <<"Value"
                  << QString().setNum(i)
                  << ": "
                  <<  QString().setNum(m_values[i])
                  << "\n";
            }*/
    dbgMath << "";
 
    dbgMath << "Max:" << QString().setNum(c.getMax()) << "";
    dbgMath << "Min:" << QString().setNum(c.getMin()) << "";
    dbgMath << "High:" << QString().setNum(c.getHighest()) << "";
    dbgMath << "Low:" << QString().setNum(c.getLowest()) << "";
    dbgMath << "Mean:" << m_producer->positionToString(c.getMean()) << "";
    dbgMath << "Total:" << QString().setNum(c.getTotal()) << "";
    //    dbgMath <<"Median:" << QString().setNum(m_median) <<"";
    //    dbgMath <<"Stddev:" << QString().setNum(m_stddev) <<"";
    //    dbgMath <<"percentile:" << QString().setNum(m_percentile) <<"";
 
    dbgMath << "";
}

References calculations(), dbgMath, KisHistogram::Calculations::getHighest(), KisHistogram::Calculations::getLowest(), KisHistogram::Calculations::getMax(), KisHistogram::Calculations::getMean(), KisHistogram::Calculations::getMin(), KisHistogram::Calculations::getTotal(), LINEAR, LOGARITHMIC, m_channel, m_producer, m_type, and KoHistogramProducer::positionToString().

getHistogramType()

enumHistogramType KisHistogram::getHistogramType ( )

inline

Definition at line 131 of file kis_histogram.h.

                                                {
        return m_type;
    }

getValue()

quint32 KisHistogram::getValue ( quint8 i )

inline

Definition at line 127 of file kis_histogram.h.

                                      {
        return m_producer->getBinAt(m_channel, i);
    }

hasSelection()

bool KisHistogram::hasSelection ( )

inline

Definition at line 152 of file kis_histogram.h.

                               {
        return m_selection;
    }

producer()

KoHistogramProducer * KisHistogram::producer ( )

inline

Definition at line 145 of file kis_histogram.h.

                                           {
        return m_producer;
    }

selectionCalculations()

KisHistogram::Calculations KisHistogram::selectionCalculations

(

)

The information on the current selection for the current channel

Definition at line 121 of file kis_histogram.cc.

{
    return m_selectionCalculations.at(m_channel);
}

References m_channel, and m_selectionCalculations.

selectionFrom()

double KisHistogram::selectionFrom ( )

inline

Definition at line 155 of file kis_histogram.h.

                                  {
        return m_selFrom;
    }

selectionTo()

double KisHistogram::selectionTo ( )

inline

Definition at line 158 of file kis_histogram.h.

                                {
        return m_selTo;
    }

setChannel()

void KisHistogram::setChannel ( qint32 channel )

inline

Definition at line 141 of file kis_histogram.h.

                                           {
        Q_ASSERT(m_channel < m_completeCalculations.size());
        m_channel = channel;
    }

setHistogramType()

void KisHistogram::setHistogramType ( enumHistogramType type )

inline

Definition at line 134 of file kis_histogram.h.

                                                         {
        m_type = type;
    }

setNoSelection()

void KisHistogram::setNoSelection ( )

inline

Definition at line 161 of file kis_histogram.h.

                                 {
        m_selection = false;
    }

setProducer()

void KisHistogram::setProducer ( KoHistogramProducer * producer )

inline

Definition at line 137 of file kis_histogram.h.

                                                           {
        m_channel = 0;
        m_producer = producer;
    }

setSelection()

void KisHistogram::setSelection ( double from, double to )

inline

Sets the current selection

Definition at line 165 of file kis_histogram.h.

                                                     {
        m_selection = true; m_selFrom = from; m_selTo = to;
    }

updateHistogram()

void KisHistogram::updateHistogram

(

)

Updates the information in the producer

Definition at line 62 of file kis_histogram.cc.

{
    if (m_bounds.isEmpty()) {
        int numChannels = m_producer->channels().count();
 
        m_completeCalculations.clear();
        m_completeCalculations.resize(numChannels);
 
        m_completeCalculations.clear();
        m_completeCalculations.resize(numChannels);
 
        return;
    }
 
    KisSequentialConstIterator srcIt(m_paintDevice, m_bounds);
    const KoColorSpace* cs = m_paintDevice->colorSpace();
 
    // Let the producer do it's work
    m_producer->clear();
 
 
    // XXX: the original code depended on their being a selection mask in the iterator
    //      if the paint device had a selection. When we changed that to passing an
    //      explicit selection to the createRectIterator call, that broke because
    //      paint devices didn't know about their selections anymore.
    //      updateHistogram should get a selection parameter.
    int numConseqPixels = srcIt.nConseqPixels();
    while (srcIt.nextPixels(numConseqPixels)) {
 
        numConseqPixels = srcIt.nConseqPixels();
        m_producer->addRegionToBin(srcIt.oldRawData(), 0, numConseqPixels, cs);
    }
 
    computeHistogram();
}

References KoHistogramProducer::addRegionToBin(), KoHistogramProducer::channels(), KoHistogramProducer::clear(), KisPaintDevice::colorSpace(), computeHistogram(), m_bounds, m_completeCalculations, m_paintDevice, m_producer, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nConseqPixels(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixels(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::oldRawData().

Member Data Documentation

m_bounds

QRect KisHistogram::m_bounds

private

Definition at line 177 of file kis_histogram.h.

m_channel

qint32 KisHistogram::m_channel {0}

private

Definition at line 181 of file kis_histogram.h.

{0};

m_completeCalculations

QVector<Calculations> KisHistogram::m_completeCalculations

private

Definition at line 186 of file kis_histogram.h.

m_paintDevice

const KisPaintDeviceSP KisHistogram::m_paintDevice

private

Definition at line 176 of file kis_histogram.h.

m_producer

KoHistogramProducer* KisHistogram::m_producer {nullptr}

private

Definition at line 178 of file kis_histogram.h.

{nullptr};

m_selection

bool KisHistogram::m_selection {false}

private

Definition at line 184 of file kis_histogram.h.

{false};

m_selectionCalculations

QVector<Calculations> KisHistogram::m_selectionCalculations

private

Definition at line 186 of file kis_histogram.h.

m_selFrom

double KisHistogram::m_selFrom {0.0}

private

Definition at line 182 of file kis_histogram.h.

{0.0};

m_selTo

double KisHistogram::m_selTo {0.0}

private

Definition at line 183 of file kis_histogram.h.

{0.0};

m_type

enumHistogramType KisHistogram::m_type {LINEAR}

private

Definition at line 179 of file kis_histogram.h.

{LINEAR};

---

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

• libs/image/kis_histogram.h
• libs/image/kis_histogram.cc