Risposte:
Sono il fondatore di Yorba, i produttori di Shotwell. Grazie per la tua domanda
Shotwell 0.7 scrive i metadati (come tag e titoli) sulle foto quando vengono esportati. I metadati sono scritti in formato EXIF, IPTC e / o XMP (a seconda di quale di questi era presente nella foto per cominciare). La maggior parte degli altri programmi fotografici può leggere questi formati, quindi se esporti le tue foto da Shotwell, altri programmi dovrebbero essere in grado di leggere i loro tag senza problemi.
Il prossimo Shotwell 0.8 può scrivere al volo metadati su file di foto - per abilitare ciò, seleziona l'opzione " Scrivi tag, titoli e altri metadati su file di foto " nella finestra di dialogo delle preferenze . Una volta selezionato, Shotwell aggiorna i metadati nei file di foto non appena vengono taggati. Per utilizzare questa funzione, crea il trunk Shotwell dal sorgente (vedi http://yorba.org/shotwell/install/#source ) o attendi semplicemente Shotwell 0.8 (che prevediamo di rilasciare più avanti a dicembre).
Purtroppo Shotwell sembra mantenere i tag nel proprio database piuttosto che incorporarli come exif, IPTC o XMP nelle immagini. Puoi controllare usando exiftool, che può essere installato installando il pacchetto libimage-exiftool-perl , disponibile nei repository.
usa il comando; exiftool testpicture.jpgper controllare una foto chiamata testpicture.jpg che avevi precedentemente taggato con Shotwell. Vedrai che l'output di exiftool non contiene tag Shotwell.
L'utilità exiftool può taggare le tue foto incorporando i tag nella foto e la cosa buona è che la maggior parte dei gestori di foto li userà, incluso Shotwell. Per esempio:
exiftool -keywords=favourite -keywords=family testpicture.jpg
Sostituisci l'elenco di parole chiave esistente con due nuove parole chiave (preferito e famiglia).
Quando testpicture.jpg viene importato in Shotwell, l'immagine verrà taggata con i preferiti e la famiglia
Potrebbe essere utile sapere che il database Shotwell è un database sqlite situato nel tuo; ~/.shotwell/datadirectory e di solito chiamato photo.db, puoi copiarlo da qualche altra parte sul tuo computer e accedervi con sqlite.
Ci sono alcuni frontend GUI per sqlite, ce n'è uno per Firefox qui oppure puoi usare sqliteman . Entrambi questi front-end hanno esportazione in funzionalità CSV; quando si esportano i tag in csv (valori separati da virgola) è possibile verificare se qualsiasi altro software di gestione delle foto importerà e mapperà i tag nel campo appropriato nei propri database. Credo che Digikam possa farlo. Digikam può anche incorporare dati exif nelle foto stesse.
Speriamo che quando Shotwell acquisirà più funzionalità questa situazione cambierà.
AGGIORNAMENTO: Mentre è vero che Shotwell 0.7 non memorizza i suoi tag nelle immagini mentre questi vengono creati, i tag possono essere incorporati nelle immagini se si sceglie di esportarli, grazie ad Adam per averlo chiarito. Speriamo che questa esportazione non abbia perdite quando si tratta di jpeg. Sospetto che lo sia, se si seleziona la dimensione originale per l'opzione Ridimensionamento nella finestra di dialogo di esportazione.
Codice python rapido (sporco?) Per farlo senza aggiornare Shotwell (penso che a partire da 0.8.x Shotwell può scrivere tag, ma non è possibile aggiornarlo su Lucid). Questa cosa scriverà le stelle come tag (commenta quel bit out, ovviamente, se non lo vuoi).
Richiede exiftool. Duplicherà tutti i tag che si trovano sia nel database di shotwell sia le immagini (ovvero quelle che Shotwell ha importato quando ha importato le immagini), quindi fai attenzione. Inoltre, ci vuole un po 'di tempo per una grande raccolta di foto.
import os
conn = sqlite3.connect("/home/ username /.shotwell/data/photo.db")
def get_tags():
return [ x[0] for x in conn.execute("SELECT name FROM TagTable").fetchall()]
def tag_query(tag):
return conn.execute("SELECT photo_id_list FROM TagTable WHERE name=?", (tag,)).fetchone()[0].split(",")
def get_tagged_photos(tag):
for id in tag_query(tag):
result = conn.execute("select filename from PhotoTable where id=?", (id,) ).fetchone()
if result:
yield result[0]
def get_photos_by_rating(rating):
return [photo[0] for photo in conn.execute("select filename from PhotoTable where rating=?",(rating,)).fetchall()]
def get_tagging_commands():
commands = []
for rating in range(1,5):
for photo in get_photos_by_rating(rating):
commands.append("exiftool -overwrite_original_in_place -preserve -keywords+=rating%d \"%s\""% (rating,photo))
for tag in [tag for tag in get_tags() if tag != "keep"]:
for photo in get_tagged_photos(tag):
commands.append("exiftool -overwrite_original_in_place -preserve -keywords+=%s \"%s\"" % (tag,photo))
return commands
commands = get_tagging_commands()
for command in commands:
print command
os.system(command)
Se vuoi un ottimo strumento / browser GUI che ti permetta di taggare le tue immagini usando i tag Exif (e quindi disponibile anche in Shotwell), ti consiglio jBrout .
Ho scritto di jBrout sul mio blog .
Per installarlo, vai su Synaptic, scegli impostazioni / repository, fai clic sulla scheda "Altro software", quindi premi il pulsante "Aggiungi" e incolla questa riga:
deb http://jbrout.free.fr/download/debian binary /
Quindi ricaricare e cercare jBrout.
Poiché ~/.shotwell/data/photo.dbviene identificato come photo.db: SQLite 3.x databasecomando file, ho usato SQLite Database Browser( sqlitebrowser) per aprirlo.
Hmmm ... puoi leggerlo :-) Ha la funzione di esportazione CVS.
Questo non è un normale approccio GUI ma c'è un modo.
Ho provato a usare lo script di user38122 per analizzare il database di shotwell e non ha funzionato. Apparentemente lo schema è stato modificato nelle ultime versioni. Invece ho scritto il seguente script che utilizza Panda (che personalmente preferisco scrivere in SQL) per fare intersezioni di tag. Nell'esempio seguente mostro tutte le immagini che hanno sia il tag 'cat' che il tag 'sleeping'.
#!/usr/bin/python
# An example of how to query the shotwell database with pandas
import sqlite3, pandas, os, time, datetime
con = sqlite3.connect('/home/dov/.local/share/shotwell/data/photo.db')
photo_df = pandas.read_sql("SELECT * from PhotoTable", con)
for c in ['exposure_time','timestamp','time_created']:
photo_df[c] = photo_df[c].map(datetime.datetime.fromtimestamp)
tag_df = pandas.read_sql('SELECT * from TagTable', con)
def get_image_ids(tag):
"""The image ids are stored morphed in the database as %016x"""
global tag_df
return set([int(s.replace('thumb',''),16)
for s in tag_df[tag_df.name==tag].photo_id_list.iloc[0].split(',')
if len(s)])
def get_photos(ids):
"""Get the photos for a list of ids"""
global photo_df
return photo_df[photo_df.id.isin(ids)].sort(['exposure_time'])
def view_pix(rows):
cmd = ('eog ' + ' '.join(['"%s"'%row.filename
for idx,row in rows.iterrows()]))
# print cmd
os.system(cmd)
print 'querying...'
# An example of how to create an intersection of two tags
ids1 = get_image_ids('cat')
ids2 = get_image_ids('sleeping')
rows = get_photos(ids1.intersection(ids2))
# An example of how to filter the rows by timestamp
time_low,time_high = datetime.datetime(2006,8,1),datetime.datetime(2009,1,1)
rows = rows[(rows.exposure_time > time_low)
& (rows.exposure_time < time_high)]
print '\n'.join([str(ts) for ts in rows['exposure_time']])
view_pix(rows)
print 'done'