diff --git a/core/libs/fileactionmanager/databaseworkeriface.cpp b/core/libs/fileactionmanager/databaseworkeriface.cpp
index 2b20218a31..4850f3e3a3 100644
--- a/core/libs/fileactionmanager/databaseworkeriface.cpp
+++ b/core/libs/fileactionmanager/databaseworkeriface.cpp
@@ -1,388 +1,389 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2012-01-18
  * Description : database worker interface
  *
  * Copyright (C) 2012 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
  *
  * 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.
  *
  * ============================================================ */
 
 #include "databaseworkeriface.h"
 
 // KDE includes
 
 #include <klocalizedstring.h>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "collectionscanner.h"
 #include "coredboperationgroup.h"
 #include "iteminfotasksplitter.h"
 #include "fileactionmngr_p.h"
 #include "scancontroller.h"
 #include "disjointmetadata.h"
+#include "faceutils.h"
 
 namespace Digikam
 {
 
 void FileActionMngrDatabaseWorker::assignTags(FileActionItemInfoList infos, const QList<int>& tagIDs)
 {
     changeTags(infos, tagIDs, true);
 }
 
 void FileActionMngrDatabaseWorker::removeTags(FileActionItemInfoList infos, const QList<int>& tagIDs)
 {
     changeTags(infos, tagIDs, false);
 }
 
 void FileActionMngrDatabaseWorker::changeTags(FileActionItemInfoList infos,
                                               const QList<int>& tagIDs, bool addOrRemove)
 {
     DisjointMetadata hub;
     QList<ItemInfo> forWriting;
 
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (const ItemInfo& info, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             hub.load(info);
 
             for (QList<int>::const_iterator tagIt = tagIDs.constBegin() ; tagIt != tagIDs.constEnd() ; ++tagIt)
             {
                 if (addOrRemove)
                 {
                     hub.setTag(*tagIt, DisjointMetadata::MetadataAvailable);
                 }
                 else
                 {
                     hub.setTag(*tagIt, DisjointMetadata::MetadataInvalid);
                 }
             }
 
             hub.write(info, DisjointMetadata::PartialWrite);
 
             if (hub.willWriteMetadata(DisjointMetadata::FullWriteIfChanged) &&
                 d->shallSendForWriting(info.id()))
             {
                 forWriting << info;
             }
 
             infos.dbProcessedOne();
             group.allowLift();
         }
     }
 
     // send for writing file metadata
 
     if (!forWriting.isEmpty())
     {
         FileActionItemInfoList forWritingTaskList = FileActionItemInfoList::continueTask(forWriting, infos.progress());
         forWritingTaskList.schedulingForWrite(i18n("Writing metadata to files"), d->fileProgressCreator());
 
         qCDebug(DIGIKAM_GENERAL_LOG) << "Scheduled to write";
 
         for (ItemInfoTaskSplitter splitter(forWritingTaskList) ; splitter.hasNext() ; )
         {
             emit writeMetadata(FileActionItemInfoList(splitter.next()), MetadataHub::WRITE_TAGS);
         }
     }
 
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::assignPickLabel(FileActionItemInfoList infos, int pickId)
 {
     DisjointMetadata hub;
     QList<ItemInfo> forWriting;
 
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (const ItemInfo& info, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             hub.load(info);
             hub.setPickLabel(pickId);
             hub.write(info, DisjointMetadata::PartialWrite);
 
             if (hub.willWriteMetadata(DisjointMetadata::FullWriteIfChanged) &&
                 d->shallSendForWriting(info.id()))
             {
                 forWriting << info;
             }
 
             infos.dbProcessedOne();
             group.allowLift();
         }
     }
 
     // send for writing file metadata
 
     if (!forWriting.isEmpty())
     {
         FileActionItemInfoList forWritingTaskList = FileActionItemInfoList::continueTask(forWriting, infos.progress());
         forWritingTaskList.schedulingForWrite(i18n("Writing metadata to files"), d->fileProgressCreator());
 
         for (ItemInfoTaskSplitter splitter(forWritingTaskList) ; splitter.hasNext() ; )
         {
             emit writeMetadata(FileActionItemInfoList(splitter.next()), MetadataHub::WRITE_PICKLABEL);
         }
     }
 
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::assignColorLabel(FileActionItemInfoList infos, int colorId)
 {
     DisjointMetadata hub;
     QList<ItemInfo> forWriting;
 
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (const ItemInfo& info, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             hub.load(info);
             hub.setColorLabel(colorId);
             hub.write(info, DisjointMetadata::PartialWrite);
 
             if (hub.willWriteMetadata(DisjointMetadata::FullWriteIfChanged) &&
                 d->shallSendForWriting(info.id()))
             {
                 forWriting << info;
             }
 
             infos.dbProcessedOne();
             group.allowLift();
         }
     }
 
     // send for writing file metadata
 
     if (!forWriting.isEmpty())
     {
         FileActionItemInfoList forWritingTaskList = FileActionItemInfoList::continueTask(forWriting, infos.progress());
         forWritingTaskList.schedulingForWrite(i18n("Writing metadata to files"), d->fileProgressCreator());
 
         for (ItemInfoTaskSplitter splitter(forWritingTaskList) ; splitter.hasNext() ; )
         {
             emit writeMetadata(FileActionItemInfoList(splitter.next()), MetadataHub::WRITE_COLORLABEL);
         }
     }
 
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::assignRating(FileActionItemInfoList infos, int rating)
 {
     DisjointMetadata hub;
     QList<ItemInfo> forWriting;
     rating = qMin(RatingMax, qMax(RatingMin, rating));
 
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (const ItemInfo& info, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             hub.load(info);
             hub.setRating(rating);
             hub.write(info, DisjointMetadata::PartialWrite);
 
             if (hub.willWriteMetadata(DisjointMetadata::FullWriteIfChanged) &&
                 d->shallSendForWriting(info.id()))
             {
                 forWriting << info;
             }
 
             infos.dbProcessedOne();
             group.allowLift();
         }
     }
 
     // send for writing file metadata
 
     if (!forWriting.isEmpty())
     {
         FileActionItemInfoList forWritingTaskList = FileActionItemInfoList::continueTask(forWriting, infos.progress());
         forWritingTaskList.schedulingForWrite(i18n("Writing metadata to files"), d->fileProgressCreator());
 
         for (ItemInfoTaskSplitter splitter(forWritingTaskList) ; splitter.hasNext() ; )
         {
             emit writeMetadata(FileActionItemInfoList(splitter.next()), MetadataHub::WRITE_RATING);
         }
     }
 
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::editGroup(int groupAction, const ItemInfo& pick, FileActionItemInfoList infos)
 {
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (const ItemInfo& constInfo, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             ItemInfo info(constInfo);
 
             switch (groupAction)
             {
                 case AddToGroup:
                     info.addToGroup(pick);
                     break;
 
                 case RemoveFromGroup:
                     info.removeFromGroup();
                     break;
 
                 case Ungroup:
                     info.clearGroup();
                     break;
             }
 
             infos.dbProcessedOne();
             group.allowLift();
         }
     }
 
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::setExifOrientation(FileActionItemInfoList infos, int orientation)
 {
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (ItemInfo info, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
-            MetadataHub hub;
-            hub.adjustFaceRectangles(info, false,
-                                           orientation,
-                                           info.orientation());
+            // Adjust Faces
+
+            FaceUtils().rotateFaces(info, orientation,
+                                          info.orientation());
 
             info.setOrientation(orientation);
         }
     }
 
     infos.dbProcessed(infos.count());
     infos.schedulingForWrite(infos.count(), i18n("Revising Exif Orientation tags"), d->fileProgressCreator());
 
     for (ItemInfoTaskSplitter splitter(infos) ; splitter.hasNext() ; )
     {
         emit writeOrientationToFiles(FileActionItemInfoList(splitter.next()), orientation);
     }
 
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::applyMetadata(FileActionItemInfoList infos, DisjointMetadata *hub)
 {
     {
         CoreDbOperationGroup group;
         group.setMaximumTime(200);
 
         foreach (const ItemInfo& info, infos)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             // apply to database
 
             hub->write(info);
             infos.dbProcessedOne();
             group.allowLift();
         }
     }
 
     if (hub->willWriteMetadata(DisjointMetadata::FullWriteIfChanged), Qt::DirectConnection)
     {
         int flags = hub->changedFlags();
 
         // don't filter by shallSendForWriting here; we write from the hub, not from freshly loaded data
 
         infos.schedulingForWrite(infos.size(), i18n("Writing metadata to files"), d->fileProgressCreator());
 
         for (ItemInfoTaskSplitter splitter(infos) ; splitter.hasNext() ; )
         {
             emit writeMetadata(FileActionItemInfoList(splitter.next()), flags);
         }
     }
 
     delete hub;
     infos.dbFinished();
 }
 
 void FileActionMngrDatabaseWorker::copyAttributes(FileActionItemInfoList infos, const QStringList& derivedPaths)
 {
     if (infos.size() == 1)
     {
         foreach (const QString& path, derivedPaths)
         {
             if (state() == WorkerObject::Deactivating)
             {
                 break;
             }
 
             ItemInfo dest = ScanController::instance()->scannedInfo(path);
             CollectionScanner::copyFileProperties(infos.first(), dest);
         }
 
         infos.dbProcessedOne();
     }
 
     infos.dbFinished();
 }
 
 } // namespace Digikam
diff --git a/core/libs/fileactionmanager/fileworkeriface.cpp b/core/libs/fileactionmanager/fileworkeriface.cpp
index 09ab9d9a6e..068a232119 100644
--- a/core/libs/fileactionmanager/fileworkeriface.cpp
+++ b/core/libs/fileactionmanager/fileworkeriface.cpp
@@ -1,331 +1,342 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2012-01-18
  * Description : database worker interface
  *
  * Copyright (C) 2012 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
  *
  * 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.
  *
  * ============================================================ */
 
 #include "fileworkeriface.h"
 
 // KDE includes
 
 #include <klocalizedstring.h>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "digikam_globals.h"
 #include "fileactionmngr_p.h"
 #include "metaenginesettings.h"
 #include "itemattributeswatch.h"
 #include "iteminfotasksplitter.h"
 #include "collectionscanner.h"
 #include "scancontroller.h"
+#include "faceutils.h"
 #include "jpegutils.h"
 #include "dimg.h"
 
 namespace Digikam
 {
 
 void FileActionMngrFileWorker::writeOrientationToFiles(FileActionItemInfoList infos, int orientation)
 {
     QStringList failedItems;
 
     foreach (const ItemInfo& info, infos)
     {
         if (state() == WorkerObject::Deactivating)
         {
             break;
         }
 
         QString path                  = info.filePath();
         DMetadata metadata(path);
         DMetadata::ImageOrientation o = (DMetadata::ImageOrientation)orientation;
         metadata.setItemOrientation(o);
 
         if (!metadata.applyChanges())
         {
             failedItems.append(info.name());
         }
         else
         {
             emit imageDataChanged(path, true, true);
             QUrl url = QUrl::fromLocalFile(path);
             ItemAttributesWatch::instance()->fileMetadataChanged(url);
         }
 
         infos.writtenToOne();
     }
 
     if (!failedItems.isEmpty())
     {
         emit imageChangeFailed(i18n("Failed to revise Exif orientation these files:"), failedItems);
     }
 
     infos.finishedWriting();
 }
 
 void FileActionMngrFileWorker::writeMetadataToFiles(FileActionItemInfoList infos)
 {
     d->startingToWrite(infos);
 
     ScanController::instance()->suspendCollectionScan();
 
     foreach (const ItemInfo& info, infos)
     {
         MetadataHub hub;
 
         if (state() == WorkerObject::Deactivating)
         {
             break;
         }
 
         hub.load(info);
         QString path = info.filePath();
 
         if (MetaEngineSettings::instance()->settings().useLazySync)
         {
             hub.write(path, MetadataHub::WRITE_ALL);
         }
         else
         {
             ScanController::FileMetadataWrite writeScope(info);
             writeScope.changed(hub.write(path, MetadataHub::WRITE_ALL));
         }
 
         // hub emits fileMetadataChanged
 
         infos.writtenToOne();
     }
 
     ScanController::instance()->resumeCollectionScan();
 
     infos.finishedWriting();
 }
 
 void FileActionMngrFileWorker::writeMetadata(FileActionItemInfoList infos, int flags)
 {
     d->startingToWrite(infos);
 
     ScanController::instance()->suspendCollectionScan();
 
     foreach (const ItemInfo& info, infos)
     {
         MetadataHub hub;
 
         if (state() == WorkerObject::Deactivating)
         {
             break;
         }
 
         hub.load(info);
 
         // apply to file metadata
 
         if (MetaEngineSettings::instance()->settings().useLazySync)
         {
             hub.writeToMetadata(info, (MetadataHub::WriteComponents)flags);
         }
         else
         {
             ScanController::FileMetadataWrite writeScope(info);
             writeScope.changed(hub.writeToMetadata(info, (MetadataHub::WriteComponents)flags));
         }
 
         // hub emits fileMetadataChanged
 
         infos.writtenToOne();
     }
 
     ScanController::instance()->resumeCollectionScan();
 
     infos.finishedWriting();
 }
 
 void FileActionMngrFileWorker::transform(FileActionItemInfoList infos, int action)
 {
     d->startingToWrite(infos);
 
     QStringList failedItems;
     ScanController::instance()->suspendCollectionScan();
 
     foreach (const ItemInfo& info, infos)
     {
         if (state() == WorkerObject::Deactivating)
         {
             break;
         }
 
         QString path                                    = info.filePath();
         QString format                                  = info.format();
         MetaEngine::ImageOrientation currentOrientation = (MetaEngine::ImageOrientation)info.orientation();
         bool isRaw                                      = info.format().startsWith(QLatin1String("RAW"));
         bool rotateAsJpeg                               = false;
         bool rotateLossy                                = false;
 
         MetaEngineSettingsContainer::RotationBehaviorFlags behavior;
         behavior              = MetaEngineSettings::instance()->settings().rotationBehavior;
         bool rotateByMetadata = (behavior & MetaEngineSettingsContainer::RotateByMetadataFlag);
 
         // Check if rotation by content, as desired, is feasible
         // We'll later check again if it was successful
 
         if (behavior & MetaEngineSettingsContainer::RotatingPixels)
         {
             if (format == QLatin1String("JPG") && JPEGUtils::isJpegImage(path))
             {
                 rotateAsJpeg = true;
             }
 
             if (behavior & MetaEngineSettingsContainer::RotateByLossyRotation)
             {
                 DImg::FORMAT frmt = DImg::fileFormat(path);
 
                 switch (frmt)
                 {
                     case DImg::JPEG:
                     case DImg::PNG:
                     case DImg::TIFF:
                     case DImg::JP2K:
                     case DImg::PGF:
                     case DImg::HEIF:
                         rotateLossy = true;
 
                     default:
                         break;
                 }
             }
         }
 
         MetaEngineRotation matrix;
         matrix                                        *= currentOrientation;
         matrix                                        *= (MetaEngineRotation::TransformationAction)action;
         MetaEngine::ImageOrientation finalOrientation  = matrix.exifOrientation();
         bool rotatedPixels                             = false;
 
         if (rotateAsJpeg)
         {
             JPEGUtils::JpegRotator rotator(path);
             rotator.setCurrentOrientation(currentOrientation);
 
             if (action == MetaEngineRotation::NoTransformation)
             {
                 rotatedPixels = rotator.autoExifTransform();
             }
             else
             {
                 rotatedPixels = rotator.exifTransform((MetaEngineRotation::TransformationAction)action);
             }
 
             if (!rotatedPixels)
             {
                 failedItems.append(info.name());
             }
         }
         else if (rotateLossy)
         {
             // Non-JPEG image: DImg
 
             DImg image;
 
             if (!image.load(path))
             {
                 failedItems.append(info.name());
             }
             else
             {
                 if (action == MetaEngineRotation::NoTransformation)
                 {
                     image.rotateAndFlip(currentOrientation);
                 }
                 else
                 {
                     image.transform(action);
                 }
 
                 // TODO: Atomic operation!!
                 // prepare metadata, including to reset Exif tag
 
                 image.prepareMetadataToSave(path, image.format(), true);
 
                 if (image.save(path, image.detectedFormat()))
                 {
                     rotatedPixels = true;
                 }
                 else
                 {
                     failedItems.append(info.name());
                 }
             }
         }
 
         int newOrientation = finalOrientation;
 
         if (rotatedPixels)
         {
             finalOrientation = MetaEngine::ORIENTATION_NORMAL;
         }
 
         // DB rotation
 
         ItemInfo(info).setOrientation(finalOrientation);
 
         // Adjust Faces
 
-        MetadataHub hub;
-        hub.adjustFaceRectangles(info, rotatedPixels,
-                                       newOrientation,
-                                       currentOrientation);
+        QSize newSize = FaceUtils().rotateFaces(info, newOrientation,
+                                                      currentOrientation);
+        if (newSize.isValid())
+        {
+            MetadataHub hub;
+            hub.load(info);
+
+            // Adjusted newSize
+
+            newSize = rotatedPixels ? newSize : info.dimensions();
+
+            hub.loadFaceTags(info, newSize);
+            hub.write(info.filePath(), MetadataHub::WRITE_TAGS, true);
+        }
 
         if (rotateByMetadata)
         {
             // Setting the rotation flag on Raws with embedded JPEG is a mess
             // Can apply to the RAW data, or to the embedded JPEG, or to both.
 
             if (!isRaw)
             {
                 DMetadata metadata(path);
                 metadata.setItemOrientation(finalOrientation);
                 metadata.applyChanges();
             }
         }
 
         CollectionScanner scanner;
         scanner.scanFile(info, CollectionScanner::NormalScan);
 
         if (!failedItems.contains(info.name()))
         {
             emit imageDataChanged(path, true, true);
             ItemAttributesWatch::instance()->fileMetadataChanged(info.fileUrl());
         }
 
         infos.writtenToOne();
     }
 
     if (!failedItems.isEmpty())
     {
         emit imageChangeFailed(i18n("Failed to transform these files:"), failedItems);
     }
 
     infos.finishedWriting();
 
     ScanController::instance()->resumeCollectionScan();
 }
 
 } // namespace Digikam
diff --git a/core/libs/fileactionmanager/metadatahub.cpp b/core/libs/fileactionmanager/metadatahub.cpp
index 3f44b1ec59..a94df4ae02 100644
--- a/core/libs/fileactionmanager/metadatahub.cpp
+++ b/core/libs/fileactionmanager/metadatahub.cpp
@@ -1,909 +1,824 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2007-01-05
  * Description : Metadata handling
  *
  * Copyright (C) 2007-2012 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
  * Copyright (C) 2007-2020 by Gilles Caulier <caulier dot gilles at gmail dot com>
  * Copyright (C) 2014-2015 by Veaceslav Munteanu <veaceslav dot munteanu90 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.
  *
  * ============================================================ */
 
 #include "metadatahub.h"
 
 // Qt includes
 
 #include <QFileInfo>
 #include <QMutex>
 #include <QMutexLocker>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "coredbaccess.h"
 #include "coredbwatch.h"
 #include "iteminfo.h"
 #include "itemcomments.h"
 #include "itemposition.h"
 #include "template.h"
 #include "templatemanager.h"
 #include "applicationsettings.h"
 #include "itemattributeswatch.h"
 #include "tagscache.h"
 #include "facetagseditor.h"
 #include "metadatahubmngr.h"
 
 #ifdef HAVE_KFILEMETADATA
 #   include "baloowrap.h"
 #endif
 
 namespace Digikam
 {
 
 class Q_DECL_HIDDEN MetadataHub::Private
 {
 public:
 
     explicit Private()
       : pickLabel(-1),
         colorLabel(-1),
         rating(-1),
         count(0),
         dateTimeStatus(MetadataHub::MetadataInvalid),
         titlesStatus(MetadataHub::MetadataInvalid),
         commentsStatus(MetadataHub::MetadataInvalid),
         pickLabelStatus(MetadataHub::MetadataInvalid),
         colorLabelStatus(MetadataHub::MetadataInvalid),
         ratingStatus(MetadataHub::MetadataInvalid),
         templateStatus(MetadataHub::MetadataInvalid)
     {
     }
 
 public:
 
     int                               pickLabel;
     int                               colorLabel;
     int                               rating;
     int                               count;
 
     QDateTime                         dateTime;
 
     CaptionsMap                       titles;
     CaptionsMap                       comments;
 
     Template                          metadataTemplate;
 
     QMap<int, MetadataHub::Status>    tags;
 
     QStringList                       tagList;
 
     QMultiMap<QString, QVariant>      faceTagsList;
 
     ItemPosition                      itemPosition;
 
     MetadataHub::Status               dateTimeStatus;
     MetadataHub::Status               titlesStatus;
     MetadataHub::Status               commentsStatus;
     MetadataHub::Status               pickLabelStatus;
     MetadataHub::Status               colorLabelStatus;
     MetadataHub::Status               ratingStatus;
     MetadataHub::Status               templateStatus;
 
 public:
 
     template <class T> void loadSingleValue(const T& data, T& storage, MetadataHub::Status& status);
 };
 
 // ------------------------------------------------------------------------------------------
 
 MetadataHub::MetadataHub()
     : d(new Private)
 {
 }
 
 MetadataHub::MetadataHub(const MetadataHub& other)
     : d(new Private(*other.d))
 {
 }
 
 MetadataHub::~MetadataHub()
 {
     delete d;
 }
 
 MetadataHub& MetadataHub::operator=(const MetadataHub& other)
 {
     (*d) = (*other.d);
 
     return *this;
 }
 
 MetadataHub* MetadataHub::clone() const
 {
     return (new MetadataHub(*this));
 }
 
 void MetadataHub::reset()
 {
     (*d) = Private();
 }
 
 // --------------------------------------------------
 
 void MetadataHub::load(const ItemInfo& info)
 {
     d->count++;
 
     //qCDebug(DIGIKAM_GENERAL_LOG) << "---------------------------------Load from ItemInfo ----------------";
 
     CaptionsMap commentMap;
     CaptionsMap titleMap;
 
     {
         CoreDbAccess access;
         ItemComments comments = info.imageComments(access);
         commentMap            = comments.toCaptionsMap();
         titleMap              = comments.toCaptionsMap(DatabaseComment::Title);
     }
 
     Template tref = info.metadataTemplate();
     Template t    = TemplateManager::defaultManager()->findByContents(tref);
 
     //qCDebug(DIGIKAM_GENERAL_LOG) << "Found Metadata Template: " << t.templateTitle();
 
     load(info.dateTime(),
          titleMap,
          commentMap,
          info.colorLabel(),
          info.pickLabel(),
          info.rating(),
          t.isNull() ? tref : t);
 
     QList<int> tagIds = info.tagIds();
     loadTags(tagIds);
 
     loadFaceTags(info, info.dimensions());
 
     d->itemPosition = info.imagePosition();
 }
 
 // private common code to merge tags
 void MetadataHub::loadTags(const QList<int>& loadedTags)
 {
     d->tags.clear();
 
     foreach (int tagId, loadedTags)
     {
         if (TagsCache::instance()->isInternalTag(tagId))
         {
             continue;
         }
 
         d->tags[tagId] = MetadataAvailable;
     }
 }
 
 // private common code to load dateTime, comment, color label, pick label, rating
 void MetadataHub::load(const QDateTime& dateTime,
                        const CaptionsMap& titles, const CaptionsMap& comments,
                        int colorLabel, int pickLabel,
                        int rating, const Template& t)
 {
     if (dateTime.isValid())
     {
         d->loadSingleValue<QDateTime>(dateTime, d->dateTime, d->dateTimeStatus);
     }
 
     d->loadSingleValue<int>(pickLabel, d->pickLabel, d->pickLabelStatus);
 
     d->loadSingleValue<int>(colorLabel, d->colorLabel, d->colorLabelStatus);
 
     d->loadSingleValue<int>(rating, d->rating, d->ratingStatus);
 
     d->loadSingleValue<CaptionsMap>(titles, d->titles, d->titlesStatus);
 
     d->loadSingleValue<CaptionsMap>(comments, d->comments, d->commentsStatus);
 
     d->loadSingleValue<Template>(t, d->metadataTemplate, d->templateStatus);
 }
 
 // template method used by comment and template
 template <class T> void MetadataHub::Private::loadSingleValue(const T& data, T& storage,
                                                               MetadataHub::Status& status)
 {
     switch (status)
     {
         case MetadataHub::MetadataInvalid:
             storage = data;
             status  = MetadataHub::MetadataAvailable;
             break;
 
         case MetadataHub::MetadataAvailable:
             qCDebug(DIGIKAM_GENERAL_LOG) << "You should not load more than one image info in metadatahub";
             break;
     }
 }
 
 // ------------------------------------------------------------------------------------------------------------
 
 /** safe **/
 bool MetadataHub::writeToMetadata(const ItemInfo& info, WriteComponent writeMode, bool ignoreLazySync, const MetaEngineSettingsContainer &settings)
 {
     applyChangeNotifications();
 
     // if no DMetadata object is needed at all, don't construct one -
     // important optimization if writing to file is turned off in setup!
 
     if (!willWriteMetadata(writeMode, settings))
     {
         return false;
     }
 
     if (!ignoreLazySync && settings.useLazySync)
     {
         MetadataHubMngr::instance()->addPending(info);
 
         return true;
     }
 
     writeToBaloo(info.filePath());
 
     DMetadata metadata(info.filePath());
 
     if (write(metadata, writeMode, settings))
     {
         bool success = metadata.applyChanges();
         ItemAttributesWatch::instance()->fileMetadataChanged(QUrl::fromLocalFile(info.filePath()));
         return success;
     }
 
     return false;
 }
 
 bool MetadataHub::write(DMetadata& metadata, WriteComponent writeMode, const MetaEngineSettingsContainer& settings)
 {
     applyChangeNotifications();
 
     bool dirty = false;
 
     metadata.setSettings(settings);
 
     // find out in advance if we have something to write - needed for FullWriteIfChanged mode
     bool saveTitle      = (settings.saveComments   && (d->titlesStatus     == MetadataAvailable) && writeMode.testFlag(WRITE_TITLE));
     bool saveComment    = (settings.saveComments   && (d->commentsStatus   == MetadataAvailable) && writeMode.testFlag(WRITE_COMMENTS));
     bool saveDateTime   = (settings.saveDateTime   && (d->dateTimeStatus   == MetadataAvailable) && writeMode.testFlag(WRITE_DATETIME));
     bool savePickLabel  = (settings.savePickLabel  && (d->pickLabelStatus  == MetadataAvailable) && writeMode.testFlag(WRITE_PICKLABEL));
     bool saveColorLabel = (settings.saveColorLabel && (d->colorLabelStatus == MetadataAvailable) && writeMode.testFlag(WRITE_COLORLABEL));
     bool saveRating     = (settings.saveRating     && (d->ratingStatus     == MetadataAvailable) && writeMode.testFlag(WRITE_RATING));
     bool saveTemplate   = (settings.saveTemplate   && (d->templateStatus   == MetadataAvailable) && writeMode.testFlag(WRITE_TEMPLATE));
     bool saveTags       = (settings.saveTags       && writeMode.testFlag(WRITE_TAGS));
     bool saveFaces      = (settings.saveFaceTags   && writeMode.testFlag(WRITE_TAGS));
     bool savePosition   = (settings.savePosition   && writeMode.testFlag(WRITE_POSITION));
 
     if (saveTitle)
     {
         // Store titles in image as Iptc Object name and Xmp.
         dirty |= metadata.setItemTitles(d->titles);
     }
 
     if (saveComment)
     {
         // Store comments in image as JFIF comments, Exif comments, Iptc Caption, and Xmp.
         dirty |= metadata.setItemComments(d->comments);
     }
 
     if (saveDateTime)
     {
         // Store Image Date & Time as Exif and Iptc tags.
         dirty |= metadata.setImageDateTime(d->dateTime, false);
     }
 
     if (savePickLabel)
     {
         // Store Image Pick Label as XMP tag.
         dirty |= metadata.setItemPickLabel(d->pickLabel);
     }
 
     if (saveColorLabel)
     {
         // Store Image Color Label as XMP tag.
         dirty |= metadata.setItemColorLabel(d->colorLabel);
     }
 
     if (saveRating)
     {
         // Store Image rating as Iptc tag.
         dirty |= metadata.setItemRating(d->rating);
     }
 
     if (saveTemplate)
     {
         QString title = d->metadataTemplate.templateTitle();
 
         if (title == Template::removeTemplateTitle())
         {
             dirty |= metadata.removeMetadataTemplate();
         }
         else if (title.isEmpty())
         {
             // Nothing to do.
         }
         else
         {
             // Store metadata template as XMP tag.
             dirty |= metadata.removeMetadataTemplate();
             dirty |= metadata.setMetadataTemplate(d->metadataTemplate);
         }
     }
 
     if (savePosition)
     {
         if (d->itemPosition.hasCoordinates())
         {
             dirty |= metadata.setGPSInfo(d->itemPosition.altitude(),
                                          d->itemPosition.latitudeNumber(),
                                          d->itemPosition.longitudeNumber());
         }
         else
         {
             dirty |= metadata.removeGPSInfo();
         }
     }
 
     dirty |= metadata.setItemFacesMap(d->faceTagsList, saveFaces);
 
     dirty |= writeTags(metadata, saveTags);
 
     return dirty;
 }
 
 bool MetadataHub::write(const QString& filePath, WriteComponent writeMode, bool ignoreLazySync, const MetaEngineSettingsContainer& settings)
 {
     applyChangeNotifications();
 
     // if no DMetadata object is needed at all, don't construct one -
     // important optimization if writing to file is turned off in setup!
 
     if (!willWriteMetadata(writeMode, settings))
     {
         return false;
     }
 
     if (!ignoreLazySync && settings.useLazySync)
     {
         ItemInfo info = ItemInfo::fromLocalFile(filePath);
         MetadataHubMngr::instance()->addPending(info);
 
         return true;
     }
 
     writeToBaloo(filePath);
 
     DMetadata metadata(filePath);
 
     if (write(metadata, writeMode, settings))
     {
         bool success = metadata.applyChanges();
         ItemAttributesWatch::instance()->fileMetadataChanged(QUrl::fromLocalFile(filePath));
 
         return success;
     }
 
     return false;
 }
 
 bool MetadataHub::write(DImg& image, WriteComponent writeMode, bool ignoreLazySync, const MetaEngineSettingsContainer& settings)
 {
     applyChangeNotifications();
 
     // if no DMetadata object is needed at all, don't construct one
 
     if (!willWriteMetadata(writeMode, settings))
     {
         return false;
     }
 
     // See DImgLoader::readMetadata() and saveMetadata()
 
     DMetadata metadata;
     metadata.setData(image.getMetadata());
 
     QString filePath = image.originalFilePath();
 
     if (filePath.isEmpty())
     {
         filePath = image.lastSavedFilePath();
     }
 
     if (!ignoreLazySync && settings.useLazySync && !filePath.isEmpty())
     {
         ItemInfo info = ItemInfo::fromLocalFile(filePath);
         MetadataHubMngr::instance()->addPending(info);
 
         return true;
     }
 
     if (!filePath.isEmpty())
     {
         writeToBaloo(filePath);
     }
 
     return write(metadata, writeMode, settings);
 }
 
 bool MetadataHub::writeTags(const QString& filePath, WriteComponent writeMode,
                             const MetaEngineSettingsContainer& settings)
 {
     applyChangeNotifications();
 
     // if no DMetadata object is needed at all, don't construct one -
     // important optimization if writing to file is turned off in setup!
 
     if (!willWriteMetadata(writeMode, settings))
     {
         return false;
     }
 
     DMetadata metadata(filePath);
     metadata.setSettings(settings);
     bool saveFaces = settings.saveFaceTags;
     bool saveTags  = settings.saveTags;
 
     if (saveFaces)
     {
         metadata.setItemFacesMap(d->faceTagsList, true);
     }
     else
     {
         metadata.setItemFacesMap(d->faceTagsList, false);
     }
 
     writeToBaloo(filePath);
 
     if (writeTags(metadata, saveTags))
     {
         bool success = metadata.applyChanges();
         ItemAttributesWatch::instance()->fileMetadataChanged(QUrl::fromLocalFile(filePath));
 
         return success;
     }
     else
     {
         return false;
     }
 }
 
 bool MetadataHub::writeTags(DMetadata& metadata, bool saveTags)
 {
     qCDebug(DIGIKAM_GENERAL_LOG) << "Writing tags";
 
     bool dirty = false;
 
     if (saveTags)
     {
         // Store tag paths as Iptc keywords tags.
         // DatabaseMode == ManagedTags is assumed.
         // To fix this constraint (not needed currently), an oldKeywords parameter is needed
         // create list of keywords to be added and to be removed
 
         QStringList tagsPathList, newKeywords;
 
         QList<int> keys = d->tags.keys();
 
         foreach (int tagId, keys)
         {
             if (!TagsCache::instance()->canBeWrittenToMetadata(tagId))
             {
                 continue;
             }
 
             // WARNING: Do not use write(QFilePath ...) when multiple image info are loaded
             // otherwise disjoint tags will not be used, use writeToMetadata(ItemInfo...)
 
             if (d->tags.value(tagId) == MetadataAvailable)
             {
                 // This works for single and multiple selection.
                 // In both situations, tags which had originally been loaded
                 // have explicitly been removed with setTag.
 
                 QString tagName = TagsCache::instance()->tagName(tagId);
                 QString tagPath = TagsCache::instance()->tagPath(tagId, TagsCache::NoLeadingSlash);
 
                 if (!tagsPathList.contains(tagPath))
                 {
                     tagsPathList << tagPath;
                 }
 
                 if (!tagName.isEmpty())
                 {
                     newKeywords << tagName;
                 }
             }
         }
 
         tagsPathList = cleanupTags(tagsPathList);
         newKeywords = cleanupTags(newKeywords);
 
         if (!newKeywords.isEmpty())
         {
             qCDebug(DIGIKAM_GENERAL_LOG) << "-------------------------- New Keywords" << newKeywords;
 
             // NOTE: See bug #175321 : we remove all old keyword from IPTC and XMP before to
             // synchronize metadata, else contents is not coherent.
 
             dirty |= metadata.setItemTagsPath(tagsPathList);
         }
         else
         {
             qCDebug(DIGIKAM_GENERAL_LOG) << "Delete all keywords";
 
             // Delete all IPTC and XMP keywords
 
             dirty |= metadata.setItemTagsPath(QStringList());
         }
     }
 
     return dirty;
 }
 
 QStringList MetadataHub::cleanupTags(const QStringList& toClean)
 {
     QSet<QString> deduplicator;
 
     for (int index = 0 ; index < toClean.size() ; ++index)
     {
         QString keyword = toClean.at(index);
 
         if (!keyword.isEmpty())
         {
             // _Digikam_root_tag_ is present in some photos tagged with older
             // version of digiKam, must be removed
 
             if (keyword.contains(QRegExp(QLatin1String("(_Digikam_root_tag_/|/_Digikam_root_tag_|_Digikam_root_tag_)"))))
             {
                 keyword = keyword.replace(QRegExp(QLatin1String("(_Digikam_root_tag_/|/_Digikam_root_tag_|_Digikam_root_tag_)")),
                                           QLatin1String(""));
             }
 
             deduplicator.insert(keyword);
         }
     }
 
     return deduplicator.values();
 }
 
 bool MetadataHub::willWriteMetadata(WriteComponent writeMode, const MetaEngineSettingsContainer& settings) const
 {
     // This is the same logic as in write(DMetadata) but without actually writing.
     // Adapt if the method above changes
 
     bool saveTitle      = (settings.saveComments   && (d->titlesStatus     == MetadataAvailable) && writeMode.testFlag(WRITE_TITLE));
     bool saveComment    = (settings.saveComments   && (d->commentsStatus   == MetadataAvailable) && writeMode.testFlag(WRITE_COMMENTS));
     bool saveDateTime   = (settings.saveDateTime   && (d->dateTimeStatus   == MetadataAvailable) && writeMode.testFlag(WRITE_DATETIME));
     bool savePickLabel  = (settings.savePickLabel  && (d->pickLabelStatus  == MetadataAvailable) && writeMode.testFlag(WRITE_PICKLABEL));
     bool saveColorLabel = (settings.saveColorLabel && (d->colorLabelStatus == MetadataAvailable) && writeMode.testFlag(WRITE_COLORLABEL));
     bool saveRating     = (settings.saveRating     && (d->ratingStatus     == MetadataAvailable) && writeMode.testFlag(WRITE_RATING));
     bool saveTemplate   = (settings.saveTemplate   && (d->templateStatus   == MetadataAvailable) && writeMode.testFlag(WRITE_TEMPLATE));
     bool saveTags       = (settings.saveTags       && writeMode.testFlag(WRITE_TAGS));
     bool saveFaces      = (settings.saveFaceTags   && writeMode.testFlag(WRITE_TAGS));
     bool savePosition   = (settings.savePosition   && writeMode.testFlag(WRITE_POSITION));
 
     return (
                saveTitle       ||
                saveComment     ||
                saveDateTime    ||
                savePickLabel   ||
                saveColorLabel  ||
                saveRating      ||
                saveTemplate    ||
                saveTags        ||
                saveFaces       ||
                savePosition
            );
 }
 
 void MetadataHub::writeToBaloo(const QString& filePath, const MetaEngineSettingsContainer& settings)
 {
 #ifdef HAVE_KFILEMETADATA
 
     BalooWrap* const baloo = BalooWrap::instance();
     int rating             = -1;
     QString* comment       = nullptr;
 
     if (!baloo->getSyncToBaloo())
     {
         qCDebug(DIGIKAM_GENERAL_LOG) << "No write to baloo +++++++++++++++++++++++++++++++++++++";
         return;
     }
 
     bool saveComment = (settings.saveComments   && d->commentsStatus   == MetadataAvailable);
     bool saveRating  = (settings.saveRating     && d->ratingStatus     == MetadataAvailable);
 
     QStringList newKeywords;
 
     for (QMap<int, MetadataHub::Status>::iterator it = d->tags.begin() ; it != d->tags.end() ; ++it)
     {
         if (!TagsCache::instance()->canBeWrittenToMetadata(it.key()))
         {
             continue;
         }
 
         // it is important that MetadataDisjoint keywords are not touched
 
         if (it.value() == MetadataAvailable)
         {
             QString tagName = TagsCache::instance()->tagName(it.key());
 
             if (!tagName.isEmpty())
             {
                 newKeywords << tagName;
             }
         }
     }
 
     if (saveComment)
     {
         comment = new QString(d->comments.value(QLatin1String("x-default")).caption);
     }
 
     if (saveRating)
     {
         rating = d->rating;
     }
 
     newKeywords = cleanupTags(newKeywords);
     QUrl url    = QUrl::fromLocalFile(filePath);
     baloo->setAllData(url, &newKeywords, comment, rating);
 #else
     Q_UNUSED(filePath);
     Q_UNUSED(settings);
 #endif
 }
 
 void MetadataHub::applyChangeNotifications()
 {
 }
 
 void Digikam::MetadataHub::loadFaceTags(const ItemInfo& info, const QSize& size)
 {
     FaceTagsEditor editor;
 
     //qCDebug(DIGIKAM_GENERAL_LOG) << "Image Dimensions ----------------" << info.dimensions();
 
     QList<FaceTagsIface> facesList = editor.confirmedFaceTagsIfaces(info.id());
     d->faceTagsList.clear();
 
     if (!facesList.isEmpty())
     {
         foreach (const FaceTagsIface& dface, facesList)
         {
             QString faceName = FaceTags::faceNameForTag(dface.tagId());
 
             if (faceName.isEmpty())
             {
                 continue;
             }
 
             QRect  temprect = dface.region().toRect();
             TagRegion::reverseToOrientation(temprect, info.orientation(), size);
             QRectF faceRect = TagRegion::absoluteToRelative(temprect, size);
             d->faceTagsList.insertMulti(faceName, QVariant(faceRect));
         }
     }
 }
 
 QMultiMap<QString, QVariant> Digikam::MetadataHub::getFaceTags()
 {
     return d->faceTagsList;
 }
 
 void Digikam::MetadataHub::setFaceTags(QMultiMap<QString, QVariant> newFaceTags, QSize size)
 {
     d->faceTagsList.clear();
     QMultiMap<QString, QVariant>::iterator it;
 
     for (it = newFaceTags.begin() ; it != newFaceTags.end() ; ++it)
     {
         QRect  temprect = it.value().toRect();
         QRectF faceRect = TagRegion::absoluteToRelative(temprect, size);
         d->faceTagsList.insertMulti(it.key(), faceRect);
     }
 }
 
-void MetadataHub::adjustFaceRectangles(const ItemInfo& info, bool rotatedPixels,
-                                                             int newOrientation,
-                                                             int oldOrientation)
-{
-    /**
-     *  Get all faces from database and rotate them
-     */
-    QList<FaceTagsIface> facesList = FaceTagsEditor().databaseFaces(info.id());
-
-    if (facesList.isEmpty())
-    {
-        return;
-    }
-
-    QSize newSize = info.dimensions();
-    QMultiMap<QString, QRect> adjustedFaces;
-
-    foreach (const FaceTagsIface& dface, facesList)
-    {
-        QRect faceRect = dface.region().toRect();
-        QString name   = FaceTags::faceNameForTag(dface.tagId());
-
-        TagRegion::reverseToOrientation(faceRect,
-                                        oldOrientation,
-                                        info.dimensions());
-
-        newSize = TagRegion::adjustToOrientation(faceRect,
-                                                 newOrientation,
-                                                 info.dimensions());
-
-        if (dface.tagId() == FaceTags::unknownPersonTagId())
-        {
-            name.clear();
-        }
-
-        adjustedFaces.insertMulti(name, faceRect);
-    }
-
-    /**
-     *  Delete all old faces and add rotated ones
-     */
-    FaceTagsEditor().removeAllFaces(info.id());
-
-    QMultiMap<QString, QRect>::ConstIterator it = adjustedFaces.constBegin();
-
-    for ( ; it != adjustedFaces.constEnd() ; ++it)
-    {
-        TagRegion region(it.value());
-
-        if (it.key().isEmpty())
-        {
-            int tagId = FaceTags::unknownPersonTagId();
-            FaceTagsIface face(FaceTagsIface::UnknownName, info.id(), tagId, region);
-
-            FaceTagsEditor().addManually(face);
-        }
-        else
-        {
-            int tagId = FaceTags::getOrCreateTagForPerson(it.key());
-
-            if (!tagId)
-            {
-                qCDebug(DIGIKAM_GENERAL_LOG) << "Failed to create a person tag for name" << it.key();
-            }
-
-            FaceTagsEditor().add(info.id(), tagId, region, false);
-        }
-    }
-
-    /**
-     * Write medatada
-     */
-    load(info);
-
-    // Adjusted newSize
-
-    if (!rotatedPixels)
-    {
-        newSize = info.dimensions();
-    }
-
-    loadFaceTags(info, newSize);
-    write(info.filePath(), MetadataHub::WRITE_ALL, true);
-}
-
 // NOTE: Unused code
 //void MetadataHub::load(const DMetadata& metadata)
 //{
 //    d->count++;
 
 //    CaptionsMap comments;
 //    CaptionsMap titles;
 //    QStringList keywords;
 //    QDateTime   datetime;
 //    int         pickLabel;
 //    int         colorLabel;
 //    int         rating;
 
 //    titles = metadata.getItemTitles();
 
 //    // Try to get comments from image :
 //    // In first, from Xmp comments tag,
 //    // In second, from standard JPEG JFIF comments section,
 //    // In third, from Exif comments tag,
 //    // In four, from Iptc comments tag.
 //    comments = metadata.getItemComments();
 
 //    // Try to get date and time from image :
 //    // In first, from Exif date & time tags,
 //    // In second, from Xmp date & time tags, or
 //    // In third, from Iptc date & time tags.
 //    // else use file system time stamp.
 //    datetime = metadata.getItemDateTime();
 
 //    if ( !datetime.isValid() )
 //    {
 //        QFileInfo info( metadata.getFilePath() );
 //        datetime = info.lastModified();
 //    }
 
 //    // Try to get image pick label from Xmp tag
 //    pickLabel = metadata.getItemPickLabel();
 
 //    // Try to get image color label from Xmp tag
 //    colorLabel = metadata.getItemColorLabel();
 
 //    // Try to get image rating from Xmp tag, or Iptc Urgency tag
 //    rating = metadata.getItemRating();
 
 //    Template tref = metadata.getMetadataTemplate();
 //    Template t    = TemplateManager::defaultManager()->findByContents(tref);
 
 //    qCDebug(DIGIKAM_GENERAL_LOG) << "Found Metadata Template: " << t.templateTitle();
 
 //    load(datetime, titles, comments, colorLabel, pickLabel, rating, t.isNull() ? tref : t);
 
 //    // Try to get image tags from Xmp using digiKam namespace tags.
 
 //    QStringList tagPaths;
 
 //    if (metadata.getItemTagsPath(tagPaths))
 //    {
 //        QList<int> tagIds = TagsCache::instance()->tagsForPaths(tagPaths);
 //        loadTags(tagIds);
 //    }
 //}
 
 //bool MetadataHub::load(const QString& filePath, const MetaEngineSettingsContainer& settings)
 //{
 
 //    DMetadata metadata;
 //    metadata.setSettings(settings);
 //    bool success = metadata.load(filePath);
 //    load(metadata); // increments count
 //    return success;
 //}
 
 /*
 // private code to merge tags with d->tagList
 void MetadataHub::loadTags(const QStringList& loadedTagPaths)
 {
     if (d->count == 1)
     {
         d->tagList = loadedTagPaths;
     }
     else
     {
         // a simple intersection
         QStringList toBeAdded;
         for (QStringList::iterator it = d->tagList.begin(); it != d->tagList.end(); ++it)
         {
             if (loadedTagPaths.indexOf(*it) == -1)
             {
                 // it's not in the loadedTagPaths list. Remove it from intersection list.
                 it = d->tagList.erase(it);
             }
             // else, it is in both lists, so no need to change d->tagList, it's already added.
         }
     }
 }
 */
 
 } // namespace Digikam
diff --git a/core/libs/fileactionmanager/metadatahub.h b/core/libs/fileactionmanager/metadatahub.h
index fc3b18dbc7..46335028e9 100644
--- a/core/libs/fileactionmanager/metadatahub.h
+++ b/core/libs/fileactionmanager/metadatahub.h
@@ -1,294 +1,287 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2007-01-05
  * Description : Metadata handling
  *
  * Copyright (C) 2007-2012 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
  * Copyright (C) 2007-2020 by Gilles Caulier <caulier dot gilles 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_METADATA_HUB_H
 #define DIGIKAM_METADATA_HUB_H
 
 // Qt includes
 
 #include <QList>
 #include <QStringList>
 #include <QDateTime>
 #include <QMap>
 
 // Local includes
 
 #include "metaenginesettings.h"
 #include "captionvalues.h"
 #include "dmetadata.h"
 #include "dimg.h"
 
 namespace Digikam
 {
 
 class ApplicationSettings;
 class ItemInfo;
 class Template;
 
 class MetadataHub
 {
 public:
 
     /**
      * The status enum describes the result of joining several metadata sets.
      * If only one set has been added, the status is always MetadataAvailable.
      * If no set has been added, the status is always MetadataInvalid
      */
     enum Status
     {
         MetadataInvalid,   ///< not yet filled with any value
         MetadataAvailable  ///< only one data set has been added, or a common value is available
     };
 
     enum WriteMode
     {
         /**
          * Write all available information
          */
         FullWrite,
 
         /**
          * Do a full write if and only if
          *     - metadata fields changed
          *     - the changed fields shall be written according to write settings
          * "Changed" in this context means changed by one of the set... methods,
          * the load() methods are ignored for this attribute.
          * This mode allows to avoid write operations when e.g. the user does not want
          * keywords to be written and only changes keywords.
          */
         FullWriteIfChanged,
 
         /**
          * Write only the changed parts.
          * Metadata fields which cannot be changed from MetadataHub (photographer ID etc.)
          * will never be written
          */
         PartialWrite
     };
 
     enum WriteComponents
     {
         WRITE_DATETIME  = 1,
         WRITE_TITLE     = 2,
         WRITE_COMMENTS  = 4,
         WRITE_PICKLABEL = 8,
         WRITE_COLORLABEL= 16,
         WRITE_RATING    = 32,
         WRITE_TEMPLATE  = 64,
         WRITE_TAGS      = 128,
         WRITE_POSITION  = 256,
         WRITE_ALL       = 511
     };
     Q_DECLARE_FLAGS(WriteComponent, WriteComponents)
 
 public:
 
     /**
      * Constructs a MetadataHub.
      * @param dbmode Determines if the database may be accessed or not. See the enum description above.
      */
     MetadataHub();
     virtual ~MetadataHub();
 
     /// Copies by value - no sharing involved.
     MetadataHub& operator=(const MetadataHub&);
     MetadataHub(const MetadataHub&);
 
     /**
      * Creates a copy (as always, by value) of this hub.
      * Shall be reimplemented by subclasses to return an object of the correct type.
      */
     virtual MetadataHub* clone() const;
 
     void reset();
 
     // --------------------------------------------------
 
     /**
      * Add metadata information contained in the ItemInfo object.
      * This method (or in combination with the other load methods)
      * can be called multiple times on the same MetadataHub object.
      * In this case, the metadata will be combined.
      */
     void load(const ItemInfo& info);
 
 //    /**
 //     * Add metadata information from the DMetadata object
 //     */
 //    void load(const DMetadata& metadata);
 
 //    /**
 //     * Load metadata information from the given file.
 //     * (Uses DMetadata, QFileInfo)
 //     * @returns True if the metadata could be loaded
 //     */
 //    bool load(const QString& filePath, const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
     // --------------------------------------------------
 
     /**
      * @brief writeToMetadata - write to metadata using image info to retrieve tags and filepath
      *                          use this method when multiple image infos are loaded in hub
      * @param info - image info to retrieve current tags
      * @param writeMode
      * @param settings
      * @return true           - if everything is successful
      */
     bool writeToMetadata(const ItemInfo& info, WriteComponent writeMode = WRITE_ALL,
                bool ignoreLazySync = false, const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
 
     /**
      * Constructs a DMetadata object for given filePath,
      * calls the above method, writes the changes out to the file,
      * and notifies the ItemAttributesWatch.
      * WARNING: Do not use this method when multiple image infos are loaded
      *          It will result in disjoint tags not being written
      *          Use writeToMetadata(Image info ...) instead
      * @return Returns if the file has been touched
      */
     bool write(const QString& filePath, WriteComponent writeMode = WRITE_ALL,
                bool ignoreLazySync = false, const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
     /**
      * Constructs a DMetadata object from the metadata stored in the given DImg object,
      * calls the above method, and changes the stored metadata in the DImg object.
      * @return Returns if the DImg object has been touched
      */
     bool write(DImg& image, WriteComponent writeMode = WRITE_ALL,
                bool ignoreLazySync = false, const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
     /**
      * Will write only Tags to image. Used by TagsManager to write tags to image
      * Other metadata are not updated.
      * @return if tags were successfully written.
      */
     bool writeTags(const QString& filePath, WriteComponent writeMode = WRITE_ALL,
                    const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
     /**
      * @brief writeTags - used to deduplicate code from writeTags and usual write, all write to tags
      *                    operations must be done here
      * @param metadata  - DMetadata object that apply changes
      * @param saveTags  - save switch
      * @return          - if tags were successfully set
      */
     bool writeTags(DMetadata& metadata, bool saveTags);
 
     /**
      * @brief cleanupTags - remove duplicates and obsolete tags before setting metadata
      * @param toClean     - tag list to be cleared and de-duplicated
      * @return            - clean tag list
      */
     QStringList cleanupTags(const QStringList& toClean);
 
     /**
      * With the currently applied changes, the given writeMode and settings,
      * returns if write(DMetadata), write(QString) or write(DImg) will actually
      * apply any changes.
      */
     bool willWriteMetadata(Digikam::MetadataHub::WriteComponent writeMode = WRITE_ALL,
                            const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings()) const;
 
     /**
      * @brief writeToBaloo - write tags, comments and rating to KDE Nepomuk replacement: Baloo
      * @param filePath     - path to file to add comments, tags and rating
      * @param settings     - metadata settings to be set
      */
     void writeToBaloo(const QString& filePath, const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
 
     // --------------------------------------------------
 
     /**
      * Dedicated method to set face rectangles from database
      * When called from outside the metadatahub and  ItemInfo is cached,
      * method dimension() can return wrong values, QSize must be specified
      * manually
      */
     void loadFaceTags(const ItemInfo& info, const QSize& size);
 
     /**
      * Get face tag names and face tag regions.
      * This is used for metadata synchronization in Image Editor
      */
     QMultiMap<QString, QVariant> getFaceTags();
 
     /**
      * Set new face tags
      */
     void setFaceTags(QMultiMap<QString, QVariant> newFaceTags, QSize size);
 
-    /**
-     * Rotate face tags
-     */
-    void adjustFaceRectangles(const ItemInfo& info, bool rotatedPixels,
-                                                    int newOrientation,
-                                                    int oldOrientation);
-
 protected:
 
     /**
      * Applies the set of metadata contained in this MetadataHub
      * to the given DMetadata object.
      * The MetaEngineSettingsContainer determine whether data is actually
      * set or not.
      * The following metadata fields may be set (depending on settings):
      * - Comment
      * - Date
      * - Rating
      * - Tags
      * - Photographer ID (data from settings)
      * - Credits (data from settings)
      *
      * The data fields taken from this MetadataHub object are only set if
      * their status is MetadataAvailable.
      * If the status is MetadataInvalid or MetadataDisjoint, the respective
      * metadata field is not touched.
      * @return Returns true if the metadata object has been touched
      */
     bool write(DMetadata& metadata, WriteComponent writeMode = WRITE_ALL,
                const MetaEngineSettingsContainer& settings = MetaEngineSettings::instance()->settings());
 
     void load(const QDateTime& dateTime,
               const CaptionsMap& titles, const CaptionsMap& comment,
               int colorLabel, int pickLabel,
               int rating, const Template& t);
     void loadTags(const QList<int>& loadedTagIds);
     void loadTags(const QStringList& loadedTagPaths);
     void notifyTagDeleted(int id);
 
     virtual void applyChangeNotifications();
 
 private:
 
     class Private;
     Private* const d;
 };
 
 } // namespace Digikam
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(Digikam::MetadataHub::WriteComponent)
 
 #endif // DIGIKAM_METADATA_HUB_H
diff --git a/core/utilities/facemanagement/database/faceutils.cpp b/core/utilities/facemanagement/database/faceutils.cpp
index aab7bd3e73..46cf0f6912 100644
--- a/core/utilities/facemanagement/database/faceutils.cpp
+++ b/core/utilities/facemanagement/database/faceutils.cpp
@@ -1,341 +1,412 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2010-08-08
  * Description : FaceEngine database interface allowing easy manipulation of face tags
  *
  * Copyright (C) 2010-2011 by Aditya Bhatt <adityabhatt1991 at gmail dot com>
  * Copyright (C) 2010-2011 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
  * Copyright (C) 2012-2020 by Gilles Caulier <caulier dot gilles 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.
  *
  * ============================================================ */
 
 #include "faceutils.h"
 
 // Qt includes
 
 #include <QImage>
 
 // Local includes
 
 #include "digikam_debug.h"
 #include "coredbaccess.h"
 #include "coredbconstants.h"
 #include "coredboperationgroup.h"
 #include "dimg.h"
 #include "facetags.h"
 #include "iteminfo.h"
 #include "itemtagpair.h"
 #include "fileactionmngr.h"
 #include "tagproperties.h"
 #include "tagscache.h"
 #include "tagregion.h"
 #include "thumbnailloadthread.h"
 
 namespace Digikam
 {
 
 // --- Constructor / Destructor -------------------------------------------------------------------------------------
 
 FaceUtils::FaceUtils()
 {
 }
 
 FaceUtils::~FaceUtils()
 {
 }
 
 // --- Mark for scanning and training -------------------------------------------------------------------------------
 
 bool FaceUtils::hasBeenScanned(qlonglong imageid) const
 {
     return hasBeenScanned(ItemInfo(imageid));
 }
 
 bool FaceUtils::hasBeenScanned(const ItemInfo& info) const
 {
     return info.tagIds().contains(FaceTags::scannedForFacesTagId());
 }
 
 void FaceUtils::markAsScanned(qlonglong imageid, bool hasBeenScanned) const
 {
     return markAsScanned(ItemInfo(imageid), hasBeenScanned);
 }
 
 void FaceUtils::markAsScanned(const ItemInfo& info, bool hasBeenScanned) const
 {
     if (hasBeenScanned)
     {
         ItemInfo(info).setTag(FaceTags::scannedForFacesTagId());
     }
     else
     {
         ItemInfo(info).removeTag(FaceTags::scannedForFacesTagId());
     }
 }
 
 // --- Convert between FacesEngine results and FaceTagsIface ---
 
 QList<FaceTagsIface> FaceUtils::toFaceTagsIfaces(qlonglong imageid,
                                                  const QList<QRectF>& detectedFaces,
                                                  const QList<Identity> recognitionResults,
                                                  const QSize& fullSize) const
 {
     QList<FaceTagsIface> faces;
 
     for (int i = 0 ; i < detectedFaces.size() ; ++i)
     {
         Identity identity;
 
         if (!recognitionResults.isEmpty())
         {
             identity = recognitionResults[i];
         }
 
         // We'll get the unknownPersonTagId if the identity is null
 
         int tagId                = FaceTags::getOrCreateTagForIdentity(identity.attributesMap());
         QRect fullSizeRect       = TagRegion::relativeToAbsolute(detectedFaces[i], fullSize);
         FaceTagsIface::Type type = identity.isNull() ? FaceTagsIface::UnknownName : FaceTagsIface::UnconfirmedName;
 
         if (!tagId || !fullSizeRect.isValid())
         {
             faces << FaceTagsIface();
             continue;
         }
 /*
         qCDebug(DIGIKAM_GENERAL_LOG) << "New Entry" << fullSizeRect << tagId;
 */
         faces << FaceTagsIface(type, imageid, tagId, TagRegion(fullSizeRect));
     }
 
     return faces;
 }
 
 // --- Images in faces and thumbnails ---
 
 void FaceUtils::storeThumbnails(ThumbnailLoadThread* const thread,
                                 const QString& filePath,
                                 const QList<FaceTagsIface>& databaseFaces,
                                 const DImg& image)
 {
     foreach (const FaceTagsIface& face, databaseFaces)
     {
         QList<QRect> rects;
         rects << face.region().toRect();
         const int margin = faceRectDisplayMargin(face.region().toRect());
         rects << face.region().toRect().adjusted(-margin, -margin, margin, margin);
 
         foreach (const QRect& rect, rects)
         {
             QRect mapped  = TagRegion::mapFromOriginalSize(image, rect);
             QImage detail = image.copyQImage(mapped);
             thread->storeDetailThumbnail(filePath, rect, detail, true);
         }
     }
 }
 
 // --- Face detection: merging results ------------------------------------------------------------------------------------
 
 QList<FaceTagsIface> FaceUtils::writeUnconfirmedResults(qlonglong imageid,
                                                         const QList<QRectF>& detectedFaces,
                                                         const QList<Identity> recognitionResults,
                                                         const QSize& fullSize)
 {
     // Build list of new entries
 
     QList<FaceTagsIface> newFaces = toFaceTagsIfaces(imageid, detectedFaces, recognitionResults, fullSize);
 
     if (newFaces.isEmpty())
     {
         return newFaces;
     }
 
     // list of existing entries
 
     QList<FaceTagsIface> currentFaces = databaseFaces(imageid);
 
     // merge new with existing entries
 
     for (int i = 0 ; i < newFaces.size() ; ++i)
     {
         FaceTagsIface& newFace = newFaces[i];
         QList<FaceTagsIface> overlappingEntries;
 
         foreach (const FaceTagsIface& oldFace, currentFaces)
         {
             double minOverlap = oldFace.isConfirmedName() ? 0.25 : 0.5;
 
             if (oldFace.region().intersects(newFace.region(), minOverlap))
             {
                 overlappingEntries << oldFace;
                 qCDebug(DIGIKAM_GENERAL_LOG) << "Entry" << oldFace.region() << oldFace.tagId()
                                              << "overlaps" << newFace.region() << newFace.tagId() << ", skipping";
             }
         }
 
         // The purpose if the next scope is to merge entries:
         // A confirmed face will never be overwritten.
         // If a name is set to an old face, it will only be replaced by a new face with a name.
 
         if (!overlappingEntries.isEmpty())
         {
             if (newFace.isUnknownName())
             {
                 // we have no name in the new face. Do we have one in the old faces?
 
                 for (int j = 0 ; j < overlappingEntries.size() ; ++j)
                 {
                     const FaceTagsIface& oldFace = overlappingEntries.at(j);
 
                     if (oldFace.isUnknownName())
                     {
                         // remove old face
                     }
                     else
                     {
                         // skip new entry if any overlapping face has a name, and we do not
 
                         newFace = FaceTagsIface();
                         break;
                     }
                 }
             }
             else
             {
                 // we have a name in the new face. Do we have names in overlapping faces?
 
                 for (int j = 0 ; j < overlappingEntries.size() ; ++j)
                 {
                     FaceTagsIface& oldFace = overlappingEntries[j];
 
                     if (oldFace.isUnknownName())
                     {
                         // remove old face
                     }
                     else if (oldFace.isUnconfirmedName())
                     {
                         if (oldFace.tagId() == newFace.tagId())
                         {
                             // remove smaller face
 
                             if (oldFace.region().intersects(newFace.region(), 1))
                             {
                                 newFace = FaceTagsIface();
                                 break;
                             }
 
                             // else remove old face
                         }
                         else
                         {
                             // assume new recognition is more trained, remove older face
                         }
                     }
                     else if (oldFace.isConfirmedName())
                     {
                         // skip new entry, confirmed has of course priority
 
                         newFace = FaceTagsIface();
                     }
                 }
             }
         }
 
         // if we did not decide to skip this face, add is to the db now
 
         if (!newFace.isNull())
         {
             // list will contain all old entries that should still be removed
 
             removeFaces(overlappingEntries);
 
             ItemTagPair pair(imageid, newFace.tagId());
 
             // UnconfirmedName and UnknownName have the same attribute
 
             addFaceAndTag(pair, newFace, FaceTagsIface::attributesForFlags(FaceTagsIface::UnconfirmedName), false);
 
             // If the face is unconfirmed and the tag is not the unknown person tag, set the unconfirmed person property.
 
             if (newFace.isUnconfirmedType() && !FaceTags::isTheUnknownPerson(newFace.tagId()))
             {
                 ItemTagPair unconfirmedPair(imageid, FaceTags::unconfirmedPersonTagId());
                 unconfirmedPair.addProperty(ImageTagPropertyName::autodetectedPerson(),newFace.getAutodetectedPersonString());
             }
         }
     }
 
     return newFaces;
 }
 
 Identity FaceUtils::identityForTag(int tagId, RecognitionDatabase& db) const
 {
     QMap<QString, QString> attributes = FaceTags::identityAttributes(tagId);
     Identity identity                 = db.findIdentity(attributes);
 
     if (!identity.isNull())
     {
         qCDebug(DIGIKAM_GENERAL_LOG) << "Found FacesEngine identity" << identity.id() << "for tag" << tagId;
         return identity;
     }
 
     qCDebug(DIGIKAM_GENERAL_LOG) << "Adding new FacesEngine identity with attributes" << attributes;
     identity                          = db.addIdentity(attributes);
 
     FaceTags::applyTagIdentityMapping(tagId, identity.attributesMap());
 
     return identity;
 }
 
 int FaceUtils::tagForIdentity(const Identity& identity) const
 {
     return FaceTags::getOrCreateTagForIdentity(identity.attributesMap());
 }
 
 // --- Editing normal tags, reimplemented with FileActionMngr ---
 
 void FaceUtils::addNormalTag(qlonglong imageid, int tagId)
 {
     FileActionMngr::instance()->assignTag(ItemInfo(imageid), tagId);
 }
 
 void FaceUtils::removeNormalTag(qlonglong imageId, int tagId)
 {
     FileActionMngr::instance()->removeTag(ItemInfo(imageId), tagId);
 }
 
 void FaceUtils::removeNormalTags(qlonglong imageId, QList<int> tagIds)
 {
     FileActionMngr::instance()->removeTags(ItemInfo(imageId), tagIds);
 }
 
 // --- Utilities ---
 
+QSize FaceUtils::rotateFaces(const ItemInfo& info, int newOrientation,
+                                                   int oldOrientation)
+{
+    /**
+     *  Get all faces from database and rotate them
+     */
+    QList<FaceTagsIface> facesList = databaseFaces(info.id());
+
+    if (facesList.isEmpty())
+    {
+        return QSize();
+    }
+
+    QSize newSize = info.dimensions();
+    QMultiMap<QString, QRect> adjustedFaces;
+
+    foreach (const FaceTagsIface& dface, facesList)
+    {
+        QRect faceRect = dface.region().toRect();
+        QString name   = FaceTags::faceNameForTag(dface.tagId());
+
+        TagRegion::reverseToOrientation(faceRect,
+                                        oldOrientation,
+                                        info.dimensions());
+
+        newSize = TagRegion::adjustToOrientation(faceRect,
+                                                 newOrientation,
+                                                 info.dimensions());
+
+        if (dface.tagId() == FaceTags::unknownPersonTagId())
+        {
+            name.clear();
+        }
+
+        adjustedFaces.insertMulti(name, faceRect);
+    }
+
+    /**
+     *  Delete all old faces and add rotated ones
+     */
+    FaceTagsEditor().removeAllFaces(info.id());
+
+    QMultiMap<QString, QRect>::ConstIterator it = adjustedFaces.constBegin();
+
+    for ( ; it != adjustedFaces.constEnd() ; ++it)
+    {
+        TagRegion region(it.value());
+
+        if (it.key().isEmpty())
+        {
+            int tagId = FaceTags::unknownPersonTagId();
+            FaceTagsIface face(FaceTagsIface::UnknownName, info.id(), tagId, region);
+
+            addManually(face);
+        }
+        else
+        {
+            int tagId = FaceTags::getOrCreateTagForPerson(it.key());
+
+            if (!tagId)
+            {
+                qCDebug(DIGIKAM_GENERAL_LOG) << "Failed to create a person tag for name" << it.key();
+            }
+
+            add(info.id(), tagId, region, false);
+        }
+    }
+
+    return newSize;
+}
+
 int FaceUtils::faceRectDisplayMargin(const QRect& rect)
 {
     /*
      * Do not change that value unless you know what you do.
      * There are a lot of pregenerated thumbnails in user's databases,
      * expensive to regenerate, depending on this very value.
      */
     int margin = qMax(rect.width(), rect.height());
     margin    /= 10;
 
     return margin;
 }
 
 } // Namespace Digikam
diff --git a/core/utilities/facemanagement/database/faceutils.h b/core/utilities/facemanagement/database/faceutils.h
index 7de25f1045..2666f560c1 100644
--- a/core/utilities/facemanagement/database/faceutils.h
+++ b/core/utilities/facemanagement/database/faceutils.h
@@ -1,142 +1,148 @@
 /* ============================================================
  *
  * This file is a part of digiKam project
  * https://www.digikam.org
  *
  * Date        : 2010-08-08
  * Description : FacesEngine database interface allowing easy manipulation of face tags
  *
  * Copyright (C) 2010-2011 by Aditya Bhatt <adityabhatt1991 at gmail dot com>
  * Copyright (C) 2010-2011 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
  * Copyright (C) 2012-2020 by Gilles Caulier <caulier dot gilles 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_FACE_UTILS_H
 #define DIGIKAM_FACE_UTILS_H
 
 // Qt includes
 
 #include <QStringList>
 
 // Local includes
 
 #include "identity.h"
 #include "recognitiondatabase.h"
 #include "iteminfo.h"
 #include "facetagseditor.h"
 #include "digikam_export.h"
 
 class QImage;
 
 namespace Digikam
 {
 
 class DImg;
 class ThumbnailLoadThread;
 class ThumbnailImageCatcher;
 
 class FaceUtils : public FaceTagsEditor
 {
 public:
 
     enum FaceRecognitionSteps
     {
         DetectFaceRegions,
         DetectAndRecognize
     };
 
 public:
 
     explicit FaceUtils();
     virtual ~FaceUtils();
 
     // --- Face detection and recognition ---
 
     /**
      * The given face list is a result of automatic detection and possibly recognition.
      * The results are written to the database and merged with existing entries.
      * The returned list contains the faces written to the database and has the same size as the given list.
      * If a face was skipped (because of an existing entry), a null FaceTagsIface will be at this place.
      */
     QList<FaceTagsIface> writeUnconfirmedResults(qlonglong imageid,
                                                  const QList<QRectF>& detectedFaces,
                                                  const QList<Identity> recognitionResults,
                                                  const QSize& fullSize);
 
     // --- Status flags ---
 
     /**
      * Tells if the image has been scanned for faces or not
      */
     bool                hasBeenScanned(const ItemInfo& info)                            const;
     bool                hasBeenScanned(qlonglong imageid)                               const;
 
     /**
      * Marks the image as scanned for faces.
      */
     void                markAsScanned(qlonglong imageid, bool hasBeenScanned = true)    const;
     void                markAsScanned(const ItemInfo& info, bool hasBeenScanned = true) const;
 
     // --- Utilities ---
 
     /**
      * This uses a thumbnail load thread to load the image detail.
      * If requested, the faces will be scaled to the given (fixed) size.
      */
 /*
     void                fillImageInFaces(ThumbnailImageCatcher* const catcher,
                                          const QString& filePath,
                                          QList<Face>& faceList,
                                          const QSize& scaleSize = QSize())              const;
 */
 
     /**
      * Store the needed thumbnails for the given faces. This can be a huge optimization
      * when the has already been loaded anyway.
      */
     void                storeThumbnails(ThumbnailLoadThread* const thread,
                                         const QString& filePath,
                                         const QList<FaceTagsIface>& databaseFaces,
                                         const DImg& image);
 
     /**
      * Conversion
      */
     QList<FaceTagsIface> toFaceTagsIfaces(qlonglong imageid,
                                          const QList<QRectF>& detectedFaces,
                                          const QList<Identity> recognitionResults,
                                          const QSize& fullSize)                         const;
 
+    /**
+     * Rotate face tags
+     */
+    QSize                rotateFaces(const ItemInfo& info, int newOrientation,
+                                                           int oldOrientation);
+
     /**
      * For display, it may be desirable to display a slightly larger region than the strict
      * face rectangle. This returns a pixel margin commonly used to increase the rectangle size
      * in all four directions.
      */
     static int          faceRectDisplayMargin(const QRect& rect);
 
     Identity identityForTag(int tagId, RecognitionDatabase& db)                         const;
     int                  tagForIdentity(const Identity& identity)                       const;
 
 protected:
 
     // Reimplemented
     virtual void addNormalTag(qlonglong imageid, int tagId);
     virtual void removeNormalTag(qlonglong imageid, int tagId);
     virtual void removeNormalTags(qlonglong imageid, QList<int> tagId);
 };
 
 } // Namespace Digikam
 
 #endif // DIGIKAM_FACE_UTILS_H