add patched digitaglinktree-1.8.4beta for uri_unencode

1 files changed, 1116 insertions, 0 deletions

diff --git a/digitaglinktree-1.8.4beta b/digitaglinktree-1.8.4beta
new file mode 100755
index 0000000..1ebcdb6
--- /dev/null
+++ b/digitaglinktree-1.8.4beta
@@ -0,0 +1,1116 @@
+#!/usr/bin/perl
+
+use DBI;
+use URI::Escape;
+
+$version="1.8.4beta";
+# Author: Rainer Krienke, krienke@uni-koblenz.de
+#
+# Description:
+#
+# This script will create a linktree for all photos in a digikam
+# database that have tags set on them. Tags are used in digikam to
+# create virtual folders containing images that all have one or more tags.
+# Since other programs do not know about these virtual folders this script
+# maps these virtual folders into the filesystem by creating a directory
+# for each tag name and then linking from the tag dir to the tagged image in the
+# digikam photo directory.
+#
+# Call this script like:
+# digitaglinktree -r /home/user/photos -l /home/user/photos/tags \
+#            -d /home/user/photos/digikam.db
+
+
+# Changes 
+#
+# 1.1->1.2:  
+# Support for hierarchical tags was added. The script can either create
+# a hierarchical directory structure for these tags (default) or treat them 
+# as tags beeing on the same level resulting in a flat dir structure (-f)
+#
+# 1.2->1.3
+# Added support for multiple tags assigned to one photo. Up to now only 
+# one tag (the last one found) was used. 
+#
+# 1.3->1.4
+# Bug fix, links with same name in one tag directory were no resolved
+# which led to "file exists" errors when trying to create the symbolic link.
+#
+# 1.4-> 1.6, 2006/08/03
+# Added an option (-A) to archive photos and tag structure in an extra directory 
+# 1.6-> 1.6.1 2006/08/15
+# Added an option (-C) for archive mode (-A). Added more information to 
+# the manual page.
+# 1.6.1-> 1.6.2 2008/11/24 (Peter Muehlenpfordt, muehlenp@gmx.de)
+# Bug fix, subtags with the same name in different branches were merged
+# into one directory.
+# 1.6.2 -> 1.6.3 2008/11/25 Rainer Krienke, krienke@uni-koblenz.de
+# Fixed a bug that shows in some later perl interpreter versions when 
+# accessing array references with $# operator. If $r is a ref to an array
+# then $#{@r} was ok in the past but now $#{r] is correct, perhaps it was
+# always correct and the fact that $#{@r} worked was just good luck ....
+# 1.6.3 -> 1.7.0 2008/11/27 Rainer Krienke, krienke@uni-koblenz.de
+# Adapted script to handle digikams v0.10 new database scheme as well
+# as the older ones. Version is determined automatically.
+# 1.7.0 -> 1.8.0 2012/02/07 Cyril Raphanel, cyril.raphanel@gmail.com
+# Added (-r) option for new digikam database as root directory for a set of albums below same file system
+# Added (-Y) option to add "year" directory below each tag
+# 1.8.0 -> 1.8.1 2012/02/08 krienke@uni-koblenz.de
+# added support to find albumroots on iremovable media described by uuid
+# in digikams database
+# 1.8.1 -> 1.8.2 2012/03/28 Cyril Raphanel, cyril.raphanel@gmail.com
+# Added (-i) option to include only some tags - default 'all'
+# Added (-e) option to exclude some tags - default ''
+# Added (-M) option to create directory hierarchy base on tags selection, number of hierarchy level to be specified
+# Added (-V) option to enable verbose mode
+# 1.8.2 -> 1.8.3 2013/10/18 Harald Heigl, hh-developing@heigl-online.at
+# Added (-u -p -t) option for user, password and type of database
+# changed to dbi-perl-system
+# adjusted for use with sqlite and mysql
+# 1.8.2 -> 1.8.3 2013/11/27 Rainer Krienke, krienke@uni-koblenz.de
+# Made mapping from filesystem uuid to mountpoints containing photos more robust using systemtool blkid
+# Changed default for -i from "all to "none" for -M mode. -i is now
+# mandatory for -M
+# 1.8.3 -> 1.8.4 2013/12/3 Rainer Krienke, krienke@uni-koblenz.de
+# Merge of the two forked versions 1.8.3 
+# by hh-developing@heigl-online.at and 1.8.3
+# by krienke@uni-koblenz.de. Basically this merge incorporates MYSQL
+# support contributed by hh-developing@heigl-online.at
+
+
+
+# ---------------------------------------------------------------------------
+# LICENSE:
+#
+# 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.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA.
+#
+# ---------------------------------------------------------------------------
+
+
+use Getopt::Std;
+use File::Spec;
+use File::Path;
+use URI::Escape;
+
+# Please adapt the sqlite version to your digikam version.
+# Do not forget to also install the correct sqlite version:
+# Digikam 0.7x needs sqlite2 
+# Digikam 0.8x needs sqlite3
+
+$archiveDirPhotos="Photos";
+$archiveDirLinks="Tags";
+
+#
+$scriptAuthor="krienke@uni-koblenz.de";	   
+
+#
+# check if sqlite can open the database
+#
+sub checkVersion{
+    my($database, $checkVersionCommand)=@_;
+    my($version); 
+
+    $version="-1";
+    (my $sqlCmd = $checkVersionCommand) =~ s/'{name}'/'TagsTree'/g;   
+    my $sth = $database->prepare($sqlCmd);
+    $sth->execute;
+    $sth->fetchall_arrayref();
+
+    if ($sth->err)
+    {
+       print "Error running SQL-Command \"$sqliteCmd\" on database \n";
+       exit(1);
+    }
+ 
+    if( $sth->rows == 0 ){
+    	$version="7";	# digikam version 0.7
+    }else{
+    	$version="8";	# digikam version 0.8
+    }
+    # Now check if we have digikam 0.10
+    
+    (my $sqlCmd = $checkVersionCommand) =~ s/'{name}'/'AlbumRoots'/g;
+    my $sth = $database->prepare($sqlCmd);
+    $sth->execute;
+    $sth->fetchall_arrayref();
+
+    if ($sth->err)
+    {
+       print "Error running SQL-Command \"$sqliteCmd\" on database \n";
+       exit(1);
+    }
+ 
+    if( $sth->rows != 0 ){
+    	$version="10";	# digikam version 0.10 KDE4
+    }
+    return($version);
+}
+
+
+#
+# Get all images that have tags from digikam database
+# refPathNames will contain all photos including path having tags 
+# The key in refPathNames is the path, value is photos name
+# rootdir is the relative album path in which photos are stored	
+# in digikam <0.10 this is the path given by the user via -r option
+# starting with digikam 0.10 rootDir may be any of the entries of table 
+# AlbumRoots column specificPath, albumId is the corresponding entry
+# of column id.
+#
+sub getTaggedImages{
+   my($refImg, $database, $rootDir, $albumId, $refPaths, $refPathNames, $vers, $tage,$tagi)=@_;
+   my($i, $image, $path, $tag, $status, $id, $pid, $tmp);
+   my($sqliteCmd, @data, @tags, %tagPath, $tagCount, $refTag);
+   
+   # Get tag information from database
+   $sqliteCmd="select id,pid,name from Tags;";
+   my $sth = $database->prepare($sqliteCmd);
+   $sth->execute;
+
+   if ($sth->err)
+   {
+      print "Error running SQL-Command \"$sqliteCmd\" on database \n";
+      exit(1);
+   }
+
+   # Note columns start at 1 (not 0).
+   $sth->bind_col(1, \$id);
+   $sth->bind_col(2, \$pid);
+   $sth->bind_col(3, \$tag);
+
+ 
+	 while ($sth->fetch) { # retrieve one row
+	    # map tag id data into array
+	    $tags[$id]->{"tag"}="$tag";
+	    $tags[$id]->{"pid"}="$pid";
+      }
+      
+      # Now build up the path for tags having parents
+      # Eg: a tag people might have a subtag friends: people
+      #                                                     |->friends
+      # We want to find out the complete path for the subtag. For friends this
+      # would be the path "people/friends".  Images with tag friends would then be
+      # linked in the directory <tagsroot>/people/friends/
+	for($i=0; $i<=$#tags; $i++){
+	 $pid=$tags[$i]->{"pid"};   # Get parent tag id of current tag
+	 $tag=$tags[$i]->{"tag"};   # Start constructing tag path
+         if( $pid == 0 ){
+             $tagPath{$i}=$tag;
+             next;
+         }
+	 
+	 while( $pid != 0){	
+	    $tag=$tags[$pid]->{"tag"} . "/$tag"; # add parents tag name to path
+	    $pid=$tags[$pid]->{"pid"};           # look if parent has another parent
+	 }
+	 # Store path constructed
+	 $tagPath{$i}=$tag;
+	 #warn "+ $tag \n";	 
+      } 
+   
+   
+   if( $vers==7 ){
+      # SQL to get all tagged images from digikam DB with names of tags 
+      $sqliteCmd="select ImageTags.name,Albums.Url,ImageTags.tagid from " . 
+           " ImageTags, Albums,Tags  " .
+	   " where Albums.id = ImageTags.dirid; ";
+   
+   }elsif( $vers == 8 ){
+      # SQL to get all tagged images from digikam DB with names of tags 
+      $sqliteCmd="select Images.name,Albums.url,ImageTags.tagid from"            .
+               " Images,Albums,ImageTags where "                        .
+	       " Images.dirid=Albums.id AND Images.id=ImageTags.imageid; ";
+   }elsif( $vers == 10 ){
+      # SQL to get all tagged images from digikam DB with names of tags 
+      # Only those images are considered that belong to the album in question
+      $sqliteCmd="select Images.name,Albums.relativePath,ImageTags.tagid, ImageInformation.digitizationDate, Images.id from" .
+                         " Images,Albums,ImageTags,ImageInformation " .
+                         " where Images.album=Albums.id AND" .
+                         " Images.id=ImageTags.imageid AND  " .
+                         " ImageInformation.imageid=ImageTags.imageid AND  " .
+			 " Albums.albumRoot=$albumId "
+   }else{
+   	warn "Unsupported digikam database version. Contact $scriptAuthor \n\n";
+	exit(1);
+   }
+
+   my $sth = $database->prepare($sqliteCmd);
+   $sth->execute;
+   if ($sth->err)
+   {
+      print "Error running SQL-Command \"$sqliteCmd\" on database \n";
+      exit(1);
+   }
+
+   # Note columns start at 1 (not 0).
+   $sth->bind_col(1, \$image);
+   $sth->bind_col(2, \$path);
+   $sth->bind_col(3, \$tag);
+   $sth->bind_col(4, \$imgdate);
+   $sth->bind_col(5, \$imgid);
+
+   while ($sth->fetch) { 
+	 ($imgYear,$foo)=split(/\-/,$imgdate);
+	 if( $imgYear eq "" ){
+	 	 $imgYear="No_Date";
+	 }
+
+	 $path=~s/\/$// if( $path =~ /\/$/ ); # remove a trailing /
+	 $refPaths->{"$rootDir$path"}=1;
+	 $refPathNames->{"$rootDir$path/$image"}=1;
+	 
+	 #print "-- $rootDir$path/$image \n";
+	 
+	 $tmp="$path";
+	 #warn "- $rootDir, $path, $image \n";
+	 # Enter all subpaths in $path as defined too
+	 do{
+          	$tmp=~s/\/[^\/]+$//;
+		$refPaths->{"$rootDir$tmp"}=1;
+		$tmp=~s/^\/$//;     # Finally delete a "/" standing alone
+	 } while (length($tmp)); 
+	 
+	 $refTag=$refImg->{"$rootDir/$path/$image"}->{"tag"};
+	 # 
+	 # One image can have several tags assigned. So we manage 
+	 # a list of tags for each image
+	 $tagCount=$#{$refTag}+1;	
+	 
+	 # Check if tag not in the including/excluding list
+	 # By default included
+	 $tagok=1;
+	 # check excluding list
+	 if ($tage eq 'all') {
+	 	 $tagok=0;
+	 }else{
+	 	 foreach $item (split(/,/, $tage)) {
+	 	 	 
+	 	 	 if ($tagPath{$tag} =~ /($item)/) {
+	 	 	 	 $tagok=0;
+	 	 	 }
+	 	 	 
+	 	 }
+	 }
+	 # check including list
+	 if ($tagi eq 'all') {
+	 	 $tagok=1;
+	 }else{
+	 	 foreach $item (split(/,/, $tagi)) {
+	 	 	 
+	 	 	 if ($tagPath{$tag} =~ /($item)/) {
+	 	 	 	 $tagok=1;
+	 	 	 }
+	 	 	 
+	 	 }
+	 }
+	 
+	 if ($tagok){
+	 	 # The tags name
+	 	 $refImg->{"$rootDir/$path/$image"}->{"tag"}->[$tagCount]=$tag;
+	 	 # tags path for sub(sub+)tags
+	 	 # print "TAG -- $tag -- PATH $path\n";
+	 	 $refImg->{"$rootDir/$path/$image"}->{"tagpath"}->[$tagCount]=$tagPath{$tag};
+	 	 $refImg->{"$rootDir/$path/$image"}->{"path"}=$path;
+	 	 $refImg->{"$rootDir/$path/$image"}->{"image"}=$image;
+	 	 $refImg->{"$rootDir/$path/$image"}->{"rootDir"}=$rootDir;
+	 	 $refImg->{"$rootDir/$path/$image"}->{"imgYear"}=$imgYear;
+	 	 $refImg->{"$rootDir/$path/$image"}->{"imgid"}=$imgid;
+	 }
+
+	 #print "$path/$image -> $tagPath($tag) \n";
+   }
+   return($status);
+}
+
+#
+# Create a directory with tag-subdirectories containing links to photos having
+# tags set. Links can be absolute or relative as well as hard or soft. 
+#
+sub createLinkTree{
+    my($refImages)=shift;
+    my($fakeRoot, $linktreeRootDir, $opt_flat, $opt_absolute, $linkMode,$dirDate)=@_;
+    my( $i, $j, $cmd, $path, $image, $tag, $qpath, $qtag, $qimage, $linkName, 
+        $tmp, $ret, $sourceDir, $destDir, $photoRootDir);
+    my($qtagPath, $relPath, $count);
+
+    if( -d "$linktreeRootDir" ){
+    	# Remove old backuplinktree
+	system("rm -rf ${linktreeRootDir}.bak");
+	if( $? ){
+	     die "Cannot run \"rm -rf ${linktreeRootDir}.bak\"\n";
+	}
+	
+	# rename current tree to .bak 
+	$ret=rename("$linktreeRootDir", "${linktreeRootDir}.bak" );
+	if( !$ret ){
+	     die "Cannot rename \"$linktreeRootDir\" to \"${linktreeRootDir}.bak\"\n";
+	}
+    }
+	
+    # Create new to level directory to hold linktree 	
+    $ret=mkdir("$linktreeRootDir");
+    if( !$ret ){
+	 die "Cannot mkdir \"$linktreeRootDir\"\n";
+    }
+    # Iterate over all tagged images and create links
+    $count=0;
+    foreach $i (keys(%$refImages)){
+	$path=$refImages->{$i}->{"path"};
+	$image=$refImages->{$i}->{"image"};
+	
+	#print "-> $photoRootDir, $path, $image, $fakeRoot\n";
+	if( ! length($fakeRoot) ){
+	   $photoRootDir=$refImages->{$i}->{"rootDir"};
+	}else{
+	   $photoRootDir=$fakeRoot;
+	}
+	#$qimage=quotemeta($image);
+	#$qpath=quotemeta($path);
+
+	# Check that the images in the linktrees themselves are
+	# ignored in the process of link creation. If we do not do this
+	# we might get into trouble when the linktree root is inside the
+	# digikam root dir and so the image links inside the liktree directory 
+	# are indexed by digikam.
+	 next if( -l "${photoRootDir}$path/$image" );
+	# $refImages always contains all images from all albums. For Mode -A 
+	# in digikam 0.10 it may happen that some albums are not on the same filesystem 
+	# like the photoRoot. in this case this album is not cloned to another 
+	# directory buth neverless
+	# refImages contains also data about photos in this album. But since it is 
+	# not cloned, the cloned root # does not exits and so the photo therin does 
+	# not exist. Thats what we check here.
+	next if( ! -r "${photoRootDir}$path/$image" ); 
+        $count++;
+
+        # Handle all of the tags for the current photo
+	for( $j=0;  $j<=$#{$refImages->{$i}->{"tag"}}; $j++){	
+	   $tag=$refImages->{$i}->{"tagpath"}->[$j];
+	   $imgYear=$refImages->{$i}->{"imgYear"};
+	   #$qtagPath=quotemeta($tagPath);
+
+	   # For tags that have subtags there is a path defined in qtagPath
+	   # describing the parentrelationship as directory path like "friends/family/brothers"
+	   # If it is defined we want to use this path instead of the flat tag name like "brothers"
+	   # Doing so results in a directory hirachy that maps the tags parent relationships 
+	   # into the filesystem.
+	   if( $opt_flat ){
+	   	# For flat option just use the last subdirectory
+	   	$tag=~s/^.+\///;
+	   }
+	   # Create subdirectories needed
+	   if( ! -d "${linktreeRootDir}/$tag" ){
+		   $ret=mkpath("${linktreeRootDir}/$tag", 0, 0755);
+
+		   if( !$ret ){
+			die "Cannot mkdir \"${linktreeRootDir}/$tag\"\n";
+		   }
+	   }
+	   # Create subdirectories needed for date
+	   if( $dirDate eq "year" ){
+	   	   if( ! -d "${linktreeRootDir}/$tag/$imgYear" ){
+	   	   	   $ret=mkpath("${linktreeRootDir}/$tag/$imgYear", 0, 0755);
+
+	   	   	   if( !$ret ){
+	   	   	   	   die "Cannot mkdir \"${linktreeRootDir}/$tag/$imgYear\"\n";
+	   	   	   }
+	   	   }
+	   	   $tag=$tag."/".$imgYear;
+	   }
+	   # Avoid conflicts for images with the same name in one tag directory
+	   $linkName=$image;
+	   $tmp=$image;
+	   while( -r "${linktreeRootDir}/$tag/$tmp" ){
+		   $linkName="_" . $linkName;		
+		   $tmp="_" . $tmp;		
+	   }
+
+	   if(length($opt_absolute)){
+	      # Create link
+	      $sourceDir="${photoRootDir}$path/$image";  
+	      $destDir="${linktreeRootDir}/$tag/$linkName";		
+	   }else{
+	      # Get relative path from absolute one
+	      # $rel=File::Spec->abs2rel( $path, $base ) ; 
+	      $relPath="";
+	      $relPath=File::Spec->abs2rel("${photoRootDir}$path", "${linktreeRootDir}/$tag" ) ;
+	      if( !length($relPath)){
+	         die "Cannot create relative path from \"${linktreeRootDir}/$tag\" to \"${photoRootDir}$path\" . Abort.\n";
+	      }
+	      # Create link
+	      #print "-> $relPath\n";
+	      $sourceDir="$relPath/$image"; 
+	      $destDir="${linktreeRootDir}/$tag/$linkName";
+	   }
+	   
+	   if( $linkMode eq "symbolic" ){
+	      $ret=symlink($sourceDir, $destDir);
+	      if( !$ret ){
+		  $ret="$!";
+		  warn "Warning: Failed symbolic linking \"$sourceDir\" to \"$destDir\": ",
+		       "\"$ret\"\n";
+	      }
+	   }elsif( $linkMode eq "hard" ){
+	      $ret=link($sourceDir, $destDir);
+	      if( !$ret ){
+		  $ret="$!";
+		  warn "Warning: Failed hard linking \"$sourceDir\" to \"$destDir\": ",
+		       "\"$ret\"\n";
+	      }
+	   }else{
+	      die "$0: Illegal linkMode: \"$linkMode\". Abort.\n";
+	   }
+	   
+	}# for
+    }
+    return($count);
+}
+
+sub createLinkTreeMultiBranch{
+	my($tag_list,$linktreeRootDir,$photoRootDir,$counttag,$countmax,$dirDate)=@_;
+	my($j,$tag);
+	my $path=$tag_list->{"path"};
+	my $image=$tag_list->{"image"};
+	my $imgid=$tag_list->{"imgid"};
+	my $imgYear=$tag_list->{"imgYear"};
+	if ($counttag<$countmax){
+		for( $j=0;  $j<=$#{${tag_list}->{"tag"}}; $j++){
+			$tag=$tag_list->{"tagpath"}->[$j];
+			# Check if we have not tried the path before
+			if(${linktreeRootDir} !~ m/($tag)(\/|$)/) {
+				# Create subdirectories needed
+				if( ! -d "${linktreeRootDir}/$tag/_all" ){
+					$ret=mkpath("${linktreeRootDir}/$tag/_all", 0, 0755);
+					
+					if( !$ret ){
+						die "Cannot mkdir \"${linktreeRootDir}/$tag/_all\"\n";
+					}
+				}
+				# Avoid conflicts for images with the same name in one tag directory
+				$linkName=$imgid."_".$image;
+				
+				# Get relative path from absolute one
+				$relPath="";
+				$relPath=File::Spec->abs2rel("${photoRootDir}$path", "${linktreeRootDir}/$tag/_all" ) ;
+				if( !length($relPath)){
+					die "Cannot create relative path from \"${linktreeRootDir}/$tag/_all\" to \"${photoRootDir}$path\" . Abort.\n";
+				}
+				# Create link
+				$sourceDir="$relPath/$image"; 
+				$destDir="${linktreeRootDir}/$tag/_all/$linkName";
+				
+				if (!-e $destDir){
+					$ret=symlink($sourceDir, $destDir);
+					if( !$ret ){
+						$ret="$!";
+						warn "Warning: Failed symbolic linking \"$sourceDir\" to \"$destDir\": ",
+						"\"$ret\"\n";
+					}
+				}
+				
+				# Manage date information
+				if( $dirDate eq "year" ){
+					# Check if we have not tried the path before
+					if(${linktreeRootDir} !~ /(Date\/$imgYear)/) {
+						if( ! -d "${linktreeRootDir}/$tag/Date/$imgYear/_all" ){
+							$ret=mkpath("${linktreeRootDir}/$tag/Date/$imgYear/_all", 0, 0755);
+							
+							if( !$ret ){
+								die "Cannot mkdir \"${linktreeRootDir}/$tag/Date/$imgYear/_all\"\n";
+							}
+						}
+						
+						# Get relative path from absolute one
+						$relPath="";
+						$relPath=File::Spec->abs2rel("${photoRootDir}$path", "${linktreeRootDir}/$tag/Date/$imgYear/_all" ) ;
+						if( !length($relPath)){
+							die "Cannot create relative path from \"${linktreeRootDir}/$tag/Date/$imgYear/_all\" to \"${photoRootDir}$path\" . Abort.\n";
+						}
+						# Create link
+						$sourceDir="$relPath/$image"; 
+						$destDir="${linktreeRootDir}/$tag/Date/$imgYear/_all/$linkName";
+						
+						if (!-e $destDir){
+							$ret=symlink($sourceDir, $destDir);
+							if( !$ret ){
+								$ret="$!";
+								warn "Warning: Failed symbolic linking \"$sourceDir\" to \"$destDir\": ",
+								"\"$ret\"\n";
+							}
+						}
+						
+						# create subdir
+						createLinkTreeMultiBranch($tag_list,"${linktreeRootDir}/$tag/Date/$imgYear",$photoRootDir,$counttag,$countmax,$dirDate);
+					}
+				}
+				
+				# Manage subdir
+        			# create subdir
+        			createLinkTreeMultiBranch($tag_list,"${linktreeRootDir}/$tag",$photoRootDir,$counttag+1,$countmax,$dirDate);
+        			
+        		}
+        	}
+	}
+
+}
+        			
+#
+# Create a directory with tag-subdirectories containing links to photos having
+# tags set. Links can be absolute or relative as well as hard or soft. 
+#
+sub createLinkTreeMulti{
+    my($refImages)=shift;
+    my($fakeRoot, $linktreeRootDir, $opt_flat, $opt_absolute, $linkMode,$dirDate,$countmax,$verbose)=@_;
+    my( $i, $j, $cmd, $path, $image, $tag, $qpath, $qtag, $qimage, $linkName, 
+        $tmp, $ret, $sourceDir, $destDir, $photoRootDir);
+    my($qtagPath, $relPath, $count);
+
+    if( -d "$linktreeRootDir" ){
+    	# Remove old backuplinktree
+	system("rm -rf ${linktreeRootDir}.bak");
+	if( $? ){
+	     die "Cannot run \"rm -rf ${linktreeRootDir}.bak\"\n";
+	}
+	
+	# rename current tree to .bak 
+	$ret=rename("$linktreeRootDir", "${linktreeRootDir}.bak" );
+	if( !$ret ){
+	     die "Cannot rename \"$linktreeRootDir\" to \"${linktreeRootDir}.bak\"\n";
+	}
+    }
+	
+    # Create new to level directory to hold linktree 	
+    $ret=mkdir("$linktreeRootDir");
+    if( !$ret ){
+	 die "Cannot mkdir \"$linktreeRootDir\"\n";
+    }
+    # Iterate over all tagged images and create links
+    $count=0;
+    foreach $i (keys(%$refImages)){
+	$path=$refImages->{$i}->{"path"};
+	$image=$refImages->{$i}->{"image"};
+	$refImages->{$i}->{"imgid"};
+	$imgYear=$refImages->{$i}->{"imgYear"};
+	
+	#print "-> $photoRootDir, $path, $image, $fakeRoot\n";
+	if( ! length($fakeRoot) ){
+	   $photoRootDir=$refImages->{$i}->{"rootDir"};
+	}else{
+	   $photoRootDir=$fakeRoot;
+	}
+	#$qimage=quotemeta($image);
+	#$qpath=quotemeta($path);
+
+	# Check that the images in the linktrees themselves are
+	# ignored in the process of link creation. If we do not do this
+	# we might get into trouble when the linktree root is inside the
+	# digikam root dir and so the image links inside the liktree directory 
+	# are indexed by digikam.
+	 next if( -l "${photoRootDir}$path/$image" );
+	# $refImages always contains all images from all albums. For Mode -A 
+	# in digikam 0.10 it may happen that some albums are not on the same filesystem 
+	# like the photoRoot. in this case this album is not cloned to another 
+	# directory buth neverless
+	# refImages contains also data about photos in this album. But since it is 
+	# not cloned, the cloned root # does not exits and so the photo therin does 
+	# not exist. Thats what we check here.
+	next if( ! -r "${photoRootDir}$path/$image" ); 
+        $count++;
+        
+        
+        ## BEGIN ##
+        if( $dirDate eq "year" ){
+        	# create root for Date tree
+        	if( ! -d "${linktreeRootDir}/Date/$imgYear/_all" ){
+        		$ret=mkpath("${linktreeRootDir}/Date/$imgYear/_all", 0, 0755);
+        		
+        		if( !$ret ){
+        			die "Cannot mkdir \"${linktreeRootDir}/Date/$imgYear/_all\"\n";
+        		}
+        	}
+        	
+        	# Get relative path from absolute one
+        	$relPath="";
+        	$relPath=File::Spec->abs2rel("${photoRootDir}$path", "${linktreeRootDir}/Date/$imgYear/_all" ) ;
+        	if( !length($relPath)){
+        		die "Cannot create relative path from \"${linktreeRootDir}/Date/$imgYear/_all\" to \"${photoRootDir}$path\" . Abort.\n";
+        	}
+        	# Create link
+        	$sourceDir="$relPath/$image"; 
+        	$destDir="${linktreeRootDir}/Date/$imgYear/_all/$linkName";
+        	
+        	if (!-e $destDir){
+        		$ret=symlink($sourceDir, $destDir);
+        		if( !$ret ){
+        			$ret="$!";
+        			warn "Warning: Failed symbolic linking \"$sourceDir\" to \"$destDir\": ",
+        			"\"$ret\"\n";
+        		}
+        	}
+        	push @imgdir,"Date/$imgYear";        				
+        }
+        
+        if ($verbose) {
+        	# print trace
+        	print localtime().":IMAGE:COUNT $count:IMAGE $image:IMAGEID $imageid \n";
+        }
+        
+        # Manage tags
+        createLinkTreeMultiBranch($refImages->{$i},${linktreeRootDir},$photoRootDir,0,$countmax,$dirDate);        
+    	
+    }
+    return($count);
+}
+
+
+
+#
+# Clone a directory into another directory.
+# source and destination have to exist
+# Files in $srcDir  will symbolically or hard linked
+# to the $cloneDir according to $cloneMode which can
+# be symbolic for symbolic links or hard for hardlinks
+# refPathNames contains path for all photos having tags set
+#
+sub cloneDir{
+   local($srcDir, $cloneDir, $linkMode, $cloneMode, $refPaths, $refPathNames)=@_;
+   local(@entries, $ki, $path, $name, $ret);
+
+   # Read directory entries
+   opendir( DIR, $srcDir ) || warn "Cannot read directory $srcDir \n";
+   local(@entries)=readdir(DIR);
+   closedir(DIR);
+
+   foreach $k (@entries){
+      next if( $k eq '.' );
+      next if( $k eq '..');
+      next if( $k =~ /digikam.*\.db/o );
+
+      #warn "-> $srcDir, $k, $cloneDir\n";
+      # Recurse into directories
+      if( -d "$srcDir/$k" ){
+         # if cloneMode is "minimal" then only clone directories and files
+	 # with photos that have tags set.
+	 if( $cloneMode ne "minimal" ||
+     	               defined($refPaths->{"$srcDir/$k"}) ){ 
+	     #warn "* $srcDir/$k defined \n";
+	     mkdir("$cloneDir/$k", 0755);
+  	     if( $? ){
+		die "Cannot run \"mkdir $cloneDir/$k\"\n";
+	     }
+             cloneDir("$srcDir/$k", "$cloneDir/$k", $linkMode, 
+	               $cloneMode, $refPaths, $refPathNames );
+         }		    
+      }else{
+         # if cloneMode is "minimal" then only clone directories and files
+	 # with photos that have tags set.
+	 #print "+ refPathNames, $srcDir/$k , ",$refPathNames->{"$srcDir/$k"}, " \n";
+	 if( $cloneMode ne "minimal" ||
+     	               defined($refPathNames->{"$srcDir/$k"}) ){ 
+	    # link files
+	    if( $linkMode eq "symbolic" ){
+               $ret=symlink( "$srcDir/$k",  "$cloneDir/$k");
+	       if( !$ret ){
+	           $ret="$!";
+		   warn "Warning: In cloning failed symbolic linking \"$srcDir/$k\" to \"$cloneDir/$k\": ",
+			"\"$ret\"\n";
+	       }
+	    }elsif( $linkMode eq "hard" ){
+	       $ret=link( "$srcDir/$k",  "$cloneDir/$k");
+	    
+	       if( !$ret ){
+	           $ret="$!";
+		   warn "Warning: In cloning failed hard linking \"$srcDir/$k\" to \"$cloneDir/$k\": ",
+			"\"$ret\"\n";
+	       }
+	    }else{
+               die "$0: Illegal cloneLinkMode: $linkMode set. Aborting.\n";
+	    }
+	 }
+      }
+   }
+}
+
+
+#
+# Create directory for cloning photos when running with -A 
+#
+sub createCloneDir{
+    my( $cloneDir, $photoDir)=@_;
+    my($ret);
+    
+    if( -d "$cloneDir" ){
+    	# Remove old backuplinktree
+	system("rm -rf ${cloneDir}.bak");
+	if( $? ){
+	     die "Cannot run \"rm -rf ${cloneDir}.bak\"\n";
+	}
+	
+	# rename current tree to .bak 
+	$ret=rename("$cloneDir", "${cloneDir}.bak" );
+	if( !$ret ){
+	     die "Cannot rename \"$cloneDir\" to \"${cloneDir}.bak\"\n";
+	}
+    }
+    $ret=mkdir("$cloneDir", 0755);
+    if( !$ret ){
+	die "Cannot run \"mkdir $cloneDir\"\n";
+    }
+    $ret=mkdir("$cloneDir/$photoDir", 0755);
+    if( !$ret ){
+	die "Cannot run \"mkdir $cloneDir/$photoDir\"\n";
+    }
+}
+
+#
+# Manage cloning of a complete directory. If the clone directory exists
+# a .bak will be created
+# Files will be linked (hard/symbolic) according to cloneLinkMode which
+# should be "symbolic" or "hard"
+# cloneMode can "minimal" or anything else. minimal means only to clone 
+# those files and directories that have tags set. Anything else means
+# to clone the whole photo tree with all files
+#
+sub runClone{
+   my($rootDir, $cloneDir, $photoDir, $cloneMode, $cloneLinkMode, 
+      $refPaths, $refPathNames)=@_;
+   my($ret);
+   my($dev_r,$dev_A, $ino,$mode,$nlink,$uid,$gid,$rdev,$size,
+      $atime,$mtime,$ctime,$blksize,$blocks);
+   
+    # Check if root and archive dir are on same filesystem
+    ($dev_r,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
+       $atime,$mtime,$ctime,$blksize,$blocks)       = stat($rootDir);
+    ($dev_A,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
+       $atime,$mtime,$ctime,$blksize,$blocks)       = stat($cloneDir);
+    #
+    if( $dev_r != $dev_A ){
+	warn "Warning: \"$rootDir\" and \"$cloneDir\" are not on the same filesystem. Please select ",
+	     "an archive directory on the same filesystem like digikams root directory! Skipped.\n";
+	return(-1);     
+    }	   
+
+    # Create clone of all entries in $rootDir into $clonedir
+    cloneDir($rootDir, "$cloneDir/$photoDir", $cloneLinkMode, 
+             $cloneMode, $refPaths, $refPathNames);
+    
+    return(0);
+}
+
+
+#
+# print out usage 
+#
+sub usage{
+    print "                  -l <taglinkdir> | -A <archivedir> \n",
+	  "                  -d <digikamdatabasefile> \n",
+      "                  [-u <user>] \n",
+      "                  [-p <password>] \n",
+      "                  [-t <typeofdatabase>] \n",
+	  "                  [-r <rootdir>]  \n",	  
+	  "                  [-H|-f|-a|-v|-C|e|M] \n",
+	  "  -l <tagdir>  path to directory where the tag directory structure with \n",
+	  "               links to the original images should be created \n",
+	  "  -d <dbfile>  full path to the digikam database file \n",
+          "  -r <rootdir> path to digikams root directory containing all photos.\n",
+	  "               For digikam vers >= 0.10 this is usually not needed and should only be used\n",
+	  "   		  in case that an album root directory cannot be found.\n",
+	  "               Option is mandatory for earlier digikam versions!\n",
+      "  -u <user>    User (used for mysql)\n",
+      "  -p <pwd>     Password (used for mysql)\n",
+      "  -t <type>    Type of database: SQLite and mysql\n",
+	  "  -A <ardir>   Create selfcontained archive of photos and tags in directory\n",
+	  "               ardir. rootdir and arDir have to be on the *same* filesystem!\n",
+	  "  -C           If -A <archdir> was given this option will put hardlinks of all\n",
+	  "               photos in the \"$archiveDirPhotos\" directory not only of those with tags.\n", 
+	  "  -a           Create absolute symbolic links instead of relative ones \n",
+	  "  -H           Use hard links instead of symbolic links in linktree. \n",
+	  "  -Y           Add Year directory below each tag directory \n",
+	  "  -f           If there are hierarchical tags (tags that have subtags) \n",
+	  "               create a flat tag directory hierarchy. So directories for\n",
+	  "               subtags are at the same directory level like their parent tags\n",
+	  "  -M  <level>  Make multi-level directory using tag classification included in each\n",
+	  "               image. Mandatory parameter:specifies the maximum tree level number.\n",
+	  "               You have to use -i with at least one tag to be processed (see below)\n",
+	  "               !Options -A -C -a -H -f not tested with this option!\n",
+	  "  -i <taglist> Include tags of comma separated list <taglist> in multi-level\n",
+	  "               mode containing given tag string in their tag path.\n",
+	  "               Use all if really all tags are needed.\n",
+	  "               Default: none\n",
+	  "  -e <taglist> Excluding tags having specific string in their tag path. \n",
+	  "               Default: none\n",
+	  "               Example Digikam,People excludes all tags having Digikam or People in their path\n",
+	  "  -V           Verbose mode \n",
+	  "  -h           Print this help \n",
+	  "  -v           Print scripts version number \n";
+    print "Exit.\n\n";
+    exit 1;
+}
+ 
+ 
+# 
+# get Album roots if digikam is 0.10 or higher 
+#
+sub getAlbumRoots{
+   my($database, $refAlbumRoots)=@_;
+   my($ret, @data, $sql, $i, $id, $path);
+   my($identifier, $uuid, $uuiddev, $ucuuiddev, $ucuuid, $device, $mountpoint);
+   my(@more);
+
+   my $sth = $database->prepare('select id, identifier,specificPath from AlbumRoots');
+   $sth->execute;
+
+   if($sth->err){ 
+       warn "$0: Cannot execute  $sql on database $database \n";
+       exit(1);
+   }
+
+   $sth->bind_col(1, \$id);
+   $sth->bind_col(2, \$identifier);
+   $sth->bind_col(3, \$path);
+
+ 
+   while ($sth->fetch) { # retrieve one row
+      # check identifier. It might be simply volumeid:?, then specificPath is the absolute
+      # path.
+      # if its volumeid:\?uuid followed by a uuid of a device, then specificPath
+      # is relative to the mountpoint of this device
+      if( $identifier =~/volumeid.*uuid/ ){
+	 $uuid=$identifier;
+	 $uuid=~s/^.*uuid=//i; 
+	 $ucuuid=uc($uuid);  # make uuid upper case because sometimes it is upper case in /dev
+	 if( -e "/dev/disk/by-uuid/$uuid" ){
+	    $uuiddev=`blkid -U $uuid`;
+	    die "Error: Cannot find system binary \"blkid\". Please install to continue.\n" if( $? != 0 );
+	 }elsif(-e "/dev/disk/by-uuid/$ucuuid" ){
+	    $uuiddev=`blkid -U $ucuuid`;
+	    die "Error: Cannot find system binary \"blkid\". Please install to continue.\n" if( $? != 0 );
+	 }else{
+	    print "Cannot find device /dev/disk/by-uuid/$uuid or  ..../$ucuuid. Skipped.\n";
+	    next;  # uuid not found in /dev/disk/by-uuid, so skip entry
+	 }
+	 chomp($uuiddev);
+	 # print "UUID: $uuid,>$uuiddev< \n";
+	 if( -e $uuiddev ){
+	    if( open(IN, "/proc/mounts" ) ){
+		  while(<IN>) {
+			chomp;
+		     ($device, $mountpoint, @more)=split( /\s+/ );
+		     #print "Device: $device, $uuiddev\n";
+		     if( $device eq $uuiddev ){
+			  # print "Device: $device, $mountpoint/$path \n";
+			  $refAlbumRoots->{$id}="$mountpoint/$path"; # Enter Album Data 
+			  $refAlbumRoots->{$id}=~s/\/$//o; # remove possible trailing /
+			  $refAlbumRoots->{$id}=~s/\/\//\//go; # replace // by /
+		     }
+		  }
+	       close(IN);
+	    }else{
+	       print "Cannot open /proc/mounts to find mountpoint for dev: $uuiddev\n";
+	    }    
+	 }else{
+	    print "Cannot find album mountpoint for identifier $identifier . Skipped.\n";
+	 }
+      }elsif ( $identifier =~/volumeid.*path/ ){
+	 $path=$identifier;
+	 $path=~s/volumeid:\?path=//o;
+	 $path=~s/|$//o;
+	 $refAlbumRoots->{$id}=$path; # Enter Album Data
+      }elsif ( $identifier =~/networkshareid.*mountpath/ ){
+            $mountpath=$identifier;
+            $mountpath=~s/^.*mountpath=//i;
+            $mountpath=uri_unescape($mountpath);
+            $refAlbumRoots->{$id}=$mountpath;	 
+      }else{
+	 $refAlbumRoots->{$id}=$path; # Enter Album Data
+      }	 
+   }
+}
+ 
+# ------------------------------------------------------------------
+# main
+# ------------------------------------------------------------------
+$ret=getopts('VYHh:Car:M:i:e:l:d:A:fvu:p:t:');
+
+if( defined($opt_h) ){
+	usage(0);
+}
+
+if( defined($opt_v) ){
+    print "Version: $version\n";
+    exit 0;    
+}
+
+$verbose=0;
+if( defined($opt_V) ){
+        $verbose=1;	
+}
+
+$dirDate='none';	
+if( defined($opt_Y) ){
+        $dirDate='year';	
+}
+
+$tage='';
+if( defined($opt_e) ){
+	$tage=$opt_e;
+}
+
+$tagi='none';
+if( defined($opt_i) ){
+	$tagi=$opt_i;
+}
+
+$user='';
+if( defined($opt_u) ){
+        $user=$opt_u;
+}
+
+$password='';
+if( defined($opt_p) ){
+        $password=$opt_p;
+}
+
+$type='SQLite';
+if( defined($opt_t) ){
+        $type=$opt_t;
+}
+
+usage if ((!length($opt_l) && ! length($opt_A)) 
+           || !length($opt_d) );
+
+$opt_f=0 if( ! length($opt_f) );
+my $database;
+my $checkVersionCommand;
+# Remove trailing /
+$opt_r=~s/\/$//;
+$opt_l=~s/\/$//;
+#
+$rootDir=$opt_r;
+$linkDir=$opt_l;
+
+if( length($opt_C) ){
+   $cloneMode="full";     # Clone all files/dirs
+}else{
+   $cloneMode="minimal";  # Only clone dirs and files haviong tags not all files
+}
+
+if( length($opt_H) ){
+   $linkMode="hard";  # type of link from linktree to phototree
+}else{
+   $linkMode="symbolic";  # type of link from linktree to phototree
+}
+
+# Check digikam Database "version"
+if ($type eq 'SQLite')
+{
+        if( ! -f $opt_d ){
+                print "Digikam database \"$opt_d\" not found. Exit.\n";
+                exit 1;
+        }
+        $database = DBI->connect("dbi:SQLite:dbname=".$opt_d, "", "")
+               or die "Can't connect to database: $DBI::errstr\n";
+      
+        $checkVersionCommand = "SELECT * FROM sqlite_master WHERE type='table' and name='{name}'";
+}
+elsif ($type eq 'mysql')
+{
+        $database = DBI->connect("dbi:mysql:".$opt_d, $opt_u, $opt_p, {mysql_enable_utf8 => 1} )
+               or die "Can't connect to database: $DBI::errstr\n";
+        $checkVersionCommand = "SELECT table_name FROM INFORMATION_SCHEMA.TABLES WHERE table_schema = 'digikam' and table_name='{name}'";
+
+}
+else
+{
+       print "Type of database \"$type\" unsupported!\n";
+       exit 1;
+}
+
+$vers=checkVersion($database, $checkVersionCommand); # Find out version of digikam
+
+if( ! -d $opt_r && $vers < 10 ){
+	print "Invalid/empty digikam photoroot directory  \"$opt_r\" . Use -r to give correct one. Exit.\n";
+	exit 1;
+}
+
+# For version .10 of digikam and newer get root albumpaths
+$ret=0;
+if( $vers >= 10 ){
+    getAlbumRoots($database, \%albumRoots);
+    foreach $i  (keys(%albumRoots)) {
+      #print "Album roots -> $i:", $albumRoots{$i}, "\n";
+      # Extract data needed from database
+      # Interprete -r as base for all albums
+      $albumRoots{$i}="$opt_r$albumRoots{$i}";
+      $ret+=getTaggedImages(\%images, $database, uri_unescape($albumRoots{$i}),  $i, \%paths, \%pathNames, $vers, $tage, $tagi);
+    }   
+}else{
+    $ret=getTaggedImages(\%images, $database, $opt_r, -1, \%paths, \%pathNames, $vers, $tage, $tagi);
+}
+
+if( $ret != 0 ){
+   warn "$0: Error looking up tag information in database. Exit.\n\n";
+   exit 1;
+}
+
+# Handle Archiving photos and tag structure
+# digikams photo dir will be cloned as a whole by using 
+# either soft or hard links ($cloneMode)
+$fakeRoot="";
+if( length($opt_A) ){
+    #    
+    # Create a new empty directory for coling, rename old if existing
+    $ret=createCloneDir($opt_A, $archiveDirPhotos);
+    if( $vers >= 10 ){
+       foreach $i  (keys(%albumRoots)) {
+           #print "$i, $albumRoots{$i}\n";
+	   $ret+=runClone($albumRoots{$i}, $opt_A, $archiveDirPhotos, $cloneMode, "hard", \%paths, \%pathNames);
+       }
+
+    }else{
+       $ret=runClone($opt_r, $opt_A, $archiveDirPhotos, $cloneMode, "hard", \%paths, \%pathNames);
+    
+    }
+    $fakeRoot="$opt_A/$archiveDirPhotos";
+    $linkDir="$opt_A/$archiveDirLinks";
+}
+
+if( ( length($opt_l) || length($opt_A)) ){
+    # When doing hard links we always use absolute linking
+    if( $linkMode eq "hard" ){
+	warn "Will use absolute hard links for linktree in archive mode...\n" if( !length($opt_a) ); 
+        $opt_a="1";
+    }	
+
+    # Create the link trees for all tagged images
+    if( defined($opt_M) ){
+    	    if ($opt_M !~ /^.*\d+$/){
+    	    	    print "Please specify number of directory level after -M\n";
+		    exit 1;
+    	    }
+	    if( $tagi eq "none" ){
+	    	print "No tags included. Use option -i <taglist>. See help (-h) for more information.\n";
+		exit 1;
+	    }
+    	    $countmax=$opt_M;
+    	    $count=createLinkTreeMulti(\%images, $fakeRoot, $linkDir, $opt_f, $opt_a, $linkMode,$dirDate,$countmax,$verbose);	
+    } else {
+    	    $count=createLinkTree(\%images, $fakeRoot, $linkDir, $opt_f, $opt_a, $linkMode,$dirDate);	
+    }
+    print "Processed $count photos. \n";
+}
+
+$database->disconnect();