KisLazyFillTools Namespace Reference

Classes
struct	FilteringOptions
struct	KeyStroke

Functions
void	cutOneWay (const KoColor &color, KisPaintDeviceSP src, KisPaintDeviceSP colorScribble, KisPaintDeviceSP backgroundScribble, KisPaintDeviceSP resultDevice, KisPaintDeviceSP maskDevice, const QRect &boundingRect)
void	normalizeAlpha8Device (KisPaintDeviceSP dev, const QRect &rect)
void	normalizeAndInvertAlpha8Device (KisPaintDeviceSP dev, const QRect &rect)
bool	operator== (const FilteringOptions &t1, const FilteringOptions &t2)
bool	operator== (const KeyStroke &t1, const KeyStroke &t2)
QVector< QPoint >	splitIntoConnectedComponents (KisPaintDeviceSP dev, const QRect &boundingRect)

Function Documentation

cutOneWay()

KRITAIMAGE_EXPORT void KisLazyFillTools::cutOneWay	(	const KoColor &	color,
		KisPaintDeviceSP	src,
		KisPaintDeviceSP	colorScribble,
		KisPaintDeviceSP	backgroundScribble,
		KisPaintDeviceSP	resultDevice,
		KisPaintDeviceSP	maskDevice,
		const QRect &	boundingRect )

Uses Boykov-Kolmogorov Max-Flow/Min-Cut algorithm to split the device src into two parts. The first part is defined by colorScribble and the second part — by backgroundScribble. In the result of the split the area defined by colorScribble in resultDevice is filled with color. Also the same area in maskDevice is filled with a non-null scribble index.

maskDevice is used for limiting the area used for filling the color.

Definition at line 77 of file kis_lazy_fill_tools.cpp.

{
    using namespace boost;
 
    KIS_ASSERT_RECOVER_RETURN(src->pixelSize() == 1);
    KIS_ASSERT_RECOVER_RETURN(colorScribble->pixelSize() == 1);
    KIS_ASSERT_RECOVER_RETURN(backgroundScribble->pixelSize() == 1);
    KIS_ASSERT_RECOVER_RETURN(maskDevice->pixelSize() == 1);
    KIS_ASSERT_RECOVER_RETURN(*resultDevice->colorSpace() == *color.colorSpace());
 
    KisLazyFillCapacityMap capacityMap(src, colorScribble, backgroundScribble, maskDevice, boundingRect);
    KisLazyFillGraph &graph = capacityMap.graph();
 
    std::vector<default_color_type> groups(num_vertices(graph));
    std::vector<int> residual_capacity(num_edges(graph), 0);
 
    std::vector<typename graph_traits<KisLazyFillGraph>::vertices_size_type> distance_vec(num_vertices(graph), 0);
    std::vector<typename graph_traits<KisLazyFillGraph>::edge_descriptor> predecessor_vec(num_vertices(graph));
 
    auto vertexIndexMap = get(boost::vertex_index, graph);
 
    typedef KisLazyFillGraph::vertex_descriptor Vertex;
 
    Vertex s(Vertex::LABEL_A);
    Vertex t(Vertex::LABEL_B);
 
    float maxFlow =
        boykov_kolmogorov_max_flow(graph,
                                   capacityMap,
                                   make_iterator_property_map(&residual_capacity[0], get(boost::edge_index, graph)),
                                   get(boost::edge_reverse, graph),
                                   make_iterator_property_map(&predecessor_vec[0], vertexIndexMap),
                                   make_iterator_property_map(&groups[0], vertexIndexMap),
                                   make_iterator_property_map(&distance_vec[0], vertexIndexMap),
                                   vertexIndexMap,
                                   s,
                                   t);
    Q_UNUSED(maxFlow);
 
    KisSequentialIterator dstIt(resultDevice, graph.rect());
    KisSequentialIterator mskIt(maskDevice, graph.rect());
 
    const int pixelSize = resultDevice->pixelSize();
 
    while (dstIt.nextPixel() && mskIt.nextPixel()) {
        KisLazyFillGraph::vertex_descriptor v(dstIt.x(), dstIt.y());
        long vertex_idx = get(boost::vertex_index, graph, v);
        default_color_type label = groups[vertex_idx];
 
        if (label == black_color) {
            memcpy(dstIt.rawData(), color.data(), pixelSize);
            *mskIt.rawData() = 10 + (int(label) << 4);
        }
    }
}

References boost::boykov_kolmogorov_max_flow(), KisPaintDevice::colorSpace(), KoColor::colorSpace(), KoColor::data(), get(), KisLazyFillCapacityMap::graph(), KIS_ASSERT_RECOVER_RETURN, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisPaintDevice::pixelSize(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisLazyFillGraph::rect(), v, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::x(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::y().

normalizeAlpha8Device()

KRITAIMAGE_EXPORT void KisLazyFillTools::normalizeAlpha8Device	(	KisPaintDeviceSP	dev,
		const QRect &	rect )

Definition at line 56 of file kis_lazy_fill_tools.cpp.

{
    quint8 maxPixel = std::numeric_limits<quint8>::min();
    quint8 minPixel = std::numeric_limits<quint8>::max();
    KritaUtils::applyToAlpha8Device(dev, rect,
                                    [&minPixel, &maxPixel](quint8 pixel) {
                                        if (pixel > maxPixel) {
                                            maxPixel = pixel;
                                        }
                                        if (pixel < minPixel) {
                                            minPixel = pixel;
                                        }
                                    });
 
    const qreal scale = 255.0 / (maxPixel - minPixel);
    KritaUtils::filterAlpha8Device(dev, rect,
                                   [minPixel, scale](quint8 pixel) {
                                       return (quint8((pixel - minPixel) * scale));
                                   });
}

References KritaUtils::applyToAlpha8Device(), and KritaUtils::filterAlpha8Device().

normalizeAndInvertAlpha8Device()

KRITAIMAGE_EXPORT void KisLazyFillTools::normalizeAndInvertAlpha8Device	(	KisPaintDeviceSP	dev,
		const QRect &	rect )

Definition at line 35 of file kis_lazy_fill_tools.cpp.

{
    quint8 maxPixel = std::numeric_limits<quint8>::min();
    quint8 minPixel = std::numeric_limits<quint8>::max();
    KritaUtils::applyToAlpha8Device(dev, rect,
                                    [&minPixel, &maxPixel](quint8 pixel) {
                                        if (pixel > maxPixel) {
                                            maxPixel = pixel;
                                        }
                                        if (pixel < minPixel) {
                                            minPixel = pixel;
                                        }
                                    });
 
    const qreal scale = 255.0 / (maxPixel - minPixel);
    KritaUtils::filterAlpha8Device(dev, rect,
                                   [minPixel, scale](quint8 pixel) {
                                       return pow2(255 - quint8((pixel - minPixel) * scale)) / 255;
                                   });
}

References KritaUtils::applyToAlpha8Device(), KritaUtils::filterAlpha8Device(), and pow2().

operator==() [1/2]

bool KisLazyFillTools::operator==	(	const FilteringOptions &	t1,
		const FilteringOptions &	t2 )

Definition at line 196 of file kis_lazy_fill_tools.cpp.

{
    return t1.useEdgeDetection == t2.useEdgeDetection &&
           qFuzzyCompare(t1.edgeDetectionSize, t2.edgeDetectionSize) &&
           qFuzzyCompare(t1.fuzzyRadius, t2.fuzzyRadius) &&
           qFuzzyCompare(t1.cleanUpAmount, t2.cleanUpAmount);
}

operator==() [2/2]

bool KisLazyFillTools::operator==	(	const KeyStroke &	t1,
		const KeyStroke &	t2 )

Definition at line 180 of file kis_lazy_fill_tools.cpp.

{
    return
        t1.dev == t2.dev &&
        t1.color == t2.color &&
        t1.isTransparent == t2.isTransparent;
}

splitIntoConnectedComponents()

KRITAIMAGE_EXPORT QVector< QPoint > KisLazyFillTools::splitIntoConnectedComponents	(	KisPaintDeviceSP	src,
		const QRect &	boundingRect )

Returns one pixel from each connected component of src.

WARNING: src is used as a temporary device, so it will be cleared(!) after the execution of the algorithm

Please note that since we modify the device inside clearNonZeroComponent() call, we must use a writable iterator, for not ending up with a lazy copied old version of a device.

Definition at line 139 of file kis_lazy_fill_tools.cpp.

{
    QVector<QPoint> points;
    const KoColorSpace *cs = dev->colorSpace();
 
    const QRect rect = dev->exactBounds() & boundingRect;
    if (rect.isEmpty()) return points;
 
    KisSequentialIterator dstIt(dev, rect);
 
    while (dstIt.nextPixel()) {
        if (cs->opacityU8(dstIt.rawData()) > 0) {
            const QPoint pt(dstIt.x(), dstIt.y());
            points << pt;
 
            KisScanlineFill fill(dev, pt, rect);
            fill.clearNonZeroComponent();
        }
    }
 
    return points;
}

References KisScanlineFill::clearNonZeroComponent(), KisPaintDevice::colorSpace(), KisPaintDevice::exactBounds(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KoColorSpace::opacityU8(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::x(), and KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::y().