File indexing completed on 2025-01-26 04:11:16

 /*
  *  SPDX-FileCopyrightText: 2013 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "kis_brushop_test.h"
 
 #include <simpletest.h>
 #include <qimage_based_test.h>
 #include <stroke_testing_utils.h>
 #include <brushengine/kis_paint_information.h>
 #include <kis_canvas_resource_provider.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <brushengine/kis_paintop_settings.h>
 #include <KisMirrorOptionData.h>
 #include <KisStandardOptionData.h>
 
 class TestBrushOp : public TestUtil::QImageBasedTest
 {
 public:
     TestBrushOp(const QString &presetFileName, const QString &prefix = "simple")
         : QImageBasedTest("brushop") {
         m_presetFileName = presetFileName;
         m_prefix = prefix;
     }
 
     virtual ~TestBrushOp() {}
 
     void test() {
         test(false, false,  0.0);
         test(false, false, 10.0);
         test(false, false, 20.0);
 
         test(true, false,  0.0);
         test(true, false, 10.0);
         test(true, false, 20.0);
 
         test(false, true,  0.0);
         test(false, true, 10.0);
         test(false, true, 20.0);
 
         test(true, true,  0.0);
         test(true, true, 10.0);
         test(true, true, 20.0);
     }
 
     void test(bool mirrorX, bool mirrorY, qreal rotation) {
         test(mirrorX, mirrorY, rotation, false, false);
         test(mirrorX, mirrorY, rotation, true,  false);
         test(mirrorX, mirrorY, rotation, false, true);
         test(mirrorX, mirrorY, rotation, true,  true);
     }
 
     void test(bool mirrorX, bool mirrorY, qreal rotation, bool mirrorDabX, bool mirrorDabY) {
         test(mirrorX, mirrorY, rotation, mirrorDabX, mirrorDabY, 0.0);
         test(mirrorX, mirrorY, rotation, mirrorDabX, mirrorDabY, 360.0 - 10.0);
         test(mirrorX, mirrorY, rotation, mirrorDabX, mirrorDabY, 360.0 - 20.0);
     }
 
     void test(bool mirrorX, bool mirrorY, qreal rotation, bool mirrorDabX, bool mirrorDabY, qreal dabRotation) {
 
         KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
         KisImageSP image = createTrivialImage(undoStore);
         image->initialRefreshGraph();
 
         KisNodeSP paint1 = findNode(image->root(), "paint1");
 
         QVERIFY(paint1->extent().isEmpty());
 
         KisPainter gc(paint1->paintDevice());
 
         QScopedPointer<KoCanvasResourceProvider> manager(
             utils::createResourceManager(image, 0, m_presetFileName));
 
         KisPaintOpPresetSP preset =
             manager->resource(KoCanvasResource::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
 
         if (mirrorDabX || mirrorDabY) {
             KisPaintOpSettingsSP settings = preset->settings()->clone();
 
             KisMirrorOptionData mirrorData;
             mirrorData.read(settings.data());
 
             mirrorData.isChecked = true;
             mirrorData.useCurve = false;
 
             mirrorData.enableHorizontalMirror = mirrorDabX;
             mirrorData.enableVerticalMirror = mirrorDabY;
 
             mirrorData.write(settings.data());
 
             preset->setSettings(settings);
         }
 
         if (dabRotation != 0.0) {
             KisPaintOpSettingsSP settings = preset->settings()->clone();
 
             KisRotationOptionData rotationData;
             rotationData.read(settings.data());
 
             rotationData.isChecked = true;
             rotationData.useCurve = false;
 
             rotationData.strengthValue = dabRotation / 360.0;
 
             rotationData.write(settings.data());
 
             preset->setSettings(settings);
         }
 
 
         QString testName =
             QString("%7_cmY_%1_cmX_%2_cR_%3_dmX_%4_dmY_%5_dR_%6")
             .arg(mirrorY)
             .arg(mirrorX)
             .arg(rotation)
             .arg(mirrorDabX)
             .arg(mirrorDabY)
             .arg(std::fmod(360.0 - dabRotation, 360.0))
             .arg(m_prefix);
 
         KisResourcesSnapshotSP resources =
             new KisResourcesSnapshot(image,
                                      paint1,
                                      manager.data());
 
         resources->setupPainter(&gc);
 
         doPaint(gc, rotation, mirrorX, mirrorY);
 
         checkOneLayer(image, paint1, testName);
     }
 
     virtual void doPaint(KisPainter &gc, qreal rotation, bool mirrorX, bool mirrorY) {
         KisPaintInformation pi(QPointF(100, 100), 1.0);
         pi.setCanvasRotation(rotation);
         pi.setCanvasMirroredH(mirrorX);
         pi.setCanvasMirroredV(mirrorY);
 
         KisDistanceInformation dist;
         gc.paintAt(pi, &dist);
     }
 
     QString m_presetFileName;
     QString m_prefix;
 };
 
 class TestBrushOpLines : public TestBrushOp
 {
 public:
     TestBrushOpLines(const QString &presetFileName)
         : TestBrushOp(presetFileName) {
     }
 
     void doPaint(KisPainter &gc, qreal rotation, bool mirrorX, bool mirrorY) override {
 
         QVector<KisPaintInformation> vector;
 
         vector << KisPaintInformation(QPointF(100, 100));
         vector << KisPaintInformation(QPointF(200, 150));
         vector << KisPaintInformation(QPointF(100, 350));
 
 
         for (auto pi : vector) {
             pi.setCanvasRotation(rotation);
             pi.setCanvasMirroredH(mirrorX);
             pi.setCanvasMirroredV(mirrorY);
         }
 
         KisDistanceInformation dist;
 
         for (int i = 1; i < vector.size(); i++) {
             gc.paintLine(vector[i - 1], vector[i], &dist);
         }
     }
 };
 
 class TestBrushOpPressureLines : public TestBrushOp
 {
 public:
     TestBrushOpPressureLines(const QString &presetFileName, const QString &prefix)
         : TestBrushOp(presetFileName, prefix) {
     }
 
     void doPaint(KisPainter &gc, qreal rotation, bool mirrorX, bool mirrorY) override {
 
         QVector<KisPaintInformation> vector;
 
         vector << KisPaintInformation(QPointF(0, 0), 0.2);
         vector << KisPaintInformation(QPointF(200, 50), 1.0);
         vector << KisPaintInformation(QPointF(100, 250), 0.0);
         vector << KisPaintInformation(QPointF(200, 150), 1.0);
         vector << KisPaintInformation(QPointF(100, 350), 1.0);
 
         for (auto pi : vector) {
             pi.setCanvasRotation(rotation);
             pi.setCanvasMirroredH(mirrorX);
             pi.setCanvasMirroredV(mirrorY);
         }
 
         KisDistanceInformation dist;
 
         for (int i = 1; i < vector.size(); i++) {
             gc.paintLine(vector[i - 1], vector[i], &dist);
         }
     }
 };
 
 #include <KoResourcePaths.h>
 void KisBrushOpTest::initTestCase()
 {
     KoResourcePaths::addAssetDir(ResourceType::Brushes, QString(SYSTEM_RESOURCES_DATA_DIR) + "/brushes");
 }
 
 void KisBrushOpTest::testRotationMirroring()
 {
     TestBrushOp t("LR_simple.kpp");
     t.test();
 }
 
 void KisBrushOpTest::testRotationMirroringDrawingAngle()
 {
     TestBrushOpLines t("LR_drawing_angle.kpp");
     t.test();
 }
 
 void KisBrushOpTest::testMagicSeven()
 {
     /**
      * A special preset that forces Qt to bug:
      *     mask size: 56
      *     brush size: 7
      *     therefore scale is: 0.125
      *     which causes QTransform work as a pure Translate in the mipmap
      */
 
     TestBrushOpPressureLines t("magic_seven.kpp", "magicseven");
     t.test();
 }
 
 SIMPLE_TEST_MAIN(KisBrushOpTest)