httpthumbnailer 1.2.0 → 1.3.0

data/lib/httpthumbnailer/plugin/thumbnailer/service/magick.rb

@@ -0,0 +1,208 @@
+require 'RMagick'
+require 'httpthumbnailer/ownership'
+
+### WARNING: 'raise' is overwritten with an image operation method; use Kernel::raise instead!
+class Magick::Image
+	include Ownership
+	include ClassLogging
+	include PerfStats
+
+	# use this on image before doing in-place (like composite!) edit so borrowed images are not changed
+	def get_for_inplace
+		get do |image|
+			if image.borrowed?
+				yield image.copy
+			else
+				yield image
+			end
+		end
+	end
+
+	def self.new_8bit(width, height, background_color = "none")
+		Magick::Image.new(width, height) {
+			self.depth = 8
+			begin
+				self.background_color = background_color
+			rescue ArgumentError
+				Kernel::raise Plugin::Thumbnailer::InvalidColorNameError.new(background_color)
+			end
+		}
+	end
+
+	def render_on_background(background_color, width = nil, height = nil, float_x = 0.5, float_y = 0.5)
+		# default to image size
+		width ||= self.columns
+		height ||= self.rows
+
+		# make sure we have enough background to fit image on top of it
+		width = self.columns if width < self.columns
+		height = self.rows if height < self.rows
+
+		self.class.new_8bit(width, height, background_color).get do |background|
+			background.composite!(self, *background.float_to_offset(self.columns, self.rows, float_x, float_y), Magick::OverCompositeOp)
+		end
+	end
+
+	# non coping version
+	def resize_to_fill(width, height = nil, float_x = 0.5, float_y = 0.5)
+		# default to square
+		height ||= width
+
+		return if width == columns and height == rows
+
+		scale = [width / columns.to_f, height / rows.to_f].max
+
+		get do |image| # this will comsume (destory) self just after resize
+			image.resize((scale * columns).ceil, (scale * rows).ceil)
+		end.get do |image|
+			next if width == image.width and height == image.height
+			image.crop(*image.float_to_offset(width, height, float_x, float_y), width, height, true)
+		end
+	end
+
+	# make rotate not to change image.page to avoid WTF moments
+	alias :rotate_orig :rotate
+	def rotate(*args)
+		out = rotate_orig(*args)
+		out.page = Magick::Rectangle.new(out.columns, out.rows, 0, 0)
+		out
+	end
+
+	def downsample(f)
+		sample(columns / f, rows / f)
+	end
+
+	def find_downsample_factor(max_width, max_height, factor = 1)
+		new_factor = factor * 2
+		if columns / new_factor > max_width * 2 and rows / new_factor > max_height * 2
+			find_downsample_factor(max_width, max_height, factor * 2)
+		else
+			factor
+		end
+	end
+
+	def float_to_offset(float_width, float_height, float_x = 0.5, float_y = 0.5)
+		base_width = self.columns
+		base_height = self.rows
+
+		x = ((base_width - float_width) * float_x).ceil
+		y = ((base_height - float_height) * float_y).ceil
+
+		x = 0 if x < 0
+		x = (base_width - float_width) if x > (base_width - float_width)
+
+		y = 0 if y < 0
+		y = (base_height - float_height) if y > (base_height - float_height)
+
+		[x, y]
+	end
+
+	def pixelate_region(x, y, w, h, size)
+		factor = 1.0 / size
+
+		# what happens here
+		# 1. get an required box cut form the image
+		# 2. resize it down by fracto
+		# 3. resize it back up by factor
+		# 4. since we may end up with bigger image (due to size of the pixelate pixel) crop it to required size again
+		# 5. composite over the original image in required position
+
+		crop(x, y, w, h, true).get do |work_space|
+			work_space.sample((factor * w).ceil, (factor * h).ceil)
+		end.get do |image|
+			image.sample(size)
+		end.get do |image|
+			image.crop(0, 0 , w, h, true)
+		end.get do |image|
+			get_for_inplace do |orig|
+				orig.composite!(image, x, y, Magick::OverCompositeOp)
+			end
+		end
+	end
+
+	def blur_region(x, y, w, h, radius, sigma)
+		# NOTE: we need to have bigger region to blure then the final regios to prevent edge artifacts
+		# TODO: how do I calculate margin better? See: https://github.com/trevor/ImageMagick/blob/82d683349c7a6adc977f6f638f1b340e01bf0ea9/branches/ImageMagick-6.5.9/magick/gem.c#L787
+		margin = [3, radius, sigma].max.ceil
+
+		mx = x - margin
+		my = y - margin
+		mw = w + margin
+		mh = h + margin
+
+		# limit the box with margin to available image size
+		mx = 0 if mx < 0
+		my = 0 if my < 0
+		mw = width - mx if mw + mx > width
+		mh = height - my if mh + my > height
+
+		crop(mx, my, mw, mh, true).get do |work_space|
+			work_space.blur_image(radius, sigma)
+		end.get do |blur|
+			blur.crop(x - mx, y - my, w, h, true)
+		end.get do |blur|
+			get_for_inplace do |orig|
+				orig.composite!(blur, x, y, Magick::OverCompositeOp)
+			end
+		end
+	end
+
+	def render_rectangle(x, y, w, h, color)
+			get_for_inplace do |orig|
+				gc = Magick::Draw.new
+				gc.fill = color
+				gc.rectangle(x, y, x + w - 1, y + h - 1)
+				gc.draw(orig)
+				orig
+			end
+	end
+
+	# helpers
+
+	def with_background_color(color)
+		if color
+			was = self.background_color
+			begin
+				begin
+					self.background_color = color
+				rescue ArgumentError
+					Kernel::raise Plugin::Thumbnailer::InvalidColorNameError.new(color)
+				end
+				yield
+			ensure
+				self.background_color = was
+			end
+		else
+			yield
+		end
+	end
+
+	def rel_to_px_pos(x, y)
+		[(x * columns).floor, (y * rows).floor]
+	end
+
+	def rel_to_px_dim(width, height)
+		[(width * columns).ceil, (height * rows).ceil]
+	end
+
+	def rel_to_px_box(x, y, width, height)
+		[*rel_to_px_pos(x, y), *rel_to_px_dim(width, height)]
+	end
+
+	def rel_to_diagonal(v)
+		(v * diagonal).ceil
+	end
+
+	def width
+		columns
+	end
+
+	def height
+		rows
+	end
+
+	def diagonal
+		@_diag ||= Math.sqrt(width ** 2 + height ** 2).ceil
+	end
+end
+

data/lib/httpthumbnailer/thumbnail_specs.rb

@@ -1,8 +1,8 @@
 class ThumbnailSpecs < Array
-	def self.from_uri(specs)
+	def self.from_string(specs)
 		ts = ThumbnailSpecs.new
 		specs.split('/').each do |spec|
-			ts << ThumbnailSpec.from_uri(spec)
+			ts << ThumbnailSpec.from_string(spec)
 		end
 		ts
 	end
@@ -23,61 +23,154 @@ class ThumbnailSpecs < Array
 end
 
 class ThumbnailSpec
-	class BadThubnailSpecError < ArgumentError
-		class MissingArgumentError < BadThubnailSpecError
-			def initialize(spec)
-				super "missing argument in: #{spec}"
-			end
+	class InvalidFormatError < ArgumentError
+		def for_edit(name)
+			exception "#{message} for edit '#{name}'"
 		end
 
-		class MissingOptionKeyOrValueError < BadThubnailSpecError
-			def initialize(option)
-				super "missing option key or value in: #{option}"
-			end
+		def in_spec(spec)
+			exception "#{message} in spec '#{spec}'"
 		end
+	end
 
-		class BadDimensionValueError < BadThubnailSpecError
-			def initialize(value)
-				super "bad dimension value: #{value}"
-			end
+	class MissingArgumentError < InvalidFormatError
+		def initialize(argument)
+			super "missing #{argument} argument"
 		end
 	end
 
-	def initialize(method, width, height, format, options = {})
-		@method = method
-		@width = cast_dimension(width)
-		@height = cast_dimension(height)
-		@format = (format == 'input' ? :input : format.upcase)
-		@options = options
+	class InvalidArgumentValueError < InvalidFormatError
+		def initialize(name, value, reason)
+			super "#{name} value '#{value}' is not #{reason}"
+		end
+	end
+
+	class MissingOptionKeyValuePairError < InvalidFormatError
+		def initialize(index)
+			super "missing key-value pair on position #{index + 1}"
+		end
+	end
+
+	class MissingOptionKeyNameError < InvalidFormatError
+		def initialize(value)
+			super "missing option key name for value '#{value}'"
+		end
+	end
+
+	class MissingOptionKeyValueError < InvalidFormatError
+		def initialize(key)
+			super "missing option value for key '#{key}'"
+		end
 	end
 
-	def self.from_uri(spec)
-		method, width, height, format, *options = *spec.split(',')
-		raise BadThubnailSpecError::MissingArgumentError.new(spec) unless method and width and height and format
+	class EditSpec
+		attr_reader :name, :args, :options
+
+		def self.from_string(string)
+			args = ThumbnailSpec.split_args(string)
+			args, options = ThumbnailSpec.partition_args_options(args)
+			name = args.shift
+
+			begin
+				options = ThumbnailSpec.parse_options(options)
+			rescue InvalidFormatError => error
+				raise error.for_edit(name)
+			end
+			new(name, args, options)
+		end
+
+		def initialize(name, args, options = {})
+			name.nil? or name.empty? and raise MissingArgumentError, 'edit name'
+
+			@name = name
+			@args = args
+			@options = options
+		end
 
-		opts = {}
-		options.each do |option|
-			key, value = option.split(':')
-			raise BadThubnailSpecError::MissingOptionKeyOrValueError.new(option) unless key and value
-			opts[key] = value
+		def to_s
+			begin
+				[@name, *@args, *ThumbnailSpec.options_to_s(@options)].join(',')
+			rescue InvalidFormatError => error
+				raise error.for_edit(name)
+			end
 		end
+	end
+
+	attr_reader :method, :width, :height, :format, :options, :edits
+
+	def self.from_string(string)
+		edits = split_edits(string)
+		spec = edits.shift
+		args = split_args(spec)
+		method, width, height, format, *options = *args
+
+		options = parse_options(options)
+		edits = edits.map{|e| EditSpec.from_string(e)}
 
-		ThumbnailSpec.new(method, width, height, format, opts)
+		new(method, width, height, format, options, edits)
+	rescue InvalidFormatError => error
+		raise error.in_spec(string)
 	end
 
+	def initialize(method, width, height, format, options = {}, edits = [])
+		method.nil? or method.empty? and raise MissingArgumentError, 'method'
+		width.nil? or width.empty? and raise MissingArgumentError, 'width'
+		height.nil? or height.empty? and raise MissingArgumentError, 'height'
+		format.nil? or format.empty? and raise MissingArgumentError, 'format'
 
-	attr_reader :method, :width, :height, :format, :options
+		width !~ /^([0-9]+|input)$/ and raise InvalidArgumentValueError.new('width', width, "an integer or 'input'")
+		height !~ /^([0-9]+|input)$/ and raise InvalidArgumentValueError.new('height', height, "an integer or 'input'")
+
+		width = width == 'input' ? :input : width.to_i
+		height = height == 'input' ? :input : height.to_i
+
+		format = format == 'input' ? :input : format.upcase
+
+		@method = method
+		@width = width
+		@height = height
+		@format = format
+		@options = options
+		@edits = edits
+	end
 
 	def to_s
-		"#{method} #{width}x#{height} (#{format.downcase}) #{options.inspect}"
+		[[@method, @width, @height, @format, *self.class.options_to_s(@options)].join(','), *@edits.map(&:to_s)].join('!')
+	end
+
+	def self.split_edits(string)
+		string.split('!')
 	end
 
-	private
+	def self.split_args(string)
+		string.split(',')
+	end
+
+	def self.partition_args_options(args)
+		options = args.drop_while{|a| not a.include?(':')}
+		args = args.take_while{|a| not a.include?(':')}
+		[args, options]
+	end
 
-	def cast_dimension(string)
-		return :input if string == 'input'
-		raise BadThubnailSpecError::BadDimensionValueError.new(string) unless string =~ /^\d+$/
-		string.to_i
+	def self.parse_options(options)
+		Hash[options.map.with_index do |pair, index|
+			pair.empty? and raise MissingOptionKeyValuePairError, index
+			pair.split(':', 2)
+		end].tap do |map|
+			map.each do |key, value|
+				key.nil? or key.empty? and raise MissingOptionKeyNameError, value
+				value.nil? or value.empty? and raise MissingOptionKeyValueError, key
+			end
+		end
+	end
+
+	def self.options_to_s(options)
+		options.sort_by{|k,v| k}.map do |key, value|
+			raise MissingOptionKeyNameError, value if key.nil? or key.to_s.empty?
+			raise MissingOptionKeyValueError, key if value.nil? or value.to_s.empty?
+			key = key.to_s.gsub('_', '-') if key.kind_of? Symbol
+			"#{key}:#{value}"
+		end
 	end
 end
 

data/lib/httpthumbnailer/thumbnailer.rb

@@ -2,6 +2,7 @@ require 'httpthumbnailer/plugin/thumbnailer'
 require 'httpthumbnailer/thumbnail_specs'
 
 class Thumbnailer < Controller
+	Plugin::Thumbnailer.logger = logger_for(Plugin::Thumbnailer)
 	self.plugin Plugin::Thumbnailer
 
 	self.define do
@@ -9,7 +10,7 @@ class Thumbnailer < Controller
 		opts[:limit_memory] = memory_limit
 
 		on put, 'thumbnail', /(.*)/ do |spec|
-			spec = ThumbnailSpec.from_uri(spec)
+			spec = ThumbnailSpec.from_string(spec)
 			log.info "thumbnailing image to single spec: #{spec}"
 
 			if settings[:optimization]
@@ -17,23 +18,32 @@ class Thumbnailer < Controller
 				opts[:max_height] = spec.height if spec.height.is_a? Integer
 			end
 
-			thumbnailer.load(req.body, opts).use do |input_image|
+			opts[:reload] = settings[:reload]
+			opts[:no_upscale_fix] = settings[:no_upscale_fix]
+			opts[:no_downsample] = settings[:no_downsample]
+
+			thumbnailer.load(req.body, opts) do |input_image|
 				log.info "original image loaded: #{input_image.mime_type}"
 
+				# take the values here since the input_image will be destroyed after thumbnail!
+				input_image_mime_type = input_image.mime_type
+				input_image_width = input_image.width
+				input_image_height = input_image.height
+
 				log.info "generating thumbnail: #{spec}"
-				input_image.thumbnail(spec) do |image|
+				input_image.thumbnail!(spec) do |image|
 					write 200, image.mime_type, image.data,
 						"X-Image-Width" => image.width,
 						"X-Image-Height" => image.height,
-						"X-Input-Image-Mime-Type" => input_image.mime_type,
-						"X-Input-Image-Width" => input_image.width,
-						"X-Input-Image-Height" => input_image.height
+						"X-Input-Image-Mime-Type" => input_image_mime_type,
+						"X-Input-Image-Width" => input_image_width,
+						"X-Input-Image-Height" => input_image_height
 				end
 			end
 		end
 
 		on put, 'thumbnails', /(.*)/ do |specs|
-			thumbnail_specs = ThumbnailSpecs.from_uri(specs)
+			thumbnail_specs = ThumbnailSpecs.from_string(specs)
 			log.info "thumbnailing image to multiple specs: #{thumbnail_specs.join(', ')}"
 
 			if settings[:optimization]
@@ -41,7 +51,11 @@ class Thumbnailer < Controller
 					opts[:max_height] = thumbnail_specs.max_height
 			end
 
-			thumbnailer.load(req.body, opts).use do |input_image|
+			opts[:reload] = settings[:reload]
+			opts[:no_upscale_fix] = settings[:no_upscale_fix]
+			opts[:no_downsample] = settings[:no_downsample]
+
+			thumbnailer.load(req.body, opts) do |input_image|
 				log.info "original image loaded: #{input_image.mime_type}"
 				write_preamble 200,
 					"X-Input-Image-Mime-Type" => input_image.mime_type,
@@ -64,6 +78,10 @@ class Thumbnailer < Controller
 							write_error_part 400, error
 						when Plugin::Thumbnailer::ZeroSizedImageError
 							write_error_part 400, error
+						when Plugin::Thumbnailer::ThumbnailArgumentError
+							write_error_part 400, error
+						when Plugin::Thumbnailer::EditArgumentError
+							write_error_part 400, error
 						else
 							log.error "unhandled error while generating multipart response for thumbnail spec: #{spec}", error
 							write_error_part 500, error
@@ -83,11 +101,11 @@ class Thumbnailer < Controller
 			end
 
 			# disable preprocessing since we don't need them here
-			opts[:no_reload] = true
-			opts[:no_downscale] = true
+			opts[:no_upscale_fix] = true
+			opts[:no_downsample] = true
 
 			# RMagick of v2.13.2 does not use ImageMagick's PingBlob so we have to actually load the image
-			thumbnailer.load(req.body, opts).use do |input_image|
+			thumbnailer.load(req.body, opts) do |input_image|
 				mime_type = input_image.mime_type
 				log.info "image loaded and identified as: #{mime_type}"
 				write_json 200, {