Test using wxString::ToCDouble() in wxAny.

[wxWidgets.git] / tests / image / image.cpp

diff --git a/tests/image/image.cpp b/tests/image/image.cpp
index 958dd922a7a0326675401fbd1c466325f3c31d1e..f0f8ad2c4c6e8d846c2a6bf8e5e60dff31fdfd56 100644 (file)
--- a/tests/image/image.cpp
+++ b/tests/image/image.cpp
@@ -24,7 +24,6 @@
 #endif // WX_PRECOMP
 
 #include "wx/anidecod.h" // wxImageArray
 #endif // WX_PRECOMP
 
 #include "wx/anidecod.h" // wxImageArray

-#include "wx/image.h"

 #include "wx/palette.h"
 #include "wx/url.h"
 #include "wx/log.h"
 #include "wx/palette.h"
 #include "wx/url.h"
 #include "wx/log.h"


@@ -32,6 +31,8 @@
 #include "wx/zstream.h"
 #include "wx/wfstream.h"
 
 #include "wx/zstream.h"
 #include "wx/wfstream.h"
 

+#include "testimage.h"
+

 struct testData {
     const char* file;
     wxBitmapType type;
 struct testData {
     const char* file;
     wxBitmapType type;


@@ -49,7 +50,7 @@ struct testData {
     { "horse.pcx", wxBITMAP_TYPE_PCX, 8 },
     { "horse.pnm", wxBITMAP_TYPE_PNM, 24 },
     { "horse.tga", wxBITMAP_TYPE_TGA, 8 },
     { "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 }

 };
 
 
 };
 
 


@@ -71,9 +72,13 @@ private:
         CPPUNIT_TEST( SizeImage );
         CPPUNIT_TEST( CompareLoadedImage );
         CPPUNIT_TEST( CompareSavedImage );
         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( SaveAnimatedGIF );
         CPPUNIT_TEST( ReadCorruptedTGA );
         CPPUNIT_TEST( GIFComment );

+        CPPUNIT_TEST( DibPadding );
+        CPPUNIT_TEST( BMPFlippingAndRLECompression );

     CPPUNIT_TEST_SUITE_END();
 
     void LoadFromSocketStream();
     CPPUNIT_TEST_SUITE_END();
 
     void LoadFromSocketStream();


@@ -82,9 +87,13 @@ private:
     void SizeImage();
     void CompareLoadedImage();
     void CompareSavedImage();
     void SizeImage();
     void CompareLoadedImage();
     void CompareSavedImage();

+    void SavePNG();
+    void SaveTIFF();

     void SaveAnimatedGIF();
     void ReadCorruptedTGA();
     void GIFComment();
     void SaveAnimatedGIF();
     void ReadCorruptedTGA();
     void GIFComment();

+    void DibPadding();
+    void BMPFlippingAndRLECompression();

 
     DECLARE_NO_COPY_CLASS(ImageTestCase)
 };
 
     DECLARE_NO_COPY_CLASS(ImageTestCase)
 };


@@ -183,7 +192,7 @@ void ImageTestCase::LoadFromZipStream()
             case wxBITMAP_TYPE_GIF:
             case wxBITMAP_TYPE_PCX:
             case wxBITMAP_TYPE_TGA:
             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
 
             continue;       // skip testing those wxImageHandlers which cannot
                             // load data from non-seekable streams
 


@@ -828,12 +837,10 @@ void ImageTestCase::SizeImage()
        CPPUNIT_ASSERT_EQUAL( actual.GetSize().x, expected.GetSize().x );
        CPPUNIT_ASSERT_EQUAL( actual.GetSize().y, expected.GetSize().y );
 
        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),
        (
          ("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

        );
    }
 }
        );
    }
 }


@@ -846,8 +853,6 @@ void ImageTestCase::CompareLoadedImage()
     wxImage expected24("horse.png");
     CPPUNIT_ASSERT( expected24.IsOk() );
 
     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)
     for (size_t i=0; i<WXSIZEOF(g_testfiles); i++)
     {
         if ( !(g_testfiles[i].bitDepth == 8 || g_testfiles[i].bitDepth == 24)


@@ -864,15 +869,11 @@ void ImageTestCase::CompareLoadedImage()
         }
 
 
         }
 
 

-        WX_ASSERT_MESSAGE
+        WX_ASSERT_EQUAL_MESSAGE

         (
             ("Compare test '%s' for loading failed", g_testfiles[i].file),
         (
             ("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

         );
     }
 
         );
     }
 


@@ -898,6 +899,7 @@ void CompareImage(const wxImageHandler& handler, const wxImage& image,
     if ( testPalette
         && ( !(type == wxBITMAP_TYPE_BMP
                 || type == wxBITMAP_TYPE_GIF
     if ( testPalette
         && ( !(type == wxBITMAP_TYPE_BMP
                 || type == wxBITMAP_TYPE_GIF

+                || type == wxBITMAP_TYPE_ICO

                 || type == wxBITMAP_TYPE_PNG)
             || type == wxBITMAP_TYPE_XPM) )
     {
                 || type == wxBITMAP_TYPE_PNG)
             || type == wxBITMAP_TYPE_XPM) )
     {


@@ -906,21 +908,15 @@ void CompareImage(const wxImageHandler& handler, const wxImage& image,
 
     const bool testAlpha = (properties & wxIMAGE_HAVE_ALPHA) != 0;
     if (testAlpha
 
     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;
     }
 
     {
         // 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;
     }
 
         return;
     }
 


@@ -942,13 +938,12 @@ void CompareImage(const wxImageHandler& handler, const wxImage& image,
     CPPUNIT_ASSERT( actual.GetSize() == expected->GetSize() );
 
     unsigned bitsPerPixel = testPalette ? 8 : (testAlpha ? 32 : 24);
     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),
     (
         ("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
     );
 
 #if wxUSE_PALETTE


@@ -963,21 +958,36 @@ void CompareImage(const wxImageHandler& handler, const wxImage& image,
         return;
     }
 
         return;
     }
 

-    WX_ASSERT_MESSAGE
+    WX_ASSERT_EQUAL_MESSAGE

     (
         ("Compare alpha test '%s' for saving failed", handler.GetExtension()),
     (
         ("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.
 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() );
 
     wxImage expected24("horse.png");
     CPPUNIT_ASSERT( expected24.IsOk() );


@@ -999,17 +1009,8 @@ void ImageTestCase::CompareSavedImage()
 
     // Create an image with alpha based on the loaded image
     wxImage expected32(expected24);
 
     // 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();
 
     const wxList& list = wxImage::GetHandlers();
     for ( wxList::compatibility_iterator node = list.GetFirst();


@@ -1023,77 +1024,134 @@ void ImageTestCase::CompareSavedImage()
         CompareImage(*handler, expected24);
         CompareImage(*handler, expected32, wxIMAGE_HAVE_ALPHA);
     }
         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

 
 

+    wxImage expected8 = expected24.ConvertToGreyscale();

 
 

-    expected8.LoadFile("horse.gif");
-    CPPUNIT_ASSERT( expected8.IsOk() );
+    /*
+    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
 
 #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();
 
     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)
         {
     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));

         }
     }
 
         }
     }
 

-    /*
-    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.
-    */
-    expected8.SetOption(wxIMAGE_OPTION_PNG_FORMAT, wxPNG_TYPE_PALETTE);
+    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);
 
     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

     {
     {

-        expected8.GetPalette().GetRGB(i, &red[i], &green[i], &blue[i]);
+        (void) image.LoadFile("horse.png");

     }
     }

-    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]);
+    CPPUNIT_ASSERT( image.IsOk() );

 
 

-    expected8.SetPalette(newPal);
+    wxMemoryOutputStream memOut;
+    image.SetOption(option, value);

 
 

-    wxImage ref8 = expected8;
+    CPPUNIT_ASSERT(image.SaveFile(memOut, wxBITMAP_TYPE_TIFF));

 
 

-    /*
-    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).
-    */
-    ref8.ConvertAlphaToMask();
-    ref8.Replace(1, 0, 0,  2, 0, 0);
+    wxMemoryInputStream memIn(memOut);
+    CPPUNIT_ASSERT(memIn.IsOk());

 
 

-    CompareImage(*wxImage::FindHandler(wxBITMAP_TYPE_PNG),
-        expected8, wxIMAGE_HAVE_PALETTE, &ref8);
-#endif
+    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()
 }
 
 void ImageTestCase::SaveAnimatedGIF()


@@ -1127,11 +1185,11 @@ void ImageTestCase::SaveAnimatedGIF()
         CPPUNIT_ASSERT( handler.LoadFile(&image, memIn, true, i) );
         memIn.SeekI(pos);
 
         CPPUNIT_ASSERT( handler.LoadFile(&image, memIn, true, i) );
         memIn.SeekI(pos);
 

-        WX_ASSERT_MESSAGE
+        WX_ASSERT_EQUAL_MESSAGE

         (
             ("Compare test for GIF frame number %d failed", i),
         (
             ("Compare test for GIF frame number %d failed", i),

-            memcmp(image.GetData(), images[i].GetData(),
-                images[i].GetWidth() * images[i].GetHeight() * 3) == 0
+            images[i],
+            image

         );
     }
 #endif // #if wxUSE_PALETTE
         );
     }
 #endif // #if wxUSE_PALETTE


@@ -1248,6 +1306,43 @@ void ImageTestCase::GIFComment()
     }
 }
 
     }
 }
 

+void ImageTestCase::DibPadding()
+{
+    /*
+    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.
+    */
+    wxImage image("horse.gif");
+    CPPUNIT_ASSERT( image.IsOk() );
+
+    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
 
 
 #endif //wxUSE_IMAGE