rmagick 1.7.4 → 1.8.0

data/ext/RMagick/rminfo.c

@@ -1,6 +1,6 @@
-/* $Id: rminfo.c,v 1.22 2004/08/18 23:22:36 rmagick Exp $ */
+/* $Id: rminfo.c,v 1.28 2005/04/30 23:01:13 rmagick Exp $ */
 /*============================================================================\
-|                Copyright (C) 2004 by Timothy P. Hunter
+|                Copyright (C) 2005 by Timothy P. Hunter
 | Name:     rminfo.c
 | Author:   Tim Hunter
 | Purpose:  Info class method definitions for RMagick.
@@ -10,6 +10,148 @@
 
 DEF_ATTR_ACCESSOR(Info, antialias, bool)
 
+/*
+ * Method:  value = Info[format, key]
+ * Purpose: get the value of an option set by Info[]=
+*/
+#define MAX_FORMAT_LEN 60
+
+VALUE
+Info_aref(VALUE self, VALUE format, VALUE key)
+{
+#if defined(HAVE_SETIMAGEOPTION)
+    Info *info;
+    char *format_p, *key_p;
+    long format_l, key_l;
+    const char *value;
+    char fkey[MaxTextExtent];
+
+    format_p = STRING_PTR_LEN(format, format_l);
+    key_p = STRING_PTR_LEN(key, key_l);
+
+    if (format_l > MAX_FORMAT_LEN || format_l + key_l > MaxTextExtent-1)
+    {
+        rb_raise(rb_eArgError, "can't reference %.60s:%.1024s - too long", format_p, key_p);
+    }
+
+    sprintf(fkey, "%.60s:%.*s", STRING_PTR(format), (int)(MaxTextExtent-61), STRING_PTR(key));
+
+    Data_Get_Struct(self, Info, info);
+    value = GetImageOption(info, fkey);
+    if (!value)
+    {
+        return Qnil;
+    }
+
+    return rb_str_new2(value);
+
+#elif defined(HAVE_ADDDEFINITIONS)
+    Info *info;
+    const char *value;
+
+    Data_Get_Struct(self, Info, info);
+    value = AccessDefinition(info, STRING_PTR(format), STRING_PTR(key));
+
+    if (!value)
+    {
+        return Qnil;
+    }
+
+    return rb_str_new2(value);
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
+/*
+    Method:     Info[format, key] = value
+    Purpose:    Call AddDefinitions (GM) or SetImageOption (IM)
+    Note:       Essentially the same function as Info#define but paired
+                with Info#[]=
+*/
+VALUE
+Info_aset(VALUE self, VALUE format, VALUE key, VALUE value)
+{
+#if defined(HAVE_SETIMAGEOPTION)
+    Info *info;
+    char *format_p, *key_p, *value_p = "";
+    long format_l, key_l;
+    char ckey[MaxTextExtent];
+    unsigned int okay;
+
+
+    Data_Get_Struct(self, Info, info);
+
+    format_p = STRING_PTR_LEN(format, format_l);
+    key_p = STRING_PTR_LEN(key, key_l);
+
+    /* Allow any argument that supports to_s */
+    value = rb_funcall(value, ID_to_s, 0);
+    value_p = STRING_PTR(value);
+
+    if (format_l > MAX_FORMAT_LEN || format_l+key_l > MaxTextExtent-1)
+    {
+        rb_raise(rb_eArgError, "%.60s:%.1024s not defined - too long", format_p, key_p);
+    }
+
+    (void) sprintf(ckey, "%.60s:%.*s", format_p, (int)(sizeof(ckey)-MAX_FORMAT_LEN), key_p);
+
+    okay = SetImageOption(info, ckey, value_p);
+    if (!okay)
+    {
+        rb_warn("%.60s:%.1024s not defined - SetImageOption failed.", format_p, key_p);
+        return Qnil;
+    }
+
+    return self;
+
+#elif defined(HAVE_ADDDEFINITIONS)
+    Info *info;
+    char *format_p, *key_p, *value_p = NULL;
+    long format_l, key_l, value_l = 0;
+    unsigned int okay;
+    ExceptionInfo exception;
+    char definitions[MaxTextExtent*2];/* Make this buffer longer than the buffer used   */
+                                      /* for SetImageOptions since AddDefinitions cats  */
+                                      /* the value onto the format:key pair.            */
+
+    Data_Get_Struct(self, Info, info);
+
+    format_p = STRING_PTR_LEN(format, format_l);
+    key_p = STRING_PTR_LEN(key, key_l);
+    value = rb_funcall(value, ID_to_s, 0);
+    value_p = STRING_PTR_LEN(value, value_l);
+
+    if ((3 + format_l + key_l + value_l) > sizeof(definitions))
+    {
+        rb_raise(rb_eArgError, "%.60s:%.1024s not defined - too long", format_p, key_p);
+    }
+    (void)sprintf(definitions, "%s:%s=", format_p, key_p);
+    if (value_l > 0)
+    {
+        strcat(definitions, value_p);
+    }
+
+    GetExceptionInfo(&exception);
+    okay = AddDefinitions(info, definitions, &exception);
+    HANDLE_ERROR
+    if (!okay)
+    {
+        rb_warn("%.60s:%.1024s not defined - AddDefinitions failed.", format_p, key_p);
+        return Qnil;
+    }
+
+    return self;
+
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
+
 /*
     Method:     Info#background_color
     Purpose:    return the name of the background color as a String
@@ -230,6 +372,7 @@ Info_define(int argc, VALUE *argv, VALUE self)
 #endif
 }
 
+
 DEF_ATTR_READER(Info, density, str)
 
 /*
@@ -554,6 +697,7 @@ VALUE Info_fuzz_eq(VALUE self, VALUE fuzz)
     return self;
 }
 
+
 DEF_ATTR_ACCESSOR(Info, group, long)
 
 /*
@@ -845,6 +989,68 @@ Info_size_eq(VALUE self, VALUE size_arg)
     return self;
 }
 
+
+/*
+    Method:     Info#undefine
+    Purpose:    Undefine image option
+*/
+
+VALUE
+Info_undefine(VALUE self, VALUE format, VALUE key)
+{
+#if defined(HAVE_SETIMAGEOPTION)
+    Info *info;
+    char *format_p, *key_p;
+    long format_l, key_l;
+    char fkey[MaxTextExtent];
+
+    format_p = STRING_PTR_LEN(format, format_l);
+    key_p = STRING_PTR_LEN(key, key_l);
+
+    if (format_l > MAX_FORMAT_LEN || format_l + key_l > MaxTextExtent)
+    {
+        rb_raise(rb_eArgError, "can't undefine %.60s:%.1024s - too long", format_p, key_p);
+    }
+
+    sprintf(fkey, "%.60s:%.*s", format_p, (int)(MaxTextExtent-61), key_p);
+
+    Data_Get_Struct(self, Info, info);
+    /* Depending on the IM version, RemoveImageOption returns either */
+    /* char * or MagickBooleanType. Ignore the return value.         */
+    (void) RemoveImageOption(info, fkey);
+    return self;
+
+#elif defined(HAVE_ADDDEFINITIONS)
+    Info *info;
+    unsigned int okay;
+    char *format_p, *key_p;
+    long format_l, key_l;
+    char fkey[MaxTextExtent];
+
+    format_p = STRING_PTR_LEN(format, format_l);
+    key_p = STRING_PTR_LEN(key, key_l);
+
+    if (format_l > MAX_FORMAT_LEN || format_l + key_l > MaxTextExtent)
+    {
+        rb_raise(rb_eArgError, "can't undefine %.60s:%.1024s - too long", format_p, key_p);
+    }
+
+    sprintf(fkey, "%.60s:%.*s", format_p, MaxTextExtent-61, key_p);
+
+    Data_Get_Struct(self, Info, info);
+    okay = RemoveDefinitions(info, fkey);
+    if (!okay)
+    {
+        rb_raise(rb_eArgError, "no such key: `%s'", fkey);
+    }
+    return self;
+
+#else
+    rm_not_implemented();
+    return (VALUE)0;
+#endif
+}
+
 /*
     Method:  Info#units
     Purpose: Get the resolution type

data/ext/RMagick/rmmain.c

@@ -1,6 +1,6 @@
-/* $Id: rmmain.c,v 1.74.2.3 2005/02/27 15:42:09 rmagick Exp $ */
+/* $Id: rmmain.c,v 1.84 2005/04/30 23:01:39 rmagick Exp $ */
 /*============================================================================\
-|                Copyright (C) 2004 by Timothy P. Hunter
+|                Copyright (C) 2005 by Timothy P. Hunter
 | Name:     rmmain.c
 | Author:   Tim Hunter
 | Purpose:  Contains all module, class, method declarations.
@@ -731,13 +731,16 @@ Init_RMagick(void)
     rb_define_method(Class_Image, "scale", Image_scale, -1);
     rb_define_method(Class_Image, "scale!", Image_scale_bang, -1);
     rb_define_method(Class_Image, "segment", Image_segment, -1);
+    rb_define_method(Class_Image, "sepiatone", Image_sepiatone, -1);
     rb_define_method(Class_Image, "set_channel_depth", Image_set_channel_depth, 2);
     rb_define_method(Class_Image, "shade", Image_shade, -1);
+    rb_define_method(Class_Image, "shadow", Image_shadow, -1);
     rb_define_method(Class_Image, "sharpen", Image_sharpen, -1);
     rb_define_method(Class_Image, "sharpen_channel", Image_sharpen_channel, -1);
     rb_define_method(Class_Image, "shave", Image_shave, 2);
     rb_define_method(Class_Image, "shave!", Image_shave_bang, 2);
     rb_define_method(Class_Image, "shear", Image_shear, 2);
+    rb_define_method(Class_Image, "sigmoidal_contrast_channel", Image_sigmoidal_contrast_channel, -1);
     rb_define_method(Class_Image, "signature", Image_signature, 0);
     rb_define_method(Class_Image, "solarize", Image_solarize, -1);
     rb_define_method(Class_Image, "<=>", Image_spaceship, 1);
@@ -925,6 +928,9 @@ Init_RMagick(void)
     rb_define_method(Class_Info, "initialize", Info_initialize, 0);
     rb_define_method(Class_Info, "freeze", rm_no_freeze, 0);
     rb_define_method(Class_Info, "define", Info_define, -1);
+    rb_define_method(Class_Info, "[]=", Info_aset, 3);
+    rb_define_method(Class_Info, "[]", Info_aref, 2);
+    rb_define_method(Class_Info, "undefine", Info_undefine, 2);
 
     DCL_ATTR_ACCESSOR(Info, antialias)
     DCL_ATTR_ACCESSOR(Info, background_color)
@@ -1187,6 +1193,9 @@ Init_RMagick(void)
         ENUMERATOR(FaxCompression)
         ENUMERATOR(Group4Compression)
         ENUMERATOR(JPEGCompression)
+#if defined(HAVE_JPEG2000COMPRESSION)
+        ENUMERATOR(JPEG2000Compression)
+#endif
         ENUMERATOR(LosslessJPEGCompression)
         ENUMERATOR(LZWCompression)
         ENUMERATOR(RunlengthEncodedCompression)
@@ -1441,7 +1450,7 @@ Init_RMagick(void)
 
 
     // Magick::Primary
-    Class_Primary = rb_struct_define(NULL, "x", "y", "z", 0);
+    Class_Primary = rb_struct_define(NULL, "x", "y", "z", NULL);
     rb_define_method(Class_Primary, "to_s", PrimaryInfo_to_s, 0);
     rb_define_const(Module_Magick, "Primary", Class_Primary);
 
@@ -1498,14 +1507,14 @@ Init_RMagick(void)
 static void version_constants(void)
 {
     const char *mgk_version;
-    char long_version[300];
+    char long_version[400];
 
     mgk_version = GetMagickVersion(NULL);
     rb_define_const(Module_Magick, "Magick_version", rb_str_new2(mgk_version));
 
     rb_define_const(Module_Magick, "Version", rb_str_new2(PACKAGE_STRING));
     sprintf(long_version,
-        "This is %s ($Date: 2005/02/27 15:42:09 $) Copyright (C) 2004 by Timothy P. Hunter\n"
+        "This is %s ($Date: 2005/04/30 23:01:39 $) Copyright (C) 2005 by Timothy P. Hunter\n"
         "Built with %s\n"
         "Built for %s\n"
         "Web page: http://rmagick.rubyforge.org\n"

data/ext/RMagick/rmutil.c

@@ -1,12 +1,13 @@
-/* $Id: rmutil.c,v 1.47.2.1 2005/01/11 23:00:56 rmagick Exp $ */
+/* $Id: rmutil.c,v 1.51 2005/03/05 16:18:39 rmagick Exp $ */
 /*============================================================================\
-|                Copyright (C) 2004 by Timothy P. Hunter
+|                Copyright (C) 2005 by Timothy P. Hunter
 | Name:     rmutil.c
 | Author:   Tim Hunter
 | Purpose:  Utility functions for RMagick
 \============================================================================*/
 
 #include "rmagick.h"
+#include <errno.h>
 
 static const char *Compliance_Const_Name(ComplianceType *);
 static const char *StyleType_Const_Name(StyleType);
@@ -168,21 +169,6 @@ rm_no_freeze(VALUE obj)
 }
 
 
-/*
- *  Extern:     rm_obj_to_s(obj)
- *  Purpose:    try to convert object to string by calling its `to_s' method
- *  Notes:      Usually run via rb_rescue so TypeError or NoMethodError can be
- *              rescued. I use this instead of rb_str_to_str so that objects
- *              that don't have `to_str' but do have `to_s' can be converted.
-*/
-VALUE
-rm_obj_to_s(VALUE obj)
-{
-    return TYPE(obj) == T_STRING ? obj : rb_funcall(obj, ID_to_s, 0);
-}
-
-
-
 /*
  *  Static:     arg_is_number
  *  Purpose:    Try to convert the argument to a double,
@@ -199,16 +185,74 @@ arg_is_number(VALUE arg)
 
 
 /*
- *  Static:     fuzz_arg_rescue
+ *  Static:     rescue_not_str
  *  Purpose:    called when `rb_str_to_str' raised an exception below
 */
 static VALUE
-fuzz_arg_rescue(VALUE arg)
+rescue_not_str(VALUE arg)
 {
     rb_raise(rb_eArgError, "argument must be a number or a string in the form 'NN%' (%s given)",
             rb_class2name(CLASS_OF(arg)));
 }
 
+/*
+ *  Extern:     rm_percentage(obj)
+ *  Purpose:    Return a double between 0.0 and 1.0, inclusive.
+ *              If the argument is a number convert to a Float object,
+ *              otherwise it's supposed to be a string in the form "NN%".
+ *              Convert to a number and then to a Float.
+*/
+double
+rm_percentage(VALUE arg)
+{
+    double pct;
+    long pct_long;
+    char *pct_str, *end;
+    int not_num;
+
+    // Try to convert the argument to a number. If failure, sets not_num to non-zero.
+    rb_protect(arg_is_number, arg, &not_num);
+
+    if (not_num)
+    {
+        arg = rb_rescue(rb_str_to_str, arg, rescue_not_str, arg);
+        pct_str = STRING_PTR(arg);
+        errno = 0;
+        pct_long = strtol(pct_str, &end, 10);
+        if (errno == ERANGE)
+        {
+            rb_raise(rb_eRangeError, "`%s' out of range", pct_str);
+        }
+        if (*end != '\0' && *end != '%')
+        {
+            rb_raise(rb_eArgError, "expected percentage, got `%s'", pct_str);
+        }
+
+        if (*end == '%' && pct_long != 0)
+        {
+            pct = ((double)pct_long) / 100.0;
+        }
+        else
+        {
+            pct = (double) pct_long;
+        }
+        if (pct < 0.0)
+        {
+            rb_raise(rb_eArgError, "percentages may not be negative (got `%s')", pct_str);
+        }
+    }
+    else
+    {
+        pct = NUM2DBL(arg);
+        if (pct < 0.0)
+        {
+            rb_raise(rb_eArgError, "percentages may not be negative (got `%g')", pct);
+        }
+    }
+
+    return pct;
+}
+
 
 /*
  *  Extern:     rm_fuzz_to_dbl(obj)
@@ -230,12 +274,21 @@ rm_fuzz_to_dbl(VALUE fuzz_arg)
     if (not_num)
     {
         // Convert to string, issue error message if failure.
-        fuzz_arg = rb_rescue(rb_str_to_str, fuzz_arg, fuzz_arg_rescue, fuzz_arg);
+        fuzz_arg = rb_rescue(rb_str_to_str, fuzz_arg, rescue_not_str, fuzz_arg);
         fuzz_str = STRING_PTR(fuzz_arg);
+        errno = 0;
         fuzz = strtod(fuzz_str, &end);
+        if (errno == ERANGE)
+        {
+            rb_raise(rb_eRangeError, "`%s' out of range", fuzz_str);
+        }
         if(*end == '%')
         {
-            fuzz = (fuzz * MaxRGB) / 100;
+            if (fuzz < 0.0)
+            {
+                rb_raise(rb_eArgError, "percentages may not be negative (got `%s')", fuzz_arg);
+            }
+            fuzz = (fuzz * MaxRGB) / 100.0;
         }
         else if(*end != '\0')
         {
@@ -245,6 +298,10 @@ rm_fuzz_to_dbl(VALUE fuzz_arg)
     else
     {
         fuzz = NUM2DBL(fuzz_arg);
+        if (fuzz < 0.0)
+        {
+            rb_raise(rb_eArgError, "fuzz may not be negative (got `%g')", fuzz_arg);
+        }
     }
 
     return fuzz;
@@ -448,7 +505,11 @@ Pixel_from_HSL(VALUE class, VALUE hsl)
 
     class = class;      // defeat "never referenced" message from icc
 
-    Check_Type(hsl, T_ARRAY);
+    hsl = rb_Array(hsl);    // Ensure array
+    if (RARRAY(hsl)->len < 3)
+    {
+        rb_raise(rb_eArgError, "array argument must have at least 3 elements");
+    }
 
     hue        = NUM2DBL(rb_ary_entry(hsl, 0));
     saturation = NUM2DBL(rb_ary_entry(hsl, 1));