gf-ralbum 0.0.2 → 0.0.5

data/lib/ralbum/image_strategies/copy_image_strategy.rb

@@ -0,0 +1,16 @@
+#
+# Copy an image from inpath to outpath
+#
+class CopyImageStrategy
+  attr_reader :name
+
+  def initialize( name )
+    @name = name
+  end
+
+  def build( inpath, outpath )
+    FileUtils.cp( inpath, outpath )
+  end
+
+end
+

data/lib/ralbum/image_strategies/linked_image_strategy.rb

@@ -0,0 +1,18 @@
+#
+# Create a link from inpath to outpath
+#
+class LinkedImageStrategy
+
+  attr_reader :name
+
+  def initialize( name )
+    @name = name
+  end
+
+  def build( inpath, outpath )
+    return if File.exist?( outpath )
+    ralbum_verbose( 1, "link " )
+    File.symlink( inpath, outpath )
+  end
+
+end

data/lib/ralbum/image_strategies/scaled_image_strategy.rb

@@ -0,0 +1,52 @@
+#
+# Strategy for build a scaled image
+#
+class ScaledImageStrategy
+
+  attr_reader :name, :width, :height, :quality
+
+  def initialize( name, width, height, quality )
+    @name = name
+    @width = width
+    @height = height
+    @quality = quality
+  end
+
+
+  #
+  # build a scaled image and store it in outpath
+  #
+  # inpath source image file
+  # outpath destination image file
+  #
+  # TODO: sostituire inpath con PhotoFile
+  # TODO: sostituire outpath con ImageFile
+  def build( inpath, outpath )
+    # TODO: ritornare un risultato per es. 1 = skipped 2 = copiato 3 = scalata immagine
+    result_msg = ""
+    img = Magick::ImageList.new(inpath)
+
+    if @width > img.columns and @height > img.rows
+      result_msg = "(c) "
+      # FileUtils.cp( inpath, outpath )
+      # rimuovere i metadata
+    else
+      result_msg = "(#{@quality}%) "
+      img.resize_to_fit!(@width, @height)
+    end
+    img.profile!('*', nil)
+
+    img.write(outpath) {|i| i.quality = quality }
+    result_msg
+  end
+
+  def write_xml( xml_iss )
+    xml_is = xml_iss.add_element( "image_strategy")
+    xml_is.attributes["name"] = self.class.to_s
+    xml_par = xml_is.add_element("par")
+    xml_par.attributes["width"] = @width.to_s
+    xml_par.attributes["height"] = @height.to_s
+    xml_par.attributes["quality"] = @quality.to_s
+  end
+
+end

data/lib/ralbum/image_strategies/sepia_scaled_image_strategy.rb

@@ -0,0 +1,50 @@
+#
+# Strategy for build a scaled image
+#
+class SepiaScaledImageStrategy
+
+  attr_reader :name, :width, :height, :quality
+
+  def initialize( name, width, height, quality )
+    @name = name
+    @width = width
+    @height = height
+    @quality = quality
+  end
+
+  #
+  # build a scaled image and store it in outpath
+  #
+  # inpath source image file
+  # outpath destination image file
+  #
+  def build( inpath, outpath )
+    # TODO: ritornare un risultato per es. 1 = skipped 2 = copiato 3 = scalata immagine
+    result_msg = ""
+    img = Magick::ImageList.new(inpath)
+
+    if @width > img.columns and @height > img.rows
+      result_msg = "(c) "
+      # FileUtils.cp( inpath, outpath )
+      # rimuovere i metadata
+    else
+      result_msg = "(#{@quality}%) "
+      img.resize_to_fit!(@width, @height)
+    end
+    img = img.sepiatone
+    img.profile!('*', nil)
+
+    img.write(outpath) {|i| i.quality = quality }
+    result_msg
+  end
+
+  def write_xml( xml_iss )
+    xml_is = xml_iss.add_element( "image_strategy")
+    xml_is.attributes["name"] = self.class.to_s
+    xml_par = xml_is.add_element("par")
+    xml_par.attributes["width"] = @width
+    xml_par.attributes["height"] = @height
+    xml_par.attributes["quality"] = @quality
+  end
+
+end

data/lib/ralbum/photo_tree/jalbum_photo_tree.rb

@@ -0,0 +1,83 @@
+# treevisitor
+require 'treevisitor/tree_node_visitor'
+require 'treevisitor/dir_tree_walker'
+require 'treevisitor/visitors/callback_tree_node_visitor2'
+
+# ralbum
+require 'ralbum/catalog'
+require 'ralbum/photo_tree/photo_tree_item'
+require 'ralbum/photo_tree/photo_tree_node'
+
+class JalbumPhotoTreeBuilder
+
+  def run( phototree_dirname )
+    photoTree = build_photo_tree_from_directory( phototree_dirname )
+    # read_meta_info_old_format( photoTree )
+    # update_meta_info( photoTree )
+    photoTree
+  end
+
+  # ------------------------------------------------------------------------------
+  #
+  # build photo tree senza metainfo
+  #
+
+  def build_photo_tree_from_directory( jalbum_dirname )
+    ralbum_verbose( 1, "phototree - building phototree from #{jalbum_dirname}" )
+
+    @photo_tree_dirname = jalbum_dirname
+    dtw = DirTreeWalker.new( jalbum_dirname )
+
+    # TODO: ignorare tutti le directory che iniziano per "." questa deve essere un'opzione di DirTreeWalker
+    dtw.add_ignore_dir( ".svn" )
+    dtw.add_ignore_dir( ".csv" )
+    dtw.add_ignore_dir( ".git" )
+    dtw.add_ignore_dir( Catalog::DEFAULT_CATALOG_DIRNAME )
+
+    dtw.add_ignore_pattern(".jalbum")
+
+    visitor = CallbackTreeNodeVisitor2.new(self)
+    dtw.run( visitor ).root # return a photo_tree
+  end
+
+  def on_enter_tree_node(pathname, parent)
+    # puts "_on_enter_tree_node #{pathname}"
+
+    if parent.nil?
+      photo_tree_node = PhotoTreeNode.new( File.basename(pathname) , parent )
+      photo_tree_node.prefix_path= File.dirname( pathname ) + File::SEPARATOR
+    else
+      photo_tree_node = PhotoTreeNode.new( File.basename(pathname), parent )
+    end
+
+    albumfiles_path = File.join(pathname, "albumfiles.txt")
+    if File.exist?( albumfiles_path )
+      create_leaf_node_from_album_file( photo_tree_node, albumfiles_path )
+    end
+    photo_tree_node
+  end
+
+  def on_visit_leaf_node( src_leaf_node, parent_node )
+  end
+
+  def create_leaf_node_from_album_file(parent, albumfiles_path)
+    # puts "-----------------"
+    File.open(albumfiles_path).each_line do |line|
+      i = line.index('#')
+      if i
+        next if i == 0
+        line = [0..i-1].strip
+      end
+      next if line.length == 0
+
+      image_filename = line.split("\t")[1]
+      next if image_filename.nil?
+      image_filename.chomp!
+      # puts image_filename
+
+      PhotoTreeItem.new(image_filename, parent )
+    end
+    # puts "----------------"
+  end
+
+end

data/lib/ralbum/photo_tree/photo_file.rb

@@ -0,0 +1,149 @@
+class PhotoFile
+
+  attr_reader :path 
+  attr_reader :size
+  attr_reader :width
+  attr_reader :height
+  attr_reader :geometry
+
+  def initialize( path )
+    if not File.exist?(path)
+      raise RAlbumException.new "file '#{path}' not exist"
+    end
+    if File.directory?(path)
+      raise RAlbumException.new "expected '#{path}' as file but it is a directory"
+    end
+
+    read_info(path)
+  end
+
+  def time
+    return @time if ! @time.nil?
+    @time = File.mtime( @path )
+  end
+
+  def md5
+    return @md5 if @md5
+    blob = File.open(path, "rb") do |f|
+      f.read
+    end
+    @md5 = MD5.new( blob ).to_s
+    # ralbum_verbose( 2, sprintf("%40s: %d %s \n", name, time, @md5 ) )
+  end
+
+  def to_s
+    s = @path + "\n"
+    s << sprintf("%40s: %s \n", "file size",     "#{@size} Kb")
+    s << sprintf("%40s: %s \n", "image size",    "#{@width} X #{@height}")
+    s << sprintf("%40s: %s \n", "timestamp",     "#{@timestamp}")
+    s << sprintf("%40s: %s \n", "exposuretime",  "#{@exposuretime} ")
+    s << sprintf("%40s: %s \n", "aperture",      "#{@aperture}")
+    s << sprintf("%40s: %s \n", "exposure_bias", "#{@exposure_bias}")
+    s << sprintf("%40s: %s \n", "flash",         "#{@flash}")
+    s << sprintf("%40s: %s \n", "focal_length",  "#{@focal_length}")
+    s << sprintf("%40s: %s \n", "iso_speed","#{@iso_speed}")
+
+    s << sprintf("%40s: %s \n", "caption","#{@caption}")
+    s << sprintf("%40s: %s \n", "keywords","#{@keywords}")
+    s << sprintf("%40s: %s \n", "copyright","#{@copyright}")
+    s
+  end
+
+  private
+
+  def read_info(path)
+    @path = path
+    image = Magick::Image::read(@path).first
+    @width  = image.columns
+    @height = image.rows
+    @geometry = "#{@width} X #{@height}"
+    @size   = image.filesize / 1024
+
+    # exif:ExposureBiasValue
+
+    # puts "   Format: #{image.format}"
+
+    #    class_type = case image.class_type
+    #    when Magick::DirectClass
+    #      "DirectClass"
+    #    when Magick::PseudoClass
+    #      "PseudoClass"
+    #    end
+    #    puts "   Class: " + class_type
+
+    #    puts "   Depth: #{image.depth} bits-per-pixel"
+    #    puts "   Colors: #{image.number_colors}"
+    #    puts "   Filesize: #{image.filesize}"
+    #    puts "   Resolution: #{image.x_resolution.to_i}x#{image.y_resolution.to_i} "+
+    #      "pixels/#{image.units == Magick::PixelsPerInchResolution ?
+    #    "inch" : "centimeter"}"
+
+    if image.properties.length > 0
+      #      puts "   Properties:"
+      #      image.properties { |name,value|
+      #        puts %Q|      #{name} = "#{value}"|
+      #      }
+
+
+      @timestamp = image.properties['exif:DateTimeOriginal']
+      @exposuretime = image.properties['exif:ExposureTime']
+      @aperture = image.properties['exif:FNumber']
+      @exposure_bias = ""
+      @flash = image.properties['exif:Flash']
+
+      # 85/1 -> 85 mm
+
+      @focal_length = image.properties['exif:FocalLength']
+      unless @focal_length.nil?
+        focal_length_split = @focal_length.split("/")
+        if focal_length_split.length > 2 and focal_length_split[1] == "1"
+          @focal_length = focal_length_split[0] + " mm"
+        end
+      end
+
+
+      @iso_speed = image.properties['exif:ISOSpeedRatings']
+    end
+
+    #    # puts image.iptc_profile
+    #    puts image.each_iptc_dataset { |dataset, data_field|
+    #      puts "#{dataset} -> #{data_field}"
+    #    }
+
+    @copyright = image.get_iptc_dataset(Magick::IPTC::Application::Copyright_Notice)
+    @keywords  = image.get_iptc_dataset(Magick::IPTC::Application::Keywords)
+    @caption   = image.get_iptc_dataset(Magick::IPTC::Application::Caption)
+  end
+
+  #  def force_read_metainfo
+  #    unless File.exist?(path)
+  #      raise RAlbumException.new "photo '#{path}' not exists"
+  #    end
+  #    blob = File.open(path, "rb") do |f|
+  #      f.read
+  #    end
+  #    @md5 = MD5.new( blob ).to_s
+  #    ralbum_verbose( 2, sprintf("%40s: %d %s \n", name, time, @md5 ) )
+  #
+  #    image = Magick::ImageList.new
+  #    image.from_blob( blob )
+  #    set_exif_property(image, "model", "Model")
+  #    set_exif_property(image, "date_and_time", "DateTimeOriginal")
+  #    set_exif_property(image, "FocalLength", "FocalLengthIn35mmFilm")
+  #    set_exif_property(image, "exposure_time", "ExposureTime")
+  #    set_exif_property(image, "white_balance", "WhiteBalance")
+  #    set_exif_property(image, "iso_speed", "ISOSpeedRatings")
+  #
+  #    @properties['width']  = image.columns
+  #    @properties['height'] = image.rows
+  #  end
+
+  #  def set_exif_property(image, key_xml, key_exif )
+  #    a = image.get_exif_by_entry(key_exif)
+  #    if a && ( value = a[0][1] )
+  #      @properties[key_xml] = value
+  #    end
+  #  end
+
+end
+

data/lib/ralbum/photo_tree/photo_tree_item.rb

@@ -0,0 +1,68 @@
+# treevisitor
+require 'gf_utilities/md5'
+require 'treevisitor/leaf_node'
+
+# ralbum
+require 'ralbum'
+require 'ralbum/options'
+require 'ralbum/ralbum_exception'
+require 'ralbum/photo_tree/photo_file'
+
+#
+# PhotoTreeItem contains a "photo"
+# (it is different from image; only albums contains images)
+#
+class PhotoTreeItem < LeafNode
+
+  attr_reader :photo_file
+
+  attr_accessor :title
+  attr_accessor :description
+
+  def initialize( filename, photo_tree_node )
+    @title = nil
+    @description = nil
+    
+    if photo_tree_node.nil?
+      raise RAlbumException.new("photo_tree_node cannot be nil")
+    end
+    if File.dirname( filename ) == "."
+      filename = File.join( photo_tree_node.path_with_prefix, filename )
+    end
+    super( filename, photo_tree_node )
+    @photo_file = PhotoFile.new(filename)
+  end
+  
+  def basename
+    File.basename( name )
+  end
+
+  def to_s
+    if title and not title.empty?
+      "'#{basename}': '#{title}'"
+    else
+      "'#{basename}'"
+    end
+  end
+
+  ############################################################################
+  # configurations
+      
+  def write_xml( xml_el )
+    xml_photo = xml_el.add_element( "photo" )            
+    xml_photo.add_element("md5").text = md5
+    xml_photo.add_element("title").text = name
+    xml_photo.add_element("description").text = self["description"]
+    xml_photo.add_element("file_date").text = time
+    
+    xml_exif = xml_photo.add_element("exif")
+    xml_exif.add_element("model").text         = self["model"]
+    xml_exif.add_element("date_and_time").text = self["date_and_time"]
+    xml_exif.add_element("FocalLength").text   = self["FocalLength"]
+    xml_exif.add_element("exposure_time").text = self["exposure_time"]
+    xml_exif.add_element("white_balance").text = self["white_balance"]
+    xml_exif.add_element("iso_speed").text     = self["iso_speed"]
+  end
+
+end
+