libgd/tests/gdimagefilter/gdCopyBlurred.c

#include <stdio.h>
#include <stdlib.h>

#include "gd.h"
#include "gdtest.h"

#define WIDTH 300
#define HEIGHT 200
#define LX (WIDTH/2)    // Line X
#define LY (HEIGHT/2)   // Line Y
#define HT 3            // Half of line-thickness

#define CLOSE_ENOUGH 0
#define PIXEL_CLOSE_ENOUGH 0


void
save(gdImagePtr im, const char *filename) {
#if 0   // set TRUE to write out some intermediate images
    FILE *out;

    out = fopen(filename, "wb");
    gdImagePng(im, out);
    fclose(out);
#else
    (void)im, (void)filename;
#endif
}/* save*/


/* Test gdImageScale() with bicubic interpolation on a simple
 * all-white image. */

gdImagePtr mkwhite(int x, int y)
{
    gdImagePtr im;

	im = gdImageCreateTrueColor(x, y);
	gdImageFilledRectangle(im, 0, 0, x-1, y-1,
                           gdImageColorExactAlpha(im, 255, 255, 255, 0));

    gdTestAssert(im != NULL);

    gdImageSetInterpolationMethod(im, GD_BICUBIC);    // FP interp'n

    return im;
}/* mkwhite*/


/* Fill with almost-black. */
void mkblack(gdImagePtr ptr)
{
    gdImageFilledRectangle(ptr, 0, 0, ptr->sx - 1, ptr->sy - 1,
                           gdImageColorExactAlpha(ptr, 2, 2, 2, 0));
}/* mkblack*/


gdImagePtr mkcross() {
    gdImagePtr im;
    int fg, n;

    im = mkwhite(WIDTH, HEIGHT);
    fg = gdImageColorAllocate(im, 0, 0, 0);

    for (n = -HT; n < HT; n++) {
        gdImageLine(im, LX-n, 0, LX-n, HEIGHT-1, fg);
        gdImageLine(im, 0, LY-n, WIDTH-1, LY-n, fg);
    }/* for */

    return im;
}/* mkcross*/



void blurblank(gdImagePtr im, int radius, double sigma) {
    gdImagePtr result;

    result = gdImageCopyGaussianBlurred(im, radius, sigma);
    gdTestAssert(!!result);
    if (!result) return;

    gdTestAssert(gdMaxPixelDiff(im, result) <= CLOSE_ENOUGH);

    gdImageDestroy(result);
}/* blurblank*/


void do_test()
{
	gdImagePtr im, imref;

	im = mkwhite(WIDTH, HEIGHT);
    imref = mkwhite(WIDTH, HEIGHT);

    /* Blur a plain white image to various radii and ensure they're
     * still similar enough. */
    blurblank(im, 1, 0.0);
    blurblank(im, 2, 0.0);
    blurblank(im, 4, 0.0);
    blurblank(im, 8, 0.0);
    blurblank(im, 16, 0.0);

    /* Ditto a black image. */
    mkblack(im);
    gdTestAssert(gdMaxPixelDiff(im, imref) >= 240); /* Leaves a little wiggle room */

    blurblank(im, 1, 0.0);
    blurblank(im, 2, 0.0);
    blurblank(im, 4, 0.0);
    blurblank(im, 8, 0.0);
    blurblank(im, 16, 0.0);

    gdImageDestroy(im);
    gdImageDestroy(imref);
}/* do_test*/

/* Ensure that RGB values are equal, then return r (which is therefore
 * the whiteness.) */
int getwhite(gdImagePtr im, int x, int y)
{
    int px, r, g, b;

    px = gdImageGetPixel(im, x, y);
    r = gdImageRed(im, px);
    g = gdImageGreen(im, px);
    b = gdImageBlue(im, px);

    gdTestAssert(r == g && r == b);

    return r;
}/* getrgb*/

int whitecmp(gdImagePtr im1, gdImagePtr im2, int x, int y) {
    int w1, w2;

    w1 = getwhite(im1, x, y);
    w2 = getwhite(im2, x, y);

    return abs(w1 - w2);
}/* whitediff*/

void do_crosstest()
{
    gdImagePtr im = mkcross();
    gdImagePtr blurred;
    const int RADIUS = 16;

    gdTestAssert(!!im);

    save(im, "cross.png");

    blurred = gdImageCopyGaussianBlurred(im, RADIUS, 0.0);
	gdTestAssert(blurred != NULL);
    save(blurred, "blurredcross.png");

    /* These spots shouldn't be affected. */
    gdTestAssert(whitecmp(im, blurred, 5, 5) <= PIXEL_CLOSE_ENOUGH);
    gdTestAssert(whitecmp(im, blurred, WIDTH-5, 5) <= PIXEL_CLOSE_ENOUGH);
    gdTestAssert(whitecmp(im, blurred, 5, HEIGHT-5) <= PIXEL_CLOSE_ENOUGH);
    gdTestAssert(whitecmp(im, blurred, WIDTH-5, HEIGHT-5) <= PIXEL_CLOSE_ENOUGH);

//    printf("%d %d %d %d\n", whitecmp(im, blurred, 0, 0), whitecmp(im, blurred, WIDTH-1, 0),
//         whitecmp(im, blurred, 0, HEIGHT-1), whitecmp(im, blurred, WIDTH-1, HEIGHT-1));

    /* Ditto these, right in the corners */
    gdTestAssert(whitecmp(im, blurred, 0, 0) <= PIXEL_CLOSE_ENOUGH);
    gdTestAssert(whitecmp(im, blurred, WIDTH-1, 0) <= PIXEL_CLOSE_ENOUGH);
    gdTestAssert(whitecmp(im, blurred, 0, HEIGHT-1) <= PIXEL_CLOSE_ENOUGH);
    gdTestAssert(whitecmp(im, blurred, WIDTH-1, HEIGHT-1) <= PIXEL_CLOSE_ENOUGH);

    /* Now, poking let's poke around the blurred lines. */

    /* Vertical line gets darker when approached from the left. */
    gdTestAssert(getwhite(blurred, 1, 1) > getwhite(blurred, LX - (HT - 1), 1));
    gdTestAssert(getwhite(blurred, LX - 2, 1) > getwhite(blurred, LX - 1, 1));

    /* ...and lighter when moving away to the right. */
    gdTestAssert(getwhite(blurred, LX + 2, 1) >= getwhite(blurred, LX + 1, 1));
    gdTestAssert(getwhite(blurred, LX + 3, 1) >= getwhite(blurred, LX + 2, 1));
    gdTestAssert(getwhite(blurred, WIDTH - 1, 1) > getwhite(blurred, LX + 1, 1));

    /* And the same way, vertically */
    gdTestAssert(getwhite(blurred, 1, 1) > getwhite(blurred, 1, LY - (HT - 1)));
    gdTestAssert(getwhite(blurred, 1, LY - (HT - 1)) > getwhite(blurred, 1, LY - (HT - 2)));

    gdTestAssert(getwhite(blurred, 1, LY)     <= getwhite(blurred, 1, LY + 1));
    gdTestAssert(getwhite(blurred, 1, LY + 1) <  getwhite(blurred, 1, LY + 3));
    gdTestAssert(getwhite(blurred, 1, LY + 3) <  getwhite(blurred, 1, HEIGHT-1));
	gdImageDestroy(blurred);
	gdImageDestroy(im);
}/* do_crosstest*/


int main()
{

    do_test();
    do_crosstest();

    return gdNumFailures();
}