ruby on rails - notidentifiedbyimagemagickerror - Guardar las dimensiones de las imágenes(ancho y alto) en Paperclip?

paperclip::errors::missingrequiredvalidatorerror

Question

Cualquier asistente de Paperclip sabe si puede usar Paperclip para guardar una imagen, también guarda las dimensiones de la imagen (ancho y alto) en 2 campos adicionales. ¿Cómo se obtienen esos datos durante el proceso de carga de Paperclip?

Answer 1

Cuando un usuario carga una imagen con clip, la proceso con el siguiente modelo:

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 función get_geometry llama a ImageMagick identify para encontrar la geometría de sus imágenes originales y redimensionadas.

Guardo los resultados en un campo de base de datos. Por ejemplo, si subí una imagen que era 1024x768 mis campos en caché contendrían:

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

Answer 2

Encontré la solución más simple: gema Fastimage (link)

Es rápido y muy, muy simple. Ejemplo:

require ''fastimage''

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

Answer 3

La gema paperclip-meta almacena en caché las dimensiones de la imagen y el tamaño del archivo para todos los estilos de imagen. Se hace referencia en el Paperclip README. El paperclip-meta repo está aquí: https://github.com/teeparham/paperclip-meta

Answer 4

Necesitarás requerir ''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

Sin embargo, no estoy seguro de cómo hacerlo funcionar con las devoluciones de llamada. Tal vez algo así como:

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 5

Solo para completar, aunque las respuestas anteriores ya muestran sugerencias bastante buenas.

Puede utilizar manejadores de eventos Paperclip en lugar de devoluciones de llamada de Rails. En este caso, el tamaño se volverá a calcular solo cuando la imagen cambie. (Si está utilizando S3 para almacenamiento, esto puede ahorrar bastante tiempo)

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

La imagen ni siquiera tiene que descargarse de S3 (o leer de un archivo), el clip lo proporciona al controlador de eventos.

Ver la sección de Eventos del archivo léame para más detalles.

Answer 6

Uso de Rails 4 Utilizo la siguiente Preocupación para guardar las dimensiones de la imagen:

    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

Entonces en tu modelo:

...

include Dimensions

extract_dimensions_for :image

...

Esto guardará sus dimensiones en un campo serializado llamado image_dimensions así como también agregará algunos otros métodos image_width , image_height y image_dimensions_max(width, height)