]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/image.cpp
fix warnings about parameters shadowing member variables
[wxWidgets.git] / src / common / image.cpp
index a2674529dec0bd15c7957f82aeb64b074f7c5971..92bbdde513e35aa9b79f661b82216eaf62e860cc 100644 (file)
 #define HAS_FILE_STREAMS (wxUSE_STREAMS && (wxUSE_FILE || wxUSE_FFILE))
 
 #if HAS_FILE_STREAMS
-    #if wxUSE_FILE
-        typedef wxFileInputStream wxImageFileInputStream;
-        typedef wxFileOutputStream wxImageFileOutputStream;
-    #elif wxUSE_FFILE
+    #if wxUSE_FFILE
         typedef wxFFileInputStream wxImageFileInputStream;
         typedef wxFFileOutputStream wxImageFileOutputStream;
+    #elif wxUSE_FILE
+        typedef wxFileInputStream wxImageFileInputStream;
+        typedef wxFileOutputStream wxImageFileOutputStream;
     #endif // wxUSE_FILE/wxUSE_FFILE
 #endif // HAS_FILE_STREAMS
 
 #if wxUSE_VARIANT
-IMPLEMENT_VARIANT_OBJECT_EXPORTED(wxImage,WXDLLEXPORT)
+IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxImage,WXDLLEXPORT)
 #endif
 
 //-----------------------------------------------------------------------------
@@ -675,13 +675,13 @@ wxImage wxImage::ResampleBicubic(int width, int height) const
     for ( int dsty = 0; dsty < height; dsty++ )
     {
         // We need to calculate the source pixel to interpolate from - Y-axis
-        double srcpixy = dsty * M_IMGDATA->m_height / height;
+        double srcpixy = double(dsty * M_IMGDATA->m_height) / height;
         double dy = srcpixy - (int)srcpixy;
 
         for ( int dstx = 0; dstx < width; dstx++ )
         {
             // X-axis of pixel to interpolate from
-            double srcpixx = dstx * M_IMGDATA->m_width / width;
+            double srcpixx = double(dstx * M_IMGDATA->m_width) / width;
             double dx = srcpixx - (int)srcpixx;
 
             // Sums for each color channel
@@ -754,20 +754,17 @@ wxImage wxImage::BlurHorizontal(int blurRadius)
     unsigned char* dst_alpha = NULL;
 
     // Check for a mask or alpha
-    if ( M_IMGDATA->m_hasMask )
+    if ( src_alpha )
+    {
+        ret_image.SetAlpha();
+        dst_alpha = ret_image.GetAlpha();
+    }
+    else if ( M_IMGDATA->m_hasMask )
     {
         ret_image.SetMaskColour(M_IMGDATA->m_maskRed,
                                 M_IMGDATA->m_maskGreen,
                                 M_IMGDATA->m_maskBlue);
     }
-    else
-    {
-        if ( src_alpha )
-        {
-            ret_image.SetAlpha();
-            dst_alpha = ret_image.GetAlpha();
-        }
-    }
 
     // number of pixels we average over
     const int blurArea = blurRadius*2 + 1;
@@ -872,20 +869,17 @@ wxImage wxImage::BlurVertical(int blurRadius)
     unsigned char* dst_alpha = NULL;
 
     // Check for a mask or alpha
-    if ( M_IMGDATA->m_hasMask )
+    if ( src_alpha )
+    {
+        ret_image.SetAlpha();
+        dst_alpha = ret_image.GetAlpha();
+    }
+    else if ( M_IMGDATA->m_hasMask )
     {
         ret_image.SetMaskColour(M_IMGDATA->m_maskRed,
                                 M_IMGDATA->m_maskGreen,
                                 M_IMGDATA->m_maskBlue);
     }
-    else
-    {
-        if ( src_alpha )
-        {
-            ret_image.SetAlpha();
-            dst_alpha = ret_image.GetAlpha();
-        }
-    }
 
     // number of pixels we average over
     const int blurArea = blurRadius*2 + 1;
@@ -1671,7 +1665,9 @@ void wxImage::SetAlpha( unsigned char *alpha, bool static_data )
         alpha = (unsigned char *)malloc(M_IMGDATA->m_width*M_IMGDATA->m_height);
     }
 
-    free(M_IMGDATA->m_alpha);
+    if( !M_IMGDATA->m_staticAlpha )
+        free(M_IMGDATA->m_alpha);
+
     M_IMGDATA->m_alpha = alpha;
     M_IMGDATA->m_staticAlpha = static_data;
 }
@@ -1904,8 +1900,11 @@ bool wxImage::ConvertAlphaToMask(unsigned char threshold)
         }
     }
 
-    free(M_IMGDATA->m_alpha);
+    if( !M_IMGDATA->m_staticAlpha )
+        free(M_IMGDATA->m_alpha);
+
     M_IMGDATA->m_alpha = NULL;
+    M_IMGDATA->m_staticAlpha = false;
 
     return true;
 }
@@ -2237,7 +2236,7 @@ bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype, int ind
 
     if (stream.IsSeekable() && !handler->CanRead(stream))
     {
-        wxLogError(_("Image file is not of type %s."), (const wxChar*) mimetype);
+        wxLogError(_("Image file is not of type %s."), mimetype);
         return false;
     }
     else
@@ -2651,6 +2650,42 @@ bool wxImageHandler::CallDoCanRead(wxInputStream& stream)
 
 #endif // wxUSE_STREAMS
 
+/* static */
+wxImageResolution
+wxImageHandler::GetResolutionFromOptions(const wxImage& image, int *x, int *y)
+{
+    wxCHECK_MSG( x && y, wxIMAGE_RESOLUTION_NONE, _T("NULL pointer") );
+
+    if ( image.HasOption(wxIMAGE_OPTION_RESOLUTIONX) &&
+         image.HasOption(wxIMAGE_OPTION_RESOLUTIONY) )
+    {
+        *x = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONX);
+        *y = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONY);
+    }
+    else if ( image.HasOption(wxIMAGE_OPTION_RESOLUTION) )
+    {
+        *x =
+        *y = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTION);
+    }
+    else // no resolution options specified
+    {
+        *x =
+        *y = 0;
+
+        return wxIMAGE_RESOLUTION_NONE;
+    }
+
+    // get the resolution unit too
+    int resUnit = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONUNIT);
+    if ( !resUnit )
+    {
+        // this is the default
+        resUnit = wxIMAGE_RESOLUTION_INCHES;
+    }
+
+    return (wxImageResolution)resUnit;
+}
+
 // ----------------------------------------------------------------------------
 // image histogram stuff
 // ----------------------------------------------------------------------------
@@ -2781,18 +2816,7 @@ unsigned long wxImage::ComputeHistogram( wxImageHistogram &h ) const
  * Rotation code by Carlos Moreno
  */
 
-// GRG: I've removed wxRotationPoint - we already have wxRealPoint which
-//      does exactly the same thing. And I also got rid of wxRotationPixel
-//      bacause of potential problems in architectures where alignment
-//      is an issue, so I had to rewrite parts of the code.
-
-static const double gs_Epsilon = 1e-10;
-
-static inline int wxCint (double x)
-{
-    return (x > 0) ? (int) (x + 0.5) : (int) (x - 0.5);
-}
-
+static const double wxROTATE_EPSILON = 1e-10;
 
 // Auxiliary function to rotate a point (x,y) with respect to point p0
 // make it inline and use a straight return to facilitate optimization
@@ -2800,42 +2824,53 @@ static inline int wxCint (double x)
 // repeating the time-consuming calls to these functions -- sin/cos can
 // be computed and stored in the calling function.
 
-inline wxRealPoint rotated_point (const wxRealPoint & p, double cos_angle, double sin_angle, const wxRealPoint & p0)
+static inline wxRealPoint
+wxRotatePoint(const wxRealPoint& p, double cos_angle, double sin_angle,
+              const wxRealPoint& p0)
 {
-    return wxRealPoint (p0.x + (p.x - p0.x) * cos_angle - (p.y - p0.y) * sin_angle,
-                        p0.y + (p.y - p0.y) * cos_angle + (p.x - p0.x) * sin_angle);
+    return wxRealPoint(p0.x + (p.x - p0.x) * cos_angle - (p.y - p0.y) * sin_angle,
+                       p0.y + (p.y - p0.y) * cos_angle + (p.x - p0.x) * sin_angle);
 }
 
-inline wxRealPoint rotated_point (double x, double y, double cos_angle, double sin_angle, const wxRealPoint & p0)
+static inline wxRealPoint
+wxRotatePoint(double x, double y, double cos_angle, double sin_angle,
+              const wxRealPoint & p0)
 {
-    return rotated_point (wxRealPoint(x,y), cos_angle, sin_angle, p0);
+    return wxRotatePoint (wxRealPoint(x,y), cos_angle, sin_angle, p0);
 }
 
-wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool interpolating, wxPoint * offset_after_rotation) const
+wxImage wxImage::Rotate(double angle,
+                        const wxPoint& centre_of_rotation,
+                        bool interpolating,
+                        wxPoint *offset_after_rotation) const
 {
-    int i;
-    angle = -angle;     // screen coordinates are a mirror image of "real" coordinates
+    // screen coordinates are a mirror image of "real" coordinates
+    angle = -angle;
+
+    const bool has_alpha = HasAlpha();
 
-    bool has_alpha = HasAlpha();
+    const int w = GetWidth();
+    const int h = GetHeight();
+
+    int i;
 
     // Create pointer-based array to accelerate access to wxImage's data
-    unsigned char ** data = new unsigned char * [GetHeight()];
+    unsigned char ** data = new unsigned char * [h];
     data[0] = GetData();
-    for (i = 1; i < GetHeight(); i++)
-        data[i] = data[i - 1] + (3 * GetWidth());
+    for (i = 1; i < h; i++)
+        data[i] = data[i - 1] + (3 * w);
 
     // Same for alpha channel
     unsigned char ** alpha = NULL;
     if (has_alpha)
     {
-        alpha = new unsigned char * [GetHeight()];
+        alpha = new unsigned char * [h];
         alpha[0] = GetAlpha();
-        for (i = 1; i < GetHeight(); i++)
-            alpha[i] = alpha[i - 1] + GetWidth();
+        for (i = 1; i < h; i++)
+            alpha[i] = alpha[i - 1] + w;
     }
 
     // precompute coefficients for rotation formula
-    // (sine and cosine of the angle)
     const double cos_angle = cos(angle);
     const double sin_angle = sin(angle);
 
@@ -2845,10 +2880,10 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
 
     const wxRealPoint p0(centre_of_rotation.x, centre_of_rotation.y);
 
-    wxRealPoint p1 = rotated_point (0, 0, cos_angle, sin_angle, p0);
-    wxRealPoint p2 = rotated_point (0, 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);
+    wxRealPoint p1 = wxRotatePoint (0, 0, cos_angle, sin_angle, p0);
+    wxRealPoint p2 = wxRotatePoint (0, h, cos_angle, sin_angle, p0);
+    wxRealPoint p3 = wxRotatePoint (w, 0, cos_angle, sin_angle, p0);
+    wxRealPoint p4 = wxRotatePoint (w, h, cos_angle, sin_angle, p0);
 
     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)));
@@ -2866,19 +2901,14 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
         *offset_after_rotation = wxPoint (x1a, y1a);
     }
 
-    // GRG: The rotated (destination) image is always accessed
-    //      sequentially, so there is no need for a pointer-based
-    //      array here (and in fact it would be slower).
-    //
-    unsigned char * dst = rotated.GetData();
+    // the rotated (destination) image is always accessed sequentially via this
+    // pointer, there is no need for pointer-based arrays here
+    unsigned char *dst = rotated.GetData();
 
-    unsigned char * alpha_dst = NULL;
-    if (has_alpha)
-        alpha_dst = rotated.GetAlpha();
+    unsigned char *alpha_dst = has_alpha ? rotated.GetAlpha() : NULL;
 
-    // GRG: if the original image has a mask, use its RGB values
-    //      as the blank pixel, else, fall back to default (black).
-    //
+    // if the original image has a mask, use its RGB values as the blank pixel,
+    // else, fall back to default (black).
     unsigned char blank_r = 0;
     unsigned char blank_g = 0;
     unsigned char blank_b = 0;
@@ -2895,44 +2925,45 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
     // performing an inverse rotation (a rotation of -angle) and getting the
     // pixel at those coordinates
 
-    // GRG: I've taken the (interpolating) test out of the loops, so that
-    //      it is done only once, instead of repeating it for each pixel.
+    const int rH = rotated.GetHeight();
+    const int rW = rotated.GetWidth();
 
-    int x;
+    // do the (interpolating) test outside of the loops, so that it is done
+    // only once, instead of repeating it for each pixel.
     if (interpolating)
     {
-        for (int y = 0; y < rotated.GetHeight(); y++)
+        for (int y = 0; y < rH; y++)
         {
-            for (x = 0; x < rotated.GetWidth(); x++)
+            for (int x = 0; x < rW; x++)
             {
-                wxRealPoint src = rotated_point (x + x1a, y + y1a, cos_angle, -sin_angle, p0);
+                wxRealPoint src = wxRotatePoint (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 < w - 0.75 &&
+                    -0.25 < src.y && src.y < h - 0.75)
                 {
                     // interpolate using the 4 enclosing grid-points.  Those
                     // points can be obtained using floor and ceiling of the
                     // exact coordinates of the point
                     int x1, y1, x2, y2;
 
-                    if (0 < src.x && src.x < GetWidth() - 1)
+                    if (0 < src.x && src.x < w - 1)
                     {
-                        x1 = wxCint(floor(src.x));
-                        x2 = wxCint(ceil(src.x));
+                        x1 = wxRound(floor(src.x));
+                        x2 = wxRound(ceil(src.x));
                     }
                     else    // else means that x is near one of the borders (0 or width-1)
                     {
-                        x1 = x2 = wxCint (src.x);
+                        x1 = x2 = wxRound (src.x);
                     }
 
-                    if (0 < src.y && src.y < GetHeight() - 1)
+                    if (0 < src.y && src.y < h - 1)
                     {
-                        y1 = wxCint(floor(src.y));
-                        y2 = wxCint(ceil(src.y));
+                        y1 = wxRound(floor(src.y));
+                        y2 = wxRound(ceil(src.y));
                     }
                     else
                     {
-                        y1 = y2 = wxCint (src.y);
+                        y1 = y2 = wxRound (src.y);
                     }
 
                     // get four points and the distances (square of the distance,
@@ -2941,7 +2972,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                     // GRG: Do not calculate the points until they are
                     //      really needed -- this way we can calculate
                     //      just one, instead of four, if d1, d2, d3
-                    //      or d4 are < gs_Epsilon
+                    //      or d4 are < wxROTATE_EPSILON
 
                     const double d1 = (src.x - x1) * (src.x - x1) + (src.y - y1) * (src.y - y1);
                     const double d2 = (src.x - x2) * (src.x - x2) + (src.y - y1) * (src.y - y1);
@@ -2954,7 +2985,8 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                     // If the point is exactly at one point of the grid of the source
                     // image, then don't interpolate -- just assign the pixel
 
-                    if (d1 < gs_Epsilon)        // d1,d2,d3,d4 are positive -- no need for abs()
+                    // d1,d2,d3,d4 are positive -- no need for abs()
+                    if (d1 < wxROTATE_EPSILON)
                     {
                         unsigned char *p = data[y1] + (3 * x1);
                         *(dst++) = *(p++);
@@ -2964,7 +2996,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         if (has_alpha)
                             *(alpha_dst++) = *(alpha[y1] + x1);
                     }
-                    else if (d2 < gs_Epsilon)
+                    else if (d2 < wxROTATE_EPSILON)
                     {
                         unsigned char *p = data[y1] + (3 * x2);
                         *(dst++) = *(p++);
@@ -2974,7 +3006,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         if (has_alpha)
                             *(alpha_dst++) = *(alpha[y1] + x2);
                     }
-                    else if (d3 < gs_Epsilon)
+                    else if (d3 < wxROTATE_EPSILON)
                     {
                         unsigned char *p = data[y2] + (3 * x2);
                         *(dst++) = *(p++);
@@ -2984,7 +3016,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
                         if (has_alpha)
                             *(alpha_dst++) = *(alpha[y2] + x2);
                     }
-                    else if (d4 < gs_Epsilon)
+                    else if (d4 < wxROTATE_EPSILON)
                     {
                         unsigned char *p = data[y2] + (3 * x1);
                         *(dst++) = *(p++);
@@ -3045,19 +3077,18 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
             }
         }
     }
-    else    // not interpolating
+    else // not interpolating
     {
-        for (int y = 0; y < rotated.GetHeight(); y++)
+        for (int y = 0; y < rH; y++)
         {
-            for (x = 0; x < rotated.GetWidth(); x++)
+            for (int x = 0; x < rW; x++)
             {
-                wxRealPoint src = rotated_point (x + x1a, y + y1a, cos_angle, -sin_angle, p0);
+                wxRealPoint src = wxRotatePoint (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 = wxRound (src.x);      // wxRound rounds to the
+                const int ys = wxRound (src.y);      // closest integer
 
-                if (0 <= xs && xs < GetWidth() &&
-                    0 <= ys && ys < GetHeight())
+                if (0 <= xs && xs < w && 0 <= ys && ys < h)
                 {
                     unsigned char *p = data[ys] + (3 * xs);
                     *(dst++) = *(p++);
@@ -3081,9 +3112,7 @@ wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool i
     }
 
     delete [] data;
-
-    if (has_alpha)
-        delete [] alpha;
+    delete [] alpha;
 
     return rotated;
 }
@@ -3101,8 +3130,8 @@ class wxImageModule: public wxModule
 DECLARE_DYNAMIC_CLASS(wxImageModule)
 public:
     wxImageModule() {}
-    bool OnInit() { wxImage::InitStandardHandlers(); return true; };
-    void OnExit() { wxImage::CleanUpHandlers(); };
+    bool OnInit() { wxImage::InitStandardHandlers(); return true; }
+    void OnExit() { wxImage::CleanUpHandlers(); }
 };
 
 IMPLEMENT_DYNAMIC_CLASS(wxImageModule, wxModule)