Class: MiniMagick::Image

Inherits:
Object
  • Object
show all
Defined in:
lib/mini_magick.rb

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (Image) initialize(input_path, tempfile = nil)

TODO:

Allow this to accept a block that can pass off to Image#combine_options

Create a new MiniMagick::Image object

DANGER: The file location passed in here is the *working copy*. That is, it gets modified. you can either copy it yourself or use the MiniMagick::Image.open(path) method which creates a temporary file for you and protects your original!

Parameters:

  • input_path (String) —

    The location of an image file



182
183
184
185
 
# File 'lib/mini_magick.rb', line 182

def initialize(input_path, tempfile = nil)
  @path = input_path
  @tempfile = tempfile # ensures that the tempfile will stick around until this image is garbage collected.
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

- (Object) method_missing(symbol, *args)

If an unknown method is called then it is sent through the mogrify program Look here to find all the commands (www.imagemagick.org/script/mogrify.php)



341
342
343
344
345
 
# File 'lib/mini_magick.rb', line 341

def method_missing(symbol, *args)
  combine_options do |c|
    c.method_missing(symbol, *args)
  end
end

Instance Attribute Details

- (String) path

The location of the current working file

Returns:

  • (String) —

    The location of the current working file



47
48
49
 
# File 'lib/mini_magick.rb', line 47

def path
  @path
end

Class Method Details

+ (Image) create(ext = nil, validate = true) {|IOStream| ... }

Used to create a new Image object data-copy. Not used to "paint" or that kind of thing.

Takes an extension in a block and can be used to build a new Image object. Used by both #open and #read to create a new object! Ensures we have a good tempfile!

Parameters:

  • ext (String) (defaults to: nil) —

    Specify the extension you want to read it as

  • validate (Boolean) (defaults to: true) —

    If false, skips validation of the created image. Defaults to true.

Yields:

  • (IOStream) —

    You can #write bits to this object to create the new Image

Returns:

  • (Image) —

    The created image



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'lib/mini_magick.rb', line 155

def create(ext = nil, validate = true, &block)
  begin
    tempfile = Tempfile.new(['mini_magick', ext.to_s.downcase])
    tempfile.binmode
    block.call(tempfile)
    tempfile.close

    image = self.new(tempfile.path, tempfile)

    if validate and !image.valid?
      raise MiniMagick::Invalid
    end
    return image
  ensure
    tempfile.close if tempfile
  end
end

+ (Object) from_blob(blob, ext = nil)

Deprecated.

Please use Image.read instead!



82
83
84
85
 
# File 'lib/mini_magick.rb', line 82

def from_blob(blob, ext = nil)
  warn "Warning: MiniMagick::Image.from_blob method is deprecated. Instead, please use Image.read"
  create(ext) { |f| f.write(blob) }
end

+ (Object) from_file(file, ext = nil)

Deprecated.

Please use MiniMagick::Image.open(file_or_url) now



141
142
143
144
 
# File 'lib/mini_magick.rb', line 141

def from_file(file, ext = nil)
  warn "Warning: MiniMagick::Image.from_file is now deprecated. Please use Image.open"
  open(file, ext)
end

+ (Object) import_pixels(blob, columns, rows, depth, map, format = "png")

Creates an image object from a binary string blob which contains raw pixel data (i.e. no header data).

Returns

  • Image

    The loaded image.

Parameters

  • blob

    String ??? Binary string blob containing raw pixel data.

  • columns

    Integer ??? Number of columns.

  • rows

    Integer ??? Number of rows.

  • depth

    Integer ??? Bit depth of the encoded pixel data.

  • map

    String ??? A code for the mapping of the pixel data. Example: 'gray' or 'rgb'.

  • format

    String ??? The file extension of the image format to be used when creating the image object. Defaults to 'png'.



102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/mini_magick.rb', line 102

def import_pixels(blob, columns, rows, depth, map, format="png")
  # Create an image object with the raw pixel data string:
  image = create(".dat", validate = false) { |f| f.write(blob) }
  # Use ImageMagick to convert the raw data file to an image file of the desired format:
  converted_image_path = image.path[0..-4] + format
  argument = "-size #{columns}x#{rows} -depth #{depth} #{map}:#{image.path} #{converted_image_path}"
  cmd = CommandBuilder.new("convert", argument) #Example: convert -size 256x256 -depth 16 gray:blob.dat blob.png
  image.run(cmd)
  # Update the image instance with the path of the properly formatted image, and return:
  image.path = converted_image_path
  image
end

+ (Image) open(file_or_url, ext = nil)

Opens a specific image file either on the local file system or at a URI.

Use this if you don't want to overwrite the image file.

Extension is either guessed from the path or you can specify it as a second parameter.

If you pass in what looks like a URL, we require 'open-uri' before opening it.

Parameters:

  • file_or_url (String) —

    Either a local file path or a URL that open-uri can read

  • ext (String) (defaults to: nil) —

    Specify the extension you want to read it as

Returns:

  • (Image) —

    The loaded image



126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/mini_magick.rb', line 126

def open(file_or_url, ext = nil)
  file_or_url = file_or_url.to_s # Force it to be a String... hell or highwater
  if file_or_url.include?("://")
    require 'open-uri'
    ext ||= File.extname(URI.parse(file_or_url).path)
    self.read(Kernel::open(file_or_url), ext)
  else
    ext ||= File.extname(file_or_url)
    File.open(file_or_url, "rb") do |f|
      self.read(f, ext)
    end
  end
end

+ (Image) read(stream, ext = nil)

This is the primary loading method used by all of the other class methods.

Use this to pass in a stream object. Must respond to Object#read(size) or be a binary string object (BLOBBBB)

As a change from the old API, please try and use IOStream objects. They are much, much better and more efficient!

Probably easier to use the #open method if you want to open a file or a URL.

Parameters:

  • stream (IOStream, String) —

    Some kind of stream object that needs to be read or is a binary String blob!

  • ext (String) (defaults to: nil) —

    A manual extension to use for reading the file. Not required, but if you are having issues, give this a try.

Returns:



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/mini_magick.rb', line 63

def read(stream, ext = nil)
  if stream.is_a?(String)
    stream = StringIO.new(stream)
  elsif stream.is_a?(File)
    if File.respond_to?(:binread)
      stream = StringIO.new File.binread(stream.path.to_s)
    else
      stream = StringIO.new File.open(stream.path.to_s,"rb") { |f| f.read }
    end
  end

  create(ext) do |f|
    while chunk = stream.read(8192)
      f.write(chunk)
    end
  end
end

Instance Method Details

- (String) <<(*args)

Sends raw commands to imagemagick's `mogrify` command. The image path is automatically appended to the command.

Remember, we are always acting on this instance of the Image when messing with this.

Returns:

  • (String) —

    Whatever the result from the command line is. May not be terribly useful.



256
257
258
 
# File 'lib/mini_magick.rb', line 256

def <<(*args)
  run_command("mogrify", *args << escaped_path)
end

- (String, ...) [](value)

A rather low-level way to interact with the "identify" command. No nice API here, just the crazy stuff you find in ImageMagick. See the examples listed!

Examples:

image["format"]      #=> "TIFF"
image["height"]      #=> 41 (pixels)
image["width"]       #=> 50 (pixels)
image["colorspace"]  #=> "DirectClassRGB"
image["dimensions"]  #=> [50, 41]
image["size"]        #=> 2050 (bits)
image["original_at"] #=> 2005-02-23 23:17:24 +0000 (Read from Exif data)
image["EXIF:ExifVersion"] #=> "0220" (Can read anything from Exif)

Parameters:

  • format (String) —

    A format for the "identify" command

Returns:

  • (String, Numeric, Array, Time, Object) —

    Depends on the method called! Defaults to String for unknown commands

See Also:

  • reference see http://www.imagemagick.org/script/command-line-options.php#format


221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
 
# File 'lib/mini_magick.rb', line 221

def [](value)
  # Why do I go to the trouble of putting in newlines? Because otherwise animated gifs screw everything up
  case value.to_s
  when "colorspace"
    run_command("identify", "-quiet", "-format", format_option("%r"), escaped_path).split("\n")[0]
  when "format"
    run_command("identify", "-quiet", "-format", format_option("%m"), escaped_path).split("\n")[0]
  when "height"
    run_command("identify", "-quiet", "-format", format_option("%h"), escaped_path).split("\n")[0].to_i
  when "width"
    run_command("identify", "-quiet", "-format", format_option("%w"), escaped_path).split("\n")[0].to_i
  when "dimensions"
    run_command("identify", "-quiet", "-format", format_option("%w %h"), escaped_path).split("\n")[0].split.map{|v|v.to_i}
  when "size"
    File.size(@path) # Do this because calling identify -format "%b" on an animated gif fails!
  when "original_at"
    # Get the EXIF original capture as a Time object
    Time.local(*self["EXIF:DateTimeOriginal"].split(/:|\s+/)) rescue nil
  when /^EXIF\:/i
    result = run_command('identify', '-quiet', '-format', "\"%[#{value}]\"", escaped_path).chop
    if result.include?(",")
      read_character_data(result)
    else
      result
    end
  else
    run_command('identify', '-quiet', '-format', "\"#{value}\"", escaped_path).split("\n")[0]
  end
end

- (Object) collapse!

Collapse images with sequences to the first frame (ie. animated gifs) and preserve quality



299
300
301
 
# File 'lib/mini_magick.rb', line 299

def collapse!
  run_command("mogrify", "-quality", "100", "#{path}[0]")
end

- (Object) combine_options(tool = :mogrify) {|command| ... }

You can use multiple commands together using this method. Very easy to use!

Examples:

image.combine_options do |c|
  c.draw "image Over 0,0 10,10 '#{MINUS_IMAGE_PATH}'"
  c.thumbnail "300x500>"
  c.background background
end

Yield Parameters:



357
358
359
360
361
362
363
364
 
# File 'lib/mini_magick.rb', line 357

def combine_options(tool = :mogrify, &block)
  c = CommandBuilder.new(tool)

  c << @path if tool == :convert
  block.call(c)
  c << @path
  run(c)
end

- (Object) composite(other_image, output_extension = 'jpg', &block) 



371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/mini_magick.rb', line 371

def composite(other_image, output_extension = 'jpg', &block)
  begin
    second_tempfile = Tempfile.new(output_extension)
    second_tempfile.binmode
  ensure
    second_tempfile.close
  end

  command = CommandBuilder.new("composite")
  block.call(command) if block
  command.push(other_image.path)
  command.push(self.path)
  command.push(second_tempfile.path)

  run(command)
  return Image.new(second_tempfile.path, second_tempfile)
end

- (Object) destroy! 



425
426
427
428
429
 
# File 'lib/mini_magick.rb', line 425

def destroy!
  return if @tempfile.nil?
  File.unlink(@tempfile.path) if File.exists?(@tempfile.path)
  @tempfile = nil
end

- (Object) escaped_path 



187
188
189
 
# File 'lib/mini_magick.rb', line 187

def escaped_path
  Pathname.new(@path).to_s.inspect
end

- (nil) format(format, page = 0)

This is used to change the format of the image. That is, from "tiff to jpg" or something like that. Once you run it, the instance is pointing to a new file with a new extension!

DANGER: This renames the file that the instance is pointing to. So, if you manually opened the file with Image.new(file_path)??? then that file is DELETED! If you used Image.open(file) then you are ok. The original file will still be there. But, any changes to it might not be???

Formatting an animation into a non-animated type will result in ImageMagick creating multiple pages (starting with 0). You can choose which page you want to manipulate. We default to the first page.

Parameters:

  • format (String) —

    The target format... like 'jpg', 'gif', 'tiff', etc.

  • page (Integer) (defaults to: 0) —

    If this is an animated gif, say which 'page' you want with an integer. Leave as default if you don't care.

Returns:

  • (nil) 


274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
 
# File 'lib/mini_magick.rb', line 274

def format(format, page = 0)
  c = CommandBuilder.new('mogrify', '-format', format)
  yield c if block_given?
  c << @path
  run(c)

  old_path = @path.dup
  @path.sub!(/(\.\w*)?$/, ".#{format}")
  File.delete(old_path) if old_path != @path

  unless File.exists?(@path)
    begin
      FileUtils.copy_file(@path.sub(".#{format}", "-#{page}.#{format}"), @path)
    rescue => ex
      raise MiniMagick::Error, "Unable to format to #{format}; #{ex}" unless File.exist?(@path)
    end
  end
ensure
  Dir[@path.sub(/(\.\w+)?$/, "-[0-9]*.#{format}")].each do |fname|
    File.unlink(fname)
  end
end

- (Object) format_option(format)

Outputs a carriage-return delimited format string for Unix and Windows



390
391
392
 
# File 'lib/mini_magick.rb', line 390

def format_option(format)
  windows? ? "\"#{format}\\n\"" : "\"#{format}\\\\n\""
end

- (Object) mime_type 



334
335
336
337
 
# File 'lib/mini_magick.rb', line 334

def mime_type
  format = self[:format]
  "image/" + format.to_s.downcase
end

- (Object) run(command_builder) 



403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
 
# File 'lib/mini_magick.rb', line 403

def run(command_builder)
  command = command_builder.command

  sub = Subexec.run(command, :timeout => MiniMagick.timeout)

  if sub.exitstatus != 0
    # Clean up after ourselves in case of an error
    destroy!

    # Raise the appropriate error
    if sub.output =~ /no decode delegate/i || sub.output =~ /did not return an image/i
      raise Invalid, sub.output
    else
      # TODO: should we do something different if the command times out ...?
      # its definitely better for logging.. otherwise we dont really know
      raise Error, "Command (#{command.inspect.gsub("\\", "")}) failed: #{{:status_code => sub.exitstatus, :output => sub.output}.inspect}"
    end
  else
    sub.output
  end
end

- (Object) run_command(command, *args) 



394
395
396
397
398
399
400
401
 
# File 'lib/mini_magick.rb', line 394

def run_command(command, *args)
  # -ping "efficiently determine image characteristics."
  if command == 'identify'
    args.unshift '-ping'
  end

  run(CommandBuilder.new(command, *args))
end

- (String) to_blob

Gives you raw image data back

Returns:

  • (String) —

    binary string



326
327
328
329
330
331
332
 
# File 'lib/mini_magick.rb', line 326

def to_blob
  f = File.new @path
  f.binmode
  f.read
ensure
  f.close if f
end

- (Boolean) valid?

Checks to make sure that MiniMagick can read the file and understand it.

This uses the 'identify' command line utility to check the file. If you are having issues with this, then please work directly with the 'identify' command and see if you can figure out what the issue is.

Returns:

  • (Boolean) 


198
199
200
201
202
203
 
# File 'lib/mini_magick.rb', line 198

def valid?
  run_command("identify", @path)
  true
rescue MiniMagick::Invalid
  false
end

- (Boolean) windows?

Check to see if we are running on win32 -- we need to escape things differently

Returns:

  • (Boolean) 


367
368
369
 
# File 'lib/mini_magick.rb', line 367

def windows?
  RUBY_PLATFORM =~ /mswin|mingw|cygwin/
end

- (IOStream, Boolean) write(output_to)

Writes the temporary file out to either a file location (by passing in a String) or by passing in a Stream that you can #write(chunk) to repeatedly

Writes the temporary image that we are using for processing to the output path

Parameters:

  • output_to (IOStream, String) —

    Some kind of stream object that needs to be read or a file path as a String

Returns:

  • (IOStream, Boolean) —

    If you pass in a file location [String] then you get a success boolean. If its a stream, you get it back.



309
310
311
312
313
314
315
316
317
318
319
320
321
322
 
# File 'lib/mini_magick.rb', line 309

def write(output_to)
  if output_to.kind_of?(String) || !output_to.respond_to?(:write)
    FileUtils.copy_file @path, output_to
    run_command "identify", output_to.to_s.inspect # Verify that we have a good image
  else # stream
    File.open(@path, "rb") do |f|
      f.binmode
      while chunk = f.read(8192)
        output_to.write(chunk)
      end
    end
    output_to
  end
end