e3bb8b19dd
Also improves migrations and updates the db schema docs. Signed-off-by: Michael Mayer <michael@photoprism.app>
715 lines
20 KiB
Go
715 lines
20 KiB
Go
package entity
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"math"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/dustin/go-humanize/english"
|
|
"github.com/jinzhu/gorm"
|
|
|
|
"github.com/photoprism/photoprism/internal/crop"
|
|
"github.com/photoprism/photoprism/internal/face"
|
|
"github.com/photoprism/photoprism/internal/form"
|
|
"github.com/photoprism/photoprism/pkg/clean"
|
|
"github.com/photoprism/photoprism/pkg/rnd"
|
|
)
|
|
|
|
const (
|
|
MarkerUnknown = ""
|
|
MarkerFace = "face" // MarkerType for faces (implemented).
|
|
MarkerLabel = "label" // MarkerType for labels (todo).
|
|
)
|
|
|
|
// Marker represents an image marker point.
|
|
type Marker struct {
|
|
MarkerUID string `gorm:"type:VARBINARY(42);primary_key;auto_increment:false;" json:"UID" yaml:"UID"`
|
|
FileUID string `gorm:"type:VARBINARY(42);index;default:'';" json:"FileUID" yaml:"FileUID"`
|
|
MarkerType string `gorm:"type:VARBINARY(8);default:'';" json:"Type" yaml:"Type"`
|
|
MarkerSrc string `gorm:"type:VARBINARY(8);default:'';" json:"Src" yaml:"Src,omitempty"`
|
|
MarkerName string `gorm:"type:VARCHAR(160);" json:"Name" yaml:"Name,omitempty"`
|
|
MarkerReview bool `json:"Review" yaml:"Review,omitempty"`
|
|
MarkerInvalid bool `json:"Invalid" yaml:"Invalid,omitempty"`
|
|
SubjUID string `gorm:"type:VARBINARY(42);index:idx_markers_subj_uid_src;" json:"SubjUID" yaml:"SubjUID,omitempty"`
|
|
SubjSrc string `gorm:"type:VARBINARY(8);index:idx_markers_subj_uid_src;default:'';" json:"SubjSrc" yaml:"SubjSrc,omitempty"`
|
|
subject *Subject `gorm:"foreignkey:SubjUID;association_foreignkey:SubjUID;association_autoupdate:false;association_autocreate:false;association_save_reference:false"`
|
|
FaceID string `gorm:"type:VARBINARY(64);index;" json:"FaceID" yaml:"FaceID,omitempty"`
|
|
FaceDist float64 `gorm:"default:-1;" json:"FaceDist" yaml:"FaceDist,omitempty"`
|
|
face *Face `gorm:"foreignkey:FaceID;association_foreignkey:ID;association_autoupdate:false;association_autocreate:false;association_save_reference:false"`
|
|
EmbeddingsJSON json.RawMessage `gorm:"type:MEDIUMBLOB;" json:"-" yaml:"EmbeddingsJSON,omitempty"`
|
|
embeddings face.Embeddings `gorm:"-"`
|
|
LandmarksJSON json.RawMessage `gorm:"type:MEDIUMBLOB;" json:"-" yaml:"LandmarksJSON,omitempty"`
|
|
X float32 `gorm:"type:FLOAT;" json:"X" yaml:"X,omitempty"`
|
|
Y float32 `gorm:"type:FLOAT;" json:"Y" yaml:"Y,omitempty"`
|
|
W float32 `gorm:"type:FLOAT;" json:"W" yaml:"W,omitempty"`
|
|
H float32 `gorm:"type:FLOAT;" json:"H" yaml:"H,omitempty"`
|
|
Q int `json:"Q" yaml:"Q,omitempty"`
|
|
Size int `gorm:"default:-1;" json:"Size" yaml:"Size,omitempty"`
|
|
Score int `gorm:"type:SMALLINT;" json:"Score" yaml:"Score,omitempty"`
|
|
Thumb string `gorm:"type:VARBINARY(128);index;default:'';" json:"Thumb" yaml:"Thumb,omitempty"`
|
|
MatchedAt *time.Time `sql:"index" json:"MatchedAt" yaml:"MatchedAt,omitempty"`
|
|
CreatedAt time.Time
|
|
UpdatedAt time.Time
|
|
}
|
|
|
|
// TableName returns the entity table name.
|
|
func (Marker) TableName() string {
|
|
return "markers"
|
|
}
|
|
|
|
// BeforeCreate creates a random UID if needed before inserting a new row to the database.
|
|
func (m *Marker) BeforeCreate(scope *gorm.Scope) error {
|
|
if rnd.IsUnique(m.MarkerUID, 'm') {
|
|
return nil
|
|
}
|
|
|
|
return scope.SetColumn("MarkerUID", rnd.GenerateUID('m'))
|
|
}
|
|
|
|
// NewMarker creates a new entity.
|
|
func NewMarker(file File, area crop.Area, subjUID, markerSrc, markerType string, size, score int) *Marker {
|
|
if file.FileHash == "" {
|
|
log.Errorf("markers: file hash is empty - possible bug")
|
|
return nil
|
|
}
|
|
|
|
m := &Marker{
|
|
FileUID: file.FileUID,
|
|
MarkerSrc: markerSrc,
|
|
MarkerType: markerType,
|
|
MarkerReview: score < 30,
|
|
MarkerInvalid: false,
|
|
SubjUID: subjUID,
|
|
FaceDist: -1,
|
|
X: area.X,
|
|
Y: area.Y,
|
|
W: area.W,
|
|
H: area.H,
|
|
Q: int(float32(math.Log(float64(score))) * float32(size) * area.W),
|
|
Size: size,
|
|
Score: score,
|
|
Thumb: area.Thumb(file.FileHash),
|
|
MatchedAt: nil,
|
|
}
|
|
|
|
return m
|
|
}
|
|
|
|
// NewFaceMarker creates a new entity.
|
|
func NewFaceMarker(f face.Face, file File, subjUid string) *Marker {
|
|
m := NewMarker(file, f.CropArea(), subjUid, SrcImage, MarkerFace, f.Size(), f.Score)
|
|
|
|
// RunFailed creating new marker?
|
|
if m == nil {
|
|
return nil
|
|
}
|
|
|
|
m.SetEmbeddings(f.Embeddings)
|
|
m.LandmarksJSON = f.RelativeLandmarksJSON()
|
|
|
|
return m
|
|
}
|
|
|
|
// SetEmbeddings assigns new face emebddings to the marker.
|
|
func (m *Marker) SetEmbeddings(e face.Embeddings) {
|
|
m.embeddings = e
|
|
m.EmbeddingsJSON = e.JSON()
|
|
}
|
|
|
|
// UpdateFile sets the file uid and thumb and updates the index if the marker already exists.
|
|
func (m *Marker) UpdateFile(file *File) (updated bool) {
|
|
if file.FileUID != "" && m.FileUID != file.FileUID {
|
|
m.FileUID = file.FileUID
|
|
updated = true
|
|
}
|
|
|
|
if file.FileHash != "" && !strings.HasPrefix(m.Thumb, file.FileHash) {
|
|
m.Thumb = crop.NewArea("crop", m.X, m.Y, m.W, m.H).Thumb(file.FileHash)
|
|
updated = true
|
|
}
|
|
|
|
if !updated || m.MarkerUID == "" {
|
|
return false
|
|
} else if err := UnscopedDb().Model(m).UpdateColumns(Values{"file_uid": m.FileUID, "thumb": m.Thumb}).Error; err != nil {
|
|
log.Errorf("faces: failed assigning marker %s to file %s (%s)", m.MarkerUID, m.FileUID, err)
|
|
return false
|
|
} else {
|
|
return true
|
|
}
|
|
}
|
|
|
|
// Updates multiple columns in the database.
|
|
func (m *Marker) Updates(values interface{}) error {
|
|
return UnscopedDb().Model(m).Updates(values).Error
|
|
}
|
|
|
|
// Update updates a column in the database.
|
|
func (m *Marker) Update(attr string, value interface{}) error {
|
|
return UnscopedDb().Model(m).Update(attr, value).Error
|
|
}
|
|
|
|
// SetName changes the marker name.
|
|
func (m *Marker) SetName(name, src string) (changed bool, err error) {
|
|
if src == SrcAuto || SrcPriority[src] < SrcPriority[m.SubjSrc] {
|
|
return false, nil
|
|
}
|
|
|
|
name = clean.Name(name)
|
|
|
|
if name == "" {
|
|
return false, nil
|
|
}
|
|
|
|
if m.MarkerName == name {
|
|
// Name didn't change.
|
|
return false, nil
|
|
}
|
|
|
|
m.SubjSrc = src
|
|
m.MarkerName = name
|
|
|
|
return true, m.SyncSubject(true)
|
|
}
|
|
|
|
// SaveForm updates the entity using form data and stores it in the database.
|
|
func (m *Marker) SaveForm(f form.Marker) (changed bool, err error) {
|
|
if m.MarkerInvalid != f.MarkerInvalid {
|
|
m.MarkerInvalid = f.MarkerInvalid
|
|
changed = true
|
|
}
|
|
|
|
if m.MarkerReview != f.MarkerReview {
|
|
m.MarkerReview = f.MarkerReview
|
|
changed = true
|
|
}
|
|
|
|
if nameChanged, err := m.SetName(f.MarkerName, f.SubjSrc); err != nil {
|
|
return changed, err
|
|
} else if nameChanged {
|
|
changed = true
|
|
}
|
|
|
|
if changed {
|
|
return changed, m.Save()
|
|
}
|
|
|
|
return changed, nil
|
|
}
|
|
|
|
// HasFace tests if the marker already has the best matching face.
|
|
func (m *Marker) HasFace(f *Face, dist float64) bool {
|
|
if m.FaceID == "" {
|
|
return false
|
|
} else if f == nil {
|
|
return m.FaceID != ""
|
|
} else if m.FaceID == f.ID {
|
|
return m.FaceID != ""
|
|
} else if m.FaceDist < 0 {
|
|
return false
|
|
} else if dist < 0 {
|
|
return true
|
|
}
|
|
|
|
return m.FaceDist <= dist
|
|
}
|
|
|
|
// SetFace sets a new face for this marker.
|
|
func (m *Marker) SetFace(f *Face, dist float64) (updated bool, err error) {
|
|
if f == nil {
|
|
return false, fmt.Errorf("face is nil")
|
|
}
|
|
|
|
if m.MarkerType != MarkerFace {
|
|
return false, fmt.Errorf("not a face marker")
|
|
}
|
|
|
|
// Any reason we don't want to set a new face for this marker?
|
|
if m.SubjSrc == SrcAuto || f.SubjUID == "" || m.SubjUID == "" || f.SubjUID == m.SubjUID {
|
|
// Don't skip if subject wasn't set manually, or subjects match.
|
|
} else if reported, err := f.ResolveCollision(m.Embeddings()); err != nil {
|
|
return false, err
|
|
} else if reported {
|
|
log.Warnf("faces: marker %s face %s has ambiguous subjects %s <> %s, subject source %s", clean.Log(m.MarkerUID), clean.Log(f.ID), clean.Log(m.SubjUID), clean.Log(f.SubjUID), SrcString(m.SubjSrc))
|
|
return false, nil
|
|
} else {
|
|
return false, nil
|
|
}
|
|
|
|
// Update face with known subject from marker?
|
|
if m.SubjSrc == SrcAuto || m.SubjUID == "" || f.SubjUID != "" {
|
|
// Don't update if face has a known subject, or marker subject is unknown.
|
|
} else if err = f.SetSubjectUID(m.SubjUID); err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// Set face.
|
|
m.face = f
|
|
|
|
// Skip update if the same face is already set.
|
|
if m.SubjUID == f.SubjUID && m.FaceID == f.ID {
|
|
// Update matching timestamp.
|
|
m.MatchedAt = TimePointer()
|
|
return false, m.Updates(Values{"MatchedAt": m.MatchedAt})
|
|
}
|
|
|
|
// Remember current values for comparison.
|
|
faceID := m.FaceID
|
|
subjUID := m.SubjUID
|
|
subjSrc := m.SubjSrc
|
|
|
|
m.FaceID = f.ID
|
|
m.FaceDist = dist
|
|
|
|
if m.FaceDist < 0 {
|
|
faceEmbedding := f.Embedding()
|
|
|
|
// Calculate the smallest distance to embeddings.
|
|
for _, e := range m.Embeddings() {
|
|
if len(e) != len(faceEmbedding) {
|
|
continue
|
|
}
|
|
|
|
if d := e.Dist(faceEmbedding); d < m.FaceDist || m.FaceDist < 0 {
|
|
m.FaceDist = d
|
|
}
|
|
}
|
|
}
|
|
|
|
if f.SubjUID != "" {
|
|
m.SubjUID = f.SubjUID
|
|
}
|
|
|
|
if err = m.SyncSubject(false); err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// Update face subject?
|
|
if m.SubjSrc == SrcAuto || m.SubjUID == "" || f.SubjUID == m.SubjUID {
|
|
// Not needed.
|
|
} else if err = f.SetSubjectUID(m.SubjUID); err != nil {
|
|
return false, err
|
|
}
|
|
|
|
updated = m.FaceID != faceID || m.SubjUID != subjUID || m.SubjSrc != subjSrc
|
|
|
|
// Update matching timestamp.
|
|
m.MatchedAt = TimePointer()
|
|
|
|
if err := m.Updates(Values{"FaceID": m.FaceID, "FaceDist": m.FaceDist, "SubjUID": m.SubjUID, "SubjSrc": m.SubjSrc, "MarkerReview": false, "MatchedAt": m.MatchedAt}); err != nil {
|
|
return false, err
|
|
} else if !updated {
|
|
return false, nil
|
|
}
|
|
|
|
return true, m.RefreshPhotos()
|
|
}
|
|
|
|
// SyncSubject maintains the marker subject relationship.
|
|
func (m *Marker) SyncSubject(updateRelated bool) (err error) {
|
|
// Face marker? If not, return.
|
|
if m.MarkerType != MarkerFace {
|
|
return nil
|
|
}
|
|
|
|
subj := m.Subject()
|
|
|
|
if subj == nil || m.SubjSrc == SrcAuto {
|
|
return nil
|
|
}
|
|
|
|
// Update subject with marker name?
|
|
if m.MarkerName == "" || subj.SubjName == m.MarkerName {
|
|
// Do nothing.
|
|
} else if subj, err = subj.UpdateName(m.MarkerName); err != nil {
|
|
return err
|
|
} else if subj != nil {
|
|
// Update subject fields in case it was merged.
|
|
m.subject = subj
|
|
m.SubjUID = subj.SubjUID
|
|
m.MarkerName = subj.SubjName
|
|
}
|
|
|
|
// Create known face for subject?
|
|
if m.FaceID != "" {
|
|
// Do nothing.
|
|
} else if f := m.Face(); f != nil {
|
|
m.FaceID = f.ID
|
|
}
|
|
|
|
// Update related markers?
|
|
if m.FaceID == "" || m.SubjUID == "" {
|
|
// Do nothing.
|
|
} else if res := Db().Model(&Face{}).Where("id = ? AND subj_uid = ''", m.FaceID).UpdateColumn("subj_uid", m.SubjUID); res.Error != nil {
|
|
return fmt.Errorf("%s (update known face)", err)
|
|
} else if !updateRelated {
|
|
return nil
|
|
} else if err := Db().Model(&Marker{}).
|
|
Where("marker_uid <> ?", m.MarkerUID).
|
|
Where("face_id = ?", m.FaceID).
|
|
Where("subj_src = ?", SrcAuto).
|
|
Where("subj_uid <> ?", m.SubjUID).
|
|
UpdateColumns(Values{"subj_uid": m.SubjUID, "subj_src": SrcAuto, "marker_review": false}).Error; err != nil {
|
|
return fmt.Errorf("%s (update related markers)", err)
|
|
} else if res.RowsAffected > 0 && m.face != nil {
|
|
log.Debugf("markers: matched %s with %s", subj.SubjName, m.FaceID)
|
|
return m.face.RefreshPhotos()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// InvalidArea tests if the marker area is invalid or out of range.
|
|
func (m *Marker) InvalidArea() error {
|
|
if m.MarkerType != MarkerFace {
|
|
return nil
|
|
}
|
|
|
|
// Ok?
|
|
if false == (m.X > 1 || m.Y > 1 || m.X < 0 || m.Y < 0 || m.W <= 0 || m.H <= 0 || m.W > 1 || m.H > 1) {
|
|
return nil
|
|
}
|
|
|
|
return fmt.Errorf("invalid %s crop area x=%d%% y=%d%% w=%d%% h=%d%%", TypeString(m.MarkerType), int(m.X*100), int(m.Y*100), int(m.W*100), int(m.H*100))
|
|
}
|
|
|
|
// Save updates the record in the database or inserts a new record if it does not already exist.
|
|
func (m *Marker) Save() error {
|
|
if err := m.InvalidArea(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return Db().Save(m).Error
|
|
}
|
|
|
|
// Create inserts a new row to the database.
|
|
func (m *Marker) Create() error {
|
|
if err := m.InvalidArea(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return Db().Create(m).Error
|
|
}
|
|
|
|
// Embeddings returns parsed marker embeddings.
|
|
func (m *Marker) Embeddings() face.Embeddings {
|
|
if len(m.EmbeddingsJSON) == 0 {
|
|
return face.Embeddings{}
|
|
} else if len(m.embeddings) > 0 {
|
|
return m.embeddings
|
|
} else if err := json.Unmarshal(m.EmbeddingsJSON, &m.embeddings); err != nil {
|
|
log.Errorf("markers: %s while parsing embeddings json", err)
|
|
}
|
|
|
|
return m.embeddings
|
|
}
|
|
|
|
// SubjectName returns the matching subject's name.
|
|
func (m *Marker) SubjectName() string {
|
|
if m.MarkerName != "" {
|
|
return m.MarkerName
|
|
} else if s := m.Subject(); s != nil {
|
|
return s.SubjName
|
|
}
|
|
|
|
return ""
|
|
}
|
|
|
|
// Subject returns the matching subject or nil.
|
|
func (m *Marker) Subject() (subj *Subject) {
|
|
if m.subject != nil {
|
|
if m.SubjUID == m.subject.SubjUID {
|
|
return m.subject
|
|
}
|
|
}
|
|
|
|
// Create subject?
|
|
if m.SubjSrc != SrcAuto && m.MarkerName != "" && m.SubjUID == "" {
|
|
if subj = NewSubject(m.MarkerName, SubjPerson, m.SubjSrc); subj == nil {
|
|
log.Errorf("faces: marker %s has invalid subject %s", clean.Log(m.MarkerUID), clean.Log(m.MarkerName))
|
|
return nil
|
|
} else if subj = FirstOrCreateSubject(subj); subj == nil {
|
|
log.Debugf("faces: marker %s has invalid subject %s", clean.Log(m.MarkerUID), clean.Log(m.MarkerName))
|
|
return nil
|
|
} else {
|
|
m.subject = subj
|
|
m.SubjUID = subj.SubjUID
|
|
}
|
|
|
|
return m.subject
|
|
}
|
|
|
|
m.subject = FindSubject(m.SubjUID)
|
|
|
|
return m.subject
|
|
}
|
|
|
|
// ClearSubject removes an existing subject association, and reports a collision.
|
|
func (m *Marker) ClearSubject(src string) error {
|
|
// Find the matching face.
|
|
if m.face == nil {
|
|
m.face = FindFace(m.FaceID)
|
|
}
|
|
|
|
defer func() {
|
|
// Find and (soft) delete unused subjects.
|
|
start := time.Now()
|
|
if count, err := DeleteOrphanPeople(); err != nil {
|
|
log.Errorf("faces: %s while clearing subject of marker %s [%s]", err, clean.Log(m.MarkerUID), time.Since(start))
|
|
} else if count > 0 {
|
|
log.Debugf("faces: %s marked as missing while clearing subject of marker %s [%s]", english.Plural(count, "person", "people"), clean.Log(m.MarkerUID), time.Since(start))
|
|
}
|
|
}()
|
|
|
|
// Update index & resolve collisions.
|
|
if err := m.Updates(Values{"MarkerName": "", "FaceID": "", "FaceDist": -1.0, "SubjUID": "", "SubjSrc": src}); err != nil {
|
|
return err
|
|
} else if m.face == nil {
|
|
m.subject = nil
|
|
return nil
|
|
} else if resolved, err := m.face.ResolveCollision(m.Embeddings()); err != nil {
|
|
return err
|
|
} else if resolved {
|
|
log.Debugf("faces: marker %s resolved ambiguous subjects for face %s", clean.Log(m.MarkerUID), clean.Log(m.face.ID))
|
|
}
|
|
|
|
// Clear references.
|
|
m.face = nil
|
|
m.subject = nil
|
|
|
|
return nil
|
|
}
|
|
|
|
// Face returns a matching face entity if possible.
|
|
func (m *Marker) Face() (f *Face) {
|
|
if m.MarkerUID == "" {
|
|
log.Debugf("markers: cannot find face when uid is empty")
|
|
return nil
|
|
}
|
|
|
|
if m.face != nil {
|
|
if m.FaceID == m.face.ID {
|
|
return m.face
|
|
}
|
|
}
|
|
|
|
// Add face if size
|
|
if m.SubjSrc != SrcAuto && m.FaceID == "" {
|
|
if m.Size < face.ClusterSizeThreshold || m.Score < face.ClusterScoreThreshold {
|
|
log.Debugf("faces: marker %s skipped adding face due to low-quality (size %d, score %d)", clean.Log(m.MarkerUID), m.Size, m.Score)
|
|
return nil
|
|
}
|
|
|
|
if emb := m.Embeddings(); emb.Empty() {
|
|
log.Warnf("faces: marker %s has no face embeddings", clean.Log(m.MarkerUID))
|
|
return nil
|
|
} else if f = NewFace(m.SubjUID, m.SubjSrc, emb); f == nil {
|
|
log.Warnf("faces: failed assigning face to marker %s", clean.Log(m.MarkerUID))
|
|
return nil
|
|
} else if f.SkipMatching() {
|
|
log.Infof("faces: skipped matching marker %s, embedding %s not distinct enough", clean.Log(m.MarkerUID), f.ID)
|
|
} else if f = FirstOrCreateFace(f); f == nil {
|
|
log.Warnf("faces: failed matching marker %s with subject %s", clean.Log(m.MarkerUID), SubjNames.Log(m.SubjUID))
|
|
return nil
|
|
} else if err := f.MatchMarkers(Faceless); err != nil {
|
|
log.Errorf("faces: failed matching marker %s with subject %s (%s)", clean.Log(m.MarkerUID), SubjNames.Log(m.SubjUID), err)
|
|
}
|
|
|
|
m.face = f
|
|
m.FaceID = f.ID
|
|
m.FaceDist = 0
|
|
} else {
|
|
m.face = FindFace(m.FaceID)
|
|
}
|
|
|
|
return m.face
|
|
}
|
|
|
|
// ClearFace removes an existing face association.
|
|
func (m *Marker) ClearFace() (updated bool, err error) {
|
|
if m.FaceID == "" {
|
|
return false, m.Matched()
|
|
}
|
|
|
|
updated = true
|
|
|
|
// Remove face references.
|
|
m.face = nil
|
|
m.FaceID = ""
|
|
m.MatchedAt = TimePointer()
|
|
|
|
// Remove subject if set automatically.
|
|
if m.SubjSrc == SrcAuto {
|
|
m.SubjUID = ""
|
|
err = m.Updates(Values{"FaceID": "", "FaceDist": -1.0, "SubjUID": "", "MatchedAt": m.MatchedAt})
|
|
} else {
|
|
err = m.Updates(Values{"FaceID": "", "FaceDist": -1.0, "MatchedAt": m.MatchedAt})
|
|
}
|
|
|
|
return updated, m.RefreshPhotos()
|
|
}
|
|
|
|
// RefreshPhotos flags related photos for metadata maintenance.
|
|
func (m *Marker) RefreshPhotos() error {
|
|
if m.MarkerUID == "" {
|
|
return fmt.Errorf("empty marker uid")
|
|
}
|
|
|
|
var err error
|
|
switch DbDialect() {
|
|
case MySQL:
|
|
err = UnscopedDb().Exec(`UPDATE photos p JOIN files f ON f.photo_id = p.id
|
|
JOIN ? m ON m.file_uid = f.file_uid SET p.checked_at = NULL
|
|
WHERE m.marker_uid = ?`,
|
|
gorm.Expr(Marker{}.TableName()), m.MarkerUID).Error
|
|
default:
|
|
err = UnscopedDb().Exec(`UPDATE photos SET checked_at = NULL WHERE id IN
|
|
(SELECT f.photo_id FROM files f JOIN ? m ON m.file_uid = f.file_uid
|
|
WHERE m.marker_uid = ? GROUP BY f.photo_id)`,
|
|
gorm.Expr(Marker{}.TableName()), m.MarkerUID).Error
|
|
}
|
|
return err
|
|
}
|
|
|
|
// Matched updates the match timestamp.
|
|
func (m *Marker) Matched() error {
|
|
m.MatchedAt = TimePointer()
|
|
return UnscopedDb().Model(m).UpdateColumns(Values{"MatchedAt": m.MatchedAt}).Error
|
|
}
|
|
|
|
// Top returns the top Y coordinate as float64.
|
|
func (m *Marker) Top() float64 {
|
|
return float64(m.Y)
|
|
}
|
|
|
|
// Left returns the left X coordinate as float64.
|
|
func (m *Marker) Left() float64 {
|
|
return float64(m.X)
|
|
}
|
|
|
|
// Right returns the right X coordinate as float64.
|
|
func (m *Marker) Right() float64 {
|
|
return float64(m.X + m.W)
|
|
}
|
|
|
|
// Bottom returns the bottom Y coordinate as float64.
|
|
func (m *Marker) Bottom() float64 {
|
|
return float64(m.Y + m.H)
|
|
}
|
|
|
|
// Surface returns the surface area.
|
|
func (m *Marker) Surface() float64 {
|
|
return float64(m.W * m.H)
|
|
}
|
|
|
|
// SurfaceRatio returns the surface ratio.
|
|
func (m *Marker) SurfaceRatio(area float64) float64 {
|
|
if area <= 0 {
|
|
return 0
|
|
}
|
|
|
|
if s := m.Surface(); s <= 0 {
|
|
return 0
|
|
} else if area > s {
|
|
return s / area
|
|
} else {
|
|
return area / s
|
|
}
|
|
}
|
|
|
|
// Overlap calculates the overlap of two markers.
|
|
func (m *Marker) Overlap(marker Marker) (x, y float64) {
|
|
x = math.Max(0, math.Min(m.Right(), marker.Right())-math.Max(m.Left(), marker.Left()))
|
|
y = math.Max(0, math.Min(m.Bottom(), marker.Bottom())-math.Max(m.Top(), marker.Top()))
|
|
|
|
return x, y
|
|
}
|
|
|
|
// OverlapArea calculates the overlap area of two markers.
|
|
func (m *Marker) OverlapArea(marker Marker) (area float64) {
|
|
x, y := m.Overlap(marker)
|
|
|
|
return x * y
|
|
}
|
|
|
|
// OverlapPercent calculates the overlap ratio of two markers in percent.
|
|
func (m *Marker) OverlapPercent(marker Marker) int {
|
|
return int(math.Round(marker.SurfaceRatio(m.OverlapArea(marker)) * 100))
|
|
}
|
|
|
|
// Unsaved tests if the marker hasn't been saved yet.
|
|
func (m *Marker) Unsaved() bool {
|
|
return m.MarkerUID == "" || m.CreatedAt.IsZero()
|
|
}
|
|
|
|
// ValidFace tests if the marker is a valid face.
|
|
func (m *Marker) ValidFace() bool {
|
|
return m.MarkerType == MarkerFace && !m.MarkerInvalid
|
|
}
|
|
|
|
// DetectedFace tests if the marker is an automatically detected face.
|
|
func (m *Marker) DetectedFace() bool {
|
|
return m.MarkerType == MarkerFace && m.MarkerSrc == SrcImage
|
|
}
|
|
|
|
// Uncertainty returns the detection uncertainty based on the score in percent.
|
|
func (m *Marker) Uncertainty() int {
|
|
switch {
|
|
case m.Score > 300:
|
|
return 1
|
|
case m.Score > 200:
|
|
return 5
|
|
case m.Score > 100:
|
|
return 10
|
|
case m.Score > 80:
|
|
return 15
|
|
case m.Score > 65:
|
|
return 20
|
|
case m.Score > 50:
|
|
return 25
|
|
case m.Score > 40:
|
|
return 30
|
|
case m.Score > 30:
|
|
return 35
|
|
case m.Score > 20:
|
|
return 40
|
|
case m.Score > 10:
|
|
return 45
|
|
}
|
|
|
|
return 50
|
|
}
|
|
|
|
// FindMarker returns an existing row if exists.
|
|
func FindMarker(markerUid string) *Marker {
|
|
if markerUid == "" {
|
|
return nil
|
|
}
|
|
|
|
var result Marker
|
|
|
|
if err := Db().Where("marker_uid = ?", markerUid).First(&result).Error; err != nil {
|
|
return nil
|
|
}
|
|
|
|
return &result
|
|
}
|
|
|
|
// CreateMarkerIfNotExists updates a marker in the database or creates a new one if needed.
|
|
func CreateMarkerIfNotExists(m *Marker) (*Marker, error) {
|
|
result := Marker{}
|
|
|
|
if m.MarkerUID != "" {
|
|
return m, nil
|
|
} else if Db().Where("file_uid = ? AND marker_type = ? AND thumb = ?", m.FileUID, m.MarkerType, m.Thumb).
|
|
First(&result).Error == nil {
|
|
return &result, nil
|
|
} else if err := m.Create(); err != nil {
|
|
return m, err
|
|
} else {
|
|
log.Debugf("markers: added %s %s for file %s", TypeString(m.MarkerType), clean.Log(m.MarkerUID), clean.Log(m.FileUID))
|
|
}
|
|
|
|
return m, nil
|
|
}
|