diff --git a/libs/image/kis_brush_mask_applicator_factories.cpp b/libs/image/kis_brush_mask_applicator_factories.cpp --- a/libs/image/kis_brush_mask_applicator_factories.cpp +++ b/libs/image/kis_brush_mask_applicator_factories.cpp @@ -21,6 +21,8 @@ #include "kis_circle_mask_generator.h" #include "kis_circle_mask_generator_p.h" #include "kis_gauss_circle_mask_generator_p.h" +#include "kis_curve_circle_mask_generator_p.h" + #include "kis_brush_mask_applicators.h" #include "kis_brush_mask_applicator_base.h" @@ -51,6 +53,16 @@ return new KisBrushMaskVectorApplicator(maskGenerator); } + +template<> +template<> +MaskApplicatorFactory::ReturnType +MaskApplicatorFactory::create(ParamType maskGenerator) +{ + return new KisBrushMaskVectorApplicator(maskGenerator); +} + + #if defined HAVE_VC struct KisCircleMaskGenerator::FastRowProcessor @@ -247,4 +259,120 @@ } } +struct KisCurveCircleMaskGenerator::FastRowProcessor +{ + FastRowProcessor(KisCurveCircleMaskGenerator *maskGenerator) + : d(maskGenerator->d.data()) {} + + template + void process(float* buffer, int width, float y, float cosa, float sina, + float centerX, float centerY); + + KisCurveCircleMaskGenerator::Private *d; +}; + + +template<> void KisCurveCircleMaskGenerator:: +FastRowProcessor::process(float* buffer, int width, float y, float cosa, float sina, + float centerX, float centerY) +{ + const bool antialiasOn = d->fadeMaker.getAliasingEnabled(); + + float y_ = y - centerY; + float sinay_ = sina * y_; + float cosay_ = cosa * y_; + + float* bufferPointer = buffer; + + qreal* curveDataPointer = d->curveData.data(); + + Vc::float_v currentIndices = Vc::float_v::IndexesFromZero(); + + Vc::float_v increment((float)Vc::float_v::size()); + Vc::float_v vCenterX(centerX); + + Vc::float_v vCosa(cosa); + Vc::float_v vSina(sina); + Vc::float_v vCosaY_(cosay_); + Vc::float_v vSinaY_(sinay_); + + Vc::float_v vYCoeff(d->ycoef); + Vc::float_v vXCoeff(d->xcoef); + Vc::float_v vCurveResolution(d->curveResolution); + + Vc::float_v vCurvedData(Vc::Zero); + Vc::float_v vCurvedData1(Vc::Zero); + + Vc::float_v vFadeRadius(d->fadeMaker.getRadius()); + Vc::float_v vFadeStartValue(d->fadeMaker.getFadeStartValue()); + Vc::float_v vFadeAFadeStart(d->fadeMaker.getAntialiasingFadeStart()); + Vc::float_v vFadeAFadeCoeff(d->fadeMaker.getAntialiasingFadeCoeff()); + + Vc::float_v vOne(Vc::One); + Vc::float_v vZero(Vc::Zero); + Vc::float_v vValMax(255.f); + + for (int i=0; i < width; i+= Vc::float_v::size()){ + + Vc::float_v x_ = currentIndices - vCenterX; + + Vc::float_v xr = x_ * vCosa - vSinaY_; + Vc::float_v yr = x_ * vSina + vCosaY_; + + Vc::float_v dist = pow2(xr * vXCoeff) + pow2(yr * vYCoeff); + + // BEGIN FadeMaker needFade vectorized + // follow fademaker rules for outsideMask + Vc::float_m outsideMask = dist > vFadeRadius; + dist(outsideMask) = vOne; + + Vc::float_m fadeStartMask(false); + // if antialias is off, do not process + if(antialiasOn){ + fadeStartMask = dist > vFadeAFadeStart; + dist((outsideMask ^ fadeStartMask) & fadeStartMask) = (vFadeStartValue + (dist - vFadeAFadeStart) * vFadeAFadeCoeff) / vValMax; + } + + Vc::float_m excludeMask = outsideMask | fadeStartMask; + + if (!excludeMask.isFull()) { + Vc::float_v valDist = dist * vCurveResolution; + // truncate + Vc::SimdArray vAlphaValue(valDist); + Vc::float_v vFloatAlphaValue = vAlphaValue; + + Vc::float_v alphaValueF = valDist - vFloatAlphaValue; + + vCurvedData.gather(curveDataPointer,vAlphaValue); + vCurvedData1.gather(curveDataPointer,vAlphaValue + 1); +// Vc::float_v vCurvedData1(curveDataPointer,vAlphaValue + 1); + + // vAlpha + Vc::float_v fullFade = ( + (1.0f - alphaValueF) * vCurvedData + + alphaValueF * vCurvedData1); + + Vc::float_m mask; + // Mask in the inner circe of the mask + mask = fullFade < vZero; + fullFade.setZero(mask); + + // Mask outer circle of mask + mask = fullFade >= vOne; + Vc::float_v vFade = (1.0f - fullFade); + vFade.setZero(mask); + + // return original dist values before vFade transform + vFade(excludeMask) = dist; + vFade.store(bufferPointer, Vc::Aligned); + + } else { + dist.store(bufferPointer, Vc::Aligned); + } + currentIndices = currentIndices + increment; + + bufferPointer += Vc::float_v::size(); + } +} + #endif /* defined HAVE_VC */ diff --git a/libs/image/kis_curve_circle_mask_generator.h b/libs/image/kis_curve_circle_mask_generator.h --- a/libs/image/kis_curve_circle_mask_generator.h +++ b/libs/image/kis_curve_circle_mask_generator.h @@ -19,11 +19,12 @@ #ifndef _KIS_CURVE_CIRCLE_MASK_GENERATOR_H_ #define _KIS_CURVE_CIRCLE_MASK_GENERATOR_H_ -#include -#include "kritaimage_export.h" - #include #include +#include + +#include "kritaimage_export.h" +#include "kis_mask_generator.h" class KisCubicCurve; class QDomElement; @@ -38,7 +39,8 @@ */ class KRITAIMAGE_EXPORT KisCurveCircleMaskGenerator : public KisMaskGenerator { - +public: + struct FastRowProcessor; public: KisCurveCircleMaskGenerator(qreal radius, qreal ratio, qreal fh, qreal fv, int spikes,const KisCubicCurve& curve, bool antialiasEdges); @@ -55,6 +57,11 @@ void toXML(QDomDocument& , QDomElement&) const override; void setSoftness(qreal softness) override; + bool shouldVectorize() const override; + KisBrushMaskApplicatorBase* applicator() override; + + void resetMaskApplicator(bool forceScalar); + static void transformCurveForSoftness(qreal softness,const QList &points, int curveResolution, QVector &result); private: diff --git a/libs/image/kis_curve_circle_mask_generator.cpp b/libs/image/kis_curve_circle_mask_generator.cpp --- a/libs/image/kis_curve_circle_mask_generator.cpp +++ b/libs/image/kis_curve_circle_mask_generator.cpp @@ -17,9 +17,27 @@ */ #include //MSVC requires that Vc come first - #include +#include +#ifdef HAVE_VC +#if defined(__clang__) +#pragma GCC diagnostic ignored "-Wundef" +#pragma GCC diagnostic ignored "-Wlocal-type-template-args" +#endif +#if defined _MSC_VER +// Lets shut up the "possible loss of data" and "forcing value to bool 'true' or 'false' +#pragma warning ( push ) +#pragma warning ( disable : 4244 ) +#pragma warning ( disable : 4800 ) +#endif +#include +#include +#if defined _MSC_VER +#pragma warning ( pop ) +#endif +#endif + #include #include #include @@ -29,38 +47,13 @@ #include "kis_fast_math.h" #include "kis_base_mask_generator.h" -#include "kis_curve_circle_mask_generator.h" -#include "kis_cubic_curve.h" #include "kis_antialiasing_fade_maker.h" +#include "kis_brush_mask_applicator_factories.h" +#include "kis_curve_circle_mask_generator.h" +#include "kis_curve_circle_mask_generator_p.h" +#include "kis_cubic_curve.h" -struct Q_DECL_HIDDEN KisCurveCircleMaskGenerator::Private -{ - Private(bool enableAntialiasing) - : fadeMaker(*this, enableAntialiasing) - { - } - - Private(const Private &rhs) - : xcoef(rhs.xcoef), - ycoef(rhs.ycoef), - curveResolution(rhs.curveResolution), - curveData(rhs.curveData), - curvePoints(rhs.curvePoints), - dirty(true), - fadeMaker(rhs.fadeMaker,*this) - { - } - - qreal xcoef, ycoef; - qreal curveResolution; - QVector curveData; - QList curvePoints; - bool dirty; - - KisAntialiasingFadeMaker1D fadeMaker; - inline quint8 value(qreal dist) const; -}; KisCurveCircleMaskGenerator::KisCurveCircleMaskGenerator(qreal diameter, qreal ratio, qreal fh, qreal fv, int spikes, const KisCubicCurve &curve, bool antialiasEdges) : KisMaskGenerator(diameter, ratio, fh, fv, spikes, antialiasEdges, CIRCLE, SoftId), d(new Private(antialiasEdges)) @@ -73,12 +66,15 @@ d->dirty = false; setScale(1.0, 1.0); + + d->applicator.reset(createOptimizedClass >(this)); } KisCurveCircleMaskGenerator::KisCurveCircleMaskGenerator(const KisCurveCircleMaskGenerator &rhs) : KisMaskGenerator(rhs), d(new Private(*rhs.d)) { + d->applicator.reset(createOptimizedClass >(this)); } KisCurveCircleMaskGenerator::~KisCurveCircleMaskGenerator() @@ -108,6 +104,16 @@ return effectiveSrcWidth() < 10 || effectiveSrcHeight() < 10; } +bool KisCurveCircleMaskGenerator::shouldVectorize() const +{ + return !shouldSupersample() && spikes() == 2; +} + +KisBrushMaskApplicatorBase* KisCurveCircleMaskGenerator::applicator() +{ + return d->applicator.data(); +} + inline quint8 KisCurveCircleMaskGenerator::Private::value(qreal dist) const { qreal distance = dist * curveResolution; @@ -118,6 +124,7 @@ qreal alpha = ( (1.0 - alphaValueF) * curveData.at(alphaValue) + alphaValueF * curveData.at(alphaValue+1)); + return (1.0 - alpha) * 255; } @@ -178,3 +185,8 @@ KisCubicCurve curve(newList); result = curve.floatTransfer( curveResolution ); } + +void KisCurveCircleMaskGenerator::resetMaskApplicator(bool forceScalar) +{ + d->applicator.reset(createOptimizedClass >(this,forceScalar)); +} diff --git a/libs/image/kis_curve_circle_mask_generator_p.h b/libs/image/kis_curve_circle_mask_generator_p.h new file mode 100644 --- /dev/null +++ b/libs/image/kis_curve_circle_mask_generator_p.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2010 Lukáš Tvrdý + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef KIS_CURVE_CIRCLE_MASK_GENERATOR_P_H +#define KIS_CURVE_CIRCLE_MASK_GENERATOR_P_H + +#include "kis_antialiasing_fade_maker.h" +#include "kis_brush_mask_applicator_base.h" + +struct Q_DECL_HIDDEN KisCurveCircleMaskGenerator::Private +{ + Private(bool enableAntialiasing) + : fadeMaker(*this, enableAntialiasing) + { + } + + Private(const Private &rhs) + : xcoef(rhs.xcoef), + ycoef(rhs.ycoef), + curveResolution(rhs.curveResolution), + curveData(rhs.curveData), + curvePoints(rhs.curvePoints), + dirty(true), + fadeMaker(rhs.fadeMaker,*this) + { + } + + qreal xcoef, ycoef; + qreal curveResolution; + QVector curveData; + QList curvePoints; + bool dirty; + + KisAntialiasingFadeMaker1D fadeMaker; + QScopedPointer applicator; + + inline quint8 value(qreal dist) const; +}; + +#endif // KIS_CURVE_CIRCLE_MASK_GENERATOR_P_H diff --git a/libs/image/kis_gauss_circle_mask_generator_p.h b/libs/image/kis_gauss_circle_mask_generator_p.h --- a/libs/image/kis_gauss_circle_mask_generator_p.h +++ b/libs/image/kis_gauss_circle_mask_generator_p.h @@ -20,6 +20,7 @@ #define _KIS_GAUSS_MASK_GENERATOR_P_H_ #include "kis_antialiasing_fade_maker.h" +#include "kis_brush_mask_applicator_base.h" struct Q_DECL_HIDDEN KisGaussCircleMaskGenerator::Private { diff --git a/libs/image/tests/KisMaskGeneratorBenchmark.h b/libs/image/tests/KisMaskGeneratorBenchmark.h --- a/libs/image/tests/KisMaskGeneratorBenchmark.h +++ b/libs/image/tests/KisMaskGeneratorBenchmark.h @@ -31,6 +31,9 @@ void testCircularGaussScalarMask(); void testCircularGaussVectorMask(); + + void testCircularSoftScalarMask(); + void testCircularSoftVectorMask(); }; #endif // KISMASKGENERATORBENCHMARK_H diff --git a/libs/image/tests/KisMaskGeneratorBenchmark.cpp b/libs/image/tests/KisMaskGeneratorBenchmark.cpp --- a/libs/image/tests/KisMaskGeneratorBenchmark.cpp +++ b/libs/image/tests/KisMaskGeneratorBenchmark.cpp @@ -17,6 +17,7 @@ */ #include +#include #include #include @@ -26,6 +27,7 @@ #include "kis_brush_mask_applicator_base.h" #include "kis_mask_generator.h" +#include "kis_cubic_curve.h" #include "krita_utils.h" #include "testutil.h" @@ -107,4 +109,30 @@ } } +void KisMaskGeneratorBenchmark::testCircularSoftScalarMask() +{ + QRect bounds(0,0,1000,1000); + KisCubicCurve pointsCurve; + pointsCurve.fromString(QString("0,1;1,0")); + { + KisCurveCircleMaskGenerator circScalar(1000, 1.0, 0.5, 0.5, 2, pointsCurve, true); + circScalar.setSoftness(0.5); + circScalar.resetMaskApplicator(true); // Force usage of scalar backend + + KisMaskGeneratorBenchmarkTester(circScalar.applicator(), bounds); + } +} + +void KisMaskGeneratorBenchmark::testCircularSoftVectorMask() +{ + QRect bounds(0,0,1000,1000); + KisCubicCurve pointsCurve; + pointsCurve.fromString(QString("0,1;1,0")); + { + KisCurveCircleMaskGenerator circVectr(1000, 1.0, 0.5, 0.5, 2, pointsCurve, true); + circVectr.setSoftness(0.5); + KisMaskGeneratorBenchmarkTester(circVectr.applicator(), bounds); + } +} + QTEST_MAIN(KisMaskGeneratorBenchmark) diff --git a/libs/image/tests/kis_mask_similarity_test.h b/libs/image/tests/kis_mask_similarity_test.h --- a/libs/image/tests/kis_mask_similarity_test.h +++ b/libs/image/tests/kis_mask_similarity_test.h @@ -28,6 +28,7 @@ void testCircleMask(); void testGaussCircleMask(); + void testSoftCircleMask(); }; #endif diff --git a/libs/image/tests/kis_mask_similarity_test.cpp b/libs/image/tests/kis_mask_similarity_test.cpp --- a/libs/image/tests/kis_mask_similarity_test.cpp +++ b/libs/image/tests/kis_mask_similarity_test.cpp @@ -19,18 +19,25 @@ #include "kis_mask_similarity_test.h" #include +#include + #include #include #include "kis_brush_mask_applicator_base.h" #include "kis_mask_generator.h" +#include "kis_cubic_curve.h" #include "krita_utils.h" +enum MaskType { + DEFAULT, CIRC_GAUSS, CIRC_SOFT, RECT_GAUSS, RECT_SOFT, STAMP +}; class KisMaskSimilarityTester { + public: - KisMaskSimilarityTester(KisBrushMaskApplicatorBase *_legacy, KisBrushMaskApplicatorBase *_vectorized, QRect _bounds) + KisMaskSimilarityTester(KisBrushMaskApplicatorBase *_legacy, KisBrushMaskApplicatorBase *_vectorized, QRect _bounds, MaskType type, bool renderImage = true) : legacy(_legacy) , vectorized(_vectorized) , m_bounds(_bounds) @@ -49,7 +56,6 @@ QImage scalarImage(m_paintDev->convertToQImage(m_colorSpace->profile())); scalarImage.invertPixels(); // Make pixel color black - scalarImage.save(QString("scalar_mask.png"),"PNG"); // Start vector processing m_paintDev->initialize(255); @@ -58,29 +64,42 @@ QImage vectorImage(m_paintDev->convertToQImage(m_colorSpace->profile())); vectorImage.invertPixels(); // Make pixel color black - vectorImage.save(QString("vector_mask.png"),"PNG"); - -// Development debug. -// Count number of identical pixels -// int equals = 0; -// for (int i = 0; i < scalarImage.width(); ++i) { -// for (int j = 0; j < scalarImage.height(); ++j) { -// if (scalarImage.pixelColor(i,j) == vectorImage.pixelColor(i,j)){ -// equals++; -// } else { -// qDebug() << scalarImage.pixelColor(i,j) << " " << vectorImage.pixelColor(i,j); -// } -// } -// } -// qDebug() << "Equal Pixels: " << equals; - - // Check for differences, max error .5% of pixel mismatch - int tolerance = m_bounds.width() * m_bounds.height() * .005f; + + if (renderImage) { + scalarImage.save(QString(getTypeName(type) + "_scalar_mask.png"),"PNG"); + vectorImage.save(QString(getTypeName(type) +"_vector_mask.png"),"PNG"); + } + + // Check for differences, max errors: 0 QPoint tmpPt; - QVERIFY(TestUtil::compareQImages(tmpPt,scalarImage, vectorImage, 0, 1, tolerance)); + QVERIFY(TestUtil::compareQImages(tmpPt,scalarImage, vectorImage, 0, 2, 0)); } private: + QString getTypeName(MaskType type) { + QString strName; + switch (type) { + case CIRC_GAUSS: + strName = "CircGauss"; + break; + case CIRC_SOFT: + strName = "CircSoft"; + break; + case RECT_GAUSS: + strName = "RectGauss"; + break; + case RECT_SOFT: + strName = "RectSoft"; + break; + case STAMP: + strName = "Stamp"; + break; + default: + strName = "Default"; + break; + } + return strName; + } protected: const KoColorSpace *m_colorSpace = KoColorSpaceRegistry::instance()->rgb8(); @@ -96,11 +115,11 @@ { QRect bounds(0,0,500,500); { - KisCircleMaskGenerator circVectr(480, 1.0, 0.5, 0.5, 2, true); + KisCircleMaskGenerator circVectr(500, 1.0, 0.5, 0.5, 2, true); KisCircleMaskGenerator circScalar(circVectr); circScalar.resetMaskApplicator(true); // Force usage of scalar backend - KisMaskSimilarityTester(circScalar.applicator(), circVectr.applicator(), bounds); + KisMaskSimilarityTester(circScalar.applicator(), circVectr.applicator(), bounds, DEFAULT); } } @@ -108,13 +127,56 @@ { QRect bounds(0,0,500,500); { - KisGaussCircleMaskGenerator circVectr(480, 1.0, 0.5, 0.5, 2, true); - circVectr.setDiameter(480); - KisGaussCircleMaskGenerator circScalar(circVectr); + KisGaussCircleMaskGenerator circVectr(500, 1.0, .8, .2, 2, true); + circVectr.setDiameter(500); + KisGaussCircleMaskGenerator circScalar(circVectr); + + circScalar.resetMaskApplicator(true); // Force usage of scalar backend + KisMaskSimilarityTester(circScalar.applicator(), circVectr.applicator(), bounds, CIRC_GAUSS); + } + // Exahustive test + for (size_t i = 0; i <= 100; i += 3){ + for (size_t j = 0; j <= 100; j += 3){ + for (size_t k = 0; k <= 100; k += 15){ + { + KisGaussCircleMaskGenerator circVectr(500, k/100.f, i/100.f, j/100.f, 2, true); + circVectr.setDiameter(500); + KisGaussCircleMaskGenerator circScalar(circVectr); + + circScalar.resetMaskApplicator(true); // Force usage of scalar backend + KisMaskSimilarityTester(circScalar.applicator(), circVectr.applicator(), bounds,CIRC_GAUSS,false); + } + } } } // end for +} + +void KisMaskSimilarityTest::testSoftCircleMask() +{ + QRect bounds(0,0,500,500); + KisCubicCurve pointsCurve; + pointsCurve.fromString(QString("0,1;1,0")); + { + KisCurveCircleMaskGenerator circVectr(500, 1.0, 0.5, 0.5, 2, pointsCurve,true); + circVectr.setDiameter(500); + // circVectr.setSoftness(1.0); + KisCurveCircleMaskGenerator circScalar(circVectr); circScalar.resetMaskApplicator(true); // Force usage of scalar backend - KisMaskSimilarityTester(circScalar.applicator(), circVectr.applicator(), bounds); + KisMaskSimilarityTester(circScalar.applicator(), circVectr.applicator(), bounds, CIRC_SOFT); } + + // Exahustive test + for (size_t i = 0; i <= 100; i += 3){ + for (size_t j = 0; j <= 100; j += 3){ + for (size_t k = 0; k <= 100; k += 15){ + { + KisCurveCircleMaskGenerator circVectr(500, k/100.f, i/100.f, j/100.f, 2,pointsCurve, true); + circVectr.setDiameter(500); + KisCurveCircleMaskGenerator circScalar(circVectr); + + circScalar.resetMaskApplicator(true); // Force usage of scalar backend + KisMaskSimilarityTester(circScalar.applicator(), circVectr.applicator(), bounds,CIRC_SOFT,false); + } + } } } // end for } QTEST_MAIN(KisMaskSimilarityTest)