Class: Gluttonberg::Library::Processor::Image

Inherits:
Object
  • Object
show all
Defined in:
lib/gluttonberg/library/processor/image.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#asset ⇒ Object

Returns the value of attribute asset.



6
7
8
 
# File 'lib/gluttonberg/library/processor/image.rb', line 6

def asset
  @asset
end

Class Method Details

.process(asset_obj) ⇒ Object 



8
9
10
11
12
13
14
 
# File 'lib/gluttonberg/library/processor/image.rb', line 8

def self.process(asset_obj)
  if asset_obj.asset_type.asset_category.name == "image"
    processor = self.new
    processor.asset = asset_obj
    processor.generate_thumb_and_proper_resolution
  end
end

Instance Method Details

#generate_cropped_image(x, y, w, h, image_type) ⇒ Object 



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/gluttonberg/library/processor/image.rb', line 51

def generate_cropped_image(x , y , w , h, image_type)
  asset_thumb = asset.asset_thumbnails.find(:first , :conditions => {:thumbnail_type => image_type.to_s })
  if asset_thumb.blank?
    asset_thumb = asset.asset_thumbnails.create({:thumbnail_type => image_type.to_s , :user_generated => true })
  else
    asset_thumb.update_attributes(:user_generated => true)
  end

  file_name = "#{asset.class.sizes[image_type.to_sym][:filename]}.#{asset.file_extension}"
  begin
    image = QuickMagick::Image.read(asset.tmp_original_file_on_disk).first
  rescue
    image = QuickMagick::Image.read(asset.tmp_original_file_on_disk).first
  end
  thumb_defined_width = asset.class.sizes[image_type.to_sym][:geometry].split('x').first#.to_i
  scaling_percent = (thumb_defined_width.to_i/(w.to_i*1.0))*100
  image.arguments << " -crop #{w}x#{h}+#{x}+#{y} +repage"
  if scaling_percent != 1.0
    image.arguments << " -resize #{scaling_percent}%"
  end
  image.save File.join(asset.tmp_directory, file_name)
  asset.move_tmp_file_to_actual_directory(file_name , true)
end

#generate_image_thumb ⇒ Object

Create thumbnailed versions of image attachements. TODO: generate thumbnails with the correct extension



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/gluttonberg/library/processor/image.rb', line 77

def generate_image_thumb
  asset.class.sizes.each_pair do |name, config|
    asset_thumb = asset.asset_thumbnails.find(:first , :conditions => {:thumbnail_type => name.to_s, :user_generated => true })
    if asset_thumb.blank?
      begin
        image = QuickMagick::Image.read(asset.tmp_original_file_on_disk).first
      rescue
        image = QuickMagick::Image.read(asset.tmp_location_on_disk).first
      end

      file_name = "#{config[:filename]}.#{asset.file_extension}"

      if config[:geometry].include?("#")
        #todo
        begin
          image.resize(suggested_measures(image, config[:geometry]))
          image.arguments << " -gravity Center  -crop #{config[:geometry].delete("#")}+0+0 +repage #{config[:grayscale] && config[:grayscale] == true ? "-colorspace Gray":""}"
        rescue => e
          puts e
        end
      else
        image.resize config[:geometry]
        image.arguments << "-colorspace Gray" if config[:grayscale] && config[:grayscale] == true
      end
      image.save File.join(asset.tmp_directory, file_name)
      asset.move_tmp_file_to_actual_directory(file_name, true)
    end # asset_thumb.blank?
  end # sizes loop

  asset.update_attribute(:custom_thumbnail , true)
end

#generate_proper_resolution ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/gluttonberg/library/processor/image.rb', line 109

def generate_proper_resolution
  asset.make_backup
  begin
    image = QuickMagick::Image.read(asset.tmp_original_file_on_disk).first
  rescue => e
    image = QuickMagick::Image.read(asset.tmp_location_on_disk).first
  end

  actual_width = image.width.to_i
  actual_height = image.height.to_i

  asset.update_attributes( :width => actual_width ,:height => actual_height)

  image.resize asset.class.max_image_size
  image.save File.join(asset.tmp_directory, asset.file_name)
  asset.move_tmp_file_to_actual_directory(asset.file_name , true)
  # remove mp3 info if any image have. it may happen in the case of updating asset from mp3 to image
  audio = AudioAssetAttribute.find( :first , :conditions => {:asset_id => asset.id})
  audio.destroy unless audio.blank?
end

#generate_thumb_and_proper_resolution ⇒ Object

Generates thumbnails for images, but also additionally checks to see if the uploaded image exceeds the specified maximum, in which case it will resize it down.



18
19
20
21
 
# File 'lib/gluttonberg/library/processor/image.rb', line 18

def generate_thumb_and_proper_resolution
  generate_proper_resolution
  generate_image_thumb
end

#suggested_measures(object, required_geometry) ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/gluttonberg/library/processor/image.rb', line 23

def suggested_measures(object , required_geometry)
  required_geometry = required_geometry.delete("#")
  required_geometry_tokens = required_geometry.split("x")
  actual_width = object.width.to_i
  actual_height = object.height.to_i
  required_width = required_geometry_tokens.first.to_i
  required_height = required_geometry_tokens.last.to_i

  ratio_required = required_width.to_f / required_height
  ratio_actual = actual_width.to_f / actual_height

  crossover_ratio = required_height.to_f / actual_height
  crossover_ratio2 = required_width.to_f / actual_width

  if(crossover_ratio < crossover_ratio2 )
    crossover_ratio = crossover_ratio2
  end

  projected_height = actual_height * crossover_ratio

  if(projected_height < required_height )
    required_width = required_width * (1 + (ratio_actual -  ratio_required ) )
  end
  projected_width = actual_width * crossover_ratio

  "#{(projected_width).ceil}x#{(projected_width/ratio_actual).ceil}"
end