Method: Magick::Image#pixel_color

Defined in:

ext/RMagick/rmimage.c

#pixel_color(*args) ⇒ Object

Get/set the color of the pixel at x,y.

Ruby usage:

- @verbatim Image#pixel_color(x, y) @endverbatim
- @verbatim Image#pixel_color(x, y, color) @endverbatim

Notes:

- Without color, does a get. With color, does a set.
- "color", if present, may be either a color name or a Magick::Pixel.
- Based on Magick++'s Magick::pixelColor methods

return value is the old color.

Parameters:

• argc —

  number of input arguments

• argv —

  array of input arguments

• self —

  this object

Returns:

• Magick::Pixel for pixel x,y. If called to set a new color, the

# File 'ext/RMagick/rmimage.c', line 9765

VALUE
Image_pixel_color(int argc, VALUE *argv, VALUE self)
{
    Image *image;
    PixelPacket old_color, new_color, *pixel;
    ExceptionInfo exception;
    long x, y;
    unsigned int set = False;
    MagickBooleanType okay;

    memset(&old_color, 0, sizeof(old_color));

    image = rm_check_destroyed(self);

    switch (argc)
    {
        case 3:
            rb_check_frozen(self);
            set = True;
            // Replace with new color? The arg can be either a color name or
            // a Magick::Pixel.
            Color_to_PixelPacket(&new_color, argv[2]);
        case 2:
            break;
        default:
            rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc);
            break;
    }

    x = NUM2LONG(argv[0]);
    y = NUM2LONG(argv[1]);

    // Get the color of a pixel
    if (!set)
    {
        GetExceptionInfo(&exception);
#if defined(HAVE_GETVIRTUALPIXELS)
        old_color = *GetVirtualPixels(image, x, y, 1, 1, &exception);
#else
        old_color = *AcquireImagePixels(image, x, y, 1, 1, &exception);
#endif
        CHECK_EXCEPTION()

        (void) DestroyExceptionInfo(&exception);

        // PseudoClass
        if (image->storage_class == PseudoClass)
        {
#if defined(HAVE_GETAUTHENTICINDEXQUEUE)
            IndexPacket *indexes = GetAuthenticIndexQueue(image);
#else
            IndexPacket *indexes = GetIndexes(image);
#endif
            old_color = image->colormap[*indexes];
        }
        if (!image->matte)
        {
            old_color.opacity = OpaqueOpacity;
        }
        return Pixel_from_PixelPacket(&old_color);
    }

    // ImageMagick segfaults if the pixel location is out of bounds.
    // Do what IM does and return the background color.
    if (x < 0 || y < 0 || (unsigned long)x >= image->columns || (unsigned long)y >= image->rows)
    {
        return Pixel_from_PixelPacket(&image->background_color);
    }

    // Set the color of a pixel. Return previous color.
    // Convert to DirectClass
    if (image->storage_class == PseudoClass)
    {
        okay = SetImageStorageClass(image, DirectClass);
        rm_check_image_exception(image, RetainOnError);
        if (!okay)
        {
            rb_raise(Class_ImageMagickError, "SetImageStorageClass failed. Can't set pixel color.");
        }
    }


#if defined(HAVE_GETAUTHENTICPIXELS) || defined(HAVE_SYNCAUTHENTICPIXELS)
    GetExceptionInfo(&exception);
#endif

#if defined(HAVE_GETAUTHENTICPIXELS)
    pixel = GetAuthenticPixels(image, x, y, 1, 1, &exception);
    CHECK_EXCEPTION()
#else
    pixel = GetImagePixels(image, x, y, 1, 1);
    rm_check_image_exception(image, RetainOnError);
#endif

    if (pixel)
    {
        old_color = *pixel;
        if (!image->matte)
        {
            old_color.opacity = OpaqueOpacity;
        }
    }
    *pixel = new_color;

#if defined(HAVE_SYNCAUTHENTICPIXELS)
    SyncAuthenticPixels(image, &exception);
    CHECK_EXCEPTION()
#else
    SyncImagePixels(image);
    rm_check_image_exception(image, RetainOnError);
#endif

#if defined(HAVE_GETAUTHENTICPIXELS) || defined(HAVE_SYNCAUTHENTICPIXELS)
    (void) DestroyExceptionInfo(&exception);
#endif

    return Pixel_from_PixelPacket(&old_color);
}