macdiggs.com

I have recently started using attachment_fu plugin to store attachments (including images, of course) in database. attachment_fu provides functionality to create thumbnail images during upload, but you can't really foresee what thumbnail sizes you will need down the road, can't you?

That's why I decided not to make any thumbnails at all during the upload stage (except for basic resizing so I will not end up with 4K-pixels images in database.

I store all the images in database (easier to migrate, easier to backup) , which adds some level of complixity when you try to output stuff to the user.

Having all that, I wanted to be able to easily output page_cachable resized images. Here's how I have implemented it.

First of all, I have GalleryImage class which "has_one :fu_attachment", which in turn "has_attachment" (and that's where attachment_fu starts to do its magic).

Here's the FuAttachment model:

class FuAttachment < ActiveRecord::Base
belongs_to :gallery_image, :foreign_key => "parent_id"
has_attachment :max_size => 30.megabytes,
:resize_to => '800×700>'

validates_as_attachment

def full_filename
""
end

end

The full_name function definition returning blank string is required because of a bug in attachment_fu (it doesn't return full_filename if you store images in database).
And GallerImage model looks like this:

class GalleryImage < ActiveRecord::Base
belongs_to :user
has_one :fu_attachment, :dependent => :destroy, :as => "parent"

def uploaded_data=(data)
oneAttachment = FuAttachment.new(:uploaded_data => data, :parent_id => self.id)
if oneAttachment.save
self.fu_attachment = oneAttachment
else
errors.add(:gallery_image, _("file could not be uploaded"))
end
end

end

Having all that, here's how my image-resizing controllers looks like:

class GalleryImageController < ApplicationController

def thumbnail
outputResized("100×82")
end

def outputResized(geom, quality=75)
begin
@picture = GalleryImage.find(params[:id])
thePic = @picture.fu_attachment
unless thePic.nil?
image = Magick::Image.from_blob(thePic.db_file.data).first
image.change_geometry!(geom) { |cols, rows, img|
img.resize!(cols, rows)
}

send_data (image.to_blob() {self.quality = quality}, :type => thePic.content_type,
:filename => thePic.filename,
:disposition => 'inline')
end
rescue
# can't display an image for any reason at all.
end
endend

When you need to output resized image, just use /gallery_image/thumbnail/<id> path. If you decide to add a new resize option, just duplicated the thumbnail function, give it a new name and set new parameters for outputResized function.

You definitely will want to cache the resizing results. In order to do that, just add "caches_page :thumbnail" just above "def thumbnail" function.

The approach might be not perfect, but it works, and it good enough to my purposes. Of course any comments are welcomed.

This entry was posted on Tuesday, July 10th, 2007 at 4:31 pm and is filed under Ruby, Ruby on Rails. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.