Public Member Functions
KisRasterKeyframeSP	getNextFrameToComposite (KisKeyframeChannel *channel, int &outFrame, bool backwards)

void	refreshConfig ()

KisPaintDeviceSP	setUpTintDevice (const QColor &tintColor, const KoColorSpace *colorSpace)

int	skinOpacity (int offset)

void	tryCompositeFrame (KisRasterKeyframeSP keyframe, KisPainter &gcFrame, KisPainter &gcDest, KisPaintDeviceSP tintSource, int opacity, const QRect &rect)

QRect	updateExtentOnFrameChange (KisRasterKeyframeChannel *channel, int prevActiveTime, int prevIgnoredTime, int nowActiveTime, int nowIgnoredTime)

Public Attributes
QVector< int >	backwardOpacities

QColor	backwardTintColor

QSet< int >	colorLabelFilter

int	configSeqNo = 0

QVector< int >	forwardOpacities

QColor	forwardTintColor

int	numberOfSkins = 0

int	tintFactor = 0

Detailed Description

Definition at line 20 of file kis_onion_skin_compositor.cpp.

Member Function Documentation

◆ getNextFrameToComposite()

KisRasterKeyframeSP KisOnionSkinCompositor::Private::getNextFrameToComposite	(	KisKeyframeChannel *	channel,
		int &	outFrame,
		bool	backwards )

inline

Definition at line 48 of file kis_onion_skin_compositor.cpp.

    {
        while (!channel->keyframeAt(outFrame).isNull()) {
            outFrame = backwards ? channel->previousKeyframeTime(outFrame) : channel->nextKeyframeTime(outFrame);
            if (colorLabelFilter.isEmpty()) {
                return channel->keyframeAt<KisRasterKeyframe>(outFrame);
            } else if (channel->keyframeAt<KisRasterKeyframe>(outFrame)) {
                if (colorLabelFilter.contains(channel->keyframeAt(outFrame)->colorLabel())) {
                    return channel->keyframeAt<KisRasterKeyframe>(outFrame);
                }
            }
        }
        return channel->keyframeAt<KisRasterKeyframe>(outFrame);
    }

References KisKeyframeChannel::keyframeAt(), KisKeyframeChannel::nextKeyframeTime(), and KisKeyframeChannel::previousKeyframeTime().

◆ refreshConfig()

void KisOnionSkinCompositor::Private::refreshConfig ( )

inline

Definition at line 75 of file kis_onion_skin_compositor.cpp.

    {
        KisImageConfig config(true);
 
        numberOfSkins = config.numberOfOnionSkins();
        tintFactor = config.onionSkinTintFactor();
        backwardTintColor = config.onionSkinTintColorBackward();
        forwardTintColor = config.onionSkinTintColorForward();
 
        backwardOpacities.resize(numberOfSkins);
        forwardOpacities.resize(numberOfSkins);
 
        const int mainState = (int) config.onionSkinState(0);
        const qreal scaleFactor = mainState * config.onionSkinOpacity(0) / 255.0;
 
        for (int i = 0; i < numberOfSkins; i++) {
            int backwardState = (int) config.onionSkinState(-(i + 1));
            int forwardState = (int) config.onionSkinState(i + 1);
 
            backwardOpacities[i] = scaleFactor * backwardState * config.onionSkinOpacity(-(i + 1));
            forwardOpacities[i] = scaleFactor * forwardState * config.onionSkinOpacity(i + 1);
        }
 
        configSeqNo++;
    }

References KisImageConfig::numberOfOnionSkins(), KisImageConfig::onionSkinOpacity(), KisImageConfig::onionSkinState(), KisImageConfig::onionSkinTintColorBackward(), KisImageConfig::onionSkinTintColorForward(), and KisImageConfig::onionSkinTintFactor().

◆ setUpTintDevice()

KisPaintDeviceSP KisOnionSkinCompositor::Private::setUpTintDevice	(	const QColor &	tintColor,
		const KoColorSpace *	colorSpace )

inline

Definition at line 39 of file kis_onion_skin_compositor.cpp.

    {
        KisPaintDeviceSP tintDevice = new KisPaintDevice(colorSpace);
        KoColor color = KoColor(tintColor, colorSpace);
        tintDevice->setDefaultPixel(color);
        return tintDevice;
    }

References KisPaintDevice::setDefaultPixel().

◆ skinOpacity()

int KisOnionSkinCompositor::Private::skinOpacity ( int offset )

inline

Definition at line 31 of file kis_onion_skin_compositor.cpp.

    {
        const QVector<int> &bo = backwardOpacities;
        const QVector<int> &fo = forwardOpacities;
 
        return offset > 0 ? fo[qAbs(offset) - 1] : bo[qAbs(offset) - 1];
    }

◆ tryCompositeFrame()

void KisOnionSkinCompositor::Private::tryCompositeFrame	(	KisRasterKeyframeSP	keyframe,
		KisPainter &	gcFrame,
		KisPainter &	gcDest,
		KisPaintDeviceSP	tintSource,
		int	opacity,
		const QRect &	rect )

inline

Definition at line 63 of file kis_onion_skin_compositor.cpp.

    {
        if (keyframe.isNull() || opacity == OPACITY_TRANSPARENT_U8) return;
 
        keyframe->writeFrameToDevice(gcFrame.device());
 
        gcFrame.bitBlt(rect.topLeft(), tintSource, rect);
 
        gcDest.setOpacityU8(opacity);
        gcDest.bitBlt(rect.topLeft(), gcFrame.device(), rect);
    }

References KisPainter::bitBlt(), KisPainter::device, OPACITY_TRANSPARENT_U8, and KisPainter::setOpacityU8().

◆ updateExtentOnFrameChange()

QRect KisOnionSkinCompositor::Private::updateExtentOnFrameChange	(	KisRasterKeyframeChannel *	channel,
		int	prevActiveTime,
		int	prevIgnoredTime,
		int	nowActiveTime,
		int	nowIgnoredTime )

Definition at line 242 of file kis_onion_skin_compositor.cpp.

{
    QRect rect;
 
    std::vector<int> skinsBefore;
    std::vector<int> skinsAfter;
 
    auto fetchSkins = [this] (KisRasterKeyframeChannel *channel, const int activeTime, int ignoredFrame) {
        std::vector<int> skinsLeft;
        std::vector<int> skinsRight;
 
        int keyframeTimeBck = activeTime;
        int keyframeTimeFwd = activeTime;
 
        auto addNextFrame = [channel, this, ignoredFrame] (int offset, int &startTime, std::vector<int> &skins, bool backwards) {
            KisRasterKeyframeSP keyframe;
            do {
                keyframe = getNextFrameToComposite(channel, startTime, backwards);
            } while (keyframe && startTime == ignoredFrame);
 
            if (keyframe && skinOpacity(-offset) != OPACITY_TRANSPARENT_U8) {
                skins.push_back(startTime);
            }
        };
 
        for (int offset = 1; offset <= numberOfSkins; offset++) {
            addNextFrame(offset, keyframeTimeBck, skinsLeft, true);
            addNextFrame(offset, keyframeTimeFwd, skinsRight, false);
        }
 
        std::reverse(skinsLeft.begin(), skinsLeft.end());
        skinsLeft.reserve(skinsLeft.size() + skinsRight.size());
        std::copy(skinsRight.begin(), skinsRight.end(), std::back_inserter(skinsLeft));
 
        return skinsLeft;
    };
 
    skinsBefore = fetchSkins(channel, prevActiveTime, prevIgnoredTime);
    skinsAfter = fetchSkins(channel, nowActiveTime, nowIgnoredTime);
 
    std::vector<int> changedSkins;
 
    std::set_symmetric_difference(skinsBefore.begin(), skinsBefore.end(),
                                  skinsAfter.begin(), skinsAfter.end(),
                                  std::back_inserter(changedSkins));
 
//    ENTER_FUNCTION() << ppVar(skinsBefore);
//    ENTER_FUNCTION() << ppVar(skinsAfter);
//    ENTER_FUNCTION() << ppVar(changedSkins);
 
    for (auto it = changedSkins.begin(); it != changedSkins.end(); ++it) {
        KIS_SAFE_ASSERT_RECOVER(channel->keyframeAt(*it)) { continue; }
        rect |= channel->frameExtents(channel->keyframeAt(*it));
    }
 
    return rect;
}