Debian Codegraph @

core/utilities/facemanagement/items/facegroup.cpp

raw
1 /* ============================================================
2 *
3 * This file is a part of digiKam project
4 * https://www.digikam.org
5 *
6 * Date : 2010-09-17
7 * Description : Managing of face tag region items on a GraphicsDImgView
8 *
9 * SPDX-FileCopyrightText: 2010 by Aditya Bhatt <adityabhatt1991 at gmail dot com>
10 * SPDX-FileCopyrightText: 2010-2011 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
11 * SPDX-FileCopyrightText: 2012-2026 by Gilles Caulier <caulier dot gilles at gmail dot com>
12 *
13 * SPDX-License-Identifier: GPL-2.0-or-later
14 *
15 * ============================================================ */
16
17 #include "facegroup_p.h"
18
19 namespace Digikam
20 {
21
22 FaceGroup::FaceGroup(GraphicsDImgView* const view)
23 : QObject(view),
24 d (new Private(this))
25 {
26 d->view = view;
27 d->visibilityController = new ItemVisibilityController(this);
28 d->visibilityController->setShallBeShown(false);
29
30 connect(AlbumManager::instance(), SIGNAL(signalAlbumRenamed(Album*)),
31 this, SLOT(slotAlbumRenamed(Album*)));
32
33 connect(AlbumManager::instance(), SIGNAL(signalAlbumsUpdated(int)),
34 this, SLOT(slotAlbumsUpdated(int)));
35
36 connect(view->previewItem(), SIGNAL(stateChanged(int)),
37 this, SLOT(itemStateChanged(int)));
38
39 connect(CoreDbAccess::databaseWatch(), SIGNAL(imageTagChange(ImageTagChangeset)),
40 this, SLOT(slotImageTagChange(ImageTagChangeset)));
41 }
42
43 FaceGroup::~FaceGroup()
44 {
45 delete d;
46 }
47
48 void FaceGroup::itemStateChanged(int itemState)
49 {
50 switch (itemState)
51 {
52 case DImgPreviewItem::NoImage:
53 case DImgPreviewItem::ImageLoadingFailed:
54 {
55 d->visibilityController->hide();
56
57 break;
58 }
59
60 case DImgPreviewItem::ImageLoaded:
61 {
62 if (d->state == FacesLoaded)
63 {
64 d->visibilityController->show();
65 }
66
67 break;
68 }
69 }
70 }
71
72 bool FaceGroup::isVisible() const
73 {
74 return d->visibilityController->shallBeShown();
75 }
76
77 bool FaceGroup::hasVisibleItems() const
78 {
79 return d->visibilityController->hasVisibleItems();
80 }
81
82 ItemInfo FaceGroup::info() const
83 {
84 return d->info;
85 }
86
87 QList<RegionFrameItem*> FaceGroup::items() const
88 {
89 QList<RegionFrameItem*> items;
90
91 for (FaceItem* const item : std::as_const(d->items)) // cppcheck-suppress constVariablePointer
92 {
93 items << item;
94 }
95
96 return items;
97 }
98
99 void FaceGroup::setAutoSuggest(bool doAutoSuggest)
100 {
101 if (d->autoSuggest == doAutoSuggest)
102 {
103 return;
104 }
105
106 d->autoSuggest = doAutoSuggest;
107 }
108
109 bool FaceGroup::autoSuggest() const
110 {
111 return d->autoSuggest;
112 }
113
114 void FaceGroup::setShowOnHover(bool show)
115 {
116 d->showOnHover = show;
117 }
118
119 bool FaceGroup::showOnHover() const
120 {
121 return d->showOnHover;
122 }
123
124 void FaceGroup::setVisible(bool visible)
125 {
126 d->visibilityController->setShallBeShown(visible);
127 d->applyVisible();
128 }
129
130 void FaceGroup::setVisibleItem(RegionFrameItem* item)
131 {
132 d->visibilityController->setItemThatShallBeShown(item);
133 d->applyVisible();
134 }
135
136 void FaceGroup::setInfo(const ItemInfo& info)
137 {
138 if (d->info != info)
139 {
140 d->clear(NoFaces);
141 }
142
143 d->info = info;
144
145 if (d->visibilityController->shallBeShown())
146 {
147 load();
148 }
149 }
150
151 void FaceGroup::aboutToSetInfo(const ItemInfo& info)
152 {
153 if (d->info == info)
154 {
155 return;
156 }
157
158 applyItemGeometryChanges();
159 }
160
161 static QPointF closestPointOfRect(const QPointF& p, const QRectF& r)
162 {
163 QPointF cp = p;
164
165 if (p.x() < r.left())
166 {
167 cp.setX(r.left());
168 }
169 else if (p.x() > r.right())
170 {
171 cp.setX(r.right());
172 }
173
174 if (p.y() < r.top())
175 {
176 cp.setY(r.top());
177 }
178 else if (p.y() > r.bottom())
179 {
180 cp.setY(r.bottom());
181 }
182
183 return cp;
184 }
185
186 RegionFrameItem* FaceGroup::closestItem(const QPointF& p, qreal* const manhattanLength) const
187 {
188 RegionFrameItem* closestItem = nullptr;
189 qreal minDistance = 0;
190 qreal minCenterDistance = 0;
191
192 for (RegionFrameItem* const item : std::as_const(d->items))
193 {
194 QRectF r = item->boundingRect().translated(item->pos());
195 qreal distance = (p - closestPointOfRect(p, r)).manhattanLength();
196
197 if (
198 !closestItem ||
199 (distance < minDistance) ||
200 ((distance == 0) && ((p - r.center()).manhattanLength()) < minCenterDistance)
201 )
202 {
203 closestItem = item;
204 minDistance = distance;
205
206 if (distance == 0)
207 {
208 minCenterDistance = (p - r.center()).manhattanLength();
209 }
210 }
211 }
212
213 if (manhattanLength)
214 {
215 *manhattanLength = minDistance;
216 }
217
218 return closestItem;
219 }
220
221 bool FaceGroup::acceptsMouseClick(const QPointF& scenePos)
222 {
223 return d->hotItems(scenePos).isEmpty();
224 }
225
226 void FaceGroup::itemHoverMoveEvent(QGraphicsSceneHoverEvent* e)
227 {
228 if (d->showOnHover && !isVisible())
229 {
230 qreal distance;
231 RegionFrameItem* const item = closestItem(e->scenePos(), &distance);
232
233 // There's a possible nuisance when the direct mouse way from hovering pos to HUD widget
234 // is not part of the condition. Maybe, we should add a exemption for this case.
235
236 if (distance < d->MaxMouseDistance)
237 {
238 setVisibleItem(item);
239 }
240 else
241 {
242 // Get all items close to pos.
243
244 QList<QGraphicsItem*> hItems = d->hotItems(e->scenePos());
245
246 // This will be the one item shown by mouse over.
247
248 QList<QObject*> visible = d->visibilityController->visibleItems(ItemVisibilityController::ExcludeFadingOut);
249
250 for (QGraphicsItem* const item2 : std::as_const(hItems))
251 {
252 for (QObject* const parent : std::as_const(visible))
253 {
254 if (static_cast<QGraphicsObject*>(parent)->isAncestorOf(item2))
255 {
256 // cppcheck-suppress useStlAlgorithm
257 return;
258 }
259 }
260 }
261
262 setVisibleItem(nullptr);
263 }
264 }
265 }
266
267 void FaceGroup::itemHoverLeaveEvent(QGraphicsSceneHoverEvent*)
268 {
269 }
270
271 void FaceGroup::itemHoverEnterEvent(QGraphicsSceneHoverEvent*)
272 {
273 }
274
275 void FaceGroup::leaveEvent(QEvent*)
276 {
277 if (d->showOnHover && !isVisible())
278 {
279 setVisibleItem(nullptr);
280 }
281 }
282
283 void FaceGroup::enterEvent(QEvent*)
284 {
285 }
286
287 bool FaceGroup::hasUnconfirmed()
288 {
289 for (const FaceItem* const item : std::as_const(d->items))
290 {
291 if (item->face().isUnconfirmedType())
292 {
293 return true;
294 }
295 }
296
297 return false;
298 }
299
300 void FaceGroup::load()
301 {
302 if (d->state == FacesLoad)
303 {
304 return;
305 }
306
307 d->state = FacesLoad;
308 d->exifRotate = (
309 MetaEngineSettings::instance()->settings().exifRotate ||
310 (
311 (d->view->previewItem()->image().detectedFormat() == DImg::RAW) &&
312 !d->view->previewItem()->image().attribute(QLatin1String("fromRawEmbeddedPreview")).toBool()
313 )
314 );
315
316 if (d->info.isNull())
317 {
318 d->clear(FacesLoaded);
319
320 return;
321 }
322
323 const QList<FaceTagsIface> faces = FaceTagsEditor().databaseFaces(d->info.id());
324
325 if (faces.isEmpty())
326 {
327 d->clear(FacesLoaded);
328
329 return;
330 }
331
332 d->clear(FacesLoad);
333
334 for (const FaceTagsIface& face : faces)
335 {
336 d->addItem(face);
337 }
338
339 if (d->view->previewItem()->isLoaded())
340 {
341 d->visibilityController->show();
342 }
343
344 // See bug 408982.
345
346 if (d->visibilityController->hasVisibleItems())
347 {
348 d->view->setFocus();
349 }
350
351 d->state = FacesLoaded;
352 }
353
354 void FaceGroup::rejectAll()
355 {
356 d->newEditPipeline->removeAllFaces(d->info);
357 d->clear(NoFaces);
358 }
359
360 void FaceGroup::markAllAsIgnored()
361 {
362 for (FaceItem* const item : std::as_const(d->items))
363 {
364 if (
365 item->face().isUnknownName() ||
366 item->face().isUnconfirmedName()
367 )
368 {
369 FaceTagsIface face = d->newEditPipeline->editTag(d->info, item->face(),
370 FaceTags::ignoredPersonTagId());
371 item->setFace(face);
372
373 item->switchMode(AssignNameWidget::IgnoredMode);
374 }
375 }
376 }
377
378 void FaceGroup::slotAlbumsUpdated(int type)
379 {
380 if (type != Album::TAG)
381 {
382 return;
383 }
384
385 if (d->items.isEmpty())
386 {
387 return;
388 }
389
390 load();
391 }
392
393 void FaceGroup::slotAlbumRenamed(Album* album)
394 {
395 if (!album || (album->type() != Album::TAG))
396 {
397 return;
398 }
399
400 for (FaceItem* const item : std::as_const(d->items))
401 {
402 if (
403 !item->face().isNull() &&
404 (item->face().tagId() == album->id())
405 )
406 {
407 item->updateCurrentTag();
408 }
409 }
410 }
411
412 void FaceGroup::slotImageTagChange(const ImageTagChangeset& changeset)
413 {
414 if (!changeset.containsImage(d->info.id()))
415 {
416 return;
417 }
418
419 if (changeset.operation() == ImageTagChangeset::PropertiesChanged)
420 {
421 if (
422 changeset.containsTag(FaceTags::unknownPersonTagId()) ||
423 changeset.containsTag(FaceTags::unconfirmedPersonTagId())
424 )
425 {
426 load();
427 }
428 }
429 }
430
431 void FaceGroup::slotAssigned(const TaggingAction& action, const ItemInfo&, const QVariant& faceIdentifier)
432 {
433 QList<QVariant> faceList(faceIdentifier.toList());
434
435 if (faceList.size() != d->MaxFaceListSize)
436 {
437 return;
438 }
439
440 FaceItem* const item = d->items[faceList[4].toInt()];
441 FaceTagsIface face = item->face();
442 QRect faceRect = item->originalRect();
443
444 if (!d->exifRotate)
445 {
446 TagRegion::adjustToOrientation(faceRect,
447 d->info.orientation(),
448 d->info.dimensions());
449 }
450
451 TagRegion currentRegion(faceRect);
452
453 if (
454 !face.isConfirmedName() ||
455 (face.region() != currentRegion) ||
456 action.shallCreateNewTag() ||
457 (
458 action.shallAssignTag() &&
459 (action.tagId() != face.tagId())
460 )
461 )
462 {
463 int tagId = 0;
464
465 if (action.shallAssignTag())
466 {
467 tagId = action.tagId();
468 }
469 else if (action.shallCreateNewTag())
470 {
471 QStringList faceNames = action.newTagName().split(QLatin1Char('/'),
472 Qt::SkipEmptyParts);
473
474 if (!faceNames.isEmpty())
475 {
476 tagId = action.parentTagId();
477
478 for (const QString& name : std::as_const(faceNames))
479 {
480 tagId = FaceTags::getOrCreateTagForPerson(name.trimmed(), tagId);
481 }
482 }
483 }
484
485 if (FaceTags::isTheUnknownPerson(tagId))
486 {
487 qCDebug(DIGIKAM_GENERAL_LOG) << "Refusing to assign the unknown person to an image";
488 return;
489 }
490
491 if (!tagId)
492 {
493 qCDebug(DIGIKAM_GENERAL_LOG) << "Failed to get person tag";
494 return;
495 }
496
497 face = d->newEditPipeline->confirmFace(d->info, face, currentRegion, tagId, true);
498 item->setFace(face);
499
500 item->switchMode(AssignNameWidget::ConfirmedMode);
501
502 QTimer::singleShot(250, this, SLOT(slotFocusRandomFace()));
503 }
504 }
505
506 void FaceGroup::slotFocusRandomFace()
507 {
508 for (const FaceItem* const item : std::as_const(d->items))
509 {
510 FaceTagsIface face = item->face();
511 const AddTagsComboBox* const comboBox = item->widget()->comboBox();
512
513 if ((comboBox) && (!face.isConfirmedName()))
514 {
515 comboBox->lineEdit()->setFocus();
516
517 return;
518 }
519 }
520 }
521
522 void FaceGroup::slotRejected(const ItemInfo&, const QVariant& faceIdentifier)
523 {
524 QList<QVariant> faceList(faceIdentifier.toList());
525
526 if (faceList.size() == d->MaxFaceListSize)
527 {
528 FaceItem* const item = d->items[faceList[4].toInt()];
529 d->newEditPipeline->removeFace(d->info, item->face());
530
531 item->setFace(FaceTagsIface());
532 d->visibilityController->hideAndRemoveItem(item);
533
534 QTimer::singleShot(250, this, SLOT(slotFocusRandomFace()));
535 }
536 }
537
538 void FaceGroup::slotIgnored(const ItemInfo&, const QVariant& faceIdentifier)
539 {
540 QList<QVariant> faceList(faceIdentifier.toList());
541
542 if (faceList.size() == d->MaxFaceListSize)
543 {
544 FaceItem* const item = d->items[faceList[4].toInt()];
545 QRect faceRect = item->originalRect();
546 FaceTagsIface face(item->face());
547
548 if (!d->exifRotate)
549 {
550 TagRegion::adjustToOrientation(faceRect,
551 d->info.orientation(),
552 d->info.dimensions());
553 }
554
555 TagRegion currentRegion(faceRect);
556
557 face = d->newEditPipeline->editRegion(d->info, face,
558 currentRegion,
559 FaceTags::ignoredPersonTagId(), false);
560
561 item->setFace(face);
562 item->switchMode(AssignNameWidget::IgnoredMode);
563
564 QTimer::singleShot(250, this, SLOT(slotFocusRandomFace()));
565 }
566 }
567
568 void FaceGroup::slotLabelClicked(const ItemInfo&, const QVariant& faceIdentifier)
569 {
570 QList<QVariant> faceList(faceIdentifier.toList());
571
572 if (faceList.size() == d->MaxFaceListSize)
573 {
574 FaceItem* const item = d->items[faceList[4].toInt()];
575 item->switchMode(AssignNameWidget::ConfirmedEditMode);
576 }
577 }
578
579 void FaceGroup::slotIgnoredClicked(const ItemInfo&, const QVariant& faceIdentifier)
580 {
581 QList<QVariant> faceList(faceIdentifier.toList());
582
583 if (faceList.size() == d->MaxFaceListSize)
584 {
585 FaceItem* const item = d->items[faceList[4].toInt()];
586 item->switchMode(AssignNameWidget::UnconfirmedEditMode);
587 }
588 }
589
590 void FaceGroup::startAutoSuggest()
591 {
592 if (!d->autoSuggest)
593 {
594 return;
595 }
596 }
597
598 void FaceGroup::addFace()
599 {
600 if (d->manuallyAddWrapItem)
601 {
602 return;
603 }
604
605 d->manuallyAddWrapItem = new ClickDragReleaseItem(d->view->previewItem());
606 d->manuallyAddWrapItem->setFocus();
607 d->view->setFocus();
608
609 connect(d->manuallyAddWrapItem, SIGNAL(started(QPointF)),
610 this, SLOT(slotAddItemStarted(QPointF)));
611
612 connect(d->manuallyAddWrapItem, SIGNAL(moving(QRectF)),
613 this, SLOT(slotAddItemMoving(QRectF)));
614
615 connect(d->manuallyAddWrapItem, SIGNAL(finished(QRectF)),
616 this, SLOT(slotAddItemFinished(QRectF)));
617
618 connect(d->manuallyAddWrapItem, SIGNAL(cancelled()),
619 this, SLOT(slotCancelAddItem()));
620 }
621
622 void FaceGroup::slotAddItemStarted(const QPointF& pos)
623 {
624 Q_UNUSED(pos);
625 }
626
627 void FaceGroup::slotAddItemMoving(const QRectF& rect)
628 {
629 if (!d->manuallyAddedItem)
630 {
631 d->manuallyAddedItem = d->createItem(FaceTagsIface());
632 d->visibilityController->addItem(d->manuallyAddedItem);
633 d->visibilityController->showItem(d->manuallyAddedItem);
634 }
635
636 d->manuallyAddedItem->setRectInSceneCoordinatesAdjusted(rect);
637 }
638
639 void FaceGroup::slotAddItemFinished(const QRectF& rect)
640 {
641 if (d->manuallyAddedItem)
642 {
643 d->manuallyAddedItem->setRectInSceneCoordinatesAdjusted(rect);
644 QRect faceRect = d->manuallyAddedItem->originalRect();
645 DImg preview(d->view->previewItem()->image().copy());
646
647 if (!d->exifRotate)
648 {
649 TagRegion::adjustToOrientation(faceRect,
650 d->info.orientation(),
651 d->info.dimensions());
652 preview.rotateAndFlip(d->info.orientation());
653 }
654
655 TagRegion addRegion(faceRect);
656 FaceTagsIface face = d->newEditPipeline->addManually(d->info,
657 preview,
658 addRegion,
659 false);
660 FaceItem* const item = d->addItem(face);
661 d->visibilityController->setItemDirectlyVisible(item, true);
662 item->switchMode(AssignNameWidget::UnconfirmedEditMode);
663 d->manuallyAddWrapItem->stackBefore(item);
664 }
665
666 slotCancelAddItem();
667 }
668
669 void FaceGroup::slotCancelAddItem()
670 {
671 delete d->manuallyAddedItem;
672 d->manuallyAddedItem = nullptr;
673
674 if (d->manuallyAddWrapItem)
675 {
676 d->view->scene()->removeItem(d->manuallyAddWrapItem);
677 d->manuallyAddWrapItem->deleteLater();
678 d->manuallyAddWrapItem = nullptr;
679 }
680 }
681
682 void FaceGroup::applyItemGeometryChanges()
683 {
684 if (d->items.isEmpty())
685 {
686 return;
687 }
688
689 for (const FaceItem* const item : std::as_const(d->items))
690 {
691 if (item->face().isNull())
692 {
693 continue;
694 }
695
696 QRect faceRect = item->originalRect();
697
698 if (!d->exifRotate)
699 {
700 TagRegion::adjustToOrientation(faceRect,
701 d->info.orientation(),
702 d->info.dimensions());
703 }
704
705 TagRegion currentRegion(faceRect);
706
707 if (item->face().region() != currentRegion)
708 {
709 d->newEditPipeline->editRegion(d->info,
710 item->face(),
711 currentRegion, -1, false);
712 }
713 }
714 }
715
716 /*
717 void ItemPreviewView::trainFaces()
718 {
719 QList<Face> trainList;
720
721 for (Face f : std::as_const(d->currentFaces))
722 {
723 if (f.name() != "" && !d->faceIface->isFaceTrained(getItemInfo().id(), f.toRect(), f.name()))
724 {
725 trainList += f;
726 }
727 }
728
729 qCDebug(DIGIKAM_GENERAL_LOG) << "Number of training faces" << trainList.size();
730
731 if (trainList.size()!=0)
732 {
733 d->faceIface->trainWithFaces(trainList);
734 d->faceIface->markFacesAsTrained(getItemInfo().id(), trainList);
735 }
736 }
737
738 void ItemPreviewView::suggestFaces()
739 {
740 // Assign tentative names to the face list.
741
742 QList<Face> recogList;
743
744 for (Face f : std::as_const(d->currentFaces))
745 {
746 if (!d->faceIface->isFaceRecognized(getItemInfo().id(), f.toRect(), f.name()) && f.name().isEmpty())
747 {
748 f.setName(d->faceIface->recognizedName(f));
749 d->faceIface->markFaceAsRecognized(getItemInfo().id(), f.toRect(), f.name());
750
751 // If the face wasn't recognized (too distant) don't suggest anything.
752
753 if (f.name().isEmpty())
754 {
755 continue;
756 }
757 else
758 {
759 recogList += f;
760 }
761 }
762 }
763
764 qCDebug(DIGIKAM_GENERAL_LOG) << "Number of suggestions = " << recogList.size();
765 qCDebug(DIGIKAM_GENERAL_LOG) << "Number of faceitems = " << d->faceitems.size();
766
767 // Now find the relevant face items and suggest faces.
768
769 for (int i = 0 ; i < recogList.size() ; ++i)
770 {
771 for (int j = 0 ; j < d->faceitems.size() ; ++j)
772 {
773 if (recogList[i].toRect() == d->faceitems[j]->originalRect())
774 {
775 qCDebug(DIGIKAM_GENERAL_LOG) << "Suggesting a name " << recogList[i].name();
776 d->faceitems[j]->suggest(recogList[i].name());
777 break;
778 }
779 }
780 }
781 }
782 */
783
784 } // namespace Digikam
785
786 #include "moc_facegroup.cpp"