regenerated after version.bkl changes fixing -compatibility_version for Darwin

[wxWidgets.git] / src / common / image.cpp

diff --git a/src/common/image.cpp b/src/common/image.cpp
index 50307d6ec88ab5ada3e46dc38bf45c0a674ac086..c888353fd9b801ee1bd972f4bc67ed7d23c02d78 100644 (file)
--- a/src/common/image.cpp
+++ b/src/common/image.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        image.cpp
+// Name:        src/common/image.cpp

 // Purpose:     wxImage
 // Author:      Robert Roebling
 // RCS-ID:      $Id$
 // Purpose:     wxImage
 // Author:      Robert Roebling
 // RCS-ID:      $Id$


@@ -7,10 +7,6 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "image.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -1755,29 +1751,36 @@ wxString wxImage::GetImageExtWildcard()
 
 wxImage::HSVValue wxImage::RGBtoHSV(const RGBValue& rgb)
 {
 
 wxImage::HSVValue wxImage::RGBtoHSV(const RGBValue& rgb)
 {

-    double hue, saturation, value;
-

     const double red = rgb.red / 255.0,
                  green = rgb.green / 255.0,
                  blue = rgb.blue / 255.0;
 
     const double red = rgb.red / 255.0,
                  green = rgb.green / 255.0,
                  blue = rgb.blue / 255.0;
 

+    // find the min and max intensity (and remember which one was it for the
+    // latter)

     double minimumRGB = red;
     double minimumRGB = red;

-    if (green < minimumRGB)
+    if ( green < minimumRGB )

         minimumRGB = green;
         minimumRGB = green;

-
-    if (blue < minimumRGB)
+    if ( blue < minimumRGB )

         minimumRGB = blue;
 
         minimumRGB = blue;
 

+    enum { RED, GREEN, BLUE } chMax = RED;

     double maximumRGB = red;
     double maximumRGB = red;

-    if (green > maximumRGB)
+    if ( green > maximumRGB )
+    {
+        chMax = GREEN;

         maximumRGB = green;
         maximumRGB = green;

-
-    if (blue > maximumRGB)
+    }
+    if ( blue > maximumRGB )
+    {
+        chMax = BLUE;

         maximumRGB = blue;
         maximumRGB = blue;

+    }

 
 

-    value = maximumRGB;
+    const double value = maximumRGB;

 
 

-    if (maximumRGB == minimumRGB)
+    double hue = 0.0, saturation;
+    const double deltaRGB = maximumRGB - minimumRGB;
+    if ( wxIsNullDouble(deltaRGB) )

     {
         // Gray has no color
         hue = 0.0;
     {
         // Gray has no color
         hue = 0.0;


@@ -1785,21 +1788,31 @@ wxImage::HSVValue wxImage::RGBtoHSV(const RGBValue& rgb)
     }
     else
     {
     }
     else
     {

-        double deltaRGB = maximumRGB - minimumRGB;
+        switch ( chMax )
+        {
+            case RED:
+                hue = (green - blue) / deltaRGB;
+                break;

 
 

-        saturation = deltaRGB / maximumRGB;
+            case GREEN:
+                hue = 2.0 + (blue - red) / deltaRGB;
+                break;

 
 

-        if ( red == maximumRGB )
-            hue = (green - blue) / deltaRGB;
-        else if (green == maximumRGB)
-            hue = 2.0 + (blue - red) / deltaRGB;
-        else
-            hue = 4.0 + (red - green) / deltaRGB;
+            case BLUE:
+                hue = 4.0 + (red - green) / deltaRGB;
+                break;
+
+            default:
+                wxFAIL_MSG(wxT("hue not specified"));
+                break;
+        }

 
 

-        hue = hue / 6.0;
+        hue /= 6.0;

 
 

-        if (hue < 0.0)
-            hue = hue + 1.0;
+        if ( hue < 0.0 )
+            hue += 1.0;
+
+        saturation = deltaRGB / maximumRGB;

     }
 
     return HSVValue(hue, saturation, value);
     }
 
     return HSVValue(hue, saturation, value);


@@ -1809,13 +1822,14 @@ wxImage::RGBValue wxImage::HSVtoRGB(const HSVValue& hsv)
 {
     double red, green, blue;
 
 {
     double red, green, blue;
 

-    if ( hsv.saturation == 0.0 )
+    if ( wxIsNullDouble(hsv.saturation) )

     {
     {

-        red = hsv.value; //Grey
+        // Grey
+        red = hsv.value;

         green = hsv.value;
         green = hsv.value;

-        blue = hsv.value; 
+        blue = hsv.value;

     }
     }

-    else
+    else // not grey

     {
         double hue = hsv.hue * 6.0;      // sector 0 to 5
         int i = (int)floor(hue);
     {
         double hue = hsv.hue * 6.0;      // sector 0 to 5
         int i = (int)floor(hue);


@@ -1881,7 +1895,7 @@ void wxImage::RotateHue(double angle)
 
     wxASSERT (angle >= -1.0 && angle <= 1.0);
     count = M_IMGDATA->m_width * M_IMGDATA->m_height;
 
     wxASSERT (angle >= -1.0 && angle <= 1.0);
     count = M_IMGDATA->m_width * M_IMGDATA->m_height;

-    if (count > 0 && angle != 0.0)
+    if ( count > 0 && !wxIsNullDouble(angle) )

     {
         srcBytePtr = M_IMGDATA->m_data;
         dstBytePtr = srcBytePtr;
     {
         srcBytePtr = M_IMGDATA->m_data;
         dstBytePtr = srcBytePtr;


@@ -2165,20 +2179,20 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
     wxRealPoint p3 = rotated_point (GetWidth(), 0, cos_angle, sin_angle, p0);
     wxRealPoint p4 = rotated_point (GetWidth(), GetHeight(), cos_angle, sin_angle, p0);
 
     wxRealPoint p3 = rotated_point (GetWidth(), 0, cos_angle, sin_angle, p0);
     wxRealPoint p4 = rotated_point (GetWidth(), GetHeight(), cos_angle, sin_angle, p0);
 

-    int x1 = (int) floor (wxMin (wxMin(p1.x, p2.x), wxMin(p3.x, p4.x)));
-    int y1 = (int) floor (wxMin (wxMin(p1.y, p2.y), wxMin(p3.y, p4.y)));
-    int x2 = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x)));
-    int y2 = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y)));
+    int x1a = (int) floor (wxMin (wxMin(p1.x, p2.x), wxMin(p3.x, p4.x)));
+    int y1a = (int) floor (wxMin (wxMin(p1.y, p2.y), wxMin(p3.y, p4.y)));
+    int x2a = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x)));
+    int y2a = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y)));

 
     // Create rotated image
 
     // Create rotated image

-    wxImage rotated (x2 - x1 + 1, y2 - y1 + 1, false);
+    wxImage rotated (x2a - x1a + 1, y2a - y1a + 1, false);

     // With alpha channel
     if (has_alpha)
         rotated.SetAlpha();
 
     if (offset_after_rotation != NULL)
     {
     // With alpha channel
     if (has_alpha)
         rotated.SetAlpha();
 
     if (offset_after_rotation != NULL)
     {

-        *offset_after_rotation = wxPoint (x1, y1);
+        *offset_after_rotation = wxPoint (x1a, y1a);

     }
 
     // GRG: The rotated (destination) image is always accessed
     }
 
     // GRG: The rotated (destination) image is always accessed


@@ -2220,7 +2234,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
         {
             for (x = 0; x < rotated.GetWidth(); x++)
             {
         {
             for (x = 0; x < rotated.GetWidth(); x++)
             {

-                wxRealPoint src = rotated_point (x + x1, y + y1, cos_angle, -sin_angle, p0);
+                wxRealPoint src = rotated_point (x + x1a, y + y1a, cos_angle, -sin_angle, p0);

 
                 if (-0.25 < src.x && src.x < GetWidth() - 0.75 &&
                     -0.25 < src.y && src.y < GetHeight() - 0.75)
 
                 if (-0.25 < src.x && src.x < GetWidth() - 0.75 &&
                     -0.25 < src.y && src.y < GetHeight() - 0.75)


@@ -2228,8 +2242,6 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                     // interpolate using the 4 enclosing grid-points.  Those
                     // points can be obtained using floor and ceiling of the
                     // exact coordinates of the point
                     // interpolate using the 4 enclosing grid-points.  Those
                     // points can be obtained using floor and ceiling of the
                     // exact coordinates of the point

-                        // C.M. 2000-02-17:  when the point is near the border, special care is required.
-

                     int x1, y1, x2, y2;
 
                     if (0 < src.x && src.x < GetWidth() - 1)
                     int x1, y1, x2, y2;
 
                     if (0 < src.x && src.x < GetWidth() - 1)


@@ -2279,10 +2291,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         *(dst++) = *p;
 
                         if (has_alpha)
                         *(dst++) = *p;
 
                         if (has_alpha)

-                        {
-                            unsigned char *p = alpha[y1] + x1;
-                            *(alpha_dst++) = *p;
-                        }
+                            *(alpha_dst++) = *(alpha[y1] + x1);

                     }
                     else if (d2 < gs_Epsilon)
                     {
                     }
                     else if (d2 < gs_Epsilon)
                     {


@@ -2292,10 +2301,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         *(dst++) = *p;
 
                         if (has_alpha)
                         *(dst++) = *p;
 
                         if (has_alpha)

-                        {
-                            unsigned char *p = alpha[y1] + x2;
-                            *(alpha_dst++) = *p;
-                        }
+                            *(alpha_dst++) = *(alpha[y1] + x2);

                     }
                     else if (d3 < gs_Epsilon)
                     {
                     }
                     else if (d3 < gs_Epsilon)
                     {


@@ -2305,10 +2311,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         *(dst++) = *p;
 
                         if (has_alpha)
                         *(dst++) = *p;
 
                         if (has_alpha)

-                        {
-                            unsigned char *p = alpha[y2] + x2;
-                            *(alpha_dst++) = *p;
-                        }
+                            *(alpha_dst++) = *(alpha[y2] + x2);

                     }
                     else if (d4 < gs_Epsilon)
                     {
                     }
                     else if (d4 < gs_Epsilon)
                     {


@@ -2318,10 +2321,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         *(dst++) = *p;
 
                         if (has_alpha)
                         *(dst++) = *p;
 
                         if (has_alpha)

-                        {
-                            unsigned char *p = alpha[y2] + x1;
-                            *(alpha_dst++) = *p;
-                        }
+                            *(alpha_dst++) = *(alpha[y2] + x1);

                     }
                     else
                     {
                     }
                     else
                     {


@@ -2350,10 +2350,10 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
 
                         if (has_alpha)
                         {
 
                         if (has_alpha)
                         {

-                            unsigned char *v1 = alpha[y1] + (x1);
-                            unsigned char *v2 = alpha[y1] + (x2);
-                            unsigned char *v3 = alpha[y2] + (x2);
-                            unsigned char *v4 = alpha[y2] + (x1);
+                            v1 = alpha[y1] + (x1);
+                            v2 = alpha[y1] + (x2);
+                            v3 = alpha[y2] + (x2);
+                            v4 = alpha[y2] + (x1);

 
                             *(alpha_dst++) = (unsigned char)
                                 ( (w1 * *v1 + w2 * *v2 +
 
                             *(alpha_dst++) = (unsigned char)
                                 ( (w1 * *v1 + w2 * *v2 +


@@ -2380,7 +2380,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
         {
             for (x = 0; x < rotated.GetWidth(); x++)
             {
         {
             for (x = 0; x < rotated.GetWidth(); x++)
             {

-                wxRealPoint src = rotated_point (x + x1, y + y1, cos_angle, -sin_angle, p0);
+                wxRealPoint src = rotated_point (x + x1a, y + y1a, cos_angle, -sin_angle, p0);

 
                 const int xs = wxCint (src.x);      // wxCint rounds to the
                 const int ys = wxCint (src.y);      // closest integer
 
                 const int xs = wxCint (src.x);      // wxCint rounds to the
                 const int ys = wxCint (src.y);      // closest integer


@@ -2394,10 +2394,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                     *(dst++) = *p;
 
                     if (has_alpha)
                     *(dst++) = *p;
 
                     if (has_alpha)

-                    {
-                        unsigned char *p = alpha[ys] + (xs);
-                        *(alpha_dst++) = *p;
-                    }
+                        *(alpha_dst++) = *(alpha[ys] + (xs));

                 }
                 else
                 {
                 }
                 else
                 {