defmodule Mogrify do
use Mogrify.Compat
alias Mogrify.Compat
alias Mogrify.Image
alias Mogrify.Option
@doc """
Opens image source.
"""
def open(path) do
path = Path.expand(path)
unless File.regular?(path), do: raise(File.Error)
%Image{path: path, ext: Path.extname(path)}
end
@doc """
Saves modified image.
## Options
* `:path` - The output path of the image. Defaults to a temporary file.
* `:in_place` - Overwrite the original image, ignoring `:path` option. Default `false`.
"""
def save(image, opts \\ []) do
cmd_opts = [stderr_to_stdout: true]
if opts[:in_place] do
final_output_path = if image.dirty[:path], do: image.dirty[:path], else: image.path
args = arguments_for_saving_in_place(image)
{_, 0} = cmd_mogrify(args, cmd_opts)
image_after_command(image, final_output_path)
else
cmd_output_path = output_path_for(image, opts)
final_output_path = Keyword.get(opts, :path, cmd_output_path)
create_folder_if_doesnt_exist!(cmd_output_path)
create_folder_if_doesnt_exist!(final_output_path)
args = arguments_for_saving(image, cmd_output_path)
{_, 0} = cmd_convert(args, cmd_opts)
# final output path may differ if temporary path was used for image format
if cmd_output_path != final_output_path do
# copy then rm, because File.rename/2 may fail across filesystem boundary
File.copy!(cmd_output_path, final_output_path)
File.rm!(cmd_output_path)
end
image_after_command(image, final_output_path)
end
end
@doc """
Creates or saves image.
Uses the `convert` command, which accepts both existing images, or image
operators. If you have an existing image, prefer save/2.
## Options
* `:path` - The output path of the image. Defaults to a temporary file.
* `:in_place` - Overwrite the original image, ignoring `:path` option. Default `false`.
* `:buffer` - Pass `true` to write to Collectable in Image.buffer instead of file.
* `:into` - Used with `:buffer` to specify a Collectable. Defaults to `""`. See `System.cmd/3`.
"""
def create(image, opts \\ []) do
if opts[:buffer] do
cmd_opts = [stderr_to_stdout: false]
cmd_opts = if opts[:into], do: cmd_opts ++ [into: opts[:into]], else: cmd_opts
{image_collectable, 0} = cmd_convert(arguments(image), cmd_opts)
image_after_buffer_command(image, image_collectable)
else
cmd_opts = [stderr_to_stdout: true]
output_path = output_path_for(image, opts)
create_folder_if_doesnt_exist!(output_path)
{_, 0} = cmd_convert(arguments_for_creating(image, output_path), cmd_opts)
image_after_command(image, output_path)
end
end
@doc """
Returns the histogram of the image
Runs ImageMagick's `histogram:info:-` command.
Results are returned as a list of maps where each map includes keys red,
blue, green, hex and count.
## Examples
iex> open("test/fixtures/rbgw.png") |> histogram
[
%{"alpha" => 255, "blue" => 255, "count" => 400, "green" => 0, "hex" => "#0000ff", "red" => 0},
%{"alpha" => 255, "blue" => 0, "count" => 225, "green" => 255, "hex" => "#00ff00", "red" => 0},
%{"alpha" => 255, "blue" => 0, "count" => 525, "green" => 0, "hex" => "#ff0000", "red" => 255},
%{"alpha" => 255, "blue" => 255, "count" => 1350, "green" => 255, "hex" => "#ffffff", "red" => 255}
]
"""
def histogram(image) do
img = image |> custom("format", "%c")
args = arguments(img) ++ [image.path, "histogram:info:-"]
res = cmd_convert(args, stderr_to_stdout: false)
res
|> elem(0)
|> process_histogram_output
end
defp image_after_command(image, output_path) do
format = Map.get(image.dirty, :format, image.format)
%{
clear_operations(image)
| path: output_path,
ext: Path.extname(output_path),
format: format
}
end
defp image_after_buffer_command(image, image_collectable) do
%{
clear_operations(image)
| buffer: image_collectable
}
end
defp clear_operations(image) do
%{image | operations: [], dirty: %{}}
end
defp cleanse_histogram(hist) do
hist
|> Enum.into(%{}, &clean_histogram_entry/1)
end
defp clean_histogram_entry({"hex", v}), do: {"hex", v}
defp clean_histogram_entry({"alpha", ""}), do: {"alpha", 255}
defp clean_histogram_entry({k, ""}), do: {k, 0}
defp clean_histogram_entry({k, v}), do: {k, v |> Float.parse() |> elem(0) |> Float.round(0) |> trunc}
def extract_histogram_data(entry) do
~r/^\s+(?<count>\d+):\s+\((?<red>[\d(?:\.\d+)?)\s]+),(?<green>[\d(?:\.\d+)?)\s]+),(?<blue>[\d(?:\.\d+)?)\s]+)(,(?<alpha>[\d(?:\.\d+)?)\s]+))?\)\s+(?<hex>\#[abcdef\d]{6,8})\s+/i
|> Regex.named_captures(entry)
|> Enum.map(fn {k, v} -> {k, v |> Compat.string_trim()} end)
|> cleanse_histogram
end
defp process_histogram_output(histogram_output) do
histogram_output
|> String.split("\n")
|> Enum.reject(fn s -> s |> String.length() == 0 end)
|> Enum.map(&extract_histogram_data/1)
end
defp output_path_for(image, save_opts) do
cond do
save_opts[:in_place] -> image.path
image.dirty[:path] -> temporary_path_for(image) # temp file to ensure image format applied
save_opts[:path] -> save_opts[:path]
true -> temporary_path_for(image)
end
end
# used with `convert`
defp arguments_for_saving(image, path) do
[image.path] ++ arguments(image) ++ [path]
end
# used with `mogrify`
defp arguments_for_saving_in_place(image) do
arguments(image) ++ [image.path]
end
defp arguments_for_creating(image, path) do
basename = if image.path, do: Path.basename(image.path), else: Path.basename(path)
base_arguments = [Path.join(Path.dirname(path), basename)]
arguments(image) ++ base_arguments
end
defp arguments(image) do
Enum.flat_map(image.operations, &normalize_arguments/1)
end
defp normalize_arguments({:image_operator, params}), do: String.split(params)
defp normalize_arguments({"annotate", params}),
do: ["-annotate"] ++ String.split(params, " ", parts: 2)
defp normalize_arguments({"morphology", params}), do: ["-morphology"] ++ String.split(params)
defp normalize_arguments({"histogram:" <> option, nil}), do: ["histogram:#{option}"]
defp normalize_arguments({"pango", params}), do: ["pango:#{params}"]
defp normalize_arguments({"stdout", params}), do: ["#{params}"]
defp normalize_arguments({"plasma", params}), do: ["plasma:#{params}"]
defp normalize_arguments({"canvas", params}), do: ["canvas:#{params}"]
defp normalize_arguments({"+" <> option, nil}), do: ["+#{option}"]
defp normalize_arguments({"-" <> option, nil}), do: ["-#{option}"]
defp normalize_arguments({option, nil}), do: ["-#{option}"]
defp normalize_arguments({"+" <> option, params}), do: ["+#{option}", to_string(params)]
defp normalize_arguments({"-" <> option, params}), do: ["-#{option}", to_string(params)]
defp normalize_arguments({:limit, params}), do: ["-limit"] ++ String.split(params)
defp normalize_arguments({option, params}), do: ["-#{option}", to_string(params)]
@doc """
Makes a copy of original image.
"""
def copy(image) do
temp = temporary_path_for(image)
File.cp!(image.path, temp)
Map.put(image, :path, temp)
end
def temporary_path_for(%{dirty: %{path: dirty_path}} = _image) do
do_temporary_path_for(dirty_path)
end
def temporary_path_for(%{path: path} = _image) do
do_temporary_path_for(path)
end
defp do_temporary_path_for(path) do
name = if path, do: Path.basename(path), else: Compat.rand_uniform(999_999)
random = Compat.rand_uniform(999_999)
Path.join(System.tmp_dir(), "#{random}-#{name}")
end
@doc """
Provides detailed information about the image.
This corresponds to the `mogrify -verbose` output which is similar to `identify`.
It does NOT correspond to `identify -verbose` which prints out much more information.
"""
def verbose(image) do
Map.merge(image, identify(image.path))
end
@doc """
Provides "identify" information about an image.
"""
def identify(file_path) do
args = [file_path]
{output, 0} = cmd_identify(args, stderr_to_stdout: false)
output
|> image_information_string_to_map()
|> put_frame_count(output)
end
@doc """
Provides "identify" information about an image with raw access attribute.
Example: identify(file_path, format: "'%[orientation]'")
"""
def identify(file_path, format: option) do
args = ["-format"] ++ [option] ++ [file_path]
{output, 0} = cmd_identify(args, stderr_to_stdout: false)
output |> String.replace("'", "")
end
defp image_information_string_to_map(image_information_string) do
~r/\b(?<animated>\[0])? (?<format>\S+) (?<width>\d+)x(?<height>\d+)/
|> Regex.named_captures(image_information_string)
|> Enum.map(&normalize_verbose_term/1)
|> Enum.into(%{})
end
defp normalize_verbose_term({"animated", "[0]"}), do: {:animated, true}
defp normalize_verbose_term({"animated", ""}), do: {:animated, false}
defp normalize_verbose_term({key, value}) when key in ["width", "height"] do
{String.to_atom(key), String.to_integer(value)}
end
defp normalize_verbose_term({key, value}), do: {String.to_atom(key), String.downcase(value)}
defp put_frame_count(%{animated: false} = map, _),
do: Map.put(map, :frame_count, 1)
defp put_frame_count(map, text) do
# skip the [0] lines which may be duplicated
matches = Regex.scan(~r/\b\[[1-9][0-9]*] \S+ \d+x\d+/, text)
# add 1 for the skipped [0] frame
frame_count = length(matches) + 1
Map.put(map, :frame_count, frame_count)
end
@doc """
Converts the image to the image format you specify.
"""
def format(image, format) do
downcase_format = String.downcase(format)
ext = ".#{downcase_format}"
rootname = Path.rootname(image.path, image.ext)
%{
image
| operations: image.operations ++ [format: format],
dirty: %{path: "#{rootname}#{ext}", format: downcase_format, ext: ext}
|> Enum.into(image.dirty)
}
end
@doc """
Resizes the image with provided geometry.
"""
def resize(image, params) do
%{image | operations: image.operations ++ [resize: params]}
end
@doc """
Changes quality of the image to desired quality.
"""
def quality(image, params) do
%{image | operations: image.operations ++ [quality: params]}
end
@doc """
Sets a pixel cache resource limit.
"""
def limit(image, type, value) do
image
|> limit("#{type} #{value}")
end
@doc """
Sets a pixel cache resource limit, in the form of a space-separated string (e.g. `"memory 30mb"`).
"""
def limit(image, params) do
%{image | operations: image.operations ++ [limit: params]}
end
@doc """
Extends the image to the specified dimensions.
"""
def extent(image, params) do
%{image | operations: image.operations ++ [extent: params]}
end
@doc """
Sets the gravity of the image.
"""
def gravity(image, params) do
%{image | operations: image.operations ++ [gravity: params]}
end
@doc """
Resize the image to fit within the specified dimensions while retaining
the original aspect ratio.
Will only resize the image if it is larger than the specified dimensions. The
resulting image may be shorter or narrower than specified in the smaller
dimension but will not be larger than the specified values.
"""
def resize_to_limit(image, params) do
resize(image, "#{params}>")
end
@doc """
Resize the image to fit within the specified dimensions while retaining
the aspect ratio of the original image.
If necessary, crop the image in the larger dimension.
"""
def resize_to_fill(image, params) do
[_, width, height] = Regex.run(~r/(\d+)x(\d+)/, params)
image = Mogrify.verbose(image)
{width, _} = Float.parse(width)
{height, _} = Float.parse(height)
cols = image.width
rows = image.height
if width != cols || height != rows do
# .to_f
scale_x = width / cols
# .to_f
scale_y = height / rows
larger_scale = max(scale_x, scale_y)
cols = (larger_scale * (cols + 0.5)) |> Float.round()
rows = (larger_scale * (rows + 0.5)) |> Float.round()
image = resize(image, if(scale_x >= scale_y, do: "#{cols}", else: "x#{rows}"))
if width != cols || height != rows do
extent(image, params)
else
image
end
else
image
end
end
def auto_orient(image) do
%{image | operations: image.operations ++ ["auto-orient": nil]}
end
def canvas(image, color) do
image_operator(image, "xc:#{color}")
end
def add_option(image, option) do
validate_option!(option)
custom(image, option.name, option.argument)
end
def custom(image, action, options \\ nil) do
%{image | operations: image.operations ++ [{action, options}]}
end
def image_operator(image, operator) do
%{image | operations: image.operations ++ [{:image_operator, operator}]}
end
defp valid_option?(%Option{require_arg: true, argument: nil}), do: false
defp valid_option?(_), do: true
defp validate_option!(%Option{name: name} = option) do
if valid_option?(option) do
option
else
[prefix, leading] = extract_prefix_and_leading(name)
option_name = name |> String.replace_leading(leading, "") |> String.replace("-", "_")
raise ArgumentError,
message:
"the option #{option_name} need arguments. Be sure to pass arguments to option_#{prefix}#{
option_name
}(arg)"
end
end
defp extract_prefix_and_leading(name) do
if String.contains?(name, "+") do
["plus_", "+"]
else
["", "-"]
end
end
defp cmd_magick(tool, args, opts) do
{command, additional_args} = command_options(tool)
System.cmd(command, additional_args ++ args, opts)
rescue
e in [ErlangError] ->
if e.original == :enoent do
raise "missing prerequisite: '#{tool}'"
else
reraise e, __STACKTRACE__
end
end
defp cmd_mogrify(args, opts), do: cmd_magick(:mogrify, args, opts)
defp cmd_identify(args, opts), do: cmd_magick(:identify, args, opts)
@doc false
def cmd_convert(args, opts), do: cmd_magick(:convert, args, opts)
defp create_folder_if_doesnt_exist!(path) do
path |> Path.dirname() |> File.mkdir_p!()
end
defp command_options(command) do
config = Application.get_env(:mogrify, :"#{command}_command", [])
path = Keyword.get(config, :path)
args = Keyword.get(config, :args, [])
if path do
{path, args}
else
default_command(command)
end
end
defp default_command(command) do
case :os.type() do
{:win32, _} -> {"magick", ["#{command}"]}
_ -> {"#{command}", []}
end
end
end
