public void TestGdImageColorTransparent()
{
int error = 0;
int pos = GlobalMembersGdtest.DefineConstants.gdMaxColors;
gdImageStruct im = gd.gdImageCreate(1, 1);
gd.gdImageColorTransparent(im, pos);
if (im.transparent == pos)
{
error = -1;
}
pos = -2;
gd.gdImageColorTransparent(im, pos);
if (im.transparent == pos)
{
error = -1;
}
gd.gdImageDestroy(im);
if (error != 0)
{
Assert.Fail("Error: {0}", error);
}
}
private static int testPixelate(gdImageStruct im)
{
if (gd.gdImagePixelate(im, -1, (uint)gdPixelateMode.GD_PIXELATE_UPPERLEFT) != 0)
{
return(0);
}
if (gd.gdImagePixelate(im, 1, (uint)gdPixelateMode.GD_PIXELATE_UPPERLEFT) != 1)
{
return(0);
}
if (gd.gdImagePixelate(im, 2, uint.MaxValue) != 0)
{
return(0);
}
SetupPixels(im);
if (gd.gdImagePixelate(im, BLOCK_SIZE, (uint)gdPixelateMode.GD_PIXELATE_UPPERLEFT) == 0)
{
return(0);
}
CheckPixels(im, expected_upperleft);
SetupPixels(im);
if (gd.gdImagePixelate(im, BLOCK_SIZE, (uint)gdPixelateMode.GD_PIXELATE_AVERAGE) == 0)
{
return(0);
}
CheckPixels(im, expected_average);
return(1);
}
private static void CheckPixels(gdImageStruct im, int[,] expected)
{
do
{
for (int y = 0; y < im.sy; y++)
{
for (int x = 0; x < im.sx; x++)
{
int p = gd.gdImageGetPixel(im, x, y);
int r = (expected[y / BLOCK_SIZE, x / BLOCK_SIZE] >> 16) & 0xFF;
int g = (expected[y / BLOCK_SIZE, x / BLOCK_SIZE] >> 8) & 0xFF;
int b = (expected[y / BLOCK_SIZE, x / BLOCK_SIZE]) & 0xFF;
if (r != (im.trueColor != 0 ? (p & 0xFF0000) >> 16 : im.red[p]))
{
Assert.Fail("Red {0:x} is expected, but {1:x}\n", r, im.trueColor != 0 ? (p & 0xFF0000) >> 16 : im.red[p]);
}
if (g != (im.trueColor != 0 ? (p & 0x00FF00) >> 8 : im.green[p]))
{
Assert.Fail("Green {0:x} is expected, but {1:x}\n", g, im.trueColor != 0 ? (p & 0x00FF00) >> 8 : im.green[p]);
}
if (b != (im.trueColor != 0 ? p & 0x0000FF : im.blue[p]))
{
Assert.Fail("Blue {0:x} is expected, but {1:x}\n", b,
im.trueColor != 0 ? p & 0x0000FF : im.blue[p]);
}
}
}
} while (false);
}
public void TestBug00060()
{
string path = string.Format("{0}/gif/bug00060.gif", GlobalMembersGdtest.DefineConstants.GDTEST_TOP_DIR);
gdImageStruct im = gd.gdImageCreateFromGif(path);
gd.gdImageDestroy(im);
}
public unsafe void TestGd2_im2im()
{
int size = 0;
var result = new GlobalMembersGdtest.CuTestImageResult(0, 0);
gdImageStruct src = gd.gdImageCreate(100, 100);
if (src == null)
{
Assert.Fail("could not create src");
}
int r = gd.gdImageColorAllocate(src, 0xFF, 0, 0);
int g = gd.gdImageColorAllocate(src, 0, 0xFF, 0);
int b = gd.gdImageColorAllocate(src, 0, 0, 0xFF);
gd.gdImageFilledRectangle(src, 0, 0, 99, 99, r);
gd.gdImageRectangle(src, 20, 20, 79, 79, g);
gd.gdImageEllipse(src, 70, 25, 30, 20, b);
const int cs = (GlobalMembersGdtest.DefineConstants.GD2_CHUNKSIZE_MIN +
GlobalMembersGdtest.DefineConstants.GD2_CHUNKSIZE_MAX) / 2;
gd.gdImageGd2(src, string.Format("gd2_im2im_{0}.gd2", "src"), cs, GlobalMembersGdtest.DefineConstants.GD2_FMT_COMPRESSED);
IntPtr p = gd.gdImageGd2Ptr(src, cs, GlobalMembersGdtest.DefineConstants.GD2_FMT_COMPRESSED, &size);
if (p == IntPtr.Zero)
{
gd.gdImageDestroy(src);
Assert.Fail("p is null\n");
}
if (size <= 0)
{
gd.gdFree(p);
gd.gdImageDestroy(src);
Assert.Fail("size is non-positive");
}
gdImageStruct dst = gd.gdImageCreateFromGd2Ptr(size, p);
if (dst == null)
{
gd.gdFree(p);
gd.gdImageDestroy(src);
Assert.Fail("could not create dst");
}
gd.gdImageGd2(dst, string.Format("gd2_im2im_{0}.gd2", "dst"), cs, GlobalMembersGdtest.DefineConstants.GD2_FMT_COMPRESSED);
GlobalMembersGdtest.gdTestImageDiff(src, dst, null, result);
if (result.pixels_changed > 0)
{
gd.gdImageDestroy(dst);
gd.gdFree(p);
gd.gdImageDestroy(src);
Assert.Fail("pixels changed: {0:D}\n", result.pixels_changed);
}
gd.gdImageDestroy(dst);
gd.gdFree(p);
gd.gdImageDestroy(src);
}
} // getrgb
private static int whitecmp(gdImageStruct im1, gdImageStruct im2, int x, int y)
{
int w1;
int w2;
w1 = getwhite(im1, x, y);
w2 = getwhite(im2, x, y);
return(Math.Abs(w1 - w2));
} // whitediff
public void TestBug00011()
{
string path = string.Format("{0}/png/emptyfile", GlobalMembersGdtest.DefineConstants.GDTEST_TOP_DIR);
gdImageStruct im = gd.gdImageCreateFromPng(path);
if (im != null)
{
Assert.Fail();
}
}
public void TestBug00002_3()
{
int error = 0;
/* fputs("flag 0\n", stdout); */
gdImageStruct im = gd.gdImageCreate(150, 150);
gdImageStruct tile = gd.gdImageCreateTrueColor(36, 36);
int tile_white = gd.gdImageColorAllocate(tile, 255, 255, 255);
int tile_black = gd.gdImageColorAllocate(tile, 55, 0, 0);
gd.gdImageColorAllocate(im, 255, 255, 255); // allocate white for background color
int im_black = gd.gdImageColorAllocate(im, 0, 0, 0);
gd.gdImageFill(tile, 0, 0, tile_white);
gd.gdImageColorTransparent(tile, tile_black);
gd.gdImageColorTransparent(im, im_black);
/* create the dots pattern */
for (int x = 0; x < 36; x += 2)
{
for (int y = 0; y < 36; y += 2)
{
gd.gdImageSetPixel(tile, x, y, tile_black);
}
}
gd.gdImageSetTile(im, tile);
gd.gdImageRectangle(im, 9, 9, 139, 139, im_black);
gd.gdImageLine(im, 9, 9, 139, 139, im_black);
gd.gdImageFill(im, 11, 12, GlobalMembersGdtest.DefineConstants.gdTiled);
/* fputs("flag 1\n", stdout); */
gd.gdImageFill(im, 0, 0, 0xffffff);
/* fputs("flag 2\n", stdout); */
gd.gdImageFill(im, 0, 0, 0xffffff);
/* fputs("flag 3\n", stdout); */
string path = string.Format("{0}/gdimagefill/bug00002_3_exp.png", GlobalMembersGdtest.DefineConstants.GDTEST_TOP_DIR);
if (GlobalMembersGdtest.gdTestImageCompareToFile(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, null, (path), (im)) == 0)
{
error = 1;
}
/* Destroy it */
gd.gdImageDestroy(im);
if (error != 0)
{
Assert.Fail("Error: {0}", error);
}
}
public void TestBug00006()
{
const int r = 255;
const int g = 0;
const int b = 0;
const int trans_c = (0 << 24) + (r << 16) + (g << 8) + b;
int error = 0;
gdImageStruct im = gd.gdImageCreateTrueColor(192, 36);
if (im == null)
{
GlobalMembersGdtest.gdTestErrorMsg(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "Cannot create image\n");
Assert.Fail();
}
gd.gdImageColorTransparent(im, trans_c);
gd.gdImageFilledRectangle(im, 0, 0, 192, 36, trans_c);
gd.gdImageGif(im, TMP_FN);
gd.gdImageDestroy(im);
im = gd.gdImageCreateFromGif(TMP_FN);
if (im == null)
{
GlobalMembersGdtest.gdTestErrorMsg(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "Cannot create image from <%s>\n", TMP_FN);
Assert.Fail();
}
int trans_c_f = ((im).transparent);
if (GlobalMembersGdtest.gdTestAssert(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "assert failed in <%s:%i>\n", trans_c_f == 1 ? 1 : 0) != 0)
{
int r_f = im.trueColor != 0 ? ((trans_c_f & 0xFF0000) >> 16) : im.red[trans_c_f];
int g_f = im.trueColor != 0 ? ((trans_c_f & 0x00FF00) >> 8) : im.green[trans_c_f];
int b_f = im.trueColor != 0 ? (trans_c_f & 0x0000FF) : im.blue[trans_c_f];
if (GlobalMembersGdtest.gdTestAssert(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "assert failed in <%s:%i>\n", r_f == r ? 1 : 0) == 0 ||
GlobalMembersGdtest.gdTestAssert(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "assert failed in <%s:%i>\n", g_f == g ? 1 : 0) == 0 ||
GlobalMembersGdtest.gdTestAssert(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "assert failed in <%s:%i>\n", b_f == b ? 1 : 0) == 0)
{
error = 1;
}
}
else
{
error = 1;
}
/* Destroy it */
gd.gdImageDestroy(im);
File.Delete(TMP_FN);
Assert.AreEqual(0, error);
}
public unsafe void TestGif_im2im()
{
int size = 0;
var result = new GlobalMembersGdtest.CuTestImageResult(0, 0);
gdImageStruct src = gd.gdImageCreate(100, 100);
if (src == null)
{
Assert.Fail("could not create src");
}
int r = gd.gdImageColorAllocate(src, 0xFF, 0, 0);
int g = gd.gdImageColorAllocate(src, 0, 0xFF, 0);
int b = gd.gdImageColorAllocate(src, 0, 0, 0xFF);
gd.gdImageFilledRectangle(src, 0, 0, 99, 99, r);
gd.gdImageRectangle(src, 20, 20, 79, 79, g);
gd.gdImageEllipse(src, 70, 25, 30, 20, b);
gd.gdImageGif(src, "gif_im2im_src.gif");
IntPtr p = gd.gdImageGifPtr(src, &size);
if (p == IntPtr.Zero)
{
gd.gdImageDestroy(src);
Assert.Fail("p is null\n");
}
if (size <= 0)
{
gd.gdFree(p);
gd.gdImageDestroy(src);
Assert.Fail("size is non-positive");
}
gdImageStruct dst = gd.gdImageCreateFromGifPtr(size, p);
if (dst == null)
{
gd.gdFree(p);
gd.gdImageDestroy(src);
Assert.Fail("could not create dst");
}
gd.gdImageGif(dst, "gif_im2im_dst.gif");
GlobalMembersGdtest.gdTestImageDiff(src, dst, null, result);
if (result.pixels_changed > 0)
{
gd.gdImageDestroy(dst);
gd.gdFree(p);
gd.gdImageDestroy(src);
Assert.Fail("pixels changed: {0:D}\n", result.pixels_changed);
}
gd.gdImageDestroy(dst);
gd.gdFree(p);
gd.gdImageDestroy(src);
}
public void TestGif_null()
{
gdImageStruct im = gd.gdImageCreateFromGif((string)null);
if (im != null)
{
gd.gdImageDestroy(im);
Assert.Fail();
}
gd.gdImageGif(im, null); // noop safely
}
public void TestJpeg_null()
{
gdImageStruct im = gd.gdImageCreateFromJpeg((string)null);
if (im != null)
{
gd.gdImageDestroy(im);
Assert.Fail();
}
gd.gdImageJpeg(im, null, 100); // noop safely
}
public void TestBmpNull()
{
gdImageStruct im = gd.gdImageCreateFromBmp((string)null);
if (im != null)
{
gd.gdImageDestroy(im);
Assert.Fail("gdImageCreateFromBmp returns non-null when passed null.");
}
gd.gdImageBmp(im, null, 0); // noop safely
}
} // save
/* Test gd.gdImageScale() with bicubic interpolation on a simple
* all-white image. */
private static gdImageStruct mkwhite(int x, int y)
{
gdImageStruct im = gd.gdImageCreateTrueColor(x, y);
gd.gdImageFilledRectangle(im, 0, 0, x - 1, y - 1, gd.gdImageColorExactAlpha(im, 255, 255, 255, 0));
GlobalMembersGdtest.gdTestAssert(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "assert failed in <%s:%i>\n", (im != null) ? 1 : 0);
gd.gdImageSetInterpolationMethod(im, gdInterpolationMethod.GD_BICUBIC); // FP interp'n
return(im);
} // mkwhite
public void TestBug00067()
{
const string file_im = "gdimagerotate/remirh128.jpg";
const string file_exp = "gdimagerotate/bug00067";
int error = 0;
string path = string.Format("{0}/{1}", GlobalMembersGdtest.DefineConstants.GDTEST_TOP_DIR, file_im);
gdImageStruct im = gd.gdImageCreateFromJpeg(path);
if (im == null)
{
GlobalMembersGdtest.gdTestErrorMsg(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "loading %s failed.", path);
Assert.Fail();
}
int color = gd.gdImageColorAllocate(im, 0, 0, 0);
if (color < 0)
{
GlobalMembersGdtest.gdTestErrorMsg(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "allocation color from image failed.");
gd.gdImageDestroy(im);
Assert.Fail();
}
for (int angle = 0; angle <= 180; angle += 15)
{
gdImageStruct exp = gd.gdImageRotateInterpolated(im, angle, color);
if (exp == null)
{
GlobalMembersGdtest.gdTestErrorMsg(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "rotating image failed for %03d.", angle);
gd.gdImageDestroy(im);
Assert.Fail();
}
path = string.Format("{0}/{1}_{2:D3}_exp.png", GlobalMembersGdtest.DefineConstants.GDTEST_TOP_DIR, file_exp, angle);
if (GlobalMembersGdtest.gdTestImageCompareToFile(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, null, path, exp) == 0)
{
GlobalMembersGdtest.gdTestErrorMsg(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "comparing rotated image to %s failed.", path);
error += 1;
}
gd.gdImageDestroy(exp);
}
gd.gdImageDestroy(im);
if (error != 0)
{
Assert.Fail("Error: {0}", error);
}
}
private static void save(gdImageStruct im, string filename)
{
#if false
// FILE *out;
//
// out = fopen(filename, "wb");
// gd.gdImagePng(im, out);
// fclose(out);
#else
//im, filename;
#endif
} // save
public unsafe void TestTiff_im2im()
{
int size = 0;
#if false
// CuTestImageResult result = {0, 0};
#endif
gdImageStruct src = gd.gdImageCreate(100, 100);
if (src == null)
{
Assert.Fail("could not create src\n");
}
int r = gd.gdImageColorAllocate(src, 0xFF, 0, 0);
int g = gd.gdImageColorAllocate(src, 0, 0xFF, 0);
int b = gd.gdImageColorAllocate(src, 0, 0, 0xFF);
gd.gdImageFilledRectangle(src, 0, 0, 99, 99, r);
gd.gdImageRectangle(src, 20, 20, 79, 79, g);
gd.gdImageEllipse(src, 70, 25, 30, 20, b);
gd.gdImageTiff(src, "tiff_im2im_src.tiff");
IntPtr p = gd.gdImageTiffPtr(src, &size);
if (p == IntPtr.Zero)
{
gd.gdImageDestroy(src);
Assert.Fail("p is null\n");
}
if (size <= 0)
{
gd.gdFree(p);
gd.gdImageDestroy(src);
Assert.Fail("size is non-positive\n");
}
gdImageStruct dst = gd.gdImageCreateFromTiffPtr(size, p);
if (dst == null)
{
gd.gdFree(p);
gd.gdImageDestroy(src);
Assert.Fail("could not create dst\n");
}
gd.gdImageTiff(src, "tiff_im2im_dst.tiff");
#if false
// gd.gdTestImageDiff(src, dst, NULL, &result);
// if (result.pixels_changed > 0) {
// status = 1;
// printf("pixels changed: %d\n", result.pixels_changed);
// }
#endif
gd.gdImageDestroy(dst);
gd.gdFree(p);
gd.gdImageDestroy(src);
}
public void TestGdImageLine_aa_outofrange()
{
gdImageStruct im = gd.gdImageCreateTrueColor(300, 300);
gd.gdImageSetAntiAliased(im, (0 << 24) + (255 << 16) + (255 << 8) + 255);
gd.gdImageLine(im, -1, -1, -1, -1, GlobalMembersGdtest.DefineConstants.gdAntiAliased);
gd.gdImageLine(im, 299, 299, 0, 299, GlobalMembersGdtest.DefineConstants.gdAntiAliased);
gd.gdImageLine(im, 1, 1, 50, 50, GlobalMembersGdtest.DefineConstants.gdAntiAliased);
/* Test for segfaults, if we reach this point, the test worked */
}
private static void CheckPixel(gdImageStruct im, int x, int y, int expected)
{
do
{
gd.gdImageSetClip(im, 0, 0, 4, 4);
var c = gd.gdImageGetPixel(im, x, y);
if (GlobalMembersGdtest.gdTestAssert(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__,
"assert failed in <%s:%i>\n", (c == (expected)) ? 1 : 0) != 1)
{
Assert.Fail("{0:D} is expected, but {1:D}\n", expected, c);
}
} while (false);
}
public static void gdImageTiff(gdImageStruct im, string outFile)
{
var fp = C.fopen(outFile ?? string.Empty, "wb");
try
{
gd.gdImageTiff(im, fp);
}
finally
{
Close(fp);
}
}
public static void gdImageJpeg(gdImageStruct im, string @out, int quality)
{
var fp = C.fopen(@out ?? string.Empty, "wb");
try
{
gd.gdImageJpeg(im, fp, quality);
}
finally
{
Close(fp);
}
}
public static void gdImageGd2(gdImageStruct im, string @out, int cs, int fmt)
{
var fp = C.fopen(@out ?? string.Empty, "wb");
try
{
gd.gdImageGd2(im, fp, cs, fmt);
}
finally
{
Close(fp);
}
}
public static void gdImageBmp(gdImageStruct im, string outFile, int compression)
{
var fp = C.fopen(outFile ?? string.Empty, "wb");
try
{
gd.gdImageBmp(im, fp, 1);
}
finally
{
Close(fp);
}
}
public void TestBug00066()
{
string path = string.Format("{0}/gif/bug00066.gif", GlobalMembersGdtest.DefineConstants.GDTEST_TOP_DIR);
gdImageStruct im = gd.gdImageCreateFromGif(path);
path = string.Format("{0}/gif/bug00066_exp.png", GlobalMembersGdtest.DefineConstants.GDTEST_TOP_DIR);
if (GlobalMembersGdtest.gdTestImageCompareToFile(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, null, (path), (im)) == 0)
{
Assert.Fail();
}
gd.gdImageDestroy(im);
}
public void TestBug00033()
{
//gd.gdSetErrorMethod(GlobalMembersGdtest.gdSilence);
string path = string.Format("{0}/png/bug00033.png", GlobalMembersGdtest.DefineConstants.GDTEST_TOP_DIR);
gdImageStruct im = gd.gdImageCreateFromPng(path);
if (im != null)
{
gd.gdImageDestroy(im);
Assert.Fail();
}
}
} // mkcross
private static void blurblank(gdImageStruct im, int radius, double sigma)
{
gdImageStruct result = gd.gdImageCopyGaussianBlurred(im, radius, sigma);
GlobalMembersGdtest.gdTestAssert(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "assert failed in <%s:%i>\n", (result != null) ? 1 : 0);
if (result == null)
{
return;
}
GlobalMembersGdtest.gdTestAssert(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "assert failed in <%s:%i>\n", (GlobalMembersGdtest.gdMaxPixelDiff(im, result) <= CLOSE_ENOUGH) ? 1 : 0);
gd.gdImageDestroy(result);
} // blurblank
public void TestJpeg_empty_file()
{
//gd.gdSetErrorMethod(GlobalMembersGdtest.gdSilence);
string path = string.Format("{0}/jpeg/empty.jpeg", GlobalMembersGdtest.DefineConstants.GDTEST_TOP_DIR);
gdImageStruct im = gd.gdImageCreateFromJpeg(path);
if (im != null)
{
gd.gdImageDestroy(im);
Assert.Fail();
}
}
public void TestGdImageLine_bug5()
{
/* Declare the image */
/* Declare output files */
/* FILE *pngout; */
gdImageStruct im = gd.gdImageCreateTrueColor(63318, 771);
/* Allocate the color white (red, green and blue all maximum). */
int white = gd.gdImageColorAllocate(im, 255, 255, 255);
/* Allocate the color white (red, green and blue all maximum). */
int black = gd.gdImageColorAllocate(im, 0, 0, 0);
/* white background */
gd.gdImageFill(im, 1, 1, white);
/* Make a reference copy. */
gdImageStruct @ref = gd.gdImageClone(im);
gd.gdImageSetAntiAliased(im, black);
/* This line used to fail. */
gd.gdImageLine(im, 28562, 631, 34266, 750, GlobalMembersGdtest.DefineConstants.gdAntiAliased);
GlobalMembersGdtest.gdTestAssert(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "assert failed in <%s:%i>\n", (GlobalMembersGdtest.gdMaxPixelDiff(im, @ref) > 0) ? 1 : 0);
#if false
// {
// FILE *pngout;
//
// /* Open a file for writing. "wb" means "write binary",
// * important under MSDOS, harmless under Unix. */
// pngout = fopen("test.png", "wb");
//
// /* Output the image to the disk file in PNG format. */
// gd.gdImagePng(im, pngout);
//
// /* Close the files. */
// fclose(pngout);
// }
#endif
/* Destroy the image in memory. */
gd.gdImageDestroy(im);
gd.gdImageDestroy(@ref);
Assert.AreEqual(0, GlobalMembersGdtest.gdNumFailures());
}
} // mkblack
private static gdImageStruct mkcross()
{
int n;
gdImageStruct im = mkwhite(WIDTH, HEIGHT);
int fg = gd.gdImageColorAllocate(im, 0, 0, 0);
for (n = -HT; n < HT; n++)
{
gd.gdImageLine(im, WIDTH / 2 - n, 0, WIDTH / 2 - n, HEIGHT - 1, fg);
gd.gdImageLine(im, 0, HEIGHT / 2 - n, WIDTH - 1, HEIGHT / 2 - n, fg);
} // for
return(im);
} // mkcross
} // do_test
/* Ensure that RGB values are equal, then return r (which is therefore
* the whiteness.) */
private static int getwhite(gdImageStruct im, int x, int y)
{
int px;
int r;
int g;
int b;
px = gd.gdImageGetPixel(im, x, y);
r = ((im).trueColor != 0 ? (((px) & 0xFF0000) >> 16) : (im).red[(px)]);
g = ((im).trueColor != 0 ? (((px) & 0x00FF00) >> 8) : (im).green[(px)]);
b = ((im).trueColor != 0 ? ((px) & 0x0000FF) : (im).blue[(px)]);
GlobalMembersGdtest.gdTestAssert(GlobalMembersGdtest.__FILE__, GlobalMembersGdtest.__LINE__, "assert failed in <%s:%i>\n", (r == g && r == b) ? 1 : 0);
return(r);
} // getrgb
public static extern void gdImagePngCtx(ref gdImageStruct im, ref gdIOCtx @out);
