Gaussian Blur / Blur Engine

[urzeye]

As @TheTwo mentioned, there is already an MR here to achieve this function. In fact, besides Clip Studio Paint, the smudging brushes in Easy Paint Tool SAI are also similar to the blur brush engine. The existing blur and smudging brushes in Krita use shaking to achieve a similar effect, which makes the smudging strokes look not smooth. Although it is subtle, it can be felt. Of course, this feeling of roughness can be alleviated by modifying the brush spacing. However, when I changed the brush spacing to 0.01, its strokes still have some roughness compared to using the blur engine, and there will be some lag at this time. Below is a comparison between using the blur engine and the smudging engine:

Actually, I have been using this MR for some time now, and I have improved the speed by replacing the original Gaussian blur with the regular blur in Krita.

According to the MR author, replacing Gaussian blur with box blur will make the speed faster. I don’t know if the regular blur in Krita is box blur, but it seems sufficient for me to use.

Another noteworthy point is that the developers believe the reason why this MR is slow is because they blurred the entire dab during testing, but in reality, this is not necessary. Here is a rendering of a straight line drawn using the blur engine in Clip Studio Paint, with a pen tip spacing of 150%:

It can be roughly seen that its blur radius is only 1/3 of the brush size. Since the Easy Paint Tool SAI seems unable to adjust the pen tip spacing, the blur width of a single dab cannot be clearly seen. The effect image after a single mouse click:

It can be seen that the fuzzy radius is approximately 1/2.

Anyway, I have been using this MR in Krita for a while now and I feel it’s great. I also hope it can be merged so that more people can use it.

[raghukamath]

Can you please post these observations in the MR is they are not already in there. It would be great if the author of the MR finishes this.

[urzeye]

Okay, I tried using AI to help with the box blurring, the following is the application code in the paint brush engine:

void KisColorSmudgeStrategyBase::blendInBackgroundWithBlurring(KisFixedPaintDeviceSP dst, KisColorSmudgeSourceSP src,
                                                               const QRect &neededRect, const QRect &srcRect, const QRect &dstRect,
                                                               const quint8 smudgeRateOpacity, const qreal smudgeRadiusValue)
{
    const bool opaqueCopy = (m_smearOp->id() == COMPOSITE_COPY || m_smearOp->id() == COMPOSITE_COPY_SPECTRAL) && smudgeRateOpacity == OPACITY_OPAQUE_U8;

    // Copy the original data into the blurring device
    KisPainter p(m_filterDevice);
    p.setCompositeOpId(COMPOSITE_COPY);
    src->bitBlt(&p, neededRect.topLeft(), neededRect);

    // Blur
    KisTransaction transaction(m_filterDevice);
    KisLodTransformScalar t(m_filterDevice);
    const int halfSize = t.scale(((qreal)srcRect.width()) * smudgeRadiusValue / 2.0);
    const int kernelSize = 2 * halfSize + 1;

    Eigen::Matrix<qreal, Eigen::Dynamic, Eigen::Dynamic> boxBlurKernel(kernelSize, kernelSize);
    qreal kernelValue = 1.0 / (kernelSize * kernelSize);
    boxBlurKernel.fill(kernelValue);
    KisConvolutionKernelSP kernel = KisConvolutionKernel::fromMatrix(boxBlurKernel, 0, 1);

    KisConvolutionPainter convolutionPainter(m_filterDevice);

    QBitArray channelFlags = QBitArray(m_filterDevice->colorSpace()->channelCount(), true);
    convolutionPainter.setChannelFlags(channelFlags);
    convolutionPainter.setProgress(nullptr);

    QPoint srcTopLeft = srcRect.topLeft();
    convolutionPainter.applyMatrix(kernel, m_filterDevice, srcTopLeft, srcTopLeft, srcRect.size(), BORDER_REPEAT);

    transaction.end();

    if (opaqueCopy) {
        // Write blur directly to dst
        m_filterDevice->readBytes(dst->data(), srcRect);
        m_filterDevice->clear();
    } else {
        // Copy the original data to the destination
        src->readBytes(dst->data(), dstRect);

        KisFixedPaintDevice tempDevice(src->colorSpace(), m_memoryAllocator);
        tempDevice.setRect(dstRect);
        tempDevice.lazyGrowBufferWithoutInitialization();

        // Write blur to temp device
        m_filterDevice->readBytes(tempDevice.data(), srcRect);
        m_filterDevice->clear();

        // Blend the blur with the destination
        m_smearOp->composite(dst->data(), dstRect.width() * dst->pixelSize(),
                             tempDevice.data(), dstRect.width() * tempDevice.pixelSize(), // stride should be random non-zero
                             0, 0,
                             1, dstRect.width() * dstRect.height(),
                             smudgeRateOpacity);
    }
}

[TheTwo]

In recent experiments, it was found that the “color running” of CSP is basically Krita’s “smearing” (except that it will blend with the canvas color, even if color blending is not turned on)
For the “intensity of blur” option in “color running”, it will only blur the first dab. This is very different from the blurry MR on the right. Therefore, there is no significant performance consumption