Salvataggio delle immagini Dimensioni (larghezza e altezza) in Graffetta?

Question

Qualsiasi mago Paperclip là fuori sa se puoi usare Paperclip per salvare un'immagine, salvare anche le dimensioni dell'immagine (larghezza e altezza) in 2 campi extra? Come si ottengono tali dati durante il processo di caricamento di Paperclip?

Answer 1

Sarà necessario richiedere 'RMagick'

uploaded_image = Magick::Image.read(image).first #image is what you've specified in paperclip to be your image 
width = uploaded_image.columns 
height = uploaded_image.rows 

Non sai come farlo lavorare con i callback, però. Forse qualcosa di simile:

attr_accessor :write_image_dimensions? 
before_save :check_image_changed 

def check_image_changed 
    self.write_image_dimensions? = image_changed? 
end 

after_save :write_image_dimensions, :if => :write_image_dimensions? 

def write_image_dimensions 
    uploaded_image = Magick::Image.read(image).first #image is what you've specified in paperclip to be your image 
    self.width = uploaded_image.columns 
    self.height = uploaded_image.rows 
    save 
end 

Answer 2

Quando un utente carica un'immagine con graffetta ho elaborarlo con il seguente modello:

class Picture < ActiveRecord::Base 
    has_attached_file :pic, :styles => { :small => "100x100>" }, :whiny => true 
    after_save :save_geometry 

    def save_geometry 
    unless @geometry_saved 
     self.original_geometry = get_geometry(:original) 
     self.small_geometry = get_geometry(:small) 
     @geometry_saved = true 
     self.save 
    end 
    end 

    def get_geometry(style = :original) 
    begin 
     Paperclip::Geometry.from_file(pic.path(style)).to_s 
    end 
    end 
end 

La funzione get_geometry chiamate ImageMagick identify per trovare la geometria delle immagini originali e ridimensionate .

Memorizzo i risultati in un campo del database. Per esempio, se ho caricato un'immagine che era 1024x768 miei campi memorizzati nella cache potrebbero contenere:

original_geometry = "1024x768" 
small_geometry = "100x75" 

Answer 3

Solo per ragioni di completezza, anche se le risposte precedenti mostrano già abbastanza buoni suggerimenti.

È possibile utilizzare i gestori di eventi di Paperclip anziché i callback di Rails. In questo caso, le dimensioni verranno ricalcolate solo quando l'immagine cambia. (Se stai usando S3 per lo storage, questo può risparmiare un bel po 'di tempo)

has_attached_file :image, :styles => ... 
after_post_process :save_image_dimensions 

def save_image_dimensions 
    geo = Paperclip::Geometry.from_file(image.queued_for_write[:original]) 
    self.image_width = geo.width 
    self.image_height = geo.height 
end 

Immagine non hanno nemmeno bisogno di essere scaricato da S3 (o leggere da un file), graffetta fornisce al gestore di eventi per sé .

Vedere sezione di the readme per dettagli.

Answer 4

Uso Rails 4 Io uso il seguente Preoccupazione per salvare le dimensioni delle immagini:

module Dimensions 

     extend ActiveSupport::Concern 

     included do 

     end 

     module ClassMethods 

     def extract_dimensions_for *fields 

      define_method(:extract_dimensions_field_list) { fields } 

      before_save :extract_dimensions 

      fields.each do |f| 
      serialize (f.to_s+"_dimensions"), Hash 

      class_eval do 

       [:width, :height].each do |axis| 
       define_method("#{f}_#{axis}") do 
        return send(f.to_s+"_dimensions")[axis] 
       end 
       end 

       define_method("#{f}_dimensions_max") do |width, height=nil| 
       dims = send(f.to_s+"_dimensions") 
       rw = width.to_f/dims[:width] 
       rh = height.to_f/dims[:height] if height 
       r = (!height || rw < rh) ? rw : rh 
       return {width: (dims[:width] * r).to_i, height: (dims[:height] * r).to_i} 
       end 

       define_method("#{f}_is_portrait?") do 
       dims = send(f.to_s+"_dimensions") 
       return dims[:width] <= dims[:height] 
       end 

       define_method("#{f}_is_landscape?") do 
       dims = send(f.to_s+"_dimensions") 
       return dims[:width] > dims[:height] 
       end 

      end 

      end 

      class_eval do 

      def extract_dimensions 

       extract_dimensions_field_list.each do |f| 

       tempfile = send(f).queued_for_write[:original] 
       unless tempfile.nil? 
        geometry = Paperclip::Geometry.from_file(tempfile) 
        self.send(f.to_s+"_dimensions=", {width: geometry.width.to_i, height: geometry.height.to_i}) 
       end 

       end 

      end 

      end 

     end 

     end 


    end 

Poi nel modello:

... 

include Dimensions 

extract_dimensions_for :image 

... 

Ciò salvare le dimensioni per un campo serializzato chiamato image_dimensions così come aggiungendo qualche altro metodo image_width, image_height e image_dimensions_max(width, height)

Answer 5

Ho trovato il solut più semplice ione: Fastimage gem (link)

È veloce e molto, molto semplice. Esempio:

require 'fastimage' 

FastImage.size("/some/local/file.gif") 
=> [266, 56] # width, height 
FastImage.type("/some/local/file.gif") 
=> :gif 

Answer 6

La gemma graffetta-meta memorizza nella cache le dimensioni dell'immagine e la dimensione del file per tutti gli stili di immagine. Si è fatto riferimento nel README Paperclip. Il repository paperclip-meta è qui: https://github.com/teeparham/paperclip-meta