File indexing completed on 2024-05-19 04:32:39

 /*
  *  SPDX-FileCopyrightText: 2011 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #ifndef __QIMAGE_BASED_TEST_H
 #define __QIMAGE_BASED_TEST_H
 
 #ifndef USE_DOCUMENT
 #define USE_DOCUMENT 1
 #endif /* USE_DOCUMENT */
 
 #include <testutil.h>
 
 
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 
 #include <KoShapeContainer.h>
 #include <KoShapeRegistry.h>
 #include <KoShapeFactoryBase.h>
 
 #if USE_DOCUMENT
 #include "KisDocument.h"
 #include "kis_shape_layer.h"
 #endif /* USE_DOCUMENT */
 
 #include "kis_undo_stores.h"
 #include "kis_image.h"
 #include "kis_selection.h"
 #include "kis_default_bounds.h"
 #include "KisImageResolutionProxy.h"
 #include "kis_paint_layer.h"
 #include "kis_adjustment_layer.h"
 #include "kis_transparency_mask.h"
 #include "kis_clone_layer.h"
 #include <KisGlobalResourcesInterface.h>
 
 #include "filter/kis_filter.h"
 #include "filter/kis_filter_registry.h"
 #include "kis_filter_configuration.h"
 
 #include "commands/kis_selection_commands.h"
 
 
 namespace TestUtil
 {
 
 class QImageBasedTest
 {
 public:
     QImageBasedTest(const QString &directoryName)
         : m_directoryName(directoryName)
     {
     }
 
     // you need to declare your own test function
     // See KisProcessingTest for example
 
 protected:
 
     /**
      * Creates a complex image connected to a surrogate undo store
      */
     KisImageSP createImage(KisSurrogateUndoStore *undoStore) {
         QImage sourceImage(fetchDataFileLazy("hakonepa.png"));
 
         QRect imageRect = QRect(QPoint(0,0), sourceImage.size());
 
         QRect transpRect(50,50,300,300);
         QRect blurRect(66,66,300,300);
         QPoint blurShift(34,34);
         QPoint cloneShift(75,75);
 
         const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
         KisImageSP image = new KisImage(undoStore, imageRect.width(), imageRect.height(), cs, "merge test");
 
         KisFilterSP filter = KisFilterRegistry::instance()->value("blur");
         Q_ASSERT(filter);
         KisFilterConfigurationSP configuration = filter->defaultConfiguration(KisGlobalResourcesInterface::instance());
         Q_ASSERT(configuration);
 
         /**
          * HACK ALERT: before this commit a07ef143f6 the meaning of
          * 'strength' was different. After that, to make the tests
          * run correctly we should manually set the old value (it is
          * not available via GUI anymore).
          */
         configuration->setProperty("strength", 500);
 
         KisAdjustmentLayerSP blur1 = new KisAdjustmentLayer(image, "blur1", configuration->cloneWithResourcesSnapshot(), 0);
         blur1->internalSelection()->clear();
         blur1->internalSelection()->pixelSelection()->select(blurRect);
         blur1->setX(blurShift.x());
         blur1->setY(blurShift.y());
 
         KisPaintLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
         paintLayer1->paintDevice()->convertFromQImage(sourceImage, 0, 0, 0);
 
         KisCloneLayerSP cloneLayer1 =
             new KisCloneLayer(paintLayer1, image, "clone1", OPACITY_OPAQUE_U8);
         cloneLayer1->setX(cloneShift.x());
         cloneLayer1->setY(cloneShift.y());
 
         image->addNode(cloneLayer1);
         image->addNode(blur1);
         image->addNode(paintLayer1);
 
         KisTransparencyMaskSP transparencyMask1 = new KisTransparencyMask(image, "tmask1");
         transparencyMask1->testingInitSelection(transpRect, paintLayer1);
 
         image->addNode(transparencyMask1, paintLayer1);
 
         return image;
     }
 
     /**
      * Creates a simple image with one empty layer and connects it to
      * a surrogate undo store
      */
     KisImageSP createTrivialImage(KisSurrogateUndoStore *undoStore) {
         QRect imageRect = QRect(0, 0, 640, 441);
 
         const KoColorSpace * cs = KoColorSpaceRegistry::instance()->rgb8();
         KisImageSP image = new KisImage(undoStore, imageRect.width(), imageRect.height(), cs, "merge test");
 
         KisPaintLayerSP paintLayer1 = new KisPaintLayer(image, "paint1", OPACITY_OPAQUE_U8);
         image->addNode(paintLayer1);
 
         return image;
     }
 
     void addGlobalSelection(KisImageSP image) {
         QRect selectionRect(40,40,300,300);
 
         KisSelectionSP selection = new KisSelection(new KisDefaultBounds(image), toQShared(new KisImageResolutionProxy(image)));
         KisPixelSelectionSP pixelSelection = selection->pixelSelection();
         pixelSelection->select(selectionRect);
 
         KUndo2Command *cmd = new KisSetGlobalSelectionCommand(image, selection);
         image->undoAdapter()->addCommand(cmd);
     }
 
 #if USE_DOCUMENT
 
     void addShapeLayer(KisDocument *doc, KisImageSP image) {
 
         KisShapeLayerSP shapeLayer = new KisShapeLayer(doc->shapeController(), image.data(), "shape", OPACITY_OPAQUE_U8);
         image->addNode(shapeLayer);
 
         KoShapeFactoryBase *f1 = KoShapeRegistry::instance()->get("StarShape");
         KoShapeFactoryBase *f2 = KoShapeRegistry::instance()->get("RectangleShape");
 
         KoShape *shape1 = f1->createDefaultShape();
         KoShape *shape2 = f2->createDefaultShape();
 
         shape1->setPosition(QPointF(100,100));
         shape2->setPosition(QPointF(200,200));
 
         shapeLayer->addShape(shape1);
         shapeLayer->addShape(shape2);
 
         QApplication::processEvents();
     }
 
 #endif /* USE_DOCUMENT*/
 
     bool checkLayersInitial(KisImageWSP image, int baseFuzzyness = 0) {
         QString prefix = "initial_with_selection";
         QString prefix2 = findNode(image->root(), "shape") ? "_with_shape" : "";
         return checkLayers(image, prefix + prefix2, baseFuzzyness);
     }
 
     bool checkLayersInitialRootOnly(KisImageWSP image, int baseFuzzyness = 0) {
         QString prefix = "initial_with_selection";
         QString prefix2 = findNode(image->root(), "shape") ? "_with_shape" : "";
         return checkLayers(image, prefix + prefix2, baseFuzzyness, false);
     }
 
     /**
      * Checks the content of image's layers against the set of
      * QImages stored in @p prefix subfolder
      */
     bool checkLayers(KisImageWSP image, const QString &prefix, int baseFuzzyness = 0, bool recursive = true) {
         QVector<QImage> images;
         QVector<QString> names;
 
         fillNamesImages(image->root(), image->bounds(), images, names, recursive);
 
         bool valid = true;
 
         const int stackSize = images.size();
         for(int i = 0; i < stackSize; i++) {
             if(!checkOneQImage(images[i], prefix, names[i], baseFuzzyness)) {
                 valid = false;
             }
         }
 
         return valid;
     }
 
     /**
      * Checks the content of one image's layer against the QImage
      * stored in @p prefix subfolder
      */
     bool checkOneLayer(KisImageWSP image, KisNodeSP node,  const QString &prefix, int baseFuzzyness = 0) {
         QVector<QImage> images;
         QVector<QString> names;
 
         fillNamesImages(node, image->bounds(), images, names);
 
         return checkOneQImage(images.first(), prefix, names.first(), baseFuzzyness);
     }
 
     // add default bounds param
     bool checkOneDevice(KisPaintDeviceSP device,
                         const QString &prefix,
                         const QString &name,
                         int baseFuzzyness = 0)
     {
         QImage image = device->convertToQImage(0);
         return checkOneQImage(image, prefix, name, baseFuzzyness);
     }
 
     KisNodeSP findNode(KisNodeSP root, const QString &name) {
         return TestUtil::findNode(root, name);
     }
 
 private:
     bool checkOneQImage(const QImage &image,
                         const QString &prefix,
                         const QString &name,
                         int baseFuzzyness)
     {
         QString realName = prefix + "_" + name + ".png";
         QString expectedName = prefix + "_" + name + "_expected.png";
 
         bool valid = true;
 
         QString fullPath = fetchDataFileLazy(m_directoryName + '/' +
                                              prefix + '/' + realName);
 
         if (fullPath.isEmpty()) {
             // Try without the testname subdirectory
             fullPath = fetchDataFileLazy(prefix + '/' +
                                          realName);
         }
 
         if (fullPath.isEmpty()) {
             // Try without the prefix subdirectory
             fullPath = fetchDataFileLazy(m_directoryName + '/' +
                                          realName);
         }
 
         QImage ref(fullPath);
 
         QPoint temp;
         int fuzzy = baseFuzzyness;
 
         {
             QStringList terms = name.split('_');
             if(terms[0] == "root" ||
                terms[0] == "blur1" ||
                terms[0] == "shape") {
 
                 fuzzy++;
             }
         }
 
         if(ref != image &&
            !TestUtil::compareQImages(temp, ref, image, fuzzy, fuzzy)) {
 
 
             dbgKrita << "--- Wrong image:" << realName;
             valid = false;
 
             image.save(QString(FILES_OUTPUT_DIR) + '/' + realName);
             ref.save(QString(FILES_OUTPUT_DIR) + '/' + expectedName);
         }
 
         return valid;
     }
 
     void fillNamesImages(KisNodeSP node, const QRect &rc,
                          QVector<QImage> &images,
                          QVector<QString> &names,
                          bool recursive = true) {
 
         while (node) {
             if(node->paintDevice()) {
                 names.append(node->name() + "_paintDevice");
                 images.append(node->paintDevice()->
                               convertToQImage(0, rc.x(), rc.y(),
                                               rc.width(), rc.height()));
             }
 
             if(node->original() && node->original() != node->paintDevice()) {
                 names.append(node->name() + "_original");
                 images.append(node->original()->
                               convertToQImage(0, rc.x(), rc.y(),
                                               rc.width(), rc.height()));
             }
 
             if(node->projection() && node->projection() != node->paintDevice()) {
                 names.append(node->name() + "_projection");
                 images.append(node->projection()->
                               convertToQImage(0, rc.x(), rc.y(),
                                               rc.width(), rc.height()));
             }
 
             if (recursive) {
                 fillNamesImages(node->firstChild(), rc, images, names);
             }
             node = node->nextSibling();
         }
     }
 
 private:
     QString m_directoryName;
 
 };
 
 }
 
 #endif /* __QIMAGE_BASED_TEST_H */