KisPredefinedBrushFactory Class Reference

#include <kis_predefined_brush_factory.h>

Inheritance diagram for KisPredefinedBrushFactory:

Public Member Functions
KoResourceLoadResult	createBrush (const KisBrushModel::BrushData &brushData, KisResourcesInterfaceSP resourcesInterface) override
KoResourceLoadResult	createBrush (const QDomElement &brushDefinition, KisResourcesInterfaceSP resourcesInterface) override
std::optional< KisBrushModel::BrushData >	createBrushModel (const QDomElement &element, KisResourcesInterfaceSP resourcesInterface) override
QString	id () const override
	KisPredefinedBrushFactory (const QString &brushType)
void	toXML (QDomDocument &doc, QDomElement &element, const KisBrushModel::BrushData &model) override
Public Member Functions inherited from KisBrushFactory
	KisBrushFactory ()
virtual QString	name () const
virtual	~KisBrushFactory ()

Static Public Member Functions
static void	loadFromBrushResource (KisBrushModel::CommonData &commonData, KisBrushModel::PredefinedBrushData &predefinedBrushData, KisBrushSP brushResource)

Private Member Functions
std::variant< KisBrushModel::BrushData, KoResourceSignature >	createBrushModelImpl (const QDomElement &element, KisResourcesInterfaceSP resourcesInterface)

Private Attributes
const QString	m_id

Detailed Description

Definition at line 18 of file kis_predefined_brush_factory.h.

Constructor & Destructor Documentation

KisPredefinedBrushFactory()

KisPredefinedBrushFactory::KisPredefinedBrushFactory

(

const QString &

brushType

)

Definition at line 20 of file kis_predefined_brush_factory.cpp.

    : m_id(brushType)
{
}

Member Function Documentation

createBrush() [1/2]

KoResourceLoadResult KisPredefinedBrushFactory::createBrush ( const KisBrushModel::BrushData & brushData, KisResourcesInterfaceSP resourcesInterface )

overridevirtual

Implements KisBrushFactory.

Definition at line 30 of file kis_predefined_brush_factory.cpp.

{
    auto resourceSourceAdapter = resourcesInterface->source<KisBrush>(ResourceType::Brushes);
    const QString brushFileName = brushData.predefinedBrush.resourceSignature.filename;
    const QString brushMD5Sum = brushData.predefinedBrush.resourceSignature.md5sum;
    KisBrushSP brush = resourceSourceAdapter.bestMatch(brushMD5Sum, brushFileName, "");
    if (!brush) {
        return KoResourceSignature(ResourceType::Brushes, brushMD5Sum, brushFileName, "");
    }
 
    // we always return a copy of the brush!
    brush = brush->clone().dynamicCast<KisBrush>();
 
    brush->setSpacing(brushData.common.spacing);
    brush->setAutoSpacing(brushData.common.useAutoSpacing, brushData.common.autoSpacingCoeff);
    brush->setAngle(brushData.common.angle);
    brush->setScale(brushData.predefinedBrush.scale);
 
    KisColorfulBrush *colorfulBrush = dynamic_cast<KisColorfulBrush*>(brush.data());
    if (colorfulBrush) {
        colorfulBrush->setAdjustmentMidPoint(brushData.predefinedBrush.adjustmentMidPoint);
        colorfulBrush->setBrightnessAdjustment(brushData.predefinedBrush.brightnessAdjustment);
        colorfulBrush->setContrastAdjustment(brushData.predefinedBrush.contrastAdjustment);
        colorfulBrush->setAutoAdjustMidPoint(brushData.predefinedBrush.autoAdjustMidPoint);
    }
 
    brush->setBrushApplication(brushData.predefinedBrush.application);
 
    return brush;
}

References KisBrushModel::PredefinedBrushData::adjustmentMidPoint, KisBrushModel::CommonData::angle, KisBrushModel::PredefinedBrushData::application, KisBrushModel::PredefinedBrushData::autoAdjustMidPoint, KisBrushModel::CommonData::autoSpacingCoeff, KisBrushModel::PredefinedBrushData::brightnessAdjustment, ResourceType::Brushes, KisBrushModel::BrushData::common, KisBrushModel::PredefinedBrushData::contrastAdjustment, KoResourceSignature::filename, KoResourceSignature::md5sum, KisBrushModel::BrushData::predefinedBrush, KisBrushModel::PredefinedBrushData::resourceSignature, KisBrushModel::PredefinedBrushData::scale, KisColorfulBrush::setAdjustmentMidPoint(), KisColorfulBrush::setAutoAdjustMidPoint(), KisColorfulBrush::setBrightnessAdjustment(), KisColorfulBrush::setContrastAdjustment(), KisBrushModel::CommonData::spacing, and KisBrushModel::CommonData::useAutoSpacing.

createBrush() [2/2]

KoResourceLoadResult KisPredefinedBrushFactory::createBrush ( const QDomElement & element, KisResourcesInterfaceSP resourcesInterface )

overridevirtual

Create a new brush from the given data or return an existing KisBrush object. If this call leads to the creation of a resource, it should be added to the resource provider, too.

Implements KisBrushFactory.

Definition at line 61 of file kis_predefined_brush_factory.cpp.

{
    auto data = createBrushModelImpl(brushDefinition, resourcesInterface);
 
    if (std::holds_alternative<KisBrushModel::BrushData>(data)) {
        return createBrush(std::get<KisBrushModel::BrushData>(data), resourcesInterface);
    } else if (std::holds_alternative<KoResourceSignature>(data)) {
        return std::get<KoResourceSignature>(data);
    }
 
    // fallback, should never reach!
    return KoResourceSignature(ResourceType::Brushes, "", "", "");
}

References ResourceType::Brushes, createBrush(), and createBrushModelImpl().

createBrushModel()

std::optional< KisBrushModel::BrushData > KisPredefinedBrushFactory::createBrushModel ( const QDomElement & element, KisResourcesInterfaceSP resourcesInterface )

overridevirtual

Implements KisBrushFactory.

Definition at line 75 of file kis_predefined_brush_factory.cpp.

{
    auto data = createBrushModelImpl(element, resourcesInterface);
    return std::holds_alternative<KisBrushModel::BrushData>(data) ?
        std::make_optional(std::get<KisBrushModel::BrushData>(data)) :
        std::nullopt;
}

References createBrushModelImpl().

createBrushModelImpl()

std::variant< KisBrushModel::BrushData, KoResourceSignature > KisPredefinedBrushFactory::createBrushModelImpl ( const QDomElement & element, KisResourcesInterfaceSP resourcesInterface )

private

we should first initialize data from the brush, because it may change the spacing properties embedded into some brushes

In Krita 4.x releases there was a bug that caused lightness adjustments to be applied to the brush twice. It happened due to the fact that copy-ctor called brushTipImage() virtual method instead of just copying the image itself.

In Krita 5 we should open these brushes in somewhat the same way. The problem is that we cannot convert the numbers precisely, because after applying a piecewise-linear function twice we get a quadratic function. So we fall-back to a blunt parameters scaling, which gives result that is just "good enough".

NOTE: AutoAdjustMidPoint option appeared only in Krita 5, so it automatically means the adjustments should be applied in the new way.

In Krita we also changed formula for contrast calculation in negative part, so we need to convert that as well.

In Krita versions before 4.4 series "ColorAsMask" could be overridden to false when the brush had no color inside. That changed in Krita 4.4.x series, when "brushApplication" replaced all the automatic heuristics

In Krita versions before 4.4 series we used to automatically select the brush application depending on the presence of the color in the brush, even when there was no "ColorAsMask" field.

Definition at line 83 of file kis_predefined_brush_factory.cpp.

{
    KisBrushModel::BrushData brush;
 
    auto resourceSourceAdapter = resourcesInterface->source<KisBrush>(ResourceType::Brushes);
    const QString brushFileName = element.attribute("filename", "");
    const QString brushMD5Sum = element.attribute("md5sum", "");
    KisBrushSP brushResource = resourceSourceAdapter.bestMatch(brushMD5Sum, brushFileName, "");
    if (!brushResource) {
        return KoResourceSignature(ResourceType::Brushes, brushMD5Sum, brushFileName, "");
    }
 
    brush.type = KisBrushModel::Predefined;
 
    loadFromBrushResource(brush.common, brush.predefinedBrush, brushResource);
 
    brush.common.angle = KisDomUtils::toDouble(element.attribute("angle", "0.0"));
    brush.common.spacing = KisDomUtils::toDouble(element.attribute("spacing", "0.25"));
    brush.common.useAutoSpacing = KisDomUtils::toInt(element.attribute("useAutoSpacing", "0"));
    brush.common.autoSpacingCoeff = KisDomUtils::toDouble(element.attribute("autoSpacingCoeff", "1.0"));
 
    brush.predefinedBrush.scale = KisDomUtils::toDouble(element.attribute("scale", "1.0"));
 
    // legacy support...
    if (element.attribute("BrushVersion", "1") == "1") {
        brush.predefinedBrush.scale *= 2.0;
    }
 
    KisColorfulBrush *colorfulBrush = dynamic_cast<KisColorfulBrush*>(brushResource.data());
    if (colorfulBrush) {
        quint8 adjustmentMidPoint = element.attribute("AdjustmentMidPoint", "127").toInt();
        qreal brightnessAdjustment = element.attribute("BrightnessAdjustment").toDouble();
        qreal contrastAdjustment = element.attribute("ContrastAdjustment").toDouble();
 
        const int adjustmentVersion = element.attribute("AdjustmentVersion", "1").toInt();
        const bool autoAdjustMidPoint = element.attribute("AutoAdjustMidPoint", "0").toInt();
        const bool hasAutoAdjustMidPoint = element.hasAttribute("AutoAdjustMidPoint");
 
        if (adjustmentVersion < 2 && !hasAutoAdjustMidPoint) {
            adjustmentMidPoint = qBound(0, 127 + (int(adjustmentMidPoint) - 127) * 2, 255);
            brightnessAdjustment *= 2.0;
            contrastAdjustment *= 2.0;
 
            if (contrastAdjustment < 0) {
                contrastAdjustment = 1.0 / (1.0 - contrastAdjustment) - 1.0;
            }
        }
 
        brush.predefinedBrush.adjustmentMidPoint = adjustmentMidPoint;
        brush.predefinedBrush.brightnessAdjustment = brightnessAdjustment;
        brush.predefinedBrush.contrastAdjustment = contrastAdjustment;
        brush.predefinedBrush.autoAdjustMidPoint = autoAdjustMidPoint;
        brush.predefinedBrush.hasColorAndTransparency = colorfulBrush->hasColorAndTransparency();
    }
 
    auto legacyBrushApplication = [] (KisColorfulBrush *colorfulBrush, bool forceColorToAlpha) {
        return (colorfulBrush && colorfulBrush->hasColorAndTransparency() && !forceColorToAlpha) ? IMAGESTAMP : ALPHAMASK;
    };
 
 
    if (element.hasAttribute("preserveLightness")) {
        const int preserveLightness = KisDomUtils::toInt(element.attribute("preserveLightness", "0"));
        const bool useColorAsMask = (bool)element.attribute("ColorAsMask", "1").toInt();
        brush.predefinedBrush.application = preserveLightness ? LIGHTNESSMAP : legacyBrushApplication(colorfulBrush, useColorAsMask);
    }
    else if (element.hasAttribute("brushApplication")) {
        enumBrushApplication brushApplication = static_cast<enumBrushApplication>(KisDomUtils::toInt(element.attribute("brushApplication", "0")));
        brush.predefinedBrush.application = brushApplication;
    }
    else if (element.hasAttribute("ColorAsMask")) {
        KIS_SAFE_ASSERT_RECOVER_NOOP(colorfulBrush);
 
        const bool useColorAsMask = (bool)element.attribute("ColorAsMask", "1").toInt();
        brush.predefinedBrush.application =legacyBrushApplication(colorfulBrush, useColorAsMask);
    }
    else {
        brush.predefinedBrush.application = legacyBrushApplication(colorfulBrush, false);
    }
 
    return {brush};
}

References KisBrushModel::PredefinedBrushData::adjustmentMidPoint, ALPHAMASK, KisBrushModel::CommonData::angle, KisBrushModel::PredefinedBrushData::application, KisBrushModel::PredefinedBrushData::autoAdjustMidPoint, KisBrushModel::CommonData::autoSpacingCoeff, KisBrushModel::PredefinedBrushData::brightnessAdjustment, ResourceType::Brushes, KisBrushModel::BrushData::common, KisBrushModel::PredefinedBrushData::contrastAdjustment, KisBrushModel::PredefinedBrushData::hasColorAndTransparency, KisColorfulBrush::hasColorAndTransparency(), IMAGESTAMP, KIS_SAFE_ASSERT_RECOVER_NOOP, LIGHTNESSMAP, loadFromBrushResource(), KisBrushModel::Predefined, KisBrushModel::BrushData::predefinedBrush, KisBrushModel::PredefinedBrushData::scale, KisBrushModel::CommonData::spacing, KisDomUtils::toDouble(), KisDomUtils::toInt(), KisBrushModel::BrushData::type, and KisBrushModel::CommonData::useAutoSpacing.

id()

QString KisPredefinedBrushFactory::id ( ) const

overridevirtual

Implements KisBrushFactory.

Definition at line 25 of file kis_predefined_brush_factory.cpp.

{
    return m_id;
}

References m_id.

loadFromBrushResource()

void KisPredefinedBrushFactory::loadFromBrushResource ( KisBrushModel::CommonData & commonData, KisBrushModel::PredefinedBrushData & predefinedBrushData, KisBrushSP brushResource )

static

Definition at line 197 of file kis_predefined_brush_factory.cpp.

{
    commonData.spacing = brushResource->spacing();
    commonData.useAutoSpacing = brushResource->autoSpacingActive();
    commonData.autoSpacingCoeff = brushResource->autoSpacingCoeff();
    predefinedBrushData.resourceSignature = brushResource->signature();
    predefinedBrushData.brushType = brushResource->brushType();
    predefinedBrushData.baseSize = { brushResource->width(), brushResource->height() };
 
    if (brushResource.dynamicCast<KisGbrBrush>()) {
        predefinedBrushData.subtype = "gbr_brush";
    } else if (brushResource.dynamicCast<KisAbrBrush>()) {
        predefinedBrushData.subtype = "abr_brush";
    } else if (brushResource.dynamicCast<KisPngBrush>()) {
        predefinedBrushData.subtype = "png_brush";
    } else if (brushResource.dynamicCast<KisSvgBrush>()) {
        predefinedBrushData.subtype = "svg_brush";
    } else {
        KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "unknown brush type");
    }
 
    KisImagePipeBrushSP imagepipeBrush = brushResource.dynamicCast<KisImagePipeBrush>();
    if (imagepipeBrush) {
        predefinedBrushData.parasiteSelection = imagepipeBrush->parasiteSelection();
    }
}

References KisBrushModel::CommonData::autoSpacingCoeff, KisBrushModel::PredefinedBrushData::baseSize, KisBrushModel::PredefinedBrushData::brushType, KIS_SAFE_ASSERT_RECOVER_NOOP, KisBrushModel::PredefinedBrushData::parasiteSelection, KisBrushModel::PredefinedBrushData::resourceSignature, KisBrushModel::CommonData::spacing, KisBrushModel::PredefinedBrushData::subtype, and KisBrushModel::CommonData::useAutoSpacing.

toXML()

void KisPredefinedBrushFactory::toXML ( QDomDocument & doc, QDomElement & element, const KisBrushModel::BrushData & model )

overridevirtual

Implements KisBrushFactory.

Definition at line 224 of file kis_predefined_brush_factory.cpp.

{
    Q_UNUSED(doc);
 
    e.setAttribute("type", id());
    e.setAttribute("BrushVersion", "2");
 
    e.setAttribute("filename", model.predefinedBrush.resourceSignature.filename);
    e.setAttribute("md5sum", model.predefinedBrush.resourceSignature.md5sum);
    e.setAttribute("spacing", QString::number(model.common.spacing));
    e.setAttribute("useAutoSpacing", QString::number(model.common.useAutoSpacing));
    e.setAttribute("autoSpacingCoeff", QString::number(model.common.autoSpacingCoeff));
    e.setAttribute("angle", QString::number(model.common.angle));
    e.setAttribute("scale", QString::number(model.predefinedBrush.scale));
    e.setAttribute("brushApplication", QString::number((int)model.predefinedBrush.application));
 
    if (id() == "abr_brush") {
        e.setAttribute("name", model.predefinedBrush.resourceSignature.name);
 
    } else {
        // all other brushes are derived from KisColorfulBrush
 
        // legacy setting, now 'brushApplication' is used instead
        e.setAttribute("ColorAsMask", QString::number((int)(model.predefinedBrush.application != IMAGESTAMP)));
 
        e.setAttribute("AdjustmentMidPoint", QString::number(model.predefinedBrush.adjustmentMidPoint));
        e.setAttribute("BrightnessAdjustment", QString::number(model.predefinedBrush.brightnessAdjustment));
        e.setAttribute("ContrastAdjustment", QString::number(model.predefinedBrush.contrastAdjustment));
        e.setAttribute("AutoAdjustMidPoint", QString::number(model.predefinedBrush.autoAdjustMidPoint));
        e.setAttribute("AdjustmentVersion", QString::number(2));
    }
}

References KisBrushModel::PredefinedBrushData::adjustmentMidPoint, KisBrushModel::CommonData::angle, KisBrushModel::PredefinedBrushData::application, KisBrushModel::PredefinedBrushData::autoAdjustMidPoint, KisBrushModel::CommonData::autoSpacingCoeff, KisBrushModel::PredefinedBrushData::brightnessAdjustment, KisBrushModel::BrushData::common, KisBrushModel::PredefinedBrushData::contrastAdjustment, KoResourceSignature::filename, IMAGESTAMP, KoResourceSignature::md5sum, KoResourceSignature::name, KisBrushModel::BrushData::predefinedBrush, KisBrushModel::PredefinedBrushData::resourceSignature, KisBrushModel::PredefinedBrushData::scale, KisBrushModel::CommonData::spacing, and KisBrushModel::CommonData::useAutoSpacing.

Member Data Documentation

m_id

const QString KisPredefinedBrushFactory::m_id

private

Definition at line 34 of file kis_predefined_brush_factory.h.

---

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

• libs/brush/kis_predefined_brush_factory.h
• libs/brush/kis_predefined_brush_factory.cpp