[EMAIL PROTECTED], 2008-10-14 09:50:35 +0200 :
> I would like to use f-spot to just import the pictures from an
> inserted memory stick into the database without any user interaction
> and graphical ui from the command line (headless
> system). Unfortunately, I have not found any information on how to
> do this e.g. with f-spot-import nor a documentation of available
> command line parameters that could be helpful.
>
> Does f-spot support such kind of batch import, at all, and is there
> a documentation somewhere?
I have an importer script that tries to do that. I used to do it in
Perl by accessing the database directly, but I rewrote it in C# to
make use of the F-Spot classes, so I don't have to care about the
database schema any more. Unfortunately, there is a drawback: part of
the code in F-Spot assumes that there's an X11 server running and
available, so although the program is runnable through the command
line with no GUI, it still needs to be run under X to work.
Old script can be found at
http://roland.entierement.nu/pages/sync-digicams.html, my new importer
is below (beware: it needs F-Spot to be patched with
http://bugzilla.gnome.org/show_bug.cgi?id=507919).
// Download pictures from a camera and import the files into F-Spot,
non-interactively
// Roland Mas <[EMAIL PROTECTED]>
// Based on code from F-Spot by Larry Ewing and others
using System;
using System.IO;
using System.Collections;
using FSpot;
using FSpot.Utils;
using Gdk;
using Mono.GetOptions;
namespace camsync2 {
struct Config {
public string camera;
public string tagname;
public string rawtagname;
public string destdir;
public string camera_name;
public int max_remaining ;
}
class MainClass {
static Tag tag;
static Tag rawtag;
static Config config ;
static Roll roll ;
static void ReadOptions (string[] args) {
CamsyncOptions options = new CamsyncOptions ();
options.ProcessArgs (args);
options.Validate();
string configfile = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
"camsync.conf");
if (options.config != null) {
configfile = options.config ;
}
Nini.Config.IConfigSource configsource = new
Nini.Config.IniConfigSource (configfile);
config.camera =
configsource.Configs["default"].Get("default_camera");
if (options.camera != null)
config.camera = options.camera ;
if (config.camera == null) {
Console.WriteLine("No camera specified,
exiting");
Environment.Exit (1);
}
Console.WriteLine ("Default camera : {0}",
config.camera);
if (options.tagname != null) {
config.tagname = options.tagname ;
} else if
(configsource.Configs[config.camera].Get("tag_name") != null) {
config.tagname =
configsource.Configs[config.camera].Get("tag_name") ;
} else if
(configsource.Configs["default"].Get("tag_name") != null) {
config.tagname =
configsource.Configs["default"].Get("tag_name") ;
} else {
Console.WriteLine("No tag specified, exiting");
Environment.Exit (1);
}
if (options.rawtagname != null) {
config.rawtagname = options.rawtagname ;
} else if
(configsource.Configs[config.camera].Get("raw_tag_name") != null) {
config.rawtagname =
configsource.Configs[config.camera].Get("raw_tag_name") ;
} else if
(configsource.Configs["default"].Get("raw_tag_name") != null) {
config.rawtagname =
configsource.Configs["default"].Get("raw_tag_name") ;
} else {
config.rawtagname = config.tagname ;
}
if (options.camera_name != null) {
config.camera_name = options.camera_name ;
} else if
(configsource.Configs[config.camera].Get("camera_name") != null) {
config.camera_name =
configsource.Configs[config.camera].Get("camera_name") ;
} else if
(configsource.Configs["default"].Get("camera_name") != null) {
config.camera_name =
configsource.Configs["default"].Get("camera_name") ;
} else {
Console.WriteLine("No camera name found,
exiting");
Environment.Exit (1);
}
if (options.destdir != null) {
config.destdir = options.destdir ;
} else if
(configsource.Configs[config.camera].Get("destination_dir") != null) {
config.destdir =
configsource.Configs[config.camera].Get("destination_dir") ;
} else if
(configsource.Configs["default"].Get("destination_dir") != null) {
config.destdir =
configsource.Configs["default"].Get("destination_dir") ;
} else {
Console.WriteLine("No destination directory
found, exiting");
Environment.Exit (1);
}
if (options.max_remaining != 0) {
config.max_remaining = options.max_remaining ;
} else if
(configsource.Configs[config.camera].GetInt("max_remaining") != 0) {
config.max_remaining =
configsource.Configs[config.camera].GetInt("max_remaining") ;
} else if
(configsource.Configs["default"].GetInt("max_remaining") != 0) {
config.max_remaining =
configsource.Configs["default"].GetInt("max_remaining") ;
} else {
config.max_remaining = 0 ;
}
}
static void RegisterPhoto(Uri uri) {
Pixbuf thumb ;
Photo photo = Core.Database.Photos.GetByUri(uri);
if (photo == null) {
if (roll == null) {
roll = Core.Database.Rolls.Create();
}
Console.WriteLine("Registering URI \"{0}\"",
uri);
photo = Core.Database.Photos.Create(uri,
roll.Id, out thumb);
photo.AddTag (tag) ;
if (ImageFile.IsRaw(uri.LocalPath)) {
photo.AddTag (rawtag) ;
}
Core.Database.Photos.Commit(photo);
Core.Database.Tags.Commit(tag);
Core.Database.Tags.Commit(rawtag);
} else {
// Console.WriteLine("URI \"{0}\" already
registered", uri);
}
}
public static void Main(string[] args) {
ReadOptions (args);
Console.WriteLine("Starting up");
Gtk.Application.Init();
Console.WriteLine("{0} photos currently registered in
database", Core.Database.Photos.TotalPhotos);
Console.WriteLine("Got here");
tag = Core.Database.Tags.GetTagByName (config.tagname);
if (tag == null) {
Console.WriteLine("No tag \"{0}\" found,
exiting", config.tagname);
return ;
}
rawtag = Core.Database.Tags.GetTagByName
(config.rawtagname);
if (rawtag == null) {
Console.WriteLine("No tag \"{0}\" found,
exiting", config.rawtagname);
return ;
}
Gnome.Vfs.Vfs.Initialize ();
Core.Database.Sync = true ;
GPhotoCamera cam = new GPhotoCamera ();
cam.DetectCameras ();
Console.WriteLine ("Found {0} cameras",
cam.CameraList.Count ()) ;
bool camera_found = false ;
int cam_id = 0 ;
while ((! camera_found)
&& (cam_id < cam.CameraList.Count ())) {
string camera_name =
cam.CameraList.GetName(cam_id);
if (camera_name.Equals(config.camera_name)) {
Console.WriteLine("Found camera \"{0}\"
at rank {1}", camera_name, cam_id);
cam.SelectCamera(cam_id);
camera_found = true ;
cam.InitializeCamera();
foreach (GPhotoCameraFile f in
cam.FileList) {
int file_id =
cam.FileList.IndexOf (f) ;
string destfile =
config.destdir + f.Directory + f.FileName ;
string dir =
Path.GetDirectoryName (destfile) ;
if (!Directory.Exists (dir)) {
Directory.CreateDirectory (dir) ;
}
if (File.Exists (destfile)) {
//
Console.WriteLine("File \"{0}\" already exists", destfile);
} else {
Console.WriteLine
("Saving file {0} as {1}", file_id, destfile) ;
cam.SaveFile(file_id,
destfile);
}
Uri uri =
UriUtils.PathToFileUri (destfile);
RegisterPhoto (uri);
}
Console.WriteLine ("{0} files on
camera", cam.FileList.Count);
if (config.max_remaining > 0) {
for (int file_id = 0 ; file_id
< cam.FileList.Count - config.max_remaining ; file_id++) {
Console.WriteLine
("Deleting {0}", file_id) ;
cam.DeleteFile
(file_id) ;
}
}
cam.ReleaseGPhotoResources () ;
break ;
} else {
Console.WriteLine("Found other camera
\"{0}\" at rank {1}", camera_name, cam_id);
}
cam_id++ ;
}
if (! camera_found) {
Console.WriteLine("Camera not found");
}
int tmp = Core.Database.Photos.TotalPhotos;
Console.WriteLine("{0} photos currently registered in
database", tmp);
Console.WriteLine("Done");
Environment.Exit (0);
}
}
public class CamsyncOptions : Options {
//--config, -f
[Option ("use configuration file", 'f', "config")]
public string config;
//--camera, -c
[Option ("import from the given camera", 'c', "camera")]
public string camera;
//--destdir, -d
[Option ("base directory for destination files", 'd',
"destdir")]
public string destdir;
//--tag, -t
[Option ("tag name", 't', "tag")]
public string tagname;
//--rawtag, -r
[Option ("raw tag name", 'r', "rawtag")]
public string rawtagname;
//--camera-name, -n
[Option ("camera name", 'n', "camera-name")]
public string camera_name;
//--max-remaining, -m
[Option ("maximum number of photos to keep", 'm',
"max-remaining")]
public int max_remaining;
public CamsyncOptions () {
base.ParsingMode = OptionsParsingMode.Both;
}
public bool Validate () {
foreach (string s in RemainingArguments) {
Console.WriteLine ("Unknown option {0}", s);
return false;
}
return true;
}
}
}
Patches welcome, as well as pushing patch #507919 upstream, and
patches to remove the X11 dependency.
Roland.
--
Roland Mas
Plant a radish, get a radish, never any doubt!
-- Bellamy & Hucklebee, in The Fantasticks
_______________________________________________
F-spot-list mailing list
[email protected]
http://mail.gnome.org/mailman/listinfo/f-spot-list
