image_vise 0.2.1 → 0.2.2

data/lib/image_vise/file_response.rb

@@ -0,0 +1,22 @@
+# Wrappers a given Tempfile for a Rack response.
+# Will close _and_ unlink the Tempfile it contains.
+class ImageVise::FileResponse
+  ONE_CHUNK_BYTES = 1024 * 1024 * 2
+  def initialize(file)
+    @file = file
+  end
+
+  def each
+    @file.flush # Make sure all the writes have been synchronized
+    # We can easily open another file descriptor
+    File.open(@file.path, 'rb') do |my_file_descriptor|
+      while data = my_file_descriptor.read(ONE_CHUNK_BYTES)
+        yield(data)
+      end
+    end
+  end
+
+  def close
+    ImageVise.close_and_unlink(@file)
+  end
+end

data/lib/image_vise/image_request.rb

@@ -0,0 +1,70 @@
+require 'openssl'
+
+class ImageVise::ImageRequest < Ks.strict(:src_url, :pipeline)
+  class InvalidRequest < ArgumentError; end
+  class SignatureError < InvalidRequest; end
+  class URLError < InvalidRequest; end
+  class MissingParameter < InvalidRequest; end
+  
+  # Initializes a new ParamsChecker from given HTTP server framework
+  # params. The params can be symbol- or string-keyed, does not matter.
+  def self.from_params(qs_params:, secrets:)
+    base64_encoded_params = qs_params.fetch(:q) rescue qs_params.fetch('q')
+    given_signature = qs_params.fetch(:sig) rescue qs_params.fetch('sig')
+
+    # Unmask slashes and equals signs (if they are present)
+    base64_encoded_params = base64_encoded_params.tr('-', '/').tr('_', '+')
+
+    # Check the signature before decoding JSON (since we will be creating symbols)
+    unless valid_signature?(base64_encoded_params, given_signature, secrets)
+      raise SignatureError, "Invalid or missing signature"
+    end
+
+    # Decode the JSON
+    # (only AFTER the signature has been validated, so we can use symbol keys)
+    decoded_json = Base64.decode64(base64_encoded_params)
+    params = JSON.parse(decoded_json, symbolize_names: true)
+
+    # Pick up the URL and validate it
+    source_url_str = params.fetch(:src_url).to_s
+    raise URLError, "the :src_url parameter must be non-empty" if source_url_str.empty?
+    pipeline_definition = params.fetch(:pipeline)
+    new(src_url: URI(source_url_str), pipeline: ImageVise::Pipeline.from_param(pipeline_definition))
+  rescue KeyError => e
+    raise InvalidRequest.new(e.message)
+  end
+
+  def to_path_params(signed_with_secret)
+    qs = to_query_string_params(signed_with_secret)
+    q_masked = qs.fetch(:q).tr('/', '-').tr('+', '_')
+    '/%s/%s' % [q_masked, qs[:sig]]
+  end
+
+  def to_query_string_params(signed_with_secret)
+    payload = JSON.dump(to_h)
+    base64_enc = Base64.strict_encode64(payload).gsub(/\=+$/, '')
+    {q: base64_enc, sig: OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, signed_with_secret, base64_enc)}
+  end
+
+  def to_h
+    {pipeline: pipeline.to_params, src_url: src_url.to_s}
+  end
+  
+  def cache_etag
+    Digest::SHA1.hexdigest(JSON.dump(to_h))
+  end
+
+  private
+
+  def self.valid_signature?(for_payload, given_signature, secrets)
+    # Check the signature against every key that we have,
+    # since different apps might be using different keys
+    seen_valid_signature = false
+    secrets.each do | stored_secret |
+      expected_signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, stored_secret, for_payload)
+      result_for_this_key = Rack::Utils.secure_compare(expected_signature, given_signature)
+      seen_valid_signature ||= result_for_this_key
+    end
+    seen_valid_signature
+  end
+end

data/lib/image_vise/operators/auto_orient.rb

@@ -0,0 +1,10 @@
+# Applies ImageMagick auto_orient to the image, so that i.e. mobile photos
+# can be oriented correctly. The operation is applied destructively (changes actual pixel data)
+#
+# The corresponding Pipeline method is `auto_orient`.
+class ImageVise::AutoOrient
+  def apply!(magick_image)
+    magick_image.auto_orient!
+  end
+  ImageVise.add_operator 'auto_orient', self
+end

data/lib/image_vise/operators/background_fill.rb

@@ -0,0 +1,18 @@
+# Applies a background fill color.
+# Can handle most 'word' colors and hex color codes but not RGB values.
+#
+# The corresponding Pipeline method is `background_fill`.
+class ImageVise::BackgroundFill < Ks.strict(:color)
+  def initialize(*)
+    super
+    self.color = color.to_s
+    raise ArgumentError, "the :color parameter must be present and not empty" if self.color.empty?
+  end
+
+  def apply!(image)
+    image.border!(0, 0, color)
+    image.alpha(Magick::DeactivateAlphaChannel)
+  end
+
+  ImageVise.add_operator 'background_fill', self
+end

data/lib/image_vise/operators/crop.rb

@@ -0,0 +1,32 @@
+# Crops the image to the given dimensions with a given gravity. Gravities are shorthand versions
+# of ImageMagick gravity parameters (see GRAVITY_PARAMS)
+#
+# The corresponding Pipeline method is `crop`.
+class ImageVise::Crop < Ks.strict(:width, :height, :gravity)
+  GRAVITY_PARAMS = {
+    'nw' => Magick::NorthWestGravity,
+    'n' => Magick::NorthGravity,
+    'ne' => Magick::NorthEastGravity,
+    'w' => Magick::WestGravity,
+    'c' => Magick::CenterGravity,
+    'e' => Magick::EastGravity,
+    'sw' => Magick::SouthWestGravity,
+    's' => Magick::SouthGravity,
+    'se' => Magick::SouthEastGravity,
+  }
+  
+  def initialize(*)
+    super
+    self.width = width.to_i
+    self.height = height.to_i
+    raise ArgumentError, ":width must positive" unless width > 0
+    raise ArgumentError, ":height must positive" unless height > 0
+    raise ArgumentError, ":gravity must be within the permitted values" unless GRAVITY_PARAMS.key? gravity
+  end
+  
+  def apply!(image)
+    image.crop!(GRAVITY_PARAMS.fetch(gravity), width, height, remove_padding_data_outside_window = true)
+  end
+
+  ImageVise.add_operator 'crop', self
+end

data/lib/image_vise/operators/ellipse_stencil.rb

@@ -0,0 +1,70 @@
+# Applies an elliptic stencil around the entire image. The stencil will fit inside the image boundaries,
+# with about 1 pixel cushion on each side to provide smooth anti-aliased edges. If the input image to be
+# provessed is square, the ellipse will turn into a neat circle.
+#
+# This adds an alpha channel to the image being processed (and premultiplies the RGB channels by it). This
+# will force the RenderEngine to return the processed image as a PNG in all cases, instead of keeping it
+# in the original format.
+#
+# The corresponding Pipeline method is `ellipse_stencil`.
+class ImageVise::EllipseStencil
+  C_black = 'black'.freeze
+  C_white = 'white'.freeze
+  private_constant :C_white, :C_black
+
+  def apply!(magick_image)
+    width, height = magick_image.columns, magick_image.rows
+    
+    # This is a bit involved. We need to do a manual composite. Here is what it entails.
+    #
+    # Given a premultiplied RGB image B, and a grayscale mask A, we need to do the following
+    # operation:
+    #
+    #    BrBgBb / Ba * (Ba * A)
+    #
+    # Since ImageMagick works with unpremultiplied alphas, it is doable - but special care
+    # must be taken not to overmult or overdivide.
+    #
+    # To begin,generate a black and white image for the stencil
+    mask = Magick::Image.new(width, height)
+    draw_circle(mask, width, height)
+    
+    # At this stage the mask contains a B/W image of the circle, black outside, white inside.
+    # Retain the alpha of the original in a separate image
+    only_alpha = magick_image.copy
+    only_alpha.alpha(Magick::ExtractAlphaChannel)
+    mask.composite!(only_alpha, Magick::CenterGravity, Magick::MultiplyCompositeOp)
+    
+    # With this composite op, enabling alpha on the destination image is
+    # not required - it will be enabled automatically.
+    # The CopyOpacityCompositeOp implies that we copy the grayscale version
+    # of the RGB channels as the alpha channel, so for some weird reason we need
+    # to disable the alpha on our mask image
+    mask.alpha(Magick::DeactivateAlphaChannel)
+    # And perform the operation (set gray(RGB) of mask as the A of magick_image)
+    magick_image.composite!(mask, Magick::CenterGravity, Magick::CopyOpacityCompositeOp)
+  ensure
+    [mask, only_alpha].each do |maybe_image|
+      ImageVise.destroy(maybe_image)
+    end
+  end
+  
+  def draw_circle(into_image, width, height)
+    center_x = (width / 2.0)
+    center_y = (height / 2.0)
+    # Make sure all the edges are anti-aliased
+    radius_width = center_x - 1.5
+    radius_height = center_y - 1.5
+
+    gc = Magick::Draw.new
+    gc.fill C_black
+    gc.rectangle(0, 0, width, height)
+    gc.fill C_white
+    gc.ellipse(center_x, center_y, radius_width, radius_height, deg_start=0, deg_end=360)
+    gc.draw(into_image)
+  ensure
+    ImageVise.destroy(gc)
+  end
+  
+  ImageVise.add_operator 'ellipse_stencil', self
+end

data/lib/image_vise/operators/fit_crop.rb

@@ -0,0 +1,33 @@
+# Fits the image based on the smaller-side fit. This means that the image is going to be fit
+# into the requested rectangle so that all of the pixels of the rectangle are filled. The
+# gravity parameter defines the crop gravity (on corners, sides, or in the middle).
+#
+# The corresponding Pipeline method is `fit_crop`.
+class ImageVise::FitCrop < Ks.strict(:width, :height, :gravity)
+  GRAVITY_PARAMS = {
+    'nw' => Magick::NorthWestGravity,
+    'n' => Magick::NorthGravity,
+    'ne' => Magick::NorthEastGravity,
+    'w' => Magick::WestGravity,
+    'c' => Magick::CenterGravity,
+    'e' => Magick::EastGravity,
+    'sw' => Magick::SouthWestGravity,
+    's' => Magick::SouthGravity,
+    'se' => Magick::SouthEastGravity,
+  }
+
+  def initialize(*)
+    super
+    self.width = width.to_i
+    self.height = height.to_i
+    raise ArgumentError, ":width must positive" unless width > 0
+    raise ArgumentError, ":height must positive" unless height > 0
+    raise ArgumentError, ":gravity must be within the permitted values" unless GRAVITY_PARAMS.key? gravity
+  end
+
+  def apply!(magick_image)
+    magick_image.resize_to_fill! width, height, GRAVITY_PARAMS.fetch(gravity)
+  end
+  
+  ImageVise.add_operator 'fit_crop', self
+end

data/lib/image_vise/operators/force_jpg_out.rb

@@ -0,0 +1,17 @@
+# Forces the output format to be JPEG and specifies the quality factor to use when saving
+#
+# The corresponding Pipeline method is `force_jpg_out`.
+class ImageVise::ForceJPGOut < Ks.strict(:quality)
+  def initialize(quality:)
+    unless (0..100).cover?(quality)
+      raise ArgumentError, "the :quality setting must be within 0..100, but was %d" % quality
+    end
+    self.quality = quality
+  end
+
+  def apply!(_, metadata)
+    metadata[:writer] = ImageVise::JPGWriter.new(quality: quality)
+  end
+
+  ImageVise.add_operator 'force_jpg_out', self
+end

data/lib/image_vise/operators/geom.rb

@@ -0,0 +1,16 @@
+# Applies a transformation using an ImageMagick geometry string
+#
+# The corresponding Pipeline method is `geom`.
+class ImageVise::Geom < Ks.strict(:geometry_string)
+  def initialize(*)
+    super
+    self.geometry_string = geometry_string.to_s
+    raise ArgumentError, "the :geom parameter must be present and not empty" if self.geometry_string.empty?
+  end
+
+  def apply!(image)
+    image.change_geometry(geometry_string) { |cols, rows, _| image.resize!(cols,rows) }
+  end
+
+  ImageVise.add_operator 'geom', self
+end

data/lib/image_vise/operators/sharpen.rb

@@ -0,0 +1,21 @@
+# Applies a sharpening filter to the image.
+#
+# The corresponding Pipeline method is `sharpen`.
+class ImageVise::Sharpen < Ks.strict(:radius, :sigma)
+  def initialize(*)
+    super
+    self.radius = radius.to_f
+    self.sigma = sigma.to_f
+    raise ArgumentError, ":radius must positive" unless sigma > 0
+    raise ArgumentError, ":sigma must positive" unless sigma > 0
+  end
+  
+  def apply!(magick_image)
+    sharpened_image = magick_image.sharpen(radius, sigma)
+    magick_image.composite!(sharpened_image, Magick::CenterGravity, Magick::CopyCompositeOp)
+  ensure
+    ImageVise.destroy(sharpened_image)
+  end
+end
+
+ImageVise.add_operator 'sharpen', ImageVise::Sharpen

data/lib/image_vise/operators/srgb.rb

@@ -0,0 +1,30 @@
+# Applies the sRGB profile to the image.
+# For this to work, your ImageMagick must be built
+# witl LCMS support. On OSX, you need to use the brew install
+# command with the following options:
+#
+#    $brew install imagemagick --with-little-cms --with-little-cms2
+#
+# You can verify if you do have LittleCMS support by checking the
+# delegates list that `$convert --version` outputs:
+#
+# For instance, if you do not have it, the list will look like this:
+#
+#    $ convert --version
+#    ...
+#    Delegates (built-in): bzlib freetype jng jpeg ltdl lzma png tiff xml zlib
+#
+# whereas if you do, the list will include the "lcms" delegate:
+#
+#    $ convert --version
+#    ...
+#    Delegates (built-in): bzlib freetype jng jpeg lcms ltdl lzma png tiff xml zlib
+#
+# The corresponding Pipeline method is `srgb`.
+class ImageVise::SRGB
+  PROFILE_PATH = File.expand_path(__dir__ + '/sRGB_v4_ICC_preference_displayclass.icc')
+  def apply!(magick_image)
+    magick_image.add_profile(PROFILE_PATH)
+  end
+  ImageVise.add_operator 'srgb', self
+end

data/lib/image_vise/operators/strip_metadata.rb

@@ -0,0 +1,10 @@
+# Strips metadata from the image (EXIF, IPTC etc.) using the
+# RMagick `strip!` method
+#
+# The corresponding Pipeline method is `strip_metadata`.
+class ImageVise::StripMetadata
+  def apply!(magick_image)
+    magick_image.strip!
+  end
+  ImageVise.add_operator 'strip_metadata', self
+end

data/lib/image_vise/pipeline.rb

@@ -0,0 +1,64 @@
+class ImageVise::Pipeline
+  def self.operator_by_name(name)
+    operator = ImageVise.operator_from(name)  or raise "Unknown operator #{name}"
+  end
+
+  def self.from_param(array_of_operator_names_to_operator_params)
+    operators = array_of_operator_names_to_operator_params.map do |(operator_name, operator_params)|
+      operator_class = operator_by_name(operator_name)
+      if operator_params && operator_params.any? && operator_class.method(:new).arity.nonzero?
+        operator_class.new(**operator_params)
+      else
+        operator_class.new
+      end
+    end
+    new(operators)
+  end
+
+  def initialize(operators = [])
+    @ops = operators.to_a
+  end
+
+  def <<(image_operator)
+    @ops << image_operator; self
+  end
+
+  def empty?
+    @ops.empty?
+  end
+
+  def method_missing(method_name, *a, &blk)
+    operator_builder = ImageVise.operator_from(method_name)
+    self << operator_builder.new(*a)
+  end
+  
+  def respond_to_missing?(method_name, *a)
+    ImageVise.defined_operators.include?(method_name.to_s)
+  end
+
+  def to_params
+    @ops.map do |operator|
+      operator_name = ImageVise.operator_name_for(operator)
+      operator_params = operator.respond_to?(:to_h) ? operator.to_h : {}
+      [operator_name, operator_params]
+    end
+  end
+
+  def apply!(magick_image, image_metadata)
+    @ops.each do |operator|
+      apply_operator_passing_metadata(magick_image, operator, image_metadata)
+    end
+  end
+
+  def apply_operator_passing_metadata(magick_image, operator, image_metadata)
+    if operator.method(:apply!).arity == 1
+      operator.apply!(magick_image)
+    else
+      operator.apply!(magick_image, image_metadata)
+    end
+  end
+
+  def each(&b)
+    @ops.each(&b)
+  end
+end