Module: Magick

Defined in:

lib/rvg/rvg.rb,
lib/rvg/misc.rb,
lib/rvg/misc.rb,
lib/rvg/misc.rb,
lib/rvg/text.rb,
lib/rvg/paint.rb,
lib/rvg/units.rb,
lib/rvg/clippath.rb,
lib/rvg/pathdata.rb,
lib/rvg/stylable.rb,
lib/rvg/container.rb,
lib/rvg/deep_equal.rb,
lib/rmagick/version.rb,
lib/rvg/describable.rb,
lib/rvg/stretchable.rb,
lib/rmagick_internal.rb,
lib/rvg/embellishable.rb,
lib/rvg/transformable.rb,
ext/RMagick/rmmain.cpp

Overview

Copyright (c) 2002 - 2009 Timothy P. Hunter Copyright (c) 2009 - RMagick contributors

Defined Under Namespace

Modules: DrawAttribute, IPTC Classes: DestroyedImageError, Draw, Enum, FatalImageMagickError, Geometry, GeometryValue, GradientFill, HatchFill, Image, ImageList, ImageMagickError, KernelInfo, OptionalMethodArguments, Pixel, RVG, SolidFill, TextureFill

Constant Summary

VERSION =

'7.1.1'

MIN_RUBY_VERSION =

'3.2.0'

MIN_IM6_VERSION =

'6.9.0'

MIN_IM7_VERSION =

'7.1.0'

IMAGEMAGICK_VERSION =

Magick::Magick_version.split[1].split('-').first

PercentGeometry =

GeometryValue.new(:PercentGeometry, 1).freeze

AspectGeometry =

GeometryValue.new(:AspectGeometry, 2).freeze

LessGeometry =

GeometryValue.new(:LessGeometry, 3).freeze

GreaterGeometry =

GeometryValue.new(:GreaterGeometry, 4).freeze

AreaGeometry =

GeometryValue.new(:AreaGeometry, 5).freeze

MinimumGeometry =

GeometryValue.new(:MinimumGeometry, 6).freeze

Magick_version =

str

Version =

str

Long_version =

str

Magick_features =

features

Class Method Summary

• .colors ⇒ Object

  If called with the optional block, iterates over the colors, otherwise returns an array of Color objects.

• .fonts ⇒ Object
• .formats(&block) ⇒ Object

  Describes the image formats supported by ImageMagick.

• .init_formats ⇒ Object
• .limit_resource(*args) ⇒ Object
• .set_cache_threshold(threshold) ⇒ Object
• .set_log_event_mask(*args) ⇒ Object
• .set_log_format(format) ⇒ Object

Class Method Details

.colors ⇒ Array<Magick::Color> .colors {|colorinfo| ... } ⇒ Object

If called with the optional block, iterates over the colors, otherwise returns an array of Color objects.

Overloads:

• .colors ⇒ Array<Magick::Color>

  Returns the array of Color.

  Returns:

  • (Array<Magick::Color>) —

    the array of Color

• .colors {|colorinfo| ... } ⇒ Object

  Yields:

  • (colorinfo)

  Yield Parameters:

  • colorinfo (Magick::Color) —

    the color

# File 'ext/RMagick/rmagick.cpp', line 41

VALUE
Magick_colors(VALUE klass)
{
    const ColorInfo **color_info_list;
    size_t number_colors, x;
    VALUE ary;
    ExceptionInfo *exception;

    exception = AcquireExceptionInfo();

    color_info_list = GetColorInfoList("*", &number_colors, exception);
    CHECK_EXCEPTION();
    DestroyExceptionInfo(exception);


    if (rb_block_given_p())
    {
        for (x = 0; x < number_colors; x++)
        {
            rb_rescue(RESCUE_FUNC(rm_yield_body), Import_ColorInfo(color_info_list[x]), RESCUE_EXCEPTION_HANDLER_FUNC(rm_yield_handle_exception), (VALUE)color_info_list);
        }
        magick_free((void *)color_info_list);
        return klass;
    }
    else
    {
        ary = rb_ary_new2((long) number_colors);
        for (x = 0; x < number_colors; x++)
        {
            rb_ary_push(ary, Import_ColorInfo(color_info_list[x]));
        }

        magick_free((void *)color_info_list);
        RB_GC_GUARD(ary);
        return ary;
    }
}

.fonts ⇒ Object

# File 'ext/RMagick/rmagick.cpp', line 92

VALUE
Magick_fonts(VALUE klass)
{
    const TypeInfo **type_info;
    size_t number_types, x;
    VALUE ary;
    ExceptionInfo *exception;

    exception = AcquireExceptionInfo();
    type_info = GetTypeInfoList("*", &number_types, exception);
    CHECK_EXCEPTION();
    DestroyExceptionInfo(exception);

    if (rb_block_given_p())
    {
        for (x = 0; x < number_types; x++)
        {
            rb_rescue(RESCUE_FUNC(rm_yield_body), Import_TypeInfo((const TypeInfo *)type_info[x]), RESCUE_EXCEPTION_HANDLER_FUNC(rm_yield_handle_exception), (VALUE)type_info);
        }
        magick_free((void *)type_info);
        return klass;
    }
    else
    {
        ary = rb_ary_new2((long)number_types);
        for (x = 0; x < number_types; x++)
        {
            rb_ary_push(ary, Import_TypeInfo((const TypeInfo *)type_info[x]));
        }
        magick_free((void *)type_info);
        RB_GC_GUARD(ary);
        return ary;
    }

}

.formats ⇒ Hash .formats {|k, v| ... } ⇒ Magick

Describes the image formats supported by ImageMagick. If the optional block is present, calls the block once for each image format. The first argument, k, is the format name. The second argument, v, is the properties string described below.

• B is "*" if the format has native blob support, or " " otherwise.
• R is "r" if ImageMagick can read that format, or "-" otherwise.
• W is "w" if ImageMagick can write that format, or "-" otherwise.
• A is "+" if the format supports multi-image files, or "-" otherwise.

Examples:

p Magick.formats
=> {"3FR"=>" r-+", "3G2"=>" r-+", "3GP"=>" r-+", "A"=>"*rw+",
...

Overloads:

• .formats ⇒ Hash

  Returns the formats hash.

  Returns:

  • (Hash) —

    the formats hash

• .formats {|k, v| ... } ⇒ Magick

  Yields:

  • (k, v)

  Yield Parameters:

  • k (String) —

    the format name

  • v (String) —

    the properties string

  Returns:

  • (Magick)

# File 'lib/rmagick_internal.rb', line 44

def formats(&block)
  formats = init_formats

  if block
    formats.each(&block)
    self
  else
    formats
  end
end

.init_formats ⇒ Object

# File 'ext/RMagick/rmagick.cpp', line 169

VALUE
Magick_init_formats(VALUE klass ATTRIBUTE_UNUSED)
{
    const MagickInfo **magick_info;
    size_t number_formats, x;
    VALUE formats;
    ExceptionInfo *exception;

    formats = rb_hash_new();

    // IM 6.1.3 added an exception argument to GetMagickInfoList
    exception = AcquireExceptionInfo();
    magick_info = GetMagickInfoList("*", &number_formats, exception);
    CHECK_EXCEPTION();
    DestroyExceptionInfo(exception);


    for (x = 0; x < number_formats; x++)
    {
        rb_hash_aset(formats,
                     rb_str_new2(magick_info[x]->name),
                     MagickInfo_to_format((const MagickInfo *)magick_info[x]));
    }
    magick_free((void *)magick_info);
    RB_GC_GUARD(formats);
    return formats;
}

.limit_resource(*args) ⇒ Object

# File 'ext/RMagick/rmagick.cpp', line 213

VALUE
Magick_limit_resource(int argc, VALUE *argv, VALUE klass)
{
    VALUE resource, limit;
    ResourceType res = UndefinedResource;
    char *str;
    ID id;
    unsigned long cur_limit;

    rb_scan_args(argc, argv, "11", &resource, &limit);

    switch (TYPE(resource))
    {
        case T_NIL:
            return klass;

        case T_SYMBOL:
            id = (ID)SYM2ID(resource);
            if (id == rb_intern("area"))
            {
                res = AreaResource;
            }
            else if (id == rb_intern("memory"))
            {
                res = MemoryResource;
            }
            else if (id == rb_intern("map"))
            {
                res = MapResource;
            }
            else if (id == rb_intern("disk"))
            {
                res = DiskResource;
            }
            else if (id == rb_intern("file"))
            {
                res = FileResource;
            }
            else if (id == rb_intern("time"))
            {
                res = TimeResource;
            }
            else
            {
                rb_raise(rb_eArgError, "unknown resource: `:%s'", rb_id2name(id));
            }
            break;

        default:
            str = StringValueCStr(resource);
            if (*str == '\0')
            {
                return klass;
            }
            else if (rm_strcasecmp("area", str) == 0)
            {
                res = AreaResource;
            }
            else if (rm_strcasecmp("memory", str) == 0)
            {
                res = MemoryResource;
            }
            else if (rm_strcasecmp("map", str) == 0)
            {
                res = MapResource;
            }
            else if (rm_strcasecmp("disk", str) == 0)
            {
                res = DiskResource;
            }
            else if (rm_strcasecmp("file", str) == 0)
            {
                res = FileResource;
            }
            else if (rm_strcasecmp("time", str) == 0)
            {
                res = TimeResource;
            }
            else
            {
                rb_raise(rb_eArgError, "unknown resource: `%s'", str);
            }
            break;
    }

    RB_GC_GUARD(resource);

    cur_limit = GetMagickResourceLimit(res);

    if (argc > 1)
    {
        SetMagickResourceLimit(res, (MagickSizeType)NUM2ULONG(limit));
    }

    RB_GC_GUARD(limit);

    return ULONG2NUM(cur_limit);
}

.set_cache_threshold(threshold) ⇒ Object

# File 'ext/RMagick/rmagick.cpp', line 320

VALUE
Magick_set_cache_threshold(VALUE klass, VALUE threshold)
{
    unsigned long thrshld = NUM2ULONG(threshold);
    SetMagickResourceLimit(MemoryResource, (MagickSizeType)thrshld);
    SetMagickResourceLimit(MapResource, (MagickSizeType)(2*thrshld));
    return klass;
}

.set_log_event_mask(*args) ⇒ Object

# File 'ext/RMagick/rmagick.cpp', line 354

VALUE
Magick_set_log_event_mask(int argc, VALUE *argv, VALUE klass)
{
    VALUE events;
    int x;

    if (argc == 0)
    {
        rb_raise(rb_eArgError, "wrong number of arguments (at least 1 required)");
    }

    // SetLogEventMask() does not provide a way to check if it failed
    // since it returns the old mask.
    for (x = 0; x < argc; x++)
    {
        const char *event = StringValueCStr(argv[x]);
        if (ParseCommandOption(MagickLogEventOptions, MagickTrue, event) == -1)
        {
            rb_raise(rb_eArgError, "invalid log event type: %s", event);
        }
    }

    // SetLogEventMask() replaces the mask on each call rather than adding to it,
    // so multiple events must be passed as a single comma-separated list.
    events = rb_str_dup(argv[0]);
    for (x = 1; x < argc; x++)
    {
        rb_str_cat_cstr(events, ",");
        rb_str_append(events, argv[x]);
    }
    SetLogEventMask(StringValueCStr(events));

    RB_GC_GUARD(events);

    return klass;
}

.set_log_format(format) ⇒ Object

# File 'ext/RMagick/rmagick.cpp', line 409

VALUE
Magick_set_log_format(VALUE klass, VALUE format)
{
    SetLogFormat(StringValueCStr(format));
    return klass;
}