#ifndef WX_PRECOMP
#endif // WX_PRECOMP
-#include "wx/image.h"
+#include "wx/anidecod.h" // wxImageArray
#include "wx/palette.h"
#include "wx/url.h"
#include "wx/log.h"
#include "wx/zstream.h"
#include "wx/wfstream.h"
+#include "testimage.h"
+
struct testData {
const char* file;
wxBitmapType type;
{ "horse.pcx", wxBITMAP_TYPE_PCX, 8 },
{ "horse.pnm", wxBITMAP_TYPE_PNM, 24 },
{ "horse.tga", wxBITMAP_TYPE_TGA, 8 },
- { "horse.tif", wxBITMAP_TYPE_TIF, 8 }
+ { "horse.tif", wxBITMAP_TYPE_TIFF, 8 }
};
CPPUNIT_TEST( SizeImage );
CPPUNIT_TEST( CompareLoadedImage );
CPPUNIT_TEST( CompareSavedImage );
+ CPPUNIT_TEST( SavePNG );
+ CPPUNIT_TEST( SaveTIFF );
+ CPPUNIT_TEST( SaveAnimatedGIF );
+ CPPUNIT_TEST( ReadCorruptedTGA );
+ CPPUNIT_TEST( GIFComment );
+ CPPUNIT_TEST( DibPadding );
+ CPPUNIT_TEST( BMPFlippingAndRLECompression );
CPPUNIT_TEST_SUITE_END();
void LoadFromSocketStream();
void SizeImage();
void CompareLoadedImage();
void CompareSavedImage();
+ void SavePNG();
+ void SaveTIFF();
+ void SaveAnimatedGIF();
+ void ReadCorruptedTGA();
+ void GIFComment();
+ void DibPadding();
+ void BMPFlippingAndRLECompression();
DECLARE_NO_COPY_CLASS(ImageTestCase)
};
case wxBITMAP_TYPE_GIF:
case wxBITMAP_TYPE_PCX:
case wxBITMAP_TYPE_TGA:
- case wxBITMAP_TYPE_TIF:
+ case wxBITMAP_TYPE_TIFF:
continue; // skip testing those wxImageHandlers which cannot
// load data from non-seekable streams
CPPUNIT_ASSERT_EQUAL( actual.GetSize().x, expected.GetSize().x );
CPPUNIT_ASSERT_EQUAL( actual.GetSize().y, expected.GetSize().y );
- const unsigned data_len = 3 * expected.GetHeight() * expected.GetWidth();
-
- WX_ASSERT_MESSAGE
+ WX_ASSERT_EQUAL_MESSAGE
(
("Resize test #%u: (%d, %d), (%d, %d)", i, st.w, st.h, st.dx, st.dy),
- memcmp(actual.GetData(), expected.GetData(), data_len) == 0
+ expected, actual
);
}
}
wxImage expected24("horse.png");
CPPUNIT_ASSERT( expected24.IsOk() );
- const size_t dataLen = expected8.GetWidth() * expected8.GetHeight() * 3;
-
for (size_t i=0; i<WXSIZEOF(g_testfiles); i++)
{
if ( !(g_testfiles[i].bitDepth == 8 || g_testfiles[i].bitDepth == 24)
}
- WX_ASSERT_MESSAGE
+ WX_ASSERT_EQUAL_MESSAGE
(
("Compare test '%s' for loading failed", g_testfiles[i].file),
-
- memcmp(actual.GetData(),
- (g_testfiles[i].bitDepth == 8)
- ? expected8.GetData()
- : expected24.GetData(),
- dataLen) == 0
+ g_testfiles[i].bitDepth == 8 ? expected8 : expected24,
+ actual
);
}
if ( testPalette
&& ( !(type == wxBITMAP_TYPE_BMP
|| type == wxBITMAP_TYPE_GIF
+ || type == wxBITMAP_TYPE_ICO
|| type == wxBITMAP_TYPE_PNG)
|| type == wxBITMAP_TYPE_XPM) )
{
const bool testAlpha = (properties & wxIMAGE_HAVE_ALPHA) != 0;
if (testAlpha
- && !(type == wxBITMAP_TYPE_PNG || type == wxBITMAP_TYPE_TGA) )
+ && !(type == wxBITMAP_TYPE_PNG || type == wxBITMAP_TYPE_TGA
+ || type == wxBITMAP_TYPE_TIFF) )
{
// don't test images with alpha if this handler doesn't support alpha
return;
}
- if (type == wxBITMAP_TYPE_JPEG /* skip lossy JPEG */
- || type == wxBITMAP_TYPE_TIF)
+ if (type == wxBITMAP_TYPE_JPEG /* skip lossy JPEG */)
{
- /*
- TIFF is skipped because the memory stream can't be loaded. Libtiff
- looks for a TIFF directory at offset 120008 while the memory
- stream size is only 120008 bytes (when saving as a file
- the file size is 120280 bytes).
- */
return;
}
CPPUNIT_ASSERT( actual.GetSize() == expected->GetSize() );
unsigned bitsPerPixel = testPalette ? 8 : (testAlpha ? 32 : 24);
- WX_ASSERT_MESSAGE
+ WX_ASSERT_EQUAL_MESSAGE
(
("Compare test '%s (%d-bit)' for saving failed",
handler.GetExtension(), bitsPerPixel),
-
- memcmp(actual.GetData(), expected->GetData(),
- expected->GetWidth() * expected->GetHeight() * 3) == 0
+ *expected,
+ actual
);
#if wxUSE_PALETTE
return;
}
- WX_ASSERT_MESSAGE
+ WX_ASSERT_EQUAL_MESSAGE
(
("Compare alpha test '%s' for saving failed", handler.GetExtension()),
-
- memcmp(actual.GetAlpha(), expected->GetAlpha(),
- expected->GetWidth() * expected->GetHeight()) == 0
+ *expected,
+ actual
);
}
+static void SetAlpha(wxImage *image)
+{
+ image->SetAlpha();
+
+ unsigned char *ptr = image->GetAlpha();
+ const int width = image->GetWidth();
+ const int height = image->GetHeight();
+ for (int y = 0; y < height; ++y)
+ {
+ for (int x = 0; x < width; ++x)
+ {
+ ptr[y*width + x] = (x*y) & wxIMAGE_ALPHA_OPAQUE;
+ }
+ }
+}
+
void ImageTestCase::CompareSavedImage()
{
// FIXME-VC6: Pre-declare the loop variables for compatibility with
// pre-standard compilers such as MSVC6 that don't implement proper scope
// for the variables declared in the for loops.
- int i, x, y;
+ int i;
wxImage expected24("horse.png");
CPPUNIT_ASSERT( expected24.IsOk() );
CPPUNIT_ASSERT( !expected24.HasAlpha() );
- unsigned long numColours = expected24.CountColours();
wxImage expected8 = expected24.ConvertToGreyscale();
- numColours = expected8.CountColours();
+#if wxUSE_PALETTE
unsigned char greys[256];
for (i = 0; i < 256; ++i)
{
}
wxPalette palette(256, greys, greys, greys);
expected8.SetPalette(palette);
+#endif // #if wxUSE_PALETTE
+
expected8.SetOption(wxIMAGE_OPTION_BMP_FORMAT, wxBMP_8BPP_PALETTE);
// Create an image with alpha based on the loaded image
wxImage expected32(expected24);
- expected32.SetAlpha();
- int width = expected32.GetWidth();
- int height = expected32.GetHeight();
- for (y = 0; y < height; ++y)
- {
- for (x = 0; x < width; ++x)
- {
- expected32.SetAlpha(x, y, (x*y) & wxIMAGE_ALPHA_OPAQUE);
- }
- }
+ SetAlpha(&expected32);
const wxList& list = wxImage::GetHandlers();
for ( wxList::compatibility_iterator node = list.GetFirst();
CompareImage(*handler, expected24);
CompareImage(*handler, expected32, wxIMAGE_HAVE_ALPHA);
}
+}
+void ImageTestCase::SavePNG()
+{
+ wxImage expected24("horse.png");
+ CPPUNIT_ASSERT( expected24.IsOk() );
+#if wxUSE_PALETTE
+ CPPUNIT_ASSERT( !expected24.HasPalette() );
+#endif // #if wxUSE_PALETTE
- expected8.LoadFile("horse.gif");
- CPPUNIT_ASSERT( expected8.IsOk() );
+ wxImage expected8 = expected24.ConvertToGreyscale();
+
+ /*
+ horse.png converted to greyscale should be saved without a palette.
+ */
+ CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG), expected8);
+
+ /*
+ But if we explicitly ask for trying to save with a palette, it should work.
+ */
+ expected8.SetOption(wxIMAGE_OPTION_PNG_FORMAT, wxPNG_TYPE_PALETTE);
+
+ CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG),
+ expected8, wxIMAGE_HAVE_PALETTE);
+
+
+ CPPUNIT_ASSERT( expected8.LoadFile("horse.gif") );
+#if wxUSE_PALETTE
CPPUNIT_ASSERT( expected8.HasPalette() );
+#endif // #if wxUSE_PALETTE
+
+ CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG),
+ expected8, wxIMAGE_HAVE_PALETTE);
+ /*
+ Add alpha to the image in such a way that there will still be a maximum
+ of 256 unique RGBA combinations. This should result in a saved
+ PNG image still being palettised and having alpha.
+ */
expected8.SetAlpha();
- width = expected8.GetWidth();
- height = expected8.GetHeight();
+ int x, y;
+ const int width = expected8.GetWidth();
+ const int height = expected8.GetHeight();
for (y = 0; y < height; ++y)
{
for (x = 0; x < width; ++x)
{
- expected8.SetAlpha(x, y, (x*y) & wxIMAGE_ALPHA_OPAQUE);
+ expected8.SetAlpha(x, y, expected8.GetRed(x, y));
}
}
+ CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG),
+ expected8, wxIMAGE_HAVE_ALPHA|wxIMAGE_HAVE_PALETTE);
+
/*
- The image contains 256 indexed colours and needs another palette entry
- for storing the transparency index. This results in wanting 257 palette
- entries but that amount is not supported by PNG, as such this image
- should not contain a palette (but still have alpha) and be stored as a
- true colour image instead.
+ Now change the alpha of the first pixel so that we can't save palettised
+ anymore because there will be 256+1 entries which is beyond PNGs limit
+ of 256 entries.
*/
+ expected8.SetAlpha(0, 0, 1);
+
CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG),
expected8, wxIMAGE_HAVE_ALPHA);
-#if wxUSE_PALETTE
/*
- Now do the same test again but remove one (random) palette entry. This
- should result in saving the PNG with a palette.
+ Even if we explicitly ask for saving palettised it should not be done.
*/
- unsigned char red[256], green[256], blue[256];
- const wxPalette& pal = expected8.GetPalette();
- const int paletteCount = pal.GetColoursCount();
- for (i = 0; i < paletteCount; ++i)
+ expected8.SetOption(wxIMAGE_OPTION_PNG_FORMAT, wxPNG_TYPE_PALETTE);
+ CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG),
+ expected8, wxIMAGE_HAVE_ALPHA);
+
+}
+
+static void TestTIFFImage(const wxString& option, int value,
+ const wxImage *compareImage = NULL)
+{
+ wxImage image;
+ if (compareImage)
+ {
+ image = *compareImage;
+ }
+ else
+ {
+ (void) image.LoadFile("horse.png");
+ }
+ CPPUNIT_ASSERT( image.IsOk() );
+
+ wxMemoryOutputStream memOut;
+ image.SetOption(option, value);
+
+ CPPUNIT_ASSERT(image.SaveFile(memOut, wxBITMAP_TYPE_TIFF));
+
+ wxMemoryInputStream memIn(memOut);
+ CPPUNIT_ASSERT(memIn.IsOk());
+
+ wxImage savedImage(memIn);
+ CPPUNIT_ASSERT(savedImage.IsOk());
+
+ WX_ASSERT_EQUAL_MESSAGE(("While checking for option %s", option),
+ true, savedImage.HasOption(option));
+
+ WX_ASSERT_EQUAL_MESSAGE(("While testing for %s", option),
+ value, savedImage.GetOptionInt(option));
+
+ WX_ASSERT_EQUAL_MESSAGE(("HasAlpha() not equal"), image.HasAlpha(), savedImage.HasAlpha());
+}
+
+void ImageTestCase::SaveTIFF()
+{
+ TestTIFFImage(wxIMAGE_OPTION_TIFF_BITSPERSAMPLE, 1);
+ TestTIFFImage(wxIMAGE_OPTION_TIFF_SAMPLESPERPIXEL, 1);
+ TestTIFFImage(wxIMAGE_OPTION_TIFF_PHOTOMETRIC, 0/*PHOTOMETRIC_MINISWHITE*/);
+ TestTIFFImage(wxIMAGE_OPTION_TIFF_PHOTOMETRIC, 1/*PHOTOMETRIC_MINISBLACK*/);
+
+ wxImage alphaImage("horse.png");
+ CPPUNIT_ASSERT( alphaImage.IsOk() );
+ SetAlpha(&alphaImage);
+
+ // RGB with alpha
+ TestTIFFImage(wxIMAGE_OPTION_TIFF_SAMPLESPERPIXEL, 4, &alphaImage);
+
+ // Grey with alpha
+ TestTIFFImage(wxIMAGE_OPTION_TIFF_SAMPLESPERPIXEL, 2, &alphaImage);
+
+ // B/W with alpha
+ alphaImage.SetOption(wxIMAGE_OPTION_TIFF_BITSPERSAMPLE, 1);
+ TestTIFFImage(wxIMAGE_OPTION_TIFF_SAMPLESPERPIXEL, 2, &alphaImage);
+}
+
+void ImageTestCase::SaveAnimatedGIF()
+{
+#if wxUSE_PALETTE
+ wxImage image("horse.gif");
+ CPPUNIT_ASSERT( image.IsOk() );
+
+ wxImageArray images;
+ images.Add(image);
+ int i;
+ for (i = 0; i < 4-1; ++i)
+ {
+ images.Add( images[i].Rotate90() );
+
+ images[i+1].SetPalette(images[0].GetPalette());
+ }
+
+ wxMemoryOutputStream memOut;
+ CPPUNIT_ASSERT( wxGIFHandler().SaveAnimation(images, &memOut) );
+
+ wxGIFHandler handler;
+ wxMemoryInputStream memIn(memOut);
+ CPPUNIT_ASSERT(memIn.IsOk());
+ const int imageCount = handler.GetImageCount(memIn);
+ CPPUNIT_ASSERT_EQUAL(4, imageCount);
+
+ for (i = 0; i < imageCount; ++i)
{
- expected8.GetPalette().GetRGB(i, &red[i], &green[i], &blue[i]);
+ wxFileOffset pos = memIn.TellI();
+ CPPUNIT_ASSERT( handler.LoadFile(&image, memIn, true, i) );
+ memIn.SeekI(pos);
+
+ WX_ASSERT_EQUAL_MESSAGE
+ (
+ ("Compare test for GIF frame number %d failed", i),
+ images[i],
+ image
+ );
}
- wxPalette newPal(paletteCount - 1, red, green, blue);
- expected8.Replace(
- red[paletteCount-1], green[paletteCount-1], blue[paletteCount-1],
- red[paletteCount-2], green[paletteCount-2], blue[paletteCount-2]);
+#endif // #if wxUSE_PALETTE
+}
+
+void ImageTestCase::ReadCorruptedTGA()
+{
+ static unsigned char corruptTGA[18+1+3] =
+ {
+ 0,
+ 0,
+ 10, // RLE compressed image.
+ 0, 0,
+ 0, 0,
+ 0,
+ 0, 0,
+ 0, 0,
+ 1, 0, // Width is 1.
+ 1, 0, // Height is 1.
+ 24, // Bits per pixel.
+ 0,
+
+ 0xff, // Run length (repeat next pixel 127+1 times).
+ 0xff, 0xff, 0xff // One 24-bit pixel.
+ };
+
+ wxMemoryInputStream memIn(corruptTGA, WXSIZEOF(corruptTGA));
+ CPPUNIT_ASSERT(memIn.IsOk());
+
+ wxImage tgaImage;
+ CPPUNIT_ASSERT( !tgaImage.LoadFile(memIn) );
+
- expected8.SetPalette(newPal);
/*
- Explicitly make known we want a palettised PNG. If we don't then this
- particular image gets saved as a true colour image because there's an
- alpha channel present and the PNG saver prefers to keep the alpha over
- saving as a palettised image that has alpha converted to a mask.
+ Instead of repeating a pixel 127+1 times, now tell it there will
+ follow 127+1 uncompressed pixels (while we only should have 1 in total).
*/
- expected8.SetOption(wxIMAGE_OPTION_PNG_FORMAT, wxPNG_TYPE_PALETTE);
+ corruptTGA[18] = 0x7f;
+ CPPUNIT_ASSERT( !tgaImage.LoadFile(memIn) );
+}
+
+static void TestGIFComment(const wxString& comment)
+{
+ wxImage image("horse.gif");
+
+ image.SetOption(wxIMAGE_OPTION_GIF_COMMENT, comment);
+ wxMemoryOutputStream memOut;
+ CPPUNIT_ASSERT(image.SaveFile(memOut, wxBITMAP_TYPE_GIF));
+
+ wxMemoryInputStream memIn(memOut);
+ CPPUNIT_ASSERT( image.LoadFile(memIn) );
+
+ CPPUNIT_ASSERT_EQUAL(comment,
+ image.GetOption(wxIMAGE_OPTION_GIF_COMMENT));
+}
+
+void ImageTestCase::GIFComment()
+{
+ // Test reading a comment.
+ wxImage image("horse.gif");
+ CPPUNIT_ASSERT_EQUAL(" Imported from GRADATION image: gray",
+ image.GetOption(wxIMAGE_OPTION_GIF_COMMENT));
+
+
+ // Test writing a comment and reading it back.
+ TestGIFComment("Giving the GIF a gifted giraffe as a gift");
+
+
+ // Test writing and reading a comment again but with a long comment.
+ TestGIFComment(wxString(wxT('a'), 256)
+ + wxString(wxT('b'), 256)
+ + wxString(wxT('c'), 256));
+
+
+ // Test writing comments in an animated GIF and reading them back.
+ CPPUNIT_ASSERT( image.LoadFile("horse.gif") );
+
+ wxImageArray images;
+ int i;
+ for (i = 0; i < 4; ++i)
+ {
+ if (i)
+ {
+ images.Add( images[i-1].Rotate90() );
+ images[i].SetPalette(images[0].GetPalette());
+ }
+ else
+ {
+ images.Add(image);
+ }
+
+ images[i].SetOption(wxIMAGE_OPTION_GIF_COMMENT,
+ wxString::Format("GIF comment for frame #%d", i+1));
+
+ }
+
- wxImage ref8 = expected8;
+ wxMemoryOutputStream memOut;
+ CPPUNIT_ASSERT( wxGIFHandler().SaveAnimation(images, &memOut) );
+ wxGIFHandler handler;
+ wxMemoryInputStream memIn(memOut);
+ CPPUNIT_ASSERT(memIn.IsOk());
+ const int imageCount = handler.GetImageCount(memIn);
+ for (i = 0; i < imageCount; ++i)
+ {
+ wxFileOffset pos = memIn.TellI();
+ CPPUNIT_ASSERT( handler.LoadFile(&image, memIn, true /*verbose?*/, i) );
+
+ CPPUNIT_ASSERT_EQUAL(
+ wxString::Format("GIF comment for frame #%d", i+1),
+ image.GetOption(wxIMAGE_OPTION_GIF_COMMENT));
+ memIn.SeekI(pos);
+ }
+}
+
+void ImageTestCase::DibPadding()
+{
/*
- Convert the alpha channel to a mask like the PNG saver does. Also convert
- the colour used for transparency from 1,0,0 to 2,0,0. The latter gets
- done by the PNG loader in search of an unused colour to use for
- transparency (this should be fixed).
+ There used to be an error with calculating the DWORD aligned scan line
+ pitch for a BMP/ICO resulting in buffer overwrites (with at least MSVC9
+ Debug this gave a heap corruption assertion when saving the mask of
+ an ICO). Test for it here.
*/
- ref8.ConvertAlphaToMask();
- ref8.Replace(1, 0, 0, 2, 0, 0);
+ wxImage image("horse.gif");
+ CPPUNIT_ASSERT( image.IsOk() );
- CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG),
- expected8, wxIMAGE_HAVE_PALETTE, &ref8);
-#endif
+ image = image.Scale(99, 99);
+
+ wxMemoryOutputStream memOut;
+ CPPUNIT_ASSERT( image.SaveFile(memOut, wxBITMAP_TYPE_ICO) );
}
+static void CompareBMPImage(const wxString& file1, const wxString& file2)
+{
+ wxImage image1(file1);
+ CPPUNIT_ASSERT( image1.IsOk() );
+
+ wxImage image2(file2);
+ CPPUNIT_ASSERT( image2.IsOk() );
+
+ CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_BMP), image1, 0, &image2);
+}
+
+void ImageTestCase::BMPFlippingAndRLECompression()
+{
+ CompareBMPImage("image/horse_grey.bmp", "image/horse_grey_flipped.bmp");
+
+ CompareBMPImage("image/horse_rle8.bmp", "image/horse_grey.bmp");
+ CompareBMPImage("image/horse_rle8.bmp", "image/horse_rle8_flipped.bmp");
+
+ CompareBMPImage("image/horse_rle4.bmp", "image/horse_rle4_flipped.bmp");
+}
#endif //wxUSE_IMAGE
projects / wxWidgets.git / blobdiff