haariface.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 2003-01-17
 * Description : Haar Database interface
 *
 * Copyright (C) 2016-2018 by Mario Frank <mario dot frank at uni minus potsdam dot de>
 * Copyright (C) 2003      by Ricardo Niederberger Cabral <nieder at mail dot ru>
 * Copyright (C) 2009-2022 by Gilles Caulier <caulier dot gilles at gmail dot com>
 * Copyright (C) 2009-2013 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
 * Copyright (C) 2009-2011 by Andi Clemens <andi dot clemens at gmail dot com>
 *
 * 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, 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.
 *
 * ============================================================ */
 
#ifndef DIGIKAM_HAAR_IFACE_H
#define DIGIKAM_HAAR_IFACE_H
 
// Qt includes
 
#include <QSet>
#include <QString>
#include <QMap>
#include <QList>
 
// Local includes
 
#include "haar.h"
#include "digikam_export.h"
 
class QImage;
 
namespace Digikam
{
 
class DImg;
class ItemInfo;
 
class HaarProgressObserver
{
public:
 
    HaarProgressObserver()                                       = default;
    virtual ~HaarProgressObserver()                              = default;
 
    virtual void imageProcessed()                                = 0;
    virtual bool isCanceled()
    {
        return false;
    };
 
private:
 
    Q_DISABLE_COPY(HaarProgressObserver)
};
 
// --------------------------------------------------------------------------
 
class DIGIKAM_DATABASE_EXPORT HaarIface
{
 
public:
 
    enum SketchType
    {
        ScannedSketch   = 0,
        HanddrawnSketch = 1
    };
 
    enum DuplicatesSearchRestrictions
    {
        None            = 0,
        SameAlbum       = 1,
        DifferentAlbum  = 2
    };
 
    enum AlbumTagRelation
    {
        NoMix           = 0,
        Union           = 1,
        Intersection    = 2,
        AlbumExclusive  = 3,
        TagExclusive    = 4
    };
 
    using DuplicatesResultsMap = QMap<qlonglong, QPair<double, QList<qlonglong> > >;
 
public:
 
    explicit HaarIface();
    explicit HaarIface(const QSet<qlonglong>& images2Scan);
    ~HaarIface();
 
    static int preferredSize();
 
    bool indexImage(const QString& filename);
    bool indexImage(const QString& filename, const QImage& image);
    bool indexImage(const QString& filename, const DImg& image);
    bool indexImage(qlonglong imageid, const QImage& image);
    bool indexImage(qlonglong imageid, const DImg& image);
 
    QMap<qlonglong, double> bestMatchesForSignature(const QString& signature,
                                                    const QList<int>& targetAlbums,
                                                    int numberOfResults = 20,
                                                    SketchType type = ScannedSketch);
 
    QPair<double, QMap<qlonglong, double> > bestMatchesForImageWithThreshold(
        qlonglong imageid,
        double requiredPercentage,
        double maximumPercentage,
        const QList<int>& targetAlbums,
        DuplicatesSearchRestrictions searchResultRestriction = DuplicatesSearchRestrictions::None,
        SketchType type = ScannedSketch
    );
 
    QPair<double, QMap<qlonglong, double> > bestMatchesForImageWithThreshold(
        const QString& imagePath,
        double requiredPercentage,
        double maximumPercentage,
        const QList<int>& targetAlbums,
        DuplicatesSearchRestrictions searchResultRestriction = DuplicatesSearchRestrictions::None,
        SketchType type = ScannedSketch
    );
 
    QString signatureAsText(const QImage& image);
 
    bool fulfillsRestrictions(qlonglong imageId,
                              int albumId,
                              qlonglong originalImageId,
                              int originalAlbumId,
                              const QList<int>& targetAlbums,
                              DuplicatesSearchRestrictions searchResultRestriction);
 
    void getBestAndWorstPossibleScore(Haar::SignatureData* const querySig,
                                      SketchType type,
                                      double* const lowestAndBestScore,
                                      double* const highestAndWorstScore);
 
    DuplicatesResultsMap findDuplicates(
        const QSet<qlonglong>& images2Scan,
        const QSet<qlonglong>::const_iterator& rangeBegin,
        const QSet<qlonglong>::const_iterator& rangeEnd,
        double requiredPercentage,
        double maximumPercentage,
        DuplicatesSearchRestrictions searchResultRestriction = DuplicatesSearchRestrictions::None,
        HaarProgressObserver* const observer = nullptr
    );
 
    static QSet<qlonglong> imagesFromAlbumsAndTags(const QList<int>& albums2Scan,
                                                   const QList<int>& tags2Scan,
                                                   AlbumTagRelation relation);
 
    static void rebuildDuplicatesAlbums(const DuplicatesResultsMap& results, bool isAlbumUpdate);
 
    bool retrieveSignatureFromDB(qlonglong imageid, Haar::SignatureData& sig);
 
    void setAlbumRootsToSearch(const QList<int>& albumRootIds);
    void setAlbumRootsToSearch(const QSet<int>& albumRootIds);
 
    QImage loadQImage(const QString& filename);
 
private:
 
    bool   indexImage(qlonglong imageid);
 
    static QMap<QString, QString> writeSAlbumQueries(const DuplicatesResultsMap& searchResults);
 
    QMultiMap<double, qlonglong> bestMatches(Haar::SignatureData* const data,
                                             int numberOfResults,
                                             const QList<int>& targetAlbums,
                                             SketchType type);
 
    QPair<double, QMap<qlonglong, double> > bestMatchesWithThreshold(qlonglong imageid,
                                                                     Haar::SignatureData* const querySig,
                                                                     double requiredPercentage,
                                                                     double maximumPercentage,
                                                                     const QList<int>& targetAlbums,
                                                                     DuplicatesSearchRestrictions searchResultRestriction,
                                                                     SketchType type);
 
    QMap<qlonglong, double> searchDatabase(Haar::SignatureData* const data,
                                           SketchType type,
                                           const QList<int>& targetAlbums,
                                           DuplicatesSearchRestrictions searchResultRestriction = None,
                                           qlonglong originalImageId = -1,
                                           int albumId = -1);
 
    double calculateScore(const Haar::SignatureData& querySig,
                          const Haar::SignatureData& targetSig,
                          const Haar::Weights& weights,
                          std::reference_wrapper<Haar::SignatureMap>* const queryMaps);
 
private:
 
    // Disable
    HaarIface(const HaarIface&)            = delete;
    HaarIface& operator=(const HaarIface&) = delete;
 
private:
 
    class Private;
    Private* const d;
};
 
} // namespace Digikam
 
#endif // DIGIKAM_HAAR_IFACE_H