KisGapMap Class Reference

#include <kis_gap_map.h>

Inheritance diagram for KisGapMap:

Classes
struct	Data

Public Types
typedef std::function< bool(KisPaintDevice *devicePtr, const QRect &rect)	FillOpacityFunc)

Public Member Functions
ALWAYS_INLINE quint16	distance (int x, int y)
ALWAYS_INLINE int	gapSize () const
template<bool BoundsCheck>
bool	isOpaque (const QPoint &p)
template<bool BoundsCheck>
bool	isOpaque (int x, int y)
	KisGapMap (int gapSize, const QRect &mapBounds, const FillOpacityFunc &fillOpacityFunc)
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Static Public Attributes
static constexpr quint16	DISTANCE_INFINITE = UINT16_MAX

Private Types
enum	TileFlagBits { TILE_DISTANCE_LOADED = 0x1 , TILE_OPACITY_LOADED = 0x2 , TILE_HAS_OPAQUE_PIXELS = 0x4 }
typedef quint8	TileFlags

Private Member Functions
ALWAYS_INLINE Data *	dataPtr (int x, int y)
void	distanceSearchRowInnerLoop (bool boundsCheck, int y, int x1, int x2)
template<bool BoundsCheck, typename CoordinateTransform >
void	gapDistanceSearch (int x, int y, CoordinateTransform op)
ALWAYS_INLINE bool	isDistanceAvailable (int x, int y)
template<bool BoundsCheck>
ALWAYS_INLINE bool	isOpaque (const QPoint &p)
template<bool BoundsCheck>
ALWAYS_INLINE bool	isOpaque (int x, int y)
quint16	lazyDistance (int x, int y)
void	loadDistanceTile (const QPoint &tile, const QRect &nearbyTilesRect, int guardBand)
void	loadOpacityTiles (const QRect &tileRect)
	Q_DISABLE_COPY (KisGapMap)
ALWAYS_INLINE TileFlags *	tileFlagsPtr (int tileX, int tileY)
void	updateDistance (const QPoint &globalPosition, quint16 newDistance)

Private Attributes
std::unique_ptr< KisTileOptimizedAccessor >	m_accessor
	An accessor for the paint device.
KisPaintDeviceSP	m_deviceSp
	A 32-bit per pixel paint device that holds the distance and other data.
const FillOpacityFunc	m_fillOpacityFunc
	A callback to get the opacity data from the fill class.
const int	m_gapSize
	Gap size in pixels for this map.
const QSize	m_numTiles
	Map size in tiles.
const QSize	m_size
	Size in pixels of the opacity/gap map.
Data *	m_tileDataPtr
	The pointer to the currently computed tile data.
QPoint	m_tilePosition
	The position of the currently computed tile compared to the whole region.

Static Private Attributes
static constexpr int	TileSize = 64

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

Detailed Description

Creates a "gap map", which is a pixel map of distances from lineart gaps (discontinuities in opaque lines), that helps detect these gaps and stop a bucket fill before spilling.

Definition at line 80 of file kis_gap_map.h.

Member Typedef Documentation

FillOpacityFunc

typedef std::function<bool(KisPaintDevice* devicePtr, const QRect& rect) KisGapMap::FillOpacityFunc)

A callback to request opacity data for pixels in the image. It can be called at any time distance() function is invoked.

Parameters

devicePtr	our underlying paint device, it contains opacity among other data. For each pixel, the offset of opacity quint8 data is 2 bytes.
rect	the bounds within the fill region (image) that are requested.

Returns

true, if at least one pixel within the tile is opaque

Definition at line 94 of file kis_gap_map.h.

TileFlags

typedef quint8 KisGapMap::TileFlags

private

Definition at line 150 of file kis_gap_map.h.

Member Enumeration Documentation

TileFlagBits

enum KisGapMap::TileFlagBits

private

Enumerator
TILE_DISTANCE_LOADED	Distance data is available.
TILE_OPACITY_LOADED	Opacity data is available.
TILE_HAS_OPAQUE_PIXELS	Some pixels of the loaded tile are opaque.

Definition at line 151 of file kis_gap_map.h.

    {
        TILE_DISTANCE_LOADED     = 0x1,      
        TILE_OPACITY_LOADED      = 0x2,      
        TILE_HAS_OPAQUE_PIXELS   = 0x4,      
    };

Constructor & Destructor Documentation

KisGapMap()

KisGapMap::KisGapMap	(	int	gapSize,
		const QRect &	mapBounds,
		const FillOpacityFunc &	fillOpacityFunc )

Create a new gap distance map object and prepare it for lazy initialization. Some memory allocation will happen upfront, but most of the calculations are deferred until distance() function is called.

Parameters

gapSize	maximum size of lineart gap to look for.
mapBounds	must begin in (0,0) and must have the same size as the filled region.
fillOpacityFunc	a callback to obtain the opacity of pixels

Definition at line 89 of file kis_gap_map.cpp.

    : m_gapSize(gapSize)
    , m_size(mapBounds.size())
    , m_numTiles(qCeil(static_cast<float>(m_size.width()) / TileSize),
                 qCeil(static_cast<float>(m_size.height()) / TileSize))
    , m_fillOpacityFunc(fillOpacityFunc)
    , m_deviceSp(new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb8()))
    , m_accessor(std::make_unique<KisTileOptimizedAccessor>(m_deviceSp))
{
    // Ensure the scanline fill uses the same coordinates.
    KIS_ASSERT((mapBounds.x() == 0) && (mapBounds.y() == 0) &&
               "Gap closing fill assumes x and y start at coordinate (0, 0)");
 
    Data defaultPixel {};
    defaultPixel.distance = DISTANCE_INFINITE;
    defaultPixel.opacity = MAX_SELECTED;    // here: max = transparent
 
    KoColor color(reinterpret_cast<quint8*>(&defaultPixel), KoColorSpaceRegistry::instance()->rgb8());
    m_deviceSp->setDefaultPixel(color);
    m_deviceSp->fill(mapBounds, color);
}

References KisGapMap::Data::distance, DISTANCE_INFINITE, KisPaintDevice::fill(), KoColorSpaceRegistry::instance(), KIS_ASSERT, m_deviceSp, MAX_SELECTED, and KisPaintDevice::setDefaultPixel().

Member Function Documentation

dataPtr()

ALWAYS_INLINE Data * KisGapMap::dataPtr ( int x, int y )

inlineprivate

Definition at line 186 of file kis_gap_map.h.

    {
        return reinterpret_cast<Data*>(m_accessor->rawData(x, y));
    }

distance()

ALWAYS_INLINE quint16 KisGapMap::distance ( int x, int y )

inline

Query the gap distance at a pixel. (x, y) are the filled region's coordinates, always starting at (0, 0).

Important: This function is not thread-safe.

Definition at line 113 of file kis_gap_map.h.

    {
        if (isDistanceAvailable(x, y)) {
            return dataPtr(x, y)->distance;
        } else {
            return lazyDistance(x, y);
        }
    }

distanceSearchRowInnerLoop()

void KisGapMap::distanceSearchRowInnerLoop ( bool boundsCheck, int y, int x1, int x2 )

private

This is a part of loadDistanceTile() implementation.

Definition at line 147 of file kis_gap_map.cpp.

{
    if (boundsCheck) {
        for (int x = x1; x <= x2; ++x) {
            if (isOpaque<true>(x, y)) {
                gapDistanceSearch<true>(x, y, TransformNone);
                gapDistanceSearch<true>(x, y, TransformRotateClockwiseMirrorHorizontally);
                gapDistanceSearch<true>(x, y, TransformRotateClockwise);
                gapDistanceSearch<true>(x, y, TransformMirrorHorizontally);
            }
        }
    } else {
        for (int x = x1; x <= x2; ++x) {
            if (isOpaque<false>(x, y)) {
                gapDistanceSearch<false>(x, y, TransformNone);
                gapDistanceSearch<false>(x, y, TransformRotateClockwiseMirrorHorizontally);
                gapDistanceSearch<false>(x, y, TransformRotateClockwise);
                gapDistanceSearch<false>(x, y, TransformMirrorHorizontally);
            }
        }
    }
}

gapDistanceSearch()

template<bool BoundsCheck, typename CoordinateTransform >

void KisGapMap::gapDistanceSearch ( int x, int y, CoordinateTransform op )

private

Update the distance map in an octant (a 45-degree sector of a half-circle) originating from the (x, y) point.

Important: The radius of the right half-circle is equal to the (gap size) for distance map, and the (gap size + 1) for the opacity map.

Which octant is used depends on the transform function. With 0 degrees being the -y axis (up): 0-45 deg - TransformNone 45-90 deg - TransformRotateClockwiseMirrorHorizontally 90-135 deg - TransformRotateClockwise 135-180 deg - TransformMirrorHorizontally

This function is a bit tricky to reason about:

• Calling it for a point at (x, y) will modify the RIGHT half-circle of the distance map, excluding the point.
• Conversely, to fully determine the distance at any specific point (mx, my) in the map, this function must be called for all points in the LEFT half-circle, that is the rect (mx - gap, my - gap, gap + 1, gap + 1).
• Lastly, only some points in the half circle will be modified, it depends on the opacity checks.

Definition at line 281 of file kis_gap_map.cpp.

{
    if (isOpaque<BoundsCheck>(op(x, y, 0, -1)) ||
        isOpaque<BoundsCheck>(op(x, y, 1, -1))) {
        return;
    }
 
    for (int yoffs = 2; yoffs < m_gapSize + 2; ++yoffs) {
        const int yDistanceSq = (yoffs - 1) * (yoffs - 1);
 
        for (int xoffs = 0; xoffs <= yoffs; ++xoffs) {
            const int offsetDistance = yDistanceSq + xoffs * xoffs;
 
            if (offsetDistance >= 1 + m_gapSize * m_gapSize) {
                break;
            }
 
            if (isOpaque<BoundsCheck>(op(x, y, xoffs, -yoffs))) {
                const float dx = static_cast<float>(xoffs) / (yoffs - 1);
                float tx = 0;
                int cx = 0;
 
                for (int cy = 1; cy < yoffs; ++cy) {
                    updateDistance(op(x, y, cx, -cy), offsetDistance);
 
                    tx += dx;
                    if (static_cast<int>(tx) > cx) {
                        cx++;
                        updateDistance(op(x, y, cx, -cy), offsetDistance);
                    }
 
                    updateDistance(op(x, y, cx + 1, -cy), offsetDistance);
                }
            }
        }
    }
}

References m_gapSize, and updateDistance().

gapSize()

ALWAYS_INLINE int KisGapMap::gapSize ( ) const

inline

Definition at line 122 of file kis_gap_map.h.

    {
        return m_gapSize;
    }

isDistanceAvailable()

ALWAYS_INLINE bool KisGapMap::isDistanceAvailable ( int x, int y )

inlineprivate

Definition at line 181 of file kis_gap_map.h.

    {
        return (*tileFlagsPtr(x / TileSize, y / TileSize) & TILE_DISTANCE_LOADED) != 0;
    }

isOpaque() [1/4]

template<bool BoundsCheck>

bool KisGapMap::isOpaque

(

const QPoint &

p

)

Definition at line 84 of file kis_gap_map.cpp.

{
    return isOpaque<BoundsCheck>(p.x(), p.y());
}

References p.

isOpaque() [2/4]

template<bool BoundsCheck>

ALWAYS_INLINE bool KisGapMap::isOpaque ( const QPoint & p )

private

isOpaque() [3/4]

template<bool BoundsCheck>

bool KisGapMap::isOpaque	(	int	x,
		int	y )

Definition at line 63 of file kis_gap_map.cpp.

{
#if KIS_GAP_MAP_DEBUG_LOGGING_AND_ASSERTS
    const TileFlags flags = *tileFlagsPtr(x / TileSize, y / TileSize);
    KIS_SAFE_ASSERT_RECOVER((flags & TILE_OPACITY_LOADED) != 0) {
        qDebug() << "ERROR: opacity at (" << x << "," << y << ") not loaded";
        return false;
    }
#endif
    if (BoundsCheck) {
        if ((x >= 0) && (x < m_size.width()) && (y >= 0) && (y < m_size.height())) {
            return dataPtr(x, y)->opacity == MIN_SELECTED;
        } else {
            return false;
        }
    } else {
        return dataPtr(x, y)->opacity == MIN_SELECTED;
    }
}

References dataPtr(), KIS_SAFE_ASSERT_RECOVER, m_size, MIN_SELECTED, KisGapMap::Data::opacity, TILE_OPACITY_LOADED, tileFlagsPtr(), and TileSize.

isOpaque() [4/4]

template<bool BoundsCheck>

ALWAYS_INLINE bool KisGapMap::isOpaque ( int x, int y )

private

lazyDistance()

quint16 KisGapMap::lazyDistance ( int x, int y )

private

Load the required tiles and return pixel's distance data.

Definition at line 334 of file kis_gap_map.cpp.

{
#if KIS_GAP_MAP_DEBUG_LOGGING_AND_ASSERTS
    qDebug() << "lazyDistance() at (" << x << "," << y << ")";
#endif
 
    const int tx = x / TileSize;
    const int ty = y / TileSize;
 
    // Clamped tile neighborhood.
    const QPoint topLeft(qMax(0, tx - 1),
                         qMax(0, ty - 1));
    const QPoint bottomRight(qMin(tx + 1, m_numTiles.width() - 1),
                             qMin(ty + 1, m_numTiles.height() - 1));
    const QRect nearbyTiles = QRect(topLeft, bottomRight);
 
    // For opacity data, we always load all the adjacent tiles (up to 9 tiles in total).
    loadOpacityTiles(nearbyTiles);
 
    // For distance data, we always load a single tile.
    loadDistanceTile(QPoint(tx, ty), nearbyTiles, m_gapSize);
 
    // The data is now ready to be returned.
    return dataPtr(x, y)->distance;
}

References dataPtr(), KisGapMap::Data::distance, loadDistanceTile(), loadOpacityTiles(), m_gapSize, m_numTiles, and TileSize.

loadDistanceTile()

void KisGapMap::loadDistanceTile ( const QPoint & tile, const QRect & nearbyTilesRect, int guardBand )

private

Calculate the gap distance data in the specified rect. NOTE: Opacity data must have been loaded already.

See also

gapDistanceSearch() for an explanation of which distance map pixels are be affected by this operation.

If the rect is smaller than the whole fill region, then the guardBand is needed and must be at least equal to the gap size. We need to do calculations in a larger region in order to compute correct distances within the requested rect.

Definition at line 180 of file kis_gap_map.cpp.

{
#if KIS_GAP_MAP_MEASURE_ELAPSED_TIME
    QElapsedTimer timer;
    timer.start();
#endif
 
    TileFlags* const pFlags = tileFlagsPtr(tile.x(), tile.y());
 
    // This tile is now considered loaded.
    *pFlags |= TILE_DISTANCE_LOADED;
 
    // Optimization: If a tile is completely transparent (TILE_HAS_OPAQUE_PIXELS == 0), then
    // we can skip the distance calculation for it. Unfortunately, with the guard bands we need
    // to check the flags of the neighboring tiles as well.
 
    const bool tileOpaque           = (*pFlags & TILE_HAS_OPAQUE_PIXELS) != 0;
    const bool tileOpaqueLeft       = (nearbyTilesRect.left()   == tile.x()) ?                                           false : (*tileFlagsPtr(tile.x() - 1, tile.y())     & TILE_HAS_OPAQUE_PIXELS) != 0;
    const bool tileOpaqueTopLeft    = (nearbyTilesRect.left()   == tile.x()) || (nearbyTilesRect.top()    == tile.y()) ? false : (*tileFlagsPtr(tile.x() - 1, tile.y() - 1) & TILE_HAS_OPAQUE_PIXELS) != 0;
    const bool tileOpaqueBottomLeft = (nearbyTilesRect.left()   == tile.x()) || (nearbyTilesRect.bottom() == tile.y()) ? false : (*tileFlagsPtr(tile.x() - 1, tile.y() + 1) & TILE_HAS_OPAQUE_PIXELS) != 0;
    const bool tileOpaqueTop        = (nearbyTilesRect.top()    == tile.y()) ?                                           false : (*tileFlagsPtr(tile.x(),     tile.y() - 1) & TILE_HAS_OPAQUE_PIXELS) != 0;
    const bool tileOpaqueBottom     = (nearbyTilesRect.bottom() == tile.y()) ?                                           false : (*tileFlagsPtr(tile.x(),     tile.y() + 1) & TILE_HAS_OPAQUE_PIXELS) != 0;
 
    if (! (tileOpaqueTopLeft || tileOpaqueTop || tileOpaqueLeft || tileOpaque || tileOpaqueBottomLeft || tileOpaqueBottom)) {
        // This tile as well as its surroundings are transparent.
        // We can simply exit without explicitly initializing the tile. The paint device's default pixel is DISTANCE_INFINITE.
 
#if KIS_GAP_MAP_MEASURE_ELAPSED_TIME
        m_distanceElapsedNanos += timer.nsecsElapsed();
#endif
        return;
    }
 
    // The area of the image covered only by this tile.
    QRect rect(tile.x() * TileSize, tile.y() * TileSize, TileSize, TileSize);
    rect.setRight(qMin(rect.right(), m_size.width() - 1));
    rect.setBottom(qMin(rect.bottom(), m_size.height() - 1));
 
    // Compromise: At the tile size 64 px and the gap size 32 px, the guard band must be
    // 31 px at most, because opacity is sampled in gap size + 1 radius, which could be two tiles
    // away and that tile might not have been loaded yet. To avoid loading one row of that tile,
    // we can clamp the guard band to 31. The error introduced by it should not be noticeable.
 
    const int guardBandVertical = qMin(guardBand, 31);
    const int y1       = tileOpaqueTopLeft    || tileOpaqueTop    ? qMax(0, rect.top() - guardBandVertical) : rect.top();
    const int y2       = tileOpaqueBottomLeft || tileOpaqueBottom ? qMin(rect.bottom() + guardBandVertical, m_size.height() - 1) : rect.bottom();
    const int x1Top    = tileOpaqueTopLeft                        ? qMax(0, rect.left() - guardBand) : rect.left();
    const int x1Middle = tileOpaqueLeft                           ? qMax(0, rect.left() - guardBand) : rect.left();
    const int x1Bottom = tileOpaqueBottomLeft                     ? qMax(0, rect.left() - guardBand) : rect.left();
    const int x2Top    = tileOpaqueTop                            ? rect.right() : rect.left() - 1;
    const int x2Middle = tileOpaque                               ? rect.right() : rect.left() - 1;
    const int x2Bottom = tileOpaqueBottom                         ? rect.right() : rect.left() - 1;
 
    // Apply conservative bounds checking. +1 for opacity.
    const bool boundsCheck =
        (rect.right() + (m_gapSize + 1) >= m_size.width()) ||  // no risk of accessing x<0
        (y1 - (m_gapSize + 1) < 0) || (y2 + (m_gapSize + 1) >= m_size.height());
 
    m_tilePosition = rect.topLeft();
    m_tileDataPtr = reinterpret_cast<Data*>(m_accessor->tileRawData(tile.x(), tile.y()));
 
    // Process the tile and its neighborhood in three passes:
    // Top (the top guard bands)
    for (int y = y1; y <= rect.top() - 1; ++y) {
        distanceSearchRowInnerLoop(boundsCheck, y, x1Top, x2Top);
    }
    // Middle (the left guard band and the tile)
    for (int y = rect.top(); y <= rect.bottom(); ++y) {
        distanceSearchRowInnerLoop(boundsCheck, y, x1Middle, x2Middle);
    }
    // Bottom (the bottom guard bands)
    for (int y = rect.bottom() + 1; y <= y2; ++y) {
        distanceSearchRowInnerLoop(boundsCheck, y, x1Bottom, x2Bottom);
    }
 
#if KIS_GAP_MAP_MEASURE_ELAPSED_TIME
    m_distanceElapsedNanos += timer.nsecsElapsed();
#endif
}

References distanceSearchRowInnerLoop(), m_accessor, m_gapSize, m_size, m_tileDataPtr, m_tilePosition, TILE_DISTANCE_LOADED, TILE_HAS_OPAQUE_PIXELS, tileFlagsPtr(), and TileSize.

loadOpacityTiles()

void KisGapMap::loadOpacityTiles ( const QRect & tileRect )

private

Definition at line 113 of file kis_gap_map.cpp.

{
#if KIS_GAP_MAP_MEASURE_ELAPSED_TIME
    QElapsedTimer timer;
    timer.start();
#endif
 
    for (int ty = tileRect.top(); ty <= tileRect.bottom(); ++ty) {
        for (int tx = tileRect.left(); tx <= tileRect.right(); ++tx) {
            TileFlags* const pFlags = tileFlagsPtr(tx, ty);
            if ((*pFlags & TILE_OPACITY_LOADED) == 0) {
                // Resize and clamp to image bounds.
                QRect rect(tx * TileSize, ty * TileSize, TileSize, TileSize);
                rect.setRight(qMin(rect.right(), m_size.width() - 1));
                rect.setBottom(qMin(rect.bottom(), m_size.height() - 1));
 
#if KIS_GAP_MAP_DEBUG_LOGGING_AND_ASSERTS
                qDebug() << "loadOpacityTiles()" << rect;
#endif
                // It's not too elegant to pass the device, but this performs the best for now.
                const bool hasOpaquePixels = m_fillOpacityFunc(m_deviceSp.data(), rect);
 
                // This tile is now loaded.
                *pFlags |= TILE_OPACITY_LOADED | (hasOpaquePixels ? TILE_HAS_OPAQUE_PIXELS : 0);
            }
        }
    }
 
#if KIS_GAP_MAP_MEASURE_ELAPSED_TIME
    m_opacityElapsedNanos += timer.nsecsElapsed();
#endif
}

References KisSharedPtr< T >::data(), m_deviceSp, m_fillOpacityFunc, m_size, TILE_HAS_OPAQUE_PIXELS, TILE_OPACITY_LOADED, tileFlagsPtr(), and TileSize.

Q_DISABLE_COPY()

KisGapMap::Q_DISABLE_COPY ( KisGapMap )

private

tileFlagsPtr()

ALWAYS_INLINE TileFlags * KisGapMap::tileFlagsPtr ( int tileX, int tileY )

inlineprivate

Definition at line 191 of file kis_gap_map.h.

    {
        return reinterpret_cast<TileFlags*>(
            m_accessor->tileRawData(tileX, tileY) + offsetof(Data, flags));
    }

updateDistance()

void KisGapMap::updateDistance ( const QPoint & globalPosition, quint16 newDistance )

private

Definition at line 319 of file kis_gap_map.cpp.

{
    const QPoint p = globalPosition - m_tilePosition;
 
    if ((p.x() < 0) || (p.x() >= TileSize) || (p.y() < 0) || (p.y() >= TileSize)) {
        return;
    }
 
    Data* ptr = m_tileDataPtr + p.x() + TileSize * p.y();
    if (ptr->distance > newDistance) {
        ptr->distance = newDistance;
    }
}

References KisGapMap::Data::distance, m_tileDataPtr, m_tilePosition, p, and TileSize.

Member Data Documentation

DISTANCE_INFINITE

constexpr quint16 KisGapMap::DISTANCE_INFINITE = UINT16_MAX

staticconstexpr

A magic number to express a pixel that is very far from any gaps.

Definition at line 84 of file kis_gap_map.h.

m_accessor

std::unique_ptr<KisTileOptimizedAccessor> KisGapMap::m_accessor

private

An accessor for the paint device.

Definition at line 206 of file kis_gap_map.h.

m_deviceSp

KisPaintDeviceSP KisGapMap::m_deviceSp

private

A 32-bit per pixel paint device that holds the distance and other data.

Definition at line 205 of file kis_gap_map.h.

m_fillOpacityFunc

const FillOpacityFunc KisGapMap::m_fillOpacityFunc

private

A callback to get the opacity data from the fill class.

Definition at line 200 of file kis_gap_map.h.

m_gapSize

const int KisGapMap::m_gapSize

private

Gap size in pixels for this map.

Definition at line 197 of file kis_gap_map.h.

m_numTiles

const QSize KisGapMap::m_numTiles

private

Map size in tiles.

Definition at line 199 of file kis_gap_map.h.

m_size

const QSize KisGapMap::m_size

private

Size in pixels of the opacity/gap map.

Definition at line 198 of file kis_gap_map.h.

m_tileDataPtr

Data* KisGapMap::m_tileDataPtr

private

The pointer to the currently computed tile data.

Definition at line 203 of file kis_gap_map.h.

m_tilePosition

QPoint KisGapMap::m_tilePosition

private

The position of the currently computed tile compared to the whole region.

Definition at line 202 of file kis_gap_map.h.

TileSize

constexpr int KisGapMap::TileSize = 64

staticconstexprprivate

For the purpose of lazy loading, the data is fetched in tile increments.

Definition at line 148 of file kis_gap_map.h.

---

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

• libs/image/floodfill/kis_gap_map.h
• libs/image/floodfill/kis_gap_map.cpp