src/common/image.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/image.cpp
   3 // Purpose:     wxImage
   4 // Author:      Robert Roebling
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __BORLANDC__
  14     #pragma hdrstop
  15 #endif
  16
  17 #if wxUSE_IMAGE
  18
  19 #include "wx/image.h"
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/log.h"
  23     #include "wx/hash.h"
  24     #include "wx/utils.h"
  25     #include "wx/math.h"
  26     #include "wx/module.h"
  27     #include "wx/palette.h"
  28     #include "wx/intl.h"
  29 #endif
  30
  31 #include "wx/filefn.h"
  32 #include "wx/wfstream.h"
  33 #include "wx/xpmdecod.h"
  34
  35 // For memcpy
  36 #include <string.h>
  37
  38 // make the code compile with either wxFile*Stream or wxFFile*Stream:
  39 #define HAS_FILE_STREAMS (wxUSE_STREAMS && (wxUSE_FILE || wxUSE_FFILE))
  40
  41 #if HAS_FILE_STREAMS
  42     #if wxUSE_FFILE
  43         typedef wxFFileInputStream wxImageFileInputStream;
  44         typedef wxFFileOutputStream wxImageFileOutputStream;
  45     #elif wxUSE_FILE
  46         typedef wxFileInputStream wxImageFileInputStream;
  47         typedef wxFileOutputStream wxImageFileOutputStream;
  48     #endif // wxUSE_FILE/wxUSE_FFILE
  49 #endif // HAS_FILE_STREAMS
  50
  51 #if wxUSE_VARIANT
  52 IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxImage,WXDLLEXPORT)
  53 #endif
  54
  55 //-----------------------------------------------------------------------------
  56 // global data
  57 //-----------------------------------------------------------------------------
  58
  59 wxList wxImage::sm_handlers;
  60 wxImage wxNullImage;
  61
  62 //-----------------------------------------------------------------------------
  63 // wxImageRefData
  64 //-----------------------------------------------------------------------------
  65
  66 class wxImageRefData: public wxObjectRefData
  67 {
  68 public:
  69     wxImageRefData();
  70     virtual ~wxImageRefData();
  71
  72     int             m_width;
  73     int             m_height;
  74     wxBitmapType    m_type;
  75     unsigned char  *m_data;
  76
  77     bool            m_hasMask;
  78     unsigned char   m_maskRed,m_maskGreen,m_maskBlue;
  79
  80     // alpha channel data, may be NULL for the formats without alpha support
  81     unsigned char  *m_alpha;
  82
  83     bool            m_ok;
  84
  85     // if true, m_data is pointer to static data and shouldn't be freed
  86     bool            m_static;
  87
  88     // same as m_static but for m_alpha
  89     bool            m_staticAlpha;
  90
  91 #if wxUSE_PALETTE
  92     wxPalette       m_palette;
  93 #endif // wxUSE_PALETTE
  94
  95     wxArrayString   m_optionNames;
  96     wxArrayString   m_optionValues;
  97
  98     wxDECLARE_NO_COPY_CLASS(wxImageRefData);
  99 };
 100
 101 wxImageRefData::wxImageRefData()
 102 {
 103     m_width = 0;
 104     m_height = 0;
 105     m_type = wxBITMAP_TYPE_INVALID;
 106     m_data =
 107     m_alpha = (unsigned char *) NULL;
 108
 109     m_maskRed = 0;
 110     m_maskGreen = 0;
 111     m_maskBlue = 0;
 112     m_hasMask = false;
 113
 114     m_ok = false;
 115     m_static =
 116     m_staticAlpha = false;
 117 }
 118
 119 wxImageRefData::~wxImageRefData()
 120 {
 121     if ( !m_static )
 122         free( m_data );
 123     if ( !m_staticAlpha )
 124         free( m_alpha );
 125 }
 126
 127
 128 //-----------------------------------------------------------------------------
 129 // wxImage
 130 //-----------------------------------------------------------------------------
 131
 132 #define M_IMGDATA static_cast<wxImageRefData*>(m_refData)
 133
 134 IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
 135
 136 bool wxImage::Create(const char* const* xpmData)
 137 {
 138 #if wxUSE_XPM
 139     UnRef();
 140
 141     wxXPMDecoder decoder;
 142     (*this) = decoder.ReadData(xpmData);
 143     return Ok();
 144 #else
 145     return false;
 146 #endif
 147 }
 148
 149 bool wxImage::Create( int width, int height, bool clear )
 150 {
 151     UnRef();
 152
 153     m_refData = new wxImageRefData();
 154
 155     M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 );
 156     if (!M_IMGDATA->m_data)
 157     {
 158         UnRef();
 159         return false;
 160     }
 161
 162     M_IMGDATA->m_width = width;
 163     M_IMGDATA->m_height = height;
 164     M_IMGDATA->m_ok = true;
 165
 166     if (clear)
 167     {
 168         Clear();
 169     }
 170
 171     return true;
 172 }
 173
 174 bool wxImage::Create( int width, int height, unsigned char* data, bool static_data )
 175 {
 176     UnRef();
 177
 178     wxCHECK_MSG( data, false, wxT("NULL data in wxImage::Create") );
 179
 180     m_refData = new wxImageRefData();
 181
 182     M_IMGDATA->m_data = data;
 183     M_IMGDATA->m_width = width;
 184     M_IMGDATA->m_height = height;
 185     M_IMGDATA->m_ok = true;
 186     M_IMGDATA->m_static = static_data;
 187
 188     return true;
 189 }
 190
 191 bool wxImage::Create( int width, int height, unsigned char* data, unsigned char* alpha, bool static_data )
 192 {
 193     UnRef();
 194
 195     wxCHECK_MSG( data, false, wxT("NULL data in wxImage::Create") );
 196
 197     m_refData = new wxImageRefData();
 198
 199     M_IMGDATA->m_data = data;
 200     M_IMGDATA->m_alpha = alpha;
 201     M_IMGDATA->m_width = width;
 202     M_IMGDATA->m_height = height;
 203     M_IMGDATA->m_ok = true;
 204     M_IMGDATA->m_static = static_data;
 205     M_IMGDATA->m_staticAlpha = static_data;
 206
 207     return true;
 208 }
 209
 210 void wxImage::Destroy()
 211 {
 212     UnRef();
 213 }
 214
 215 void wxImage::Clear(unsigned char value)
 216 {
 217     memset(M_IMGDATA->m_data, value, M_IMGDATA->m_width*M_IMGDATA->m_height*3);
 218 }
 219
 220 wxObjectRefData* wxImage::CreateRefData() const
 221 {
 222     return new wxImageRefData;
 223 }
 224
 225 wxObjectRefData* wxImage::CloneRefData(const wxObjectRefData* that) const
 226 {
 227     const wxImageRefData* refData = static_cast<const wxImageRefData*>(that);
 228     wxCHECK_MSG(refData->m_ok, NULL, wxT("invalid image") );
 229
 230     wxImageRefData* refData_new = new wxImageRefData;
 231     refData_new->m_width = refData->m_width;
 232     refData_new->m_height = refData->m_height;
 233     refData_new->m_maskRed = refData->m_maskRed;
 234     refData_new->m_maskGreen = refData->m_maskGreen;
 235     refData_new->m_maskBlue = refData->m_maskBlue;
 236     refData_new->m_hasMask = refData->m_hasMask;
 237     refData_new->m_ok = true;
 238     unsigned size = unsigned(refData->m_width) * unsigned(refData->m_height);
 239     if (refData->m_alpha != NULL)
 240     {
 241         refData_new->m_alpha = (unsigned char*)malloc(size);
 242         memcpy(refData_new->m_alpha, refData->m_alpha, size);
 243     }
 244     size *= 3;
 245     refData_new->m_data = (unsigned char*)malloc(size);
 246     memcpy(refData_new->m_data, refData->m_data, size);
 247 #if wxUSE_PALETTE
 248     refData_new->m_palette = refData->m_palette;
 249 #endif
 250     refData_new->m_optionNames = refData->m_optionNames;
 251     refData_new->m_optionValues = refData->m_optionValues;
 252     return refData_new;
 253 }
 254
 255 wxImage wxImage::Copy() const
 256 {
 257     wxImage image;
 258
 259     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 260
 261     image.m_refData = CloneRefData(m_refData);
 262
 263     return image;
 264 }
 265
 266 wxImage wxImage::ShrinkBy( int xFactor , int yFactor ) const
 267 {
 268     if( xFactor == 1 && yFactor == 1 )
 269         return *this;
 270
 271     wxImage image;
 272
 273     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 274
 275     // can't scale to/from 0 size
 276     wxCHECK_MSG( (xFactor > 0) && (yFactor > 0), image,
 277                  wxT("invalid new image size") );
 278
 279     long old_height = M_IMGDATA->m_height,
 280          old_width  = M_IMGDATA->m_width;
 281
 282     wxCHECK_MSG( (old_height > 0) && (old_width > 0), image,
 283                  wxT("invalid old image size") );
 284
 285     long width = old_width / xFactor ;
 286     long height = old_height / yFactor ;
 287
 288     image.Create( width, height, false );
 289
 290     char unsigned *data = image.GetData();
 291
 292     wxCHECK_MSG( data, image, wxT("unable to create image") );
 293
 294     bool hasMask = false ;
 295     unsigned char maskRed = 0;
 296     unsigned char maskGreen = 0;
 297     unsigned char maskBlue =0 ;
 298
 299     unsigned char *source_data = M_IMGDATA->m_data;
 300     unsigned char *target_data = data;
 301     unsigned char *source_alpha = 0 ;
 302     unsigned char *target_alpha = 0 ;
 303     if (M_IMGDATA->m_hasMask)
 304     {
 305         hasMask = true ;
 306         maskRed = M_IMGDATA->m_maskRed;
 307         maskGreen = M_IMGDATA->m_maskGreen;
 308         maskBlue =M_IMGDATA->m_maskBlue ;
 309
 310         image.SetMaskColour( M_IMGDATA->m_maskRed,
 311                              M_IMGDATA->m_maskGreen,
 312                              M_IMGDATA->m_maskBlue );
 313     }
 314     else
 315     {
 316         source_alpha = M_IMGDATA->m_alpha ;
 317         if ( source_alpha )
 318         {
 319             image.SetAlpha() ;
 320             target_alpha = image.GetAlpha() ;
 321         }
 322     }
 323
 324     for (long y = 0; y < height; y++)
 325     {
 326         for (long x = 0; x < width; x++)
 327         {
 328             unsigned long avgRed = 0 ;
 329             unsigned long avgGreen = 0;
 330             unsigned long avgBlue = 0;
 331             unsigned long avgAlpha = 0 ;
 332             unsigned long counter = 0 ;
 333             // determine average
 334             for ( int y1 = 0 ; y1 < yFactor ; ++y1 )
 335             {
 336                 long y_offset = (y * yFactor + y1) * old_width;
 337                 for ( int x1 = 0 ; x1 < xFactor ; ++x1 )
 338                 {
 339                     unsigned char *pixel = source_data + 3 * ( y_offset + x * xFactor + x1 ) ;
 340                     unsigned char red = pixel[0] ;
 341                     unsigned char green = pixel[1] ;
 342                     unsigned char blue = pixel[2] ;
 343                     unsigned char alpha = 255  ;
 344                     if ( source_alpha )
 345                         alpha = *(source_alpha + y_offset + x * xFactor + x1) ;
 346                     if ( !hasMask || red != maskRed || green != maskGreen || blue != maskBlue )
 347                     {
 348                         if ( alpha > 0 )
 349                         {
 350                             avgRed += red ;
 351                             avgGreen += green ;
 352                             avgBlue += blue ;
 353                         }
 354                         avgAlpha += alpha ;
 355                         counter++ ;
 356                     }
 357                 }
 358             }
 359             if ( counter == 0 )
 360             {
 361                 *(target_data++) = M_IMGDATA->m_maskRed ;
 362                 *(target_data++) = M_IMGDATA->m_maskGreen ;
 363                 *(target_data++) = M_IMGDATA->m_maskBlue ;
 364             }
 365             else
 366             {
 367                 if ( source_alpha )
 368                     *(target_alpha++) = (unsigned char)(avgAlpha / counter ) ;
 369                 *(target_data++) = (unsigned char)(avgRed / counter);
 370                 *(target_data++) = (unsigned char)(avgGreen / counter);
 371                 *(target_data++) = (unsigned char)(avgBlue / counter);
 372             }
 373         }
 374     }
 375
 376     // In case this is a cursor, make sure the hotspot is scaled accordingly:
 377     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
 378         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
 379                 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X))/xFactor);
 380     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) )
 381         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,
 382                 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y))/yFactor);
 383
 384     return image;
 385 }
 386
 387 wxImage
 388 wxImage::Scale( int width, int height, wxImageResizeQuality quality ) const
 389 {
 390     wxImage image;
 391
 392     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
 393
 394     // can't scale to/from 0 size
 395     wxCHECK_MSG( (width > 0) && (height > 0), image,
 396                  wxT("invalid new image size") );
 397
 398     long old_height = M_IMGDATA->m_height,
 399          old_width  = M_IMGDATA->m_width;
 400     wxCHECK_MSG( (old_height > 0) && (old_width > 0), image,
 401                  wxT("invalid old image size") );
 402
 403     // If the image's new width and height are the same as the original, no
 404     // need to waste time or CPU cycles
 405     if ( old_width == width && old_height == height )
 406         return *this;
 407
 408     // resample the image using either the nearest neighbourhood, bilinear or
 409     // bicubic method as specified
 410     switch ( quality )
 411     {
 412         case wxIMAGE_QUALITY_BICUBIC:
 413         case wxIMAGE_QUALITY_BILINEAR:
 414             // both of these algorithms should be used for up-sampling the
 415             // image only, when down-sampling always use box averaging for best
 416             // results
 417             if ( width < old_width && height < old_height )
 418                 image = ResampleBox(width, height);
 419             else if ( quality == wxIMAGE_QUALITY_BILINEAR )
 420                 image = ResampleBilinear(width, height);
 421             else if ( quality == wxIMAGE_QUALITY_BICUBIC )
 422                 image = ResampleBicubic(width, height);
 423             break;
 424
 425         case wxIMAGE_QUALITY_NEAREST:
 426             if ( old_width % width == 0 && old_width >= width &&
 427                 old_height % height == 0 && old_height >= height )
 428             {
 429                 return ShrinkBy( old_width / width , old_height / height );
 430             }
 431
 432             image = ResampleNearest(width, height);
 433             break;
 434     }
 435
 436     // If the original image has a mask, apply the mask to the new image
 437     if (M_IMGDATA->m_hasMask)
 438     {
 439         image.SetMaskColour( M_IMGDATA->m_maskRed,
 440                             M_IMGDATA->m_maskGreen,
 441                             M_IMGDATA->m_maskBlue );
 442     }
 443
 444     // In case this is a cursor, make sure the hotspot is scaled accordingly:
 445     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
 446         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
 447                 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X)*width)/old_width);
 448     if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) )
 449         image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,
 450                 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y)*height)/old_height);
 451
 452     return image;
 453 }
 454
 455 wxImage wxImage::ResampleNearest(int width, int height) const
 456 {
 457     wxImage image;
 458     image.Create( width, height, false );
 459
 460     unsigned char *data = image.GetData();
 461
 462     wxCHECK_MSG( data, image, wxT("unable to create image") );
 463
 464     unsigned char *source_data = M_IMGDATA->m_data;
 465     unsigned char *target_data = data;
 466     unsigned char *source_alpha = 0 ;
 467     unsigned char *target_alpha = 0 ;
 468
 469     if ( !M_IMGDATA->m_hasMask )
 470     {
 471         source_alpha = M_IMGDATA->m_alpha ;
 472         if ( source_alpha )
 473         {
 474             image.SetAlpha() ;
 475             target_alpha = image.GetAlpha() ;
 476         }
 477     }
 478
 479     long old_height = M_IMGDATA->m_height,
 480          old_width  = M_IMGDATA->m_width;
 481     long x_delta = (old_width<<16) / width;
 482     long y_delta = (old_height<<16) / height;
 483
 484     unsigned char* dest_pixel = target_data;
 485
 486     long y = 0;
 487     for ( long j = 0; j < height; j++ )
 488     {
 489         unsigned char* src_line = &source_data[(y>>16)*old_width*3];
 490         unsigned char* src_alpha_line = source_alpha ? &source_alpha[(y>>16)*old_width] : 0 ;
 491
 492         long x = 0;
 493         for ( long i = 0; i < width; i++ )
 494         {
 495             unsigned char* src_pixel = &src_line[(x>>16)*3];
 496             unsigned char* src_alpha_pixel = source_alpha ? &src_alpha_line[(x>>16)] : 0 ;
 497             dest_pixel[0] = src_pixel[0];
 498             dest_pixel[1] = src_pixel[1];
 499             dest_pixel[2] = src_pixel[2];
 500             dest_pixel += 3;
 501             if ( source_alpha )
 502                 *(target_alpha++) = *src_alpha_pixel ;
 503             x += x_delta;
 504         }
 505
 506         y += y_delta;
 507     }
 508
 509     return image;
 510 }
 511
 512 wxImage wxImage::ResampleBox(int width, int height) const
 513 {
 514     // This function implements a simple pre-blur/box averaging method for
 515     // downsampling that gives reasonably smooth results To scale the image
 516     // down we will need to gather a grid of pixels of the size of the scale
 517     // factor in each direction and then do an averaging of the pixels.
 518
 519     wxImage ret_image(width, height, false);
 520
 521     const double scale_factor_x = double(M_IMGDATA->m_width) / width;
 522     const double scale_factor_y = double(M_IMGDATA->m_height) / height;
 523
 524     const int scale_factor_x_2 = (int)(scale_factor_x / 2);
 525     const int scale_factor_y_2 = (int)(scale_factor_y / 2);
 526
 527     unsigned char* src_data = M_IMGDATA->m_data;
 528     unsigned char* src_alpha = M_IMGDATA->m_alpha;
 529     unsigned char* dst_data = ret_image.GetData();
 530     unsigned char* dst_alpha = NULL;
 531
 532     if ( src_alpha )
 533     {
 534         ret_image.SetAlpha();
 535         dst_alpha = ret_image.GetAlpha();
 536     }
 537
 538     int averaged_pixels, src_pixel_index;
 539     double sum_r, sum_g, sum_b, sum_a;
 540
 541     for ( int y = 0; y < height; y++ )         // Destination image - Y direction
 542     {
 543         // Source pixel in the Y direction
 544         int src_y = (int)(y * scale_factor_y);
 545
 546         for ( int x = 0; x < width; x++ )      // Destination image - X direction
 547         {
 548             // Source pixel in the X direction
 549             int src_x = (int)(x * scale_factor_x);
 550
 551             // Box of pixels to average
 552             averaged_pixels = 0;
 553             sum_r = sum_g = sum_b = sum_a = 0.0;
 554
 555             for ( int j = int(src_y - scale_factor_y/2.0 + 1);
 556                   j <= int(src_y + scale_factor_y_2);
 557                   j++ )
 558             {
 559                 // We don't care to average pixels that don't exist (edges)
 560                 if ( j < 0 || j > M_IMGDATA->m_height - 1 )
 561                     continue;
 562
 563                 for ( int i = int(src_x - scale_factor_x/2.0 + 1);
 564                       i <= src_x + scale_factor_x_2;
 565                       i++ )
 566                 {
 567                     // Don't average edge pixels
 568                     if ( i < 0 || i > M_IMGDATA->m_width - 1 )
 569                         continue;
 570
 571                     // Calculate the actual index in our source pixels
 572                     src_pixel_index = j * M_IMGDATA->m_width + i;
 573
 574                     sum_r += src_data[src_pixel_index * 3 + 0];
 575                     sum_g += src_data[src_pixel_index * 3 + 1];
 576                     sum_b += src_data[src_pixel_index * 3 + 2];
 577                     if ( src_alpha )
 578                         sum_a += src_alpha[src_pixel_index];
 579
 580                     averaged_pixels++;
 581                 }
 582             }
 583
 584             // Calculate the average from the sum and number of averaged pixels
 585             dst_data[0] = (unsigned char)(sum_r / averaged_pixels);
 586             dst_data[1] = (unsigned char)(sum_g / averaged_pixels);
 587             dst_data[2] = (unsigned char)(sum_b / averaged_pixels);
 588             dst_data += 3;
 589             if ( src_alpha )
 590                 *dst_alpha++ = (unsigned char)(sum_a / averaged_pixels);
 591         }
 592     }
 593
 594     return ret_image;
 595 }
 596
 597 wxImage wxImage::ResampleBilinear(int width, int height) const
 598 {
 599     // This function implements a Bilinear algorithm for resampling.
 600     wxImage ret_image(width, height, false);
 601     unsigned char* src_data = M_IMGDATA->m_data;
 602     unsigned char* src_alpha = M_IMGDATA->m_alpha;
 603     unsigned char* dst_data = ret_image.GetData();
 604     unsigned char* dst_alpha = NULL;
 605
 606     if ( src_alpha )
 607     {
 608         ret_image.SetAlpha();
 609         dst_alpha = ret_image.GetAlpha();
 610     }
 611     double HFactor = double(M_IMGDATA->m_height) / height;
 612     double WFactor = double(M_IMGDATA->m_width) / width;
 613
 614     int srcpixymax = M_IMGDATA->m_height - 1;
 615     int srcpixxmax = M_IMGDATA->m_width - 1;
 616
 617     double srcpixy, srcpixy1, srcpixy2, dy, dy1;
 618     double srcpixx, srcpixx1, srcpixx2, dx, dx1;
 619
 620     // initialize alpha values to avoid g++ warnings about possibly
 621     // uninitialized variables
 622     double r1, g1, b1, a1 = 0;
 623     double r2, g2, b2, a2 = 0;
 624
 625     for ( int dsty = 0; dsty < height; dsty++ )
 626     {
 627         // We need to calculate the source pixel to interpolate from - Y-axis
 628         srcpixy = double(dsty) * HFactor;
 629         srcpixy1 = int(srcpixy);
 630         srcpixy2 = ( srcpixy1 == srcpixymax ) ? srcpixy1 : srcpixy1 + 1.0;
 631         dy = srcpixy - (int)srcpixy;
 632         dy1 = 1.0 - dy;
 633
 634
 635         for ( int dstx = 0; dstx < width; dstx++ )
 636         {
 637             // X-axis of pixel to interpolate from
 638             srcpixx = double(dstx) * WFactor;
 639             srcpixx1 = int(srcpixx);
 640             srcpixx2 = ( srcpixx1 == srcpixxmax ) ? srcpixx1 : srcpixx1 + 1.0;
 641             dx = srcpixx - (int)srcpixx;
 642             dx1 = 1.0 - dx;
 643
 644             int x_offset1 = srcpixx1 < 0.0 ? 0 : srcpixx1 > srcpixxmax ? srcpixxmax : (int)srcpixx1;
 645             int x_offset2 = srcpixx2 < 0.0 ? 0 : srcpixx2 > srcpixxmax ? srcpixxmax : (int)srcpixx2;
 646             int y_offset1 = srcpixy1 < 0.0 ? 0 : srcpixy1 > srcpixymax ? srcpixymax : (int)srcpixy1;
 647             int y_offset2 = srcpixy2 < 0.0 ? 0 : srcpixy2 > srcpixymax ? srcpixymax : (int)srcpixy2;
 648
 649             int src_pixel_index00 = y_offset1 * M_IMGDATA->m_width + x_offset1;
 650             int src_pixel_index01 = y_offset1 * M_IMGDATA->m_width + x_offset2;
 651             int src_pixel_index10 = y_offset2 * M_IMGDATA->m_width + x_offset1;
 652             int src_pixel_index11 = y_offset2 * M_IMGDATA->m_width + x_offset2;
 653
 654             //first line
 655             r1 = src_data[src_pixel_index00 * 3 + 0] * dx1 + src_data[src_pixel_index01 * 3 + 0] * dx;
 656             g1 = src_data[src_pixel_index00 * 3 + 1] * dx1 + src_data[src_pixel_index01 * 3 + 1] * dx;
 657             b1 = src_data[src_pixel_index00 * 3 + 2] * dx1 + src_data[src_pixel_index01 * 3 + 2] * dx;
 658             if ( src_alpha )
 659                 a1 = src_alpha[src_pixel_index00] * dx1 + src_alpha[src_pixel_index01] * dx;
 660
 661             //second line
 662             r2 = src_data[src_pixel_index10 * 3 + 0] * dx1 + src_data[src_pixel_index11 * 3 + 0] * dx;
 663             g2 = src_data[src_pixel_index10 * 3 + 1] * dx1 + src_data[src_pixel_index11 * 3 + 1] * dx;
 664             b2 = src_data[src_pixel_index10 * 3 + 2] * dx1 + src_data[src_pixel_index11 * 3 + 2] * dx;
 665             if ( src_alpha )
 666                 a2 = src_alpha[src_pixel_index10] * dx1 + src_alpha[src_pixel_index11] * dx;
 667
 668             //result lines
 669
 670             dst_data[0] = r1 * dy1 + r2 * dy;
 671             dst_data[1] = g1 * dy1 + g2 * dy;
 672             dst_data[2] = b1 * dy1 + b2 * dy;
 673             dst_data += 3;
 674
 675             if ( src_alpha )
 676                 *dst_alpha++ = a1 * dy1 + a2 * dy;
 677         }
 678     }
 679
 680     return ret_image;
 681 }
 682
 683 // The following two local functions are for the B-spline weighting of the
 684 // bicubic sampling algorithm
 685 static inline double spline_cube(double value)
 686 {
 687     return value <= 0.0 ? 0.0 : value * value * value;
 688 }
 689
 690 static inline double spline_weight(double value)
 691 {
 692     return (spline_cube(value + 2) -
 693             4 * spline_cube(value + 1) +
 694             6 * spline_cube(value) -
 695             4 * spline_cube(value - 1)) / 6;
 696 }
 697
 698 // This is the bicubic resampling algorithm
 699 wxImage wxImage::ResampleBicubic(int width, int height) const
 700 {
 701     // This function implements a Bicubic B-Spline algorithm for resampling.
 702     // This method is certainly a little slower than wxImage's default pixel
 703     // replication method, however for most reasonably sized images not being
 704     // upsampled too much on a fairly average CPU this difference is hardly
 705     // noticeable and the results are far more pleasing to look at.
 706     //
 707     // This particular bicubic algorithm does pixel weighting according to a
 708     // B-Spline that basically implements a Gaussian bell-like weighting
 709     // kernel. Because of this method the results may appear a bit blurry when
 710     // upsampling by large factors.  This is basically because a slight
 711     // gaussian blur is being performed to get the smooth look of the upsampled
 712     // image.
 713
 714     // Edge pixels: 3-4 possible solutions
 715     // - (Wrap/tile) Wrap the image, take the color value from the opposite
 716     // side of the image.
 717     // - (Mirror)    Duplicate edge pixels, so that pixel at coordinate (2, n),
 718     // where n is nonpositive, will have the value of (2, 1).
 719     // - (Ignore)    Simply ignore the edge pixels and apply the kernel only to
 720     // pixels which do have all neighbours.
 721     // - (Clamp)     Choose the nearest pixel along the border. This takes the
 722     // border pixels and extends them out to infinity.
 723     //
 724     // NOTE: below the y_offset and x_offset variables are being set for edge
 725     // pixels using the "Mirror" method mentioned above
 726
 727     wxImage ret_image;
 728
 729     ret_image.Create(width, height, false);
 730
 731     unsigned char* src_data = M_IMGDATA->m_data;
 732     unsigned char* src_alpha = M_IMGDATA->m_alpha;
 733     unsigned char* dst_data = ret_image.GetData();
 734     unsigned char* dst_alpha = NULL;
 735
 736     if ( src_alpha )
 737     {
 738         ret_image.SetAlpha();
 739         dst_alpha = ret_image.GetAlpha();
 740     }
 741
 742     for ( int dsty = 0; dsty < height; dsty++ )
 743     {
 744         // We need to calculate the source pixel to interpolate from - Y-axis
 745         double srcpixy = double(dsty * M_IMGDATA->m_height) / height;
 746         double dy = srcpixy - (int)srcpixy;
 747
 748         for ( int dstx = 0; dstx < width; dstx++ )
 749         {
 750             // X-axis of pixel to interpolate from
 751             double srcpixx = double(dstx * M_IMGDATA->m_width) / width;
 752             double dx = srcpixx - (int)srcpixx;
 753
 754             // Sums for each color channel
 755             double sum_r = 0, sum_g = 0, sum_b = 0, sum_a = 0;
 756
 757             // Here we actually determine the RGBA values for the destination pixel
 758             for ( int k = -1; k <= 2; k++ )
 759             {
 760                 // Y offset
 761                 int y_offset = srcpixy + k < 0.0
 762                                 ? 0
 763                                 : srcpixy + k >= M_IMGDATA->m_height
 764                                        ? M_IMGDATA->m_height - 1
 765                                        : (int)(srcpixy + k);
 766
 767                 // Loop across the X axis
 768                 for ( int i = -1; i <= 2; i++ )
 769                 {
 770                     // X offset
 771                     int x_offset = srcpixx + i < 0.0
 772                                     ? 0
 773                                     : srcpixx + i >= M_IMGDATA->m_width
 774                                             ? M_IMGDATA->m_width - 1
 775                                             : (int)(srcpixx + i);
 776
 777                     // Calculate the exact position where the source data
 778                     // should be pulled from based on the x_offset and y_offset
 779                     int src_pixel_index = y_offset*M_IMGDATA->m_width + x_offset;
 780
 781                     // Calculate the weight for the specified pixel according
 782                     // to the bicubic b-spline kernel we're using for
 783                     // interpolation
 784                     double
 785                         pixel_weight = spline_weight(i - dx)*spline_weight(k - dy);
 786
 787                     // Create a sum of all velues for each color channel
 788                     // adjusted for the pixel's calculated weight
 789                     sum_r += src_data[src_pixel_index * 3 + 0] * pixel_weight;
 790                     sum_g += src_data[src_pixel_index * 3 + 1] * pixel_weight;
 791                     sum_b += src_data[src_pixel_index * 3 + 2] * pixel_weight;
 792                     if ( src_alpha )
 793                         sum_a += src_alpha[src_pixel_index] * pixel_weight;
 794                 }
 795             }
 796
 797             // Put the data into the destination image.  The summed values are
 798             // of double data type and are rounded here for accuracy
 799             dst_data[0] = (unsigned char)(sum_r + 0.5);
 800             dst_data[1] = (unsigned char)(sum_g + 0.5);
 801             dst_data[2] = (unsigned char)(sum_b + 0.5);
 802             dst_data += 3;
 803
 804             if ( src_alpha )
 805                 *dst_alpha++ = (unsigned char)sum_a;
 806         }
 807     }
 808
 809     return ret_image;
 810 }
 811
 812 // Blur in the horizontal direction
 813 wxImage wxImage::BlurHorizontal(int blurRadius) const
 814 {
 815     wxImage ret_image;
 816     ret_image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false);
 817
 818     unsigned char* src_data = M_IMGDATA->m_data;
 819     unsigned char* dst_data = ret_image.GetData();
 820     unsigned char* src_alpha = M_IMGDATA->m_alpha;
 821     unsigned char* dst_alpha = NULL;
 822
 823     // Check for a mask or alpha
 824     if ( src_alpha )
 825     {
 826         ret_image.SetAlpha();
 827         dst_alpha = ret_image.GetAlpha();
 828     }
 829     else if ( M_IMGDATA->m_hasMask )
 830     {
 831         ret_image.SetMaskColour(M_IMGDATA->m_maskRed,
 832                                 M_IMGDATA->m_maskGreen,
 833                                 M_IMGDATA->m_maskBlue);
 834     }
 835
 836     // number of pixels we average over
 837     const int blurArea = blurRadius*2 + 1;
 838
 839     // Horizontal blurring algorithm - average all pixels in the specified blur
 840     // radius in the X or horizontal direction
 841     for ( int y = 0; y < M_IMGDATA->m_height; y++ )
 842     {
 843         // Variables used in the blurring algorithm
 844         long sum_r = 0,
 845              sum_g = 0,
 846              sum_b = 0,
 847              sum_a = 0;
 848
 849         long pixel_idx;
 850         const unsigned char *src;
 851         unsigned char *dst;
 852
 853         // Calculate the average of all pixels in the blur radius for the first
 854         // pixel of the row
 855         for ( int kernel_x = -blurRadius; kernel_x <= blurRadius; kernel_x++ )
 856         {
 857             // To deal with the pixels at the start of a row so it's not
 858             // grabbing GOK values from memory at negative indices of the
 859             // image's data or grabbing from the previous row
 860             if ( kernel_x < 0 )
 861                 pixel_idx = y * M_IMGDATA->m_width;
 862             else
 863                 pixel_idx = kernel_x + y * M_IMGDATA->m_width;
 864
 865             src = src_data + pixel_idx*3;
 866             sum_r += src[0];
 867             sum_g += src[1];
 868             sum_b += src[2];
 869             if ( src_alpha )
 870                 sum_a += src_alpha[pixel_idx];
 871         }
 872
 873         dst = dst_data + y * M_IMGDATA->m_width*3;
 874         dst[0] = (unsigned char)(sum_r / blurArea);
 875         dst[1] = (unsigned char)(sum_g / blurArea);
 876         dst[2] = (unsigned char)(sum_b / blurArea);
 877         if ( src_alpha )
 878             dst_alpha[y * M_IMGDATA->m_width] = (unsigned char)(sum_a / blurArea);
 879
 880         // Now average the values of the rest of the pixels by just moving the
 881         // blur radius box along the row
 882         for ( int x = 1; x < M_IMGDATA->m_width; x++ )
 883         {
 884             // Take care of edge pixels on the left edge by essentially
 885             // duplicating the edge pixel
 886             if ( x - blurRadius - 1 < 0 )
 887                 pixel_idx = y * M_IMGDATA->m_width;
 888             else
 889                 pixel_idx = (x - blurRadius - 1) + y * M_IMGDATA->m_width;
 890
 891             // Subtract the value of the pixel at the left side of the blur
 892             // radius box
 893             src = src_data + pixel_idx*3;
 894             sum_r -= src[0];
 895             sum_g -= src[1];
 896             sum_b -= src[2];
 897             if ( src_alpha )
 898                 sum_a -= src_alpha[pixel_idx];
 899
 900             // Take care of edge pixels on the right edge
 901             if ( x + blurRadius > M_IMGDATA->m_width - 1 )
 902                 pixel_idx = M_IMGDATA->m_width - 1 + y * M_IMGDATA->m_width;
 903             else
 904                 pixel_idx = x + blurRadius + y * M_IMGDATA->m_width;
 905
 906             // Add the value of the pixel being added to the end of our box
 907             src = src_data + pixel_idx*3;
 908             sum_r += src[0];
 909             sum_g += src[1];
 910             sum_b += src[2];
 911             if ( src_alpha )
 912                 sum_a += src_alpha[pixel_idx];
 913
 914             // Save off the averaged data
 915             dst = dst_data + x*3 + y*M_IMGDATA->m_width*3;
 916             dst[0] = (unsigned char)(sum_r / blurArea);
 917             dst[1] = (unsigned char)(sum_g / blurArea);
 918             dst[2] = (unsigned char)(sum_b / blurArea);
 919             if ( src_alpha )
 920                 dst_alpha[x + y * M_IMGDATA->m_width] = (unsigned char)(sum_a / blurArea);
 921         }
 922     }
 923
 924     return ret_image;
 925 }
 926
 927 // Blur in the vertical direction
 928 wxImage wxImage::BlurVertical(int blurRadius) const
 929 {
 930     wxImage ret_image;
 931     ret_image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false);
 932
 933     unsigned char* src_data = M_IMGDATA->m_data;
 934     unsigned char* dst_data = ret_image.GetData();
 935     unsigned char* src_alpha = M_IMGDATA->m_alpha;
 936     unsigned char* dst_alpha = NULL;
 937
 938     // Check for a mask or alpha
 939     if ( src_alpha )
 940     {
 941         ret_image.SetAlpha();
 942         dst_alpha = ret_image.GetAlpha();
 943     }
 944     else if ( M_IMGDATA->m_hasMask )
 945     {
 946         ret_image.SetMaskColour(M_IMGDATA->m_maskRed,
 947                                 M_IMGDATA->m_maskGreen,
 948                                 M_IMGDATA->m_maskBlue);
 949     }
 950
 951     // number of pixels we average over
 952     const int blurArea = blurRadius*2 + 1;
 953
 954     // Vertical blurring algorithm - same as horizontal but switched the
 955     // opposite direction
 956     for ( int x = 0; x < M_IMGDATA->m_width; x++ )
 957     {
 958         // Variables used in the blurring algorithm
 959         long sum_r = 0,
 960              sum_g = 0,
 961              sum_b = 0,
 962              sum_a = 0;
 963
 964         long pixel_idx;
 965         const unsigned char *src;
 966         unsigned char *dst;
 967
 968         // Calculate the average of all pixels in our blur radius box for the
 969         // first pixel of the column
 970         for ( int kernel_y = -blurRadius; kernel_y <= blurRadius; kernel_y++ )
 971         {
 972             // To deal with the pixels at the start of a column so it's not
 973             // grabbing GOK values from memory at negative indices of the
 974             // image's data or grabbing from the previous column
 975             if ( kernel_y < 0 )
 976                 pixel_idx = x;
 977             else
 978                 pixel_idx = x + kernel_y * M_IMGDATA->m_width;
 979
 980             src = src_data + pixel_idx*3;
 981             sum_r += src[0];
 982             sum_g += src[1];
 983             sum_b += src[2];
 984             if ( src_alpha )
 985                 sum_a += src_alpha[pixel_idx];
 986         }
 987
 988         dst = dst_data + x*3;
 989         dst[0] = (unsigned char)(sum_r / blurArea);
 990         dst[1] = (unsigned char)(sum_g / blurArea);
 991         dst[2] = (unsigned char)(sum_b / blurArea);
 992         if ( src_alpha )
 993             dst_alpha[x] = (unsigned char)(sum_a / blurArea);
 994
 995         // Now average the values of the rest of the pixels by just moving the
 996         // box along the column from top to bottom
 997         for ( int y = 1; y < M_IMGDATA->m_height; y++ )
 998         {
 999             // Take care of pixels that would be beyond the top edge by
1000             // duplicating the top edge pixel for the column
1001             if ( y - blurRadius - 1 < 0 )
1002                 pixel_idx = x;
1003             else
1004                 pixel_idx = x + (y - blurRadius - 1) * M_IMGDATA->m_width;
1005
1006             // Subtract the value of the pixel at the top of our blur radius box
1007             src = src_data + pixel_idx*3;
1008             sum_r -= src[0];
1009             sum_g -= src[1];
1010             sum_b -= src[2];
1011             if ( src_alpha )
1012                 sum_a -= src_alpha[pixel_idx];
1013
1014             // Take care of the pixels that would be beyond the bottom edge of
1015             // the image similar to the top edge
1016             if ( y + blurRadius > M_IMGDATA->m_height - 1 )
1017                 pixel_idx = x + (M_IMGDATA->m_height - 1) * M_IMGDATA->m_width;
1018             else
1019                 pixel_idx = x + (blurRadius + y) * M_IMGDATA->m_width;
1020
1021             // Add the value of the pixel being added to the end of our box
1022             src = src_data + pixel_idx*3;
1023             sum_r += src[0];
1024             sum_g += src[1];
1025             sum_b += src[2];
1026             if ( src_alpha )
1027                 sum_a += src_alpha[pixel_idx];
1028
1029             // Save off the averaged data
1030             dst = dst_data + (x + y * M_IMGDATA->m_width) * 3;
1031             dst[0] = (unsigned char)(sum_r / blurArea);
1032             dst[1] = (unsigned char)(sum_g / blurArea);
1033             dst[2] = (unsigned char)(sum_b / blurArea);
1034             if ( src_alpha )
1035                 dst_alpha[x + y * M_IMGDATA->m_width] = (unsigned char)(sum_a / blurArea);
1036         }
1037     }
1038
1039     return ret_image;
1040 }
1041
1042 // The new blur function
1043 wxImage wxImage::Blur(int blurRadius) const
1044 {
1045     wxImage ret_image;
1046     ret_image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false);
1047
1048     // Blur the image in each direction
1049     ret_image = BlurHorizontal(blurRadius);
1050     ret_image = ret_image.BlurVertical(blurRadius);
1051
1052     return ret_image;
1053 }
1054
1055 wxImage wxImage::Rotate90( bool clockwise ) const
1056 {
1057     wxImage image;
1058
1059     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1060
1061     image.Create( M_IMGDATA->m_height, M_IMGDATA->m_width, false );
1062
1063     unsigned char *data = image.GetData();
1064
1065     wxCHECK_MSG( data, image, wxT("unable to create image") );
1066
1067     unsigned char *source_data = M_IMGDATA->m_data;
1068     unsigned char *target_data;
1069     unsigned char *alpha_data = 0 ;
1070     unsigned char *source_alpha = 0 ;
1071     unsigned char *target_alpha = 0 ;
1072
1073     if (M_IMGDATA->m_hasMask)
1074     {
1075         image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
1076     }
1077     else
1078     {
1079         source_alpha = M_IMGDATA->m_alpha ;
1080         if ( source_alpha )
1081         {
1082             image.SetAlpha() ;
1083             alpha_data = image.GetAlpha() ;
1084         }
1085     }
1086
1087     long height = M_IMGDATA->m_height;
1088     long width  = M_IMGDATA->m_width;
1089
1090     for (long j = 0; j < height; j++)
1091     {
1092         for (long i = 0; i < width; i++)
1093         {
1094             if (clockwise)
1095             {
1096                 target_data = data + (((i+1)*height) - j - 1)*3;
1097                 if(source_alpha)
1098                     target_alpha = alpha_data + (((i+1)*height) - j - 1);
1099             }
1100             else
1101             {
1102                 target_data = data + ((height*(width-1)) + j - (i*height))*3;
1103                 if(source_alpha)
1104                     target_alpha = alpha_data + ((height*(width-1)) + j - (i*height));
1105             }
1106             memcpy( target_data, source_data, 3 );
1107             source_data += 3;
1108
1109             if(source_alpha)
1110             {
1111                 memcpy( target_alpha, source_alpha, 1 );
1112                 source_alpha += 1;
1113             }
1114         }
1115     }
1116
1117     return image;
1118 }
1119
1120 wxImage wxImage::Mirror( bool horizontally ) const
1121 {
1122     wxImage image;
1123
1124     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1125
1126     image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
1127
1128     unsigned char *data = image.GetData();
1129     unsigned char *alpha = NULL;
1130
1131     wxCHECK_MSG( data, image, wxT("unable to create image") );
1132
1133     if (M_IMGDATA->m_alpha != NULL) {
1134         image.SetAlpha();
1135         alpha = image.GetAlpha();
1136         wxCHECK_MSG( alpha, image, wxT("unable to create alpha channel") );
1137     }
1138
1139     if (M_IMGDATA->m_hasMask)
1140         image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
1141
1142     long height = M_IMGDATA->m_height;
1143     long width  = M_IMGDATA->m_width;
1144
1145     unsigned char *source_data = M_IMGDATA->m_data;
1146     unsigned char *target_data;
1147
1148     if (horizontally)
1149     {
1150         for (long j = 0; j < height; j++)
1151         {
1152             data += width*3;
1153             target_data = data-3;
1154             for (long i = 0; i < width; i++)
1155             {
1156                 memcpy( target_data, source_data, 3 );
1157                 source_data += 3;
1158                 target_data -= 3;
1159             }
1160         }
1161
1162         if (alpha != NULL)
1163         {
1164             // src_alpha starts at the first pixel and increases by 1 after each step
1165             // (a step here is the copy of the alpha value of one pixel)
1166             const unsigned char *src_alpha = M_IMGDATA->m_alpha;
1167             // dest_alpha starts just beyond the first line, decreases before each step,
1168             // and after each line is finished, increases by 2 widths (skipping the line
1169             // just copied and the line that will be copied next)
1170             unsigned char *dest_alpha = alpha + width;
1171
1172             for (long jj = 0; jj < height; ++jj)
1173             {
1174                 for (long i = 0; i < width; ++i) {
1175                     *(--dest_alpha) = *(src_alpha++); // copy one pixel
1176                 }
1177                 dest_alpha += 2 * width; // advance beyond the end of the next line
1178             }
1179         }
1180     }
1181     else
1182     {
1183         for (long i = 0; i < height; i++)
1184         {
1185             target_data = data + 3*width*(height-1-i);
1186             memcpy( target_data, source_data, (size_t)3*width );
1187             source_data += 3*width;
1188         }
1189
1190         if (alpha != NULL)
1191         {
1192             // src_alpha starts at the first pixel and increases by 1 width after each step
1193             // (a step here is the copy of the alpha channel of an entire line)
1194             const unsigned char *src_alpha = M_IMGDATA->m_alpha;
1195             // dest_alpha starts just beyond the last line (beyond the whole image)
1196             // and decreases by 1 width before each step
1197             unsigned char *dest_alpha = alpha + width * height;
1198
1199             for (long jj = 0; jj < height; ++jj)
1200             {
1201                 dest_alpha -= width;
1202                 memcpy( dest_alpha, src_alpha, (size_t)width );
1203                 src_alpha += width;
1204             }
1205         }
1206     }
1207
1208     return image;
1209 }
1210
1211 wxImage wxImage::GetSubImage( const wxRect &rect ) const
1212 {
1213     wxImage image;
1214
1215     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1216
1217     wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) &&
1218                  (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight()),
1219                  image, wxT("invalid subimage size") );
1220
1221     const int subwidth = rect.GetWidth();
1222     const int subheight = rect.GetHeight();
1223
1224     image.Create( subwidth, subheight, false );
1225
1226     const unsigned char *src_data = GetData();
1227     const unsigned char *src_alpha = M_IMGDATA->m_alpha;
1228     unsigned char *subdata = image.GetData();
1229     unsigned char *subalpha = NULL;
1230
1231     wxCHECK_MSG( subdata, image, wxT("unable to create image") );
1232
1233     if (src_alpha != NULL) {
1234         image.SetAlpha();
1235         subalpha = image.GetAlpha();
1236         wxCHECK_MSG( subalpha, image, wxT("unable to create alpha channel"));
1237     }
1238
1239     if (M_IMGDATA->m_hasMask)
1240         image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
1241
1242     const int width = GetWidth();
1243     const int pixsoff = rect.GetLeft() + width * rect.GetTop();
1244
1245     src_data += 3 * pixsoff;
1246     src_alpha += pixsoff; // won't be used if was NULL, so this is ok
1247
1248     for (long j = 0; j < subheight; ++j)
1249     {
1250         memcpy( subdata, src_data, 3 * subwidth );
1251         subdata += 3 * subwidth;
1252         src_data += 3 * width;
1253         if (subalpha != NULL) {
1254             memcpy( subalpha, src_alpha, subwidth );
1255             subalpha += subwidth;
1256             src_alpha += width;
1257         }
1258     }
1259
1260     return image;
1261 }
1262
1263 wxImage wxImage::Size( const wxSize& size, const wxPoint& pos,
1264                        int r_, int g_, int b_ ) const
1265 {
1266     wxImage image;
1267
1268     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1269     wxCHECK_MSG( (size.GetWidth() > 0) && (size.GetHeight() > 0), image, wxT("invalid size") );
1270
1271     int width = GetWidth(), height = GetHeight();
1272     image.Create(size.GetWidth(), size.GetHeight(), false);
1273
1274     unsigned char r = (unsigned char)r_;
1275     unsigned char g = (unsigned char)g_;
1276     unsigned char b = (unsigned char)b_;
1277     if ((r_ == -1) && (g_ == -1) && (b_ == -1))
1278     {
1279         GetOrFindMaskColour( &r, &g, &b );
1280         image.SetMaskColour(r, g, b);
1281     }
1282
1283     image.SetRGB(wxRect(), r, g, b);
1284
1285     // we have two coordinate systems:
1286     // source:     starting at 0,0 of source image
1287     // destination starting at 0,0 of destination image
1288     // Documentation says:
1289     // "The image is pasted into a new image [...] at the position pos relative
1290     // to the upper left of the new image." this means the transition rule is:
1291     // "dest coord" = "source coord" + pos;
1292
1293     // calculate the intersection using source coordinates:
1294     wxRect srcRect(0, 0, width, height);
1295     wxRect dstRect(-pos, size);
1296
1297     srcRect.Intersect(dstRect);
1298
1299     if (!srcRect.IsEmpty())
1300     {
1301         // insertion point is needed in destination coordinates.
1302         // NB: it is not always "pos"!
1303         wxPoint ptInsert = srcRect.GetTopLeft() + pos;
1304
1305         if ((srcRect.GetWidth() == width) && (srcRect.GetHeight() == height))
1306             image.Paste(*this, ptInsert.x, ptInsert.y);
1307         else
1308             image.Paste(GetSubImage(srcRect), ptInsert.x, ptInsert.y);
1309     }
1310
1311     return image;
1312 }
1313
1314 void wxImage::Paste( const wxImage &image, int x, int y )
1315 {
1316     wxCHECK_RET( Ok(), wxT("invalid image") );
1317     wxCHECK_RET( image.Ok(), wxT("invalid image") );
1318
1319     AllocExclusive();
1320
1321     int xx = 0;
1322     int yy = 0;
1323     int width = image.GetWidth();
1324     int height = image.GetHeight();
1325
1326     if (x < 0)
1327     {
1328         xx = -x;
1329         width += x;
1330     }
1331     if (y < 0)
1332     {
1333         yy = -y;
1334         height += y;
1335     }
1336
1337     if ((x+xx)+width > M_IMGDATA->m_width)
1338         width = M_IMGDATA->m_width - (x+xx);
1339     if ((y+yy)+height > M_IMGDATA->m_height)
1340         height = M_IMGDATA->m_height - (y+yy);
1341
1342     if (width < 1) return;
1343     if (height < 1) return;
1344
1345     if ((!HasMask() && !image.HasMask()) ||
1346         (HasMask() && !image.HasMask()) ||
1347        ((HasMask() && image.HasMask() &&
1348          (GetMaskRed()==image.GetMaskRed()) &&
1349          (GetMaskGreen()==image.GetMaskGreen()) &&
1350          (GetMaskBlue()==image.GetMaskBlue()))))
1351     {
1352         unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
1353         int source_step = image.GetWidth()*3;
1354
1355         unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
1356         int target_step = M_IMGDATA->m_width*3;
1357         for (int j = 0; j < height; j++)
1358         {
1359             memcpy( target_data, source_data, width*3 );
1360             source_data += source_step;
1361             target_data += target_step;
1362         }
1363     }
1364
1365     // Copy over the alpha channel from the original image
1366     if ( image.HasAlpha() )
1367     {
1368         if ( !HasAlpha() )
1369             InitAlpha();
1370
1371         unsigned char* source_data = image.GetAlpha() + xx + yy*image.GetWidth();
1372         int source_step = image.GetWidth();
1373
1374         unsigned char* target_data = GetAlpha() + (x+xx) + (y+yy)*M_IMGDATA->m_width;
1375         int target_step = M_IMGDATA->m_width;
1376
1377         for (int j = 0; j < height; j++,
1378                                     source_data += source_step,
1379                                     target_data += target_step)
1380         {
1381             memcpy( target_data, source_data, width );
1382         }
1383     }
1384
1385     if (!HasMask() && image.HasMask())
1386     {
1387         unsigned char r = image.GetMaskRed();
1388         unsigned char g = image.GetMaskGreen();
1389         unsigned char b = image.GetMaskBlue();
1390
1391         unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
1392         int source_step = image.GetWidth()*3;
1393
1394         unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
1395         int target_step = M_IMGDATA->m_width*3;
1396
1397         for (int j = 0; j < height; j++)
1398         {
1399             for (int i = 0; i < width*3; i+=3)
1400             {
1401                 if ((source_data[i]   != r) ||
1402                     (source_data[i+1] != g) ||
1403                     (source_data[i+2] != b))
1404                 {
1405                     memcpy( target_data+i, source_data+i, 3 );
1406                 }
1407             }
1408             source_data += source_step;
1409             target_data += target_step;
1410         }
1411     }
1412 }
1413
1414 void wxImage::Replace( unsigned char r1, unsigned char g1, unsigned char b1,
1415                        unsigned char r2, unsigned char g2, unsigned char b2 )
1416 {
1417     wxCHECK_RET( Ok(), wxT("invalid image") );
1418
1419     AllocExclusive();
1420
1421     unsigned char *data = GetData();
1422
1423     const int w = GetWidth();
1424     const int h = GetHeight();
1425
1426     for (int j = 0; j < h; j++)
1427         for (int i = 0; i < w; i++)
1428         {
1429             if ((data[0] == r1) && (data[1] == g1) && (data[2] == b1))
1430             {
1431                 data[0] = r2;
1432                 data[1] = g2;
1433                 data[2] = b2;
1434             }
1435             data += 3;
1436         }
1437 }
1438
1439 wxImage wxImage::ConvertToGreyscale( double lr, double lg, double lb ) const
1440 {
1441     wxImage image;
1442
1443     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1444
1445     image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false);
1446
1447     unsigned char *dest = image.GetData();
1448
1449     wxCHECK_MSG( dest, image, wxT("unable to create image") );
1450
1451     unsigned char *src = M_IMGDATA->m_data;
1452     bool hasMask = M_IMGDATA->m_hasMask;
1453     unsigned char maskRed = M_IMGDATA->m_maskRed;
1454     unsigned char maskGreen = M_IMGDATA->m_maskGreen;
1455     unsigned char maskBlue = M_IMGDATA->m_maskBlue;
1456
1457     if ( hasMask )
1458         image.SetMaskColour(maskRed, maskGreen, maskBlue);
1459
1460     const long size = M_IMGDATA->m_width * M_IMGDATA->m_height;
1461     for ( long i = 0; i < size; i++, src += 3, dest += 3 )
1462     {
1463         // don't modify the mask
1464         if ( hasMask && src[0] == maskRed && src[1] == maskGreen && src[2] == maskBlue )
1465         {
1466             memcpy(dest, src, 3);
1467         }
1468         else
1469         {
1470             // calculate the luma
1471             double luma = (src[0] * lr + src[1] * lg + src[2] * lb) + 0.5;
1472             dest[0] = dest[1] = dest[2] = static_cast<unsigned char>(luma);
1473         }
1474     }
1475
1476     // copy the alpha channel, if any
1477     if (HasAlpha())
1478     {
1479         const size_t alphaSize = GetWidth() * GetHeight();
1480         unsigned char *alpha = (unsigned char*)malloc(alphaSize);
1481         memcpy(alpha, GetAlpha(), alphaSize);
1482         image.InitAlpha();
1483         image.SetAlpha(alpha);
1484     }
1485
1486     return image;
1487 }
1488
1489 wxImage wxImage::ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const
1490 {
1491     wxImage image;
1492
1493     wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1494
1495     image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
1496
1497     unsigned char *data = image.GetData();
1498
1499     wxCHECK_MSG( data, image, wxT("unable to create image") );
1500
1501     if (M_IMGDATA->m_hasMask)
1502     {
1503         if (M_IMGDATA->m_maskRed == r && M_IMGDATA->m_maskGreen == g &&
1504                                          M_IMGDATA->m_maskBlue == b)
1505             image.SetMaskColour( 255, 255, 255 );
1506         else
1507             image.SetMaskColour( 0, 0, 0 );
1508     }
1509
1510     long size = M_IMGDATA->m_height * M_IMGDATA->m_width;
1511
1512     unsigned char *srcd = M_IMGDATA->m_data;
1513     unsigned char *tard = image.GetData();
1514
1515     for ( long i = 0; i < size; i++, srcd += 3, tard += 3 )
1516     {
1517         if (srcd[0] == r && srcd[1] == g && srcd[2] == b)
1518             tard[0] = tard[1] = tard[2] = 255;
1519         else
1520             tard[0] = tard[1] = tard[2] = 0;
1521     }
1522
1523     return image;
1524 }
1525
1526 int wxImage::GetWidth() const
1527 {
1528     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1529
1530     return M_IMGDATA->m_width;
1531 }
1532
1533 int wxImage::GetHeight() const
1534 {
1535     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1536
1537     return M_IMGDATA->m_height;
1538 }
1539
1540 wxBitmapType wxImage::GetType() const
1541 {
1542     wxCHECK_MSG( IsOk(), wxBITMAP_TYPE_INVALID, wxT("invalid image") );
1543
1544     return M_IMGDATA->m_type;
1545 }
1546
1547 void wxImage::SetType(wxBitmapType type)
1548 {
1549     wxCHECK_RET( IsOk(), "must create the image before setting its type");
1550
1551     // type can be wxBITMAP_TYPE_INVALID to reset the image type to default
1552     wxASSERT_MSG( type != wxBITMAP_TYPE_MAX, "invalid bitmap type" );
1553
1554     M_IMGDATA->m_type = type;
1555 }
1556
1557 long wxImage::XYToIndex(int x, int y) const
1558 {
1559     if ( Ok() &&
1560             x >= 0 && y >= 0 &&
1561                 x < M_IMGDATA->m_width && y < M_IMGDATA->m_height )
1562     {
1563         return y*M_IMGDATA->m_width + x;
1564     }
1565
1566     return -1;
1567 }
1568
1569 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
1570 {
1571     long pos = XYToIndex(x, y);
1572     wxCHECK_RET( pos != -1, wxT("invalid image coordinates") );
1573
1574     AllocExclusive();
1575
1576     pos *= 3;
1577
1578     M_IMGDATA->m_data[ pos   ] = r;
1579     M_IMGDATA->m_data[ pos+1 ] = g;
1580     M_IMGDATA->m_data[ pos+2 ] = b;
1581 }
1582
1583 void wxImage::SetRGB( const wxRect& rect_, unsigned char r, unsigned char g, unsigned char b )
1584 {
1585     wxCHECK_RET( Ok(), wxT("invalid image") );
1586
1587     AllocExclusive();
1588
1589     wxRect rect(rect_);
1590     wxRect imageRect(0, 0, GetWidth(), GetHeight());
1591     if ( rect == wxRect() )
1592     {
1593         rect = imageRect;
1594     }
1595     else
1596     {
1597         wxCHECK_RET( imageRect.Contains(rect.GetTopLeft()) &&
1598                      imageRect.Contains(rect.GetBottomRight()),
1599                      wxT("invalid bounding rectangle") );
1600     }
1601
1602     int x1 = rect.GetLeft(),
1603         y1 = rect.GetTop(),
1604         x2 = rect.GetRight() + 1,
1605         y2 = rect.GetBottom() + 1;
1606
1607     unsigned char *data wxDUMMY_INITIALIZE(NULL);
1608     int x, y, width = GetWidth();
1609     for (y = y1; y < y2; y++)
1610     {
1611         data = M_IMGDATA->m_data + (y*width + x1)*3;
1612         for (x = x1; x < x2; x++)
1613         {
1614             *data++ = r;
1615             *data++ = g;
1616             *data++ = b;
1617         }
1618     }
1619 }
1620
1621 unsigned char wxImage::GetRed( int x, int y ) const
1622 {
1623     long pos = XYToIndex(x, y);
1624     wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") );
1625
1626     pos *= 3;
1627
1628     return M_IMGDATA->m_data[pos];
1629 }
1630
1631 unsigned char wxImage::GetGreen( int x, int y ) const
1632 {
1633     long pos = XYToIndex(x, y);
1634     wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") );
1635
1636     pos *= 3;
1637
1638     return M_IMGDATA->m_data[pos+1];
1639 }
1640
1641 unsigned char wxImage::GetBlue( int x, int y ) const
1642 {
1643     long pos = XYToIndex(x, y);
1644     wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") );
1645
1646     pos *= 3;
1647
1648     return M_IMGDATA->m_data[pos+2];
1649 }
1650
1651 bool wxImage::IsOk() const
1652 {
1653     // image of 0 width or height can't be considered ok - at least because it
1654     // causes crashes in ConvertToBitmap() if we don't catch it in time
1655     wxImageRefData *data = M_IMGDATA;
1656     return data && data->m_ok && data->m_width && data->m_height;
1657 }
1658
1659 unsigned char *wxImage::GetData() const
1660 {
1661     wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") );
1662
1663     return M_IMGDATA->m_data;
1664 }
1665
1666 void wxImage::SetData( unsigned char *data, bool static_data  )
1667 {
1668     wxCHECK_RET( Ok(), wxT("invalid image") );
1669
1670     wxImageRefData *newRefData = new wxImageRefData();
1671
1672     newRefData->m_width = M_IMGDATA->m_width;
1673     newRefData->m_height = M_IMGDATA->m_height;
1674     newRefData->m_data = data;
1675     newRefData->m_ok = true;
1676     newRefData->m_maskRed = M_IMGDATA->m_maskRed;
1677     newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
1678     newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
1679     newRefData->m_hasMask = M_IMGDATA->m_hasMask;
1680     newRefData->m_static = static_data;
1681
1682     UnRef();
1683
1684     m_refData = newRefData;
1685 }
1686
1687 void wxImage::SetData( unsigned char *data, int new_width, int new_height, bool static_data )
1688 {
1689     wxImageRefData *newRefData = new wxImageRefData();
1690
1691     if (m_refData)
1692     {
1693         newRefData->m_width = new_width;
1694         newRefData->m_height = new_height;
1695         newRefData->m_data = data;
1696         newRefData->m_ok = true;
1697         newRefData->m_maskRed = M_IMGDATA->m_maskRed;
1698         newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
1699         newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
1700         newRefData->m_hasMask = M_IMGDATA->m_hasMask;
1701     }
1702     else
1703     {
1704         newRefData->m_width = new_width;
1705         newRefData->m_height = new_height;
1706         newRefData->m_data = data;
1707         newRefData->m_ok = true;
1708     }
1709     newRefData->m_static = static_data;
1710
1711     UnRef();
1712
1713     m_refData = newRefData;
1714 }
1715
1716 // ----------------------------------------------------------------------------
1717 // alpha channel support
1718 // ----------------------------------------------------------------------------
1719
1720 void wxImage::SetAlpha(int x, int y, unsigned char alpha)
1721 {
1722     wxCHECK_RET( HasAlpha(), wxT("no alpha channel") );
1723
1724     long pos = XYToIndex(x, y);
1725     wxCHECK_RET( pos != -1, wxT("invalid image coordinates") );
1726
1727     AllocExclusive();
1728
1729     M_IMGDATA->m_alpha[pos] = alpha;
1730 }
1731
1732 unsigned char wxImage::GetAlpha(int x, int y) const
1733 {
1734     wxCHECK_MSG( HasAlpha(), 0, wxT("no alpha channel") );
1735
1736     long pos = XYToIndex(x, y);
1737     wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") );
1738
1739     return M_IMGDATA->m_alpha[pos];
1740 }
1741
1742 bool
1743 wxImage::ConvertColourToAlpha(unsigned char r, unsigned char g, unsigned char b)
1744 {
1745     SetAlpha(NULL);
1746
1747     const int w = M_IMGDATA->m_width;
1748     const int h = M_IMGDATA->m_height;
1749
1750     unsigned char *alpha = GetAlpha();
1751     unsigned char *data = GetData();
1752
1753     for ( int y = 0; y < h; y++ )
1754     {
1755         for ( int x = 0; x < w; x++ )
1756         {
1757             *alpha++ = *data;
1758             *data++ = r;
1759             *data++ = g;
1760             *data++ = b;
1761         }
1762     }
1763
1764     return true;
1765 }
1766
1767 void wxImage::SetAlpha( unsigned char *alpha, bool static_data )
1768 {
1769     wxCHECK_RET( Ok(), wxT("invalid image") );
1770
1771     AllocExclusive();
1772
1773     if ( !alpha )
1774     {
1775         alpha = (unsigned char *)malloc(M_IMGDATA->m_width*M_IMGDATA->m_height);
1776     }
1777
1778     if( !M_IMGDATA->m_staticAlpha )
1779         free(M_IMGDATA->m_alpha);
1780
1781     M_IMGDATA->m_alpha = alpha;
1782     M_IMGDATA->m_staticAlpha = static_data;
1783 }
1784
1785 unsigned char *wxImage::GetAlpha() const
1786 {
1787     wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") );
1788
1789     return M_IMGDATA->m_alpha;
1790 }
1791
1792 void wxImage::InitAlpha()
1793 {
1794     wxCHECK_RET( !HasAlpha(), wxT("image already has an alpha channel") );
1795
1796     // initialize memory for alpha channel
1797     SetAlpha();
1798
1799     unsigned char *alpha = M_IMGDATA->m_alpha;
1800     const size_t lenAlpha = M_IMGDATA->m_width * M_IMGDATA->m_height;
1801
1802     if ( HasMask() )
1803     {
1804         // use the mask to initialize the alpha channel.
1805         const unsigned char * const alphaEnd = alpha + lenAlpha;
1806
1807         const unsigned char mr = M_IMGDATA->m_maskRed;
1808         const unsigned char mg = M_IMGDATA->m_maskGreen;
1809         const unsigned char mb = M_IMGDATA->m_maskBlue;
1810         for ( unsigned char *src = M_IMGDATA->m_data;
1811               alpha < alphaEnd;
1812               src += 3, alpha++ )
1813         {
1814             *alpha = (src[0] == mr && src[1] == mg && src[2] == mb)
1815                             ? wxIMAGE_ALPHA_TRANSPARENT
1816                             : wxIMAGE_ALPHA_OPAQUE;
1817         }
1818
1819         M_IMGDATA->m_hasMask = false;
1820     }
1821     else // no mask
1822     {
1823         // make the image fully opaque
1824         memset(alpha, wxIMAGE_ALPHA_OPAQUE, lenAlpha);
1825     }
1826 }
1827
1828 // ----------------------------------------------------------------------------
1829 // mask support
1830 // ----------------------------------------------------------------------------
1831
1832 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
1833 {
1834     wxCHECK_RET( Ok(), wxT("invalid image") );
1835
1836     AllocExclusive();
1837
1838     M_IMGDATA->m_maskRed = r;
1839     M_IMGDATA->m_maskGreen = g;
1840     M_IMGDATA->m_maskBlue = b;
1841     M_IMGDATA->m_hasMask = true;
1842 }
1843
1844 bool wxImage::GetOrFindMaskColour( unsigned char *r, unsigned char *g, unsigned char *b ) const
1845 {
1846     wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1847
1848     if (M_IMGDATA->m_hasMask)
1849     {
1850         if (r) *r = M_IMGDATA->m_maskRed;
1851         if (g) *g = M_IMGDATA->m_maskGreen;
1852         if (b) *b = M_IMGDATA->m_maskBlue;
1853         return true;
1854     }
1855     else
1856     {
1857         FindFirstUnusedColour(r, g, b);
1858         return false;
1859     }
1860 }
1861
1862 unsigned char wxImage::GetMaskRed() const
1863 {
1864     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1865
1866     return M_IMGDATA->m_maskRed;
1867 }
1868
1869 unsigned char wxImage::GetMaskGreen() const
1870 {
1871     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1872
1873     return M_IMGDATA->m_maskGreen;
1874 }
1875
1876 unsigned char wxImage::GetMaskBlue() const
1877 {
1878     wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1879
1880     return M_IMGDATA->m_maskBlue;
1881 }
1882
1883 void wxImage::SetMask( bool mask )
1884 {
1885     wxCHECK_RET( Ok(), wxT("invalid image") );
1886
1887     AllocExclusive();
1888
1889     M_IMGDATA->m_hasMask = mask;
1890 }
1891
1892 bool wxImage::HasMask() const
1893 {
1894     wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1895
1896     return M_IMGDATA->m_hasMask;
1897 }
1898
1899 bool wxImage::IsTransparent(int x, int y, unsigned char threshold) const
1900 {
1901     long pos = XYToIndex(x, y);
1902     wxCHECK_MSG( pos != -1, false, wxT("invalid image coordinates") );
1903
1904     // check mask
1905     if ( M_IMGDATA->m_hasMask )
1906     {
1907         const unsigned char *p = M_IMGDATA->m_data + 3*pos;
1908         if ( p[0] == M_IMGDATA->m_maskRed &&
1909                 p[1] == M_IMGDATA->m_maskGreen &&
1910                     p[2] == M_IMGDATA->m_maskBlue )
1911         {
1912             return true;
1913         }
1914     }
1915
1916     // then check alpha
1917     if ( M_IMGDATA->m_alpha )
1918     {
1919         if ( M_IMGDATA->m_alpha[pos] < threshold )
1920         {
1921             // transparent enough
1922             return true;
1923         }
1924     }
1925
1926     // not transparent
1927     return false;
1928 }
1929
1930 bool wxImage::SetMaskFromImage(const wxImage& mask,
1931                                unsigned char mr, unsigned char mg, unsigned char mb)
1932 {
1933     // check that the images are the same size
1934     if ( (M_IMGDATA->m_height != mask.GetHeight() ) || (M_IMGDATA->m_width != mask.GetWidth () ) )
1935     {
1936         wxLogError( _("Image and mask have different sizes.") );
1937         return false;
1938     }
1939
1940     // find unused colour
1941     unsigned char r,g,b ;
1942     if (!FindFirstUnusedColour(&r, &g, &b))
1943     {
1944         wxLogError( _("No unused colour in image being masked.") );
1945         return false ;
1946     }
1947
1948     AllocExclusive();
1949
1950     unsigned char *imgdata = GetData();
1951     unsigned char *maskdata = mask.GetData();
1952
1953     const int w = GetWidth();
1954     const int h = GetHeight();
1955
1956     for (int j = 0; j < h; j++)
1957     {
1958         for (int i = 0; i < w; i++)
1959         {
1960             if ((maskdata[0] == mr) && (maskdata[1]  == mg) && (maskdata[2] == mb))
1961             {
1962                 imgdata[0] = r;
1963                 imgdata[1] = g;
1964                 imgdata[2] = b;
1965             }
1966             imgdata  += 3;
1967             maskdata += 3;
1968         }
1969     }
1970
1971     SetMaskColour(r, g, b);
1972     SetMask(true);
1973
1974     return true;
1975 }
1976
1977 bool wxImage::ConvertAlphaToMask(unsigned char threshold)
1978 {
1979     if ( !HasAlpha() )
1980         return true;
1981
1982     unsigned char mr, mg, mb;
1983     if ( !FindFirstUnusedColour(&mr, &mg, &mb) )
1984     {
1985         wxLogError( _("No unused colour in image being masked.") );
1986         return false;
1987     }
1988
1989     ConvertAlphaToMask(mr, mg, mb, threshold);
1990     return true;
1991 }
1992
1993 void wxImage::ConvertAlphaToMask(unsigned char mr,
1994                                  unsigned char mg,
1995                                  unsigned char mb,
1996                                  unsigned char threshold)
1997 {
1998     if ( !HasAlpha() )
1999         return;
2000
2001     AllocExclusive();
2002
2003     SetMask(true);
2004     SetMaskColour(mr, mg, mb);
2005
2006     unsigned char *imgdata = GetData();
2007     unsigned char *alphadata = GetAlpha();
2008
2009     int w = GetWidth();
2010     int h = GetHeight();
2011
2012     for (int y = 0; y < h; y++)
2013     {
2014         for (int x = 0; x < w; x++, imgdata += 3, alphadata++)
2015         {
2016             if (*alphadata < threshold)
2017             {
2018                 imgdata[0] = mr;
2019                 imgdata[1] = mg;
2020                 imgdata[2] = mb;
2021             }
2022         }
2023     }
2024
2025     if ( !M_IMGDATA->m_staticAlpha )
2026         free(M_IMGDATA->m_alpha);
2027
2028     M_IMGDATA->m_alpha = NULL;
2029     M_IMGDATA->m_staticAlpha = false;
2030 }
2031
2032 // ----------------------------------------------------------------------------
2033 // Palette functions
2034 // ----------------------------------------------------------------------------
2035
2036 #if wxUSE_PALETTE
2037
2038 bool wxImage::HasPalette() const
2039 {
2040     if (!Ok())
2041         return false;
2042
2043     return M_IMGDATA->m_palette.Ok();
2044 }
2045
2046 const wxPalette& wxImage::GetPalette() const
2047 {
2048     wxCHECK_MSG( Ok(), wxNullPalette, wxT("invalid image") );
2049
2050     return M_IMGDATA->m_palette;
2051 }
2052
2053 void wxImage::SetPalette(const wxPalette& palette)
2054 {
2055     wxCHECK_RET( Ok(), wxT("invalid image") );
2056
2057     AllocExclusive();
2058
2059     M_IMGDATA->m_palette = palette;
2060 }
2061
2062 #endif // wxUSE_PALETTE
2063
2064 // ----------------------------------------------------------------------------
2065 // Option functions (arbitrary name/value mapping)
2066 // ----------------------------------------------------------------------------
2067
2068 void wxImage::SetOption(const wxString& name, const wxString& value)
2069 {
2070     AllocExclusive();
2071
2072     int idx = M_IMGDATA->m_optionNames.Index(name, false);
2073     if ( idx == wxNOT_FOUND )
2074     {
2075         M_IMGDATA->m_optionNames.Add(name);
2076         M_IMGDATA->m_optionValues.Add(value);
2077     }
2078     else
2079     {
2080         M_IMGDATA->m_optionNames[idx] = name;
2081         M_IMGDATA->m_optionValues[idx] = value;
2082     }
2083 }
2084
2085 void wxImage::SetOption(const wxString& name, int value)
2086 {
2087     wxString valStr;
2088     valStr.Printf(wxT("%d"), value);
2089     SetOption(name, valStr);
2090 }
2091
2092 wxString wxImage::GetOption(const wxString& name) const
2093 {
2094     if ( !M_IMGDATA )
2095         return wxEmptyString;
2096
2097     int idx = M_IMGDATA->m_optionNames.Index(name, false);
2098     if ( idx == wxNOT_FOUND )
2099         return wxEmptyString;
2100     else
2101         return M_IMGDATA->m_optionValues[idx];
2102 }
2103
2104 int wxImage::GetOptionInt(const wxString& name) const
2105 {
2106     return wxAtoi(GetOption(name));
2107 }
2108
2109 bool wxImage::HasOption(const wxString& name) const
2110 {
2111     return M_IMGDATA ? M_IMGDATA->m_optionNames.Index(name, false) != wxNOT_FOUND
2112                      : false;
2113 }
2114
2115 // ----------------------------------------------------------------------------
2116 // image I/O
2117 // ----------------------------------------------------------------------------
2118
2119 bool wxImage::LoadFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
2120                         wxBitmapType WXUNUSED_UNLESS_STREAMS(type),
2121                         int WXUNUSED_UNLESS_STREAMS(index) )
2122 {
2123 #if HAS_FILE_STREAMS
2124     if (wxFileExists(filename))
2125     {
2126         wxImageFileInputStream stream(filename);
2127         wxBufferedInputStream bstream( stream );
2128         return LoadFile(bstream, type, index);
2129     }
2130     else
2131     {
2132         wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
2133
2134         return false;
2135     }
2136 #else // !HAS_FILE_STREAMS
2137     return false;
2138 #endif // HAS_FILE_STREAMS
2139 }
2140
2141 bool wxImage::LoadFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
2142                         const wxString& WXUNUSED_UNLESS_STREAMS(mimetype),
2143                         int WXUNUSED_UNLESS_STREAMS(index) )
2144 {
2145 #if HAS_FILE_STREAMS
2146     if (wxFileExists(filename))
2147     {
2148         wxImageFileInputStream stream(filename);
2149         wxBufferedInputStream bstream( stream );
2150         return LoadFile(bstream, mimetype, index);
2151     }
2152     else
2153     {
2154         wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
2155
2156         return false;
2157     }
2158 #else // !HAS_FILE_STREAMS
2159     return false;
2160 #endif // HAS_FILE_STREAMS
2161 }
2162
2163
2164 bool wxImage::SaveFile( const wxString& filename ) const
2165 {
2166     wxString ext = filename.AfterLast('.').Lower();
2167
2168     wxImageHandler *handler = FindHandler(ext, wxBITMAP_TYPE_ANY);
2169     if ( !handler)
2170     {
2171        wxLogError(_("Can't save image to file '%s': unknown extension."),
2172                   filename);
2173        return false;
2174     }
2175
2176     return SaveFile(filename, handler->GetType());
2177 }
2178
2179 bool wxImage::SaveFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
2180                         wxBitmapType WXUNUSED_UNLESS_STREAMS(type) ) const
2181 {
2182 #if HAS_FILE_STREAMS
2183     wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2184
2185     ((wxImage*)this)->SetOption(wxIMAGE_OPTION_FILENAME, filename);
2186
2187     wxImageFileOutputStream stream(filename);
2188
2189     if ( stream.IsOk() )
2190     {
2191         wxBufferedOutputStream bstream( stream );
2192         return SaveFile(bstream, type);
2193     }
2194 #endif // HAS_FILE_STREAMS
2195
2196     return false;
2197 }
2198
2199 bool wxImage::SaveFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
2200                         const wxString& WXUNUSED_UNLESS_STREAMS(mimetype) ) const
2201 {
2202 #if HAS_FILE_STREAMS
2203     wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2204
2205     ((wxImage*)this)->SetOption(wxIMAGE_OPTION_FILENAME, filename);
2206
2207     wxImageFileOutputStream stream(filename);
2208
2209     if ( stream.IsOk() )
2210     {
2211         wxBufferedOutputStream bstream( stream );
2212         return SaveFile(bstream, mimetype);
2213     }
2214 #endif // HAS_FILE_STREAMS
2215
2216     return false;
2217 }
2218
2219 bool wxImage::CanRead( const wxString& WXUNUSED_UNLESS_STREAMS(name) )
2220 {
2221 #if HAS_FILE_STREAMS
2222     wxImageFileInputStream stream(name);
2223     return CanRead(stream);
2224 #else
2225     return false;
2226 #endif
2227 }
2228
2229 int wxImage::GetImageCount( const wxString& WXUNUSED_UNLESS_STREAMS(name),
2230                             wxBitmapType WXUNUSED_UNLESS_STREAMS(type) )
2231 {
2232 #if HAS_FILE_STREAMS
2233     wxImageFileInputStream stream(name);
2234     if (stream.Ok())
2235         return GetImageCount(stream, type);
2236 #endif
2237
2238   return 0;
2239 }
2240
2241 #if wxUSE_STREAMS
2242
2243 bool wxImage::CanRead( wxInputStream &stream )
2244 {
2245     const wxList& list = GetHandlers();
2246
2247     for ( wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext() )
2248     {
2249         wxImageHandler *handler=(wxImageHandler*)node->GetData();
2250         if (handler->CanRead( stream ))
2251             return true;
2252     }
2253
2254     return false;
2255 }
2256
2257 int wxImage::GetImageCount( wxInputStream &stream, wxBitmapType type )
2258 {
2259     wxImageHandler *handler;
2260
2261     if ( type == wxBITMAP_TYPE_ANY )
2262     {
2263         const wxList& list = GetHandlers();
2264
2265         for ( wxList::compatibility_iterator node = list.GetFirst();
2266               node;
2267               node = node->GetNext() )
2268         {
2269              handler = (wxImageHandler*)node->GetData();
2270              if ( handler->CanRead(stream) )
2271              {
2272                  const int count = handler->GetImageCount(stream);
2273                  if ( count >= 0 )
2274                      return count;
2275              }
2276
2277         }
2278
2279         wxLogWarning(_("No handler found for image type."));
2280         return 0;
2281     }
2282
2283     handler = FindHandler(type);
2284
2285     if ( !handler )
2286     {
2287         wxLogWarning(_("No image handler for type %ld defined."), type);
2288         return false;
2289     }
2290
2291     if ( handler->CanRead(stream) )
2292     {
2293         return handler->GetImageCount(stream);
2294     }
2295     else
2296     {
2297         wxLogError(_("Image file is not of type %ld."), type);
2298         return 0;
2299     }
2300 }
2301
2302 bool wxImage::DoLoad(wxImageHandler& handler, wxInputStream& stream, int index)
2303 {
2304     // save the options values which can be clobbered by the handler (e.g. many
2305     // of them call Destroy() before trying to load the file)
2306     const unsigned maxWidth = GetOptionInt(wxIMAGE_OPTION_MAX_WIDTH),
2307                    maxHeight = GetOptionInt(wxIMAGE_OPTION_MAX_HEIGHT);
2308
2309     if ( !handler.LoadFile(this, stream, true/*verbose*/, index) )
2310         return false;
2311
2312     M_IMGDATA->m_type = handler.GetType();
2313
2314     // rescale the image to the specified size if needed
2315     if ( maxWidth || maxHeight )
2316     {
2317         const unsigned widthOrig = GetWidth(),
2318                        heightOrig = GetHeight();
2319
2320         // this uses the same (trivial) algorithm as the JPEG handler
2321         unsigned width = widthOrig,
2322                  height = heightOrig;
2323         while ( (maxWidth && width > maxWidth) ||
2324                     (maxHeight && height > maxHeight) )
2325         {
2326             width /= 2;
2327             height /= 2;
2328         }
2329
2330         if ( width != widthOrig || height != heightOrig )
2331             Rescale(width, height, wxIMAGE_QUALITY_HIGH);
2332     }
2333
2334     return true;
2335 }
2336
2337 bool wxImage::LoadFile( wxInputStream& stream, wxBitmapType type, int index )
2338 {
2339     AllocExclusive();
2340
2341     wxImageHandler *handler;
2342
2343     if ( type == wxBITMAP_TYPE_ANY )
2344     {
2345         const wxList& list = GetHandlers();
2346         for ( wxList::compatibility_iterator node = list.GetFirst();
2347               node;
2348               node = node->GetNext() )
2349         {
2350              handler = (wxImageHandler*)node->GetData();
2351              if ( handler->CanRead(stream) && DoLoad(*handler, stream, index) )
2352                  return true;
2353         }
2354
2355         wxLogWarning( _("No handler found for image type.") );
2356
2357         return false;
2358     }
2359     //else: have specific type
2360
2361     handler = FindHandler(type);
2362     if ( !handler )
2363     {
2364         wxLogWarning( _("No image handler for type %ld defined."), type );
2365         return false;
2366     }
2367
2368     if ( stream.IsSeekable() && !handler->CanRead(stream) )
2369     {
2370         wxLogError(_("Image file is not of type %ld."), type);
2371         return false;
2372     }
2373
2374     return DoLoad(*handler, stream, index);
2375 }
2376
2377 bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype, int index )
2378 {
2379     UnRef();
2380
2381     m_refData = new wxImageRefData;
2382
2383     wxImageHandler *handler = FindHandlerMime(mimetype);
2384
2385     if ( !handler )
2386     {
2387         wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
2388         return false;
2389     }
2390
2391     if ( stream.IsSeekable() && !handler->CanRead(stream) )
2392     {
2393         wxLogError(_("Image file is not of type %s."), mimetype);
2394         return false;
2395     }
2396
2397     return DoLoad(*handler, stream, index);
2398 }
2399
2400 bool wxImage::DoSave(wxImageHandler& handler, wxOutputStream& stream) const
2401 {
2402     wxImage * const self = const_cast<wxImage *>(this);
2403     if ( !handler.SaveFile(self, stream) )
2404         return false;
2405
2406     M_IMGDATA->m_type = handler.GetType();
2407     return true;
2408 }
2409
2410 bool wxImage::SaveFile( wxOutputStream& stream, wxBitmapType type ) const
2411 {
2412     wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2413
2414     wxImageHandler *handler = FindHandler(type);
2415     if ( !handler )
2416     {
2417         wxLogWarning( _("No image handler for type %d defined."), type );
2418         return false;
2419     }
2420
2421     return DoSave(*handler, stream);
2422 }
2423
2424 bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype ) const
2425 {
2426     wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2427
2428     wxImageHandler *handler = FindHandlerMime(mimetype);
2429     if ( !handler )
2430     {
2431         wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
2432     }
2433
2434     return DoSave(*handler, stream);
2435 }
2436
2437 #endif // wxUSE_STREAMS
2438
2439 // ----------------------------------------------------------------------------
2440 // image I/O handlers
2441 // ----------------------------------------------------------------------------
2442
2443 void wxImage::AddHandler( wxImageHandler *handler )
2444 {
2445     // Check for an existing handler of the type being added.
2446     if (FindHandler( handler->GetType() ) == 0)
2447     {
2448         sm_handlers.Append( handler );
2449     }
2450     else
2451     {
2452         // This is not documented behaviour, merely the simplest 'fix'
2453         // for preventing duplicate additions.  If someone ever has
2454         // a good reason to add and remove duplicate handlers (and they
2455         // may) we should probably refcount the duplicates.
2456         //   also an issue in InsertHandler below.
2457
2458         wxLogDebug( wxT("Adding duplicate image handler for '%s'"),
2459                     handler->GetName().c_str() );
2460         delete handler;
2461     }
2462 }
2463
2464 void wxImage::InsertHandler( wxImageHandler *handler )
2465 {
2466     // Check for an existing handler of the type being added.
2467     if (FindHandler( handler->GetType() ) == 0)
2468     {
2469         sm_handlers.Insert( handler );
2470     }
2471     else
2472     {
2473         // see AddHandler for additional comments.
2474         wxLogDebug( wxT("Inserting duplicate image handler for '%s'"),
2475                     handler->GetName().c_str() );
2476         delete handler;
2477     }
2478 }
2479
2480 bool wxImage::RemoveHandler( const wxString& name )
2481 {
2482     wxImageHandler *handler = FindHandler(name);
2483     if (handler)
2484     {
2485         sm_handlers.DeleteObject(handler);
2486         delete handler;
2487         return true;
2488     }
2489     else
2490         return false;
2491 }
2492
2493 wxImageHandler *wxImage::FindHandler( const wxString& name )
2494 {
2495     wxList::compatibility_iterator node = sm_handlers.GetFirst();
2496     while (node)
2497     {
2498         wxImageHandler *handler = (wxImageHandler*)node->GetData();
2499         if (handler->GetName().Cmp(name) == 0) return handler;
2500
2501         node = node->GetNext();
2502     }
2503     return NULL;
2504 }
2505
2506 wxImageHandler *wxImage::FindHandler( const wxString& extension, wxBitmapType bitmapType )
2507 {
2508     wxList::compatibility_iterator node = sm_handlers.GetFirst();
2509     while (node)
2510     {
2511         wxImageHandler *handler = (wxImageHandler*)node->GetData();
2512         if ((bitmapType == wxBITMAP_TYPE_ANY) || (handler->GetType() == bitmapType))
2513         {
2514             if (handler->GetExtension() == extension)
2515                 return handler;
2516             if (handler->GetAltExtensions().Index(extension, false) != wxNOT_FOUND)
2517                 return handler;
2518         }
2519         node = node->GetNext();
2520     }
2521     return NULL;
2522 }
2523
2524 wxImageHandler *wxImage::FindHandler(wxBitmapType bitmapType )
2525 {
2526     wxList::compatibility_iterator node = sm_handlers.GetFirst();
2527     while (node)
2528     {
2529         wxImageHandler *handler = (wxImageHandler *)node->GetData();
2530         if (handler->GetType() == bitmapType) return handler;
2531         node = node->GetNext();
2532     }
2533     return NULL;
2534 }
2535
2536 wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype )
2537 {
2538     wxList::compatibility_iterator node = sm_handlers.GetFirst();
2539     while (node)
2540     {
2541         wxImageHandler *handler = (wxImageHandler *)node->GetData();
2542         if (handler->GetMimeType().IsSameAs(mimetype, false)) return handler;
2543         node = node->GetNext();
2544     }
2545     return NULL;
2546 }
2547
2548 void wxImage::InitStandardHandlers()
2549 {
2550 #if wxUSE_STREAMS
2551     AddHandler(new wxBMPHandler);
2552 #endif // wxUSE_STREAMS
2553 }
2554
2555 void wxImage::CleanUpHandlers()
2556 {
2557     wxList::compatibility_iterator node = sm_handlers.GetFirst();
2558     while (node)
2559     {
2560         wxImageHandler *handler = (wxImageHandler *)node->GetData();
2561         wxList::compatibility_iterator next = node->GetNext();
2562         delete handler;
2563         node = next;
2564     }
2565
2566     sm_handlers.Clear();
2567 }
2568
2569 wxString wxImage::GetImageExtWildcard()
2570 {
2571     wxString fmts;
2572
2573     wxList& Handlers = wxImage::GetHandlers();
2574     wxList::compatibility_iterator Node = Handlers.GetFirst();
2575     while ( Node )
2576     {
2577         wxImageHandler* Handler = (wxImageHandler*)Node->GetData();
2578         fmts += wxT("*.") + Handler->GetExtension();
2579         for (size_t i = 0; i < Handler->GetAltExtensions().size(); i++)
2580             fmts += wxT(";*.") + Handler->GetAltExtensions()[i];
2581         Node = Node->GetNext();
2582         if ( Node ) fmts += wxT(";");
2583     }
2584
2585     return wxT("(") + fmts + wxT(")|") + fmts;
2586 }
2587
2588 wxImage::HSVValue wxImage::RGBtoHSV(const RGBValue& rgb)
2589 {
2590     const double red = rgb.red / 255.0,
2591                  green = rgb.green / 255.0,
2592                  blue = rgb.blue / 255.0;
2593
2594     // find the min and max intensity (and remember which one was it for the
2595     // latter)
2596     double minimumRGB = red;
2597     if ( green < minimumRGB )
2598         minimumRGB = green;
2599     if ( blue < minimumRGB )
2600         minimumRGB = blue;
2601
2602     enum { RED, GREEN, BLUE } chMax = RED;
2603     double maximumRGB = red;
2604     if ( green > maximumRGB )
2605     {
2606         chMax = GREEN;
2607         maximumRGB = green;
2608     }
2609     if ( blue > maximumRGB )
2610     {
2611         chMax = BLUE;
2612         maximumRGB = blue;
2613     }
2614
2615     const double value = maximumRGB;
2616
2617     double hue = 0.0, saturation;
2618     const double deltaRGB = maximumRGB - minimumRGB;
2619     if ( wxIsNullDouble(deltaRGB) )
2620     {
2621         // Gray has no color
2622         hue = 0.0;
2623         saturation = 0.0;
2624     }
2625     else
2626     {
2627         switch ( chMax )
2628         {
2629             case RED:
2630                 hue = (green - blue) / deltaRGB;
2631                 break;
2632
2633             case GREEN:
2634                 hue = 2.0 + (blue - red) / deltaRGB;
2635                 break;
2636
2637             case BLUE:
2638                 hue = 4.0 + (red - green) / deltaRGB;
2639                 break;
2640
2641             default:
2642                 wxFAIL_MSG(wxT("hue not specified"));
2643                 break;
2644         }
2645
2646         hue /= 6.0;
2647
2648         if ( hue < 0.0 )
2649             hue += 1.0;
2650
2651         saturation = deltaRGB / maximumRGB;
2652     }
2653
2654     return HSVValue(hue, saturation, value);
2655 }
2656
2657 wxImage::RGBValue wxImage::HSVtoRGB(const HSVValue& hsv)
2658 {
2659     double red, green, blue;
2660
2661     if ( wxIsNullDouble(hsv.saturation) )
2662     {
2663         // Grey
2664         red = hsv.value;
2665         green = hsv.value;
2666         blue = hsv.value;
2667     }
2668     else // not grey
2669     {
2670         double hue = hsv.hue * 6.0;      // sector 0 to 5
2671         int i = (int)floor(hue);
2672         double f = hue - i;          // fractional part of h
2673         double p = hsv.value * (1.0 - hsv.saturation);
2674
2675         switch (i)
2676         {
2677             case 0:
2678                 red = hsv.value;
2679                 green = hsv.value * (1.0 - hsv.saturation * (1.0 - f));
2680                 blue = p;
2681                 break;
2682
2683             case 1:
2684                 red = hsv.value * (1.0 - hsv.saturation * f);
2685                 green = hsv.value;
2686                 blue = p;
2687                 break;
2688
2689             case 2:
2690                 red = p;
2691                 green = hsv.value;
2692                 blue = hsv.value * (1.0 - hsv.saturation * (1.0 - f));
2693                 break;
2694
2695             case 3:
2696                 red = p;
2697                 green = hsv.value * (1.0 - hsv.saturation * f);
2698                 blue = hsv.value;
2699                 break;
2700
2701             case 4:
2702                 red = hsv.value * (1.0 - hsv.saturation * (1.0 - f));
2703                 green = p;
2704                 blue = hsv.value;
2705                 break;
2706
2707             default:    // case 5:
2708                 red = hsv.value;
2709                 green = p;
2710                 blue = hsv.value * (1.0 - hsv.saturation * f);
2711                 break;
2712         }
2713     }
2714
2715     return RGBValue((unsigned char)(red * 255.0),
2716                     (unsigned char)(green * 255.0),
2717                     (unsigned char)(blue * 255.0));
2718 }
2719
2720 /*
2721  * Rotates the hue of each pixel of the image. angle is a double in the range
2722  * -1.0..1.0 where -1.0 is -360 degrees and 1.0 is 360 degrees
2723  */
2724 void wxImage::RotateHue(double angle)
2725 {
2726     AllocExclusive();
2727
2728     unsigned char *srcBytePtr;
2729     unsigned char *dstBytePtr;
2730     unsigned long count;
2731     wxImage::HSVValue hsv;
2732     wxImage::RGBValue rgb;
2733
2734     wxASSERT (angle >= -1.0 && angle <= 1.0);
2735     count = M_IMGDATA->m_width * M_IMGDATA->m_height;
2736     if ( count > 0 && !wxIsNullDouble(angle) )
2737     {
2738         srcBytePtr = M_IMGDATA->m_data;
2739         dstBytePtr = srcBytePtr;
2740         do
2741         {
2742             rgb.red = *srcBytePtr++;
2743             rgb.green = *srcBytePtr++;
2744             rgb.blue = *srcBytePtr++;
2745             hsv = RGBtoHSV(rgb);
2746
2747             hsv.hue = hsv.hue + angle;
2748             if (hsv.hue > 1.0)
2749                 hsv.hue = hsv.hue - 1.0;
2750             else if (hsv.hue < 0.0)
2751                 hsv.hue = hsv.hue + 1.0;
2752
2753             rgb = HSVtoRGB(hsv);
2754             *dstBytePtr++ = rgb.red;
2755             *dstBytePtr++ = rgb.green;
2756             *dstBytePtr++ = rgb.blue;
2757         } while (--count != 0);
2758     }
2759 }
2760
2761 //-----------------------------------------------------------------------------
2762 // wxImageHandler
2763 //-----------------------------------------------------------------------------
2764
2765 IMPLEMENT_ABSTRACT_CLASS(wxImageHandler,wxObject)
2766
2767 #if wxUSE_STREAMS
2768 int wxImageHandler::GetImageCount( wxInputStream& stream )
2769 {
2770     // NOTE: this code is the same of wxAnimationDecoder::CanRead and
2771     //       wxImageHandler::CallDoCanRead
2772
2773     if ( !stream.IsSeekable() )
2774         return false;        // can't test unseekable stream
2775
2776     wxFileOffset posOld = stream.TellI();
2777     int n = DoGetImageCount(stream);
2778
2779     // restore the old position to be able to test other formats and so on
2780     if ( stream.SeekI(posOld) == wxInvalidOffset )
2781     {
2782         wxLogDebug(wxT("Failed to rewind the stream in wxImageHandler!"));
2783
2784         // reading would fail anyhow as we're not at the right position
2785         return false;
2786     }
2787
2788     return n;
2789 }
2790
2791 bool wxImageHandler::CanRead( const wxString& name )
2792 {
2793     if (wxFileExists(name))
2794     {
2795         wxImageFileInputStream stream(name);
2796         return CanRead(stream);
2797     }
2798
2799     wxLogError( _("Can't check image format of file '%s': file does not exist."), name.c_str() );
2800
2801     return false;
2802 }
2803
2804 bool wxImageHandler::CallDoCanRead(wxInputStream& stream)
2805 {
2806     // NOTE: this code is the same of wxAnimationDecoder::CanRead and
2807     //       wxImageHandler::GetImageCount
2808
2809     if ( !stream.IsSeekable() )
2810         return false;        // can't test unseekable stream
2811
2812     wxFileOffset posOld = stream.TellI();
2813     bool ok = DoCanRead(stream);
2814
2815     // restore the old position to be able to test other formats and so on
2816     if ( stream.SeekI(posOld) == wxInvalidOffset )
2817     {
2818         wxLogDebug(wxT("Failed to rewind the stream in wxImageHandler!"));
2819
2820         // reading would fail anyhow as we're not at the right position
2821         return false;
2822     }
2823
2824     return ok;
2825 }
2826
2827 #endif // wxUSE_STREAMS
2828
2829 /* static */
2830 wxImageResolution
2831 wxImageHandler::GetResolutionFromOptions(const wxImage& image, int *x, int *y)
2832 {
2833     wxCHECK_MSG( x && y, wxIMAGE_RESOLUTION_NONE, wxT("NULL pointer") );
2834
2835     if ( image.HasOption(wxIMAGE_OPTION_RESOLUTIONX) &&
2836          image.HasOption(wxIMAGE_OPTION_RESOLUTIONY) )
2837     {
2838         *x = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONX);
2839         *y = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONY);
2840     }
2841     else if ( image.HasOption(wxIMAGE_OPTION_RESOLUTION) )
2842     {
2843         *x =
2844         *y = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTION);
2845     }
2846     else // no resolution options specified
2847     {
2848         *x =
2849         *y = 0;
2850
2851         return wxIMAGE_RESOLUTION_NONE;
2852     }
2853
2854     // get the resolution unit too
2855     int resUnit = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONUNIT);
2856     if ( !resUnit )
2857     {
2858         // this is the default
2859         resUnit = wxIMAGE_RESOLUTION_INCHES;
2860     }
2861
2862     return (wxImageResolution)resUnit;
2863 }
2864
2865 // ----------------------------------------------------------------------------
2866 // image histogram stuff
2867 // ----------------------------------------------------------------------------
2868
2869 bool
2870 wxImageHistogram::FindFirstUnusedColour(unsigned char *r,
2871                                         unsigned char *g,
2872                                         unsigned char *b,
2873                                         unsigned char r2,
2874                                         unsigned char b2,
2875                                         unsigned char g2) const
2876 {
2877     unsigned long key = MakeKey(r2, g2, b2);
2878
2879     while ( find(key) != end() )
2880     {
2881         // color already used
2882         r2++;
2883         if ( r2 >= 255 )
2884         {
2885             r2 = 0;
2886             g2++;
2887             if ( g2 >= 255 )
2888             {
2889                 g2 = 0;
2890                 b2++;
2891                 if ( b2 >= 255 )
2892                 {
2893                     wxLogError(_("No unused colour in image.") );
2894                     return false;
2895                 }
2896             }
2897         }
2898
2899         key = MakeKey(r2, g2, b2);
2900     }
2901
2902     if ( r )
2903         *r = r2;
2904     if ( g )
2905         *g = g2;
2906     if ( b )
2907         *b = b2;
2908
2909     return true;
2910 }
2911
2912 bool
2913 wxImage::FindFirstUnusedColour(unsigned char *r,
2914                                unsigned char *g,
2915                                unsigned char *b,
2916                                unsigned char r2,
2917                                unsigned char b2,
2918                                unsigned char g2) const
2919 {
2920     wxImageHistogram histogram;
2921
2922     ComputeHistogram(histogram);
2923
2924     return histogram.FindFirstUnusedColour(r, g, b, r2, g2, b2);
2925 }
2926
2927
2928
2929 // GRG, Dic/99
2930 // Counts and returns the number of different colours. Optionally stops
2931 // when it exceeds 'stopafter' different colours. This is useful, for
2932 // example, to see if the image can be saved as 8-bit (256 colour or
2933 // less, in this case it would be invoked as CountColours(256)). Default
2934 // value for stopafter is -1 (don't care).
2935 //
2936 unsigned long wxImage::CountColours( unsigned long stopafter ) const
2937 {
2938     wxHashTable h;
2939     wxObject dummy;
2940     unsigned char r, g, b;
2941     unsigned char *p;
2942     unsigned long size, nentries, key;
2943
2944     p = GetData();
2945     size = GetWidth() * GetHeight();
2946     nentries = 0;
2947
2948     for (unsigned long j = 0; (j < size) && (nentries <= stopafter) ; j++)
2949     {
2950         r = *(p++);
2951         g = *(p++);
2952         b = *(p++);
2953         key = wxImageHistogram::MakeKey(r, g, b);
2954
2955         if (h.Get(key) == NULL)
2956         {
2957             h.Put(key, &dummy);
2958             nentries++;
2959         }
2960     }
2961
2962     return nentries;
2963 }
2964
2965
2966 unsigned long wxImage::ComputeHistogram( wxImageHistogram &h ) const
2967 {
2968     unsigned char *p = GetData();
2969     unsigned long nentries = 0;
2970
2971     h.clear();
2972
2973     const unsigned long size = GetWidth() * GetHeight();
2974
2975     unsigned char r, g, b;
2976     for ( unsigned long n = 0; n < size; n++ )
2977     {
2978         r = *p++;
2979         g = *p++;
2980         b = *p++;
2981
2982         wxImageHistogramEntry& entry = h[wxImageHistogram::MakeKey(r, g, b)];
2983
2984         if ( entry.value++ == 0 )
2985             entry.index = nentries++;
2986     }
2987
2988     return nentries;
2989 }
2990
2991 /*
2992  * Rotation code by Carlos Moreno
2993  */
2994
2995 static const double wxROTATE_EPSILON = 1e-10;
2996
2997 // Auxiliary function to rotate a point (x,y) with respect to point p0
2998 // make it inline and use a straight return to facilitate optimization
2999 // also, the function receives the sine and cosine of the angle to avoid
3000 // repeating the time-consuming calls to these functions -- sin/cos can
3001 // be computed and stored in the calling function.
3002
3003 static inline wxRealPoint
3004 wxRotatePoint(const wxRealPoint& p, double cos_angle, double sin_angle,
3005               const wxRealPoint& p0)
3006 {
3007     return wxRealPoint(p0.x + (p.x - p0.x) * cos_angle - (p.y - p0.y) * sin_angle,
3008                        p0.y + (p.y - p0.y) * cos_angle + (p.x - p0.x) * sin_angle);
3009 }
3010
3011 static inline wxRealPoint
3012 wxRotatePoint(double x, double y, double cos_angle, double sin_angle,
3013               const wxRealPoint & p0)
3014 {
3015     return wxRotatePoint (wxRealPoint(x,y), cos_angle, sin_angle, p0);
3016 }
3017
3018 wxImage wxImage::Rotate(double angle,
3019                         const wxPoint& centre_of_rotation,
3020                         bool interpolating,
3021                         wxPoint *offset_after_rotation) const
3022 {
3023     // screen coordinates are a mirror image of "real" coordinates
3024     angle = -angle;
3025
3026     const bool has_alpha = HasAlpha();
3027
3028     const int w = GetWidth();
3029     const int h = GetHeight();
3030
3031     int i;
3032
3033     // Create pointer-based array to accelerate access to wxImage's data
3034     unsigned char ** data = new unsigned char * [h];
3035     data[0] = GetData();
3036     for (i = 1; i < h; i++)
3037         data[i] = data[i - 1] + (3 * w);
3038
3039     // Same for alpha channel
3040     unsigned char ** alpha = NULL;
3041     if (has_alpha)
3042     {
3043         alpha = new unsigned char * [h];
3044         alpha[0] = GetAlpha();
3045         for (i = 1; i < h; i++)
3046             alpha[i] = alpha[i - 1] + w;
3047     }
3048
3049     // precompute coefficients for rotation formula
3050     const double cos_angle = cos(angle);
3051     const double sin_angle = sin(angle);
3052
3053     // Create new Image to store the result
3054     // First, find rectangle that covers the rotated image;  to do that,
3055     // rotate the four corners
3056
3057     const wxRealPoint p0(centre_of_rotation.x, centre_of_rotation.y);
3058
3059     wxRealPoint p1 = wxRotatePoint (0, 0, cos_angle, sin_angle, p0);
3060     wxRealPoint p2 = wxRotatePoint (0, h, cos_angle, sin_angle, p0);
3061     wxRealPoint p3 = wxRotatePoint (w, 0, cos_angle, sin_angle, p0);
3062     wxRealPoint p4 = wxRotatePoint (w, h, cos_angle, sin_angle, p0);
3063
3064     int x1a = (int) floor (wxMin (wxMin(p1.x, p2.x), wxMin(p3.x, p4.x)));
3065     int y1a = (int) floor (wxMin (wxMin(p1.y, p2.y), wxMin(p3.y, p4.y)));
3066     int x2a = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x)));
3067     int y2a = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y)));
3068
3069     // Create rotated image
3070     wxImage rotated (x2a - x1a + 1, y2a - y1a + 1, false);
3071     // With alpha channel
3072     if (has_alpha)
3073         rotated.SetAlpha();
3074
3075     if (offset_after_rotation != NULL)
3076     {
3077         *offset_after_rotation = wxPoint (x1a, y1a);
3078     }
3079
3080     // the rotated (destination) image is always accessed sequentially via this
3081     // pointer, there is no need for pointer-based arrays here
3082     unsigned char *dst = rotated.GetData();
3083
3084     unsigned char *alpha_dst = has_alpha ? rotated.GetAlpha() : NULL;
3085
3086     // if the original image has a mask, use its RGB values as the blank pixel,
3087     // else, fall back to default (black).
3088     unsigned char blank_r = 0;
3089     unsigned char blank_g = 0;
3090     unsigned char blank_b = 0;
3091
3092     if (HasMask())
3093     {
3094         blank_r = GetMaskRed();
3095         blank_g = GetMaskGreen();
3096         blank_b = GetMaskBlue();
3097         rotated.SetMaskColour( blank_r, blank_g, blank_b );
3098     }
3099
3100     // Now, for each point of the rotated image, find where it came from, by
3101     // performing an inverse rotation (a rotation of -angle) and getting the
3102     // pixel at those coordinates
3103
3104     const int rH = rotated.GetHeight();
3105     const int rW = rotated.GetWidth();
3106
3107     // do the (interpolating) test outside of the loops, so that it is done
3108     // only once, instead of repeating it for each pixel.
3109     if (interpolating)
3110     {
3111         for (int y = 0; y < rH; y++)
3112         {
3113             for (int x = 0; x < rW; x++)
3114             {
3115                 wxRealPoint src = wxRotatePoint (x + x1a, y + y1a, cos_angle, -sin_angle, p0);
3116
3117                 if (-0.25 < src.x && src.x < w - 0.75 &&
3118                     -0.25 < src.y && src.y < h - 0.75)
3119                 {
3120                     // interpolate using the 4 enclosing grid-points.  Those
3121                     // points can be obtained using floor and ceiling of the
3122                     // exact coordinates of the point
3123                     int x1, y1, x2, y2;
3124
3125                     if (0 < src.x && src.x < w - 1)
3126                     {
3127                         x1 = wxRound(floor(src.x));
3128                         x2 = wxRound(ceil(src.x));
3129                     }
3130                     else    // else means that x is near one of the borders (0 or width-1)
3131                     {
3132                         x1 = x2 = wxRound (src.x);
3133                     }
3134
3135                     if (0 < src.y && src.y < h - 1)
3136                     {
3137                         y1 = wxRound(floor(src.y));
3138                         y2 = wxRound(ceil(src.y));
3139                     }
3140                     else
3141                     {
3142                         y1 = y2 = wxRound (src.y);
3143                     }
3144
3145                     // get four points and the distances (square of the distance,
3146                     // for efficiency reasons) for the interpolation formula
3147
3148                     // GRG: Do not calculate the points until they are
3149                     //      really needed -- this way we can calculate
3150                     //      just one, instead of four, if d1, d2, d3
3151                     //      or d4 are < wxROTATE_EPSILON
3152
3153                     const double d1 = (src.x - x1) * (src.x - x1) + (src.y - y1) * (src.y - y1);
3154                     const double d2 = (src.x - x2) * (src.x - x2) + (src.y - y1) * (src.y - y1);
3155                     const double d3 = (src.x - x2) * (src.x - x2) + (src.y - y2) * (src.y - y2);
3156                     const double d4 = (src.x - x1) * (src.x - x1) + (src.y - y2) * (src.y - y2);
3157
3158                     // Now interpolate as a weighted average of the four surrounding
3159                     // points, where the weights are the distances to each of those points
3160
3161                     // If the point is exactly at one point of the grid of the source
3162                     // image, then don't interpolate -- just assign the pixel
3163
3164                     // d1,d2,d3,d4 are positive -- no need for abs()
3165                     if (d1 < wxROTATE_EPSILON)
3166                     {
3167                         unsigned char *p = data[y1] + (3 * x1);
3168                         *(dst++) = *(p++);
3169                         *(dst++) = *(p++);
3170                         *(dst++) = *p;
3171
3172                         if (has_alpha)
3173                             *(alpha_dst++) = *(alpha[y1] + x1);
3174                     }
3175                     else if (d2 < wxROTATE_EPSILON)
3176                     {
3177                         unsigned char *p = data[y1] + (3 * x2);
3178                         *(dst++) = *(p++);
3179                         *(dst++) = *(p++);
3180                         *(dst++) = *p;
3181
3182                         if (has_alpha)
3183                             *(alpha_dst++) = *(alpha[y1] + x2);
3184                     }
3185                     else if (d3 < wxROTATE_EPSILON)
3186                     {
3187                         unsigned char *p = data[y2] + (3 * x2);
3188                         *(dst++) = *(p++);
3189                         *(dst++) = *(p++);
3190                         *(dst++) = *p;
3191
3192                         if (has_alpha)
3193                             *(alpha_dst++) = *(alpha[y2] + x2);
3194                     }
3195                     else if (d4 < wxROTATE_EPSILON)
3196                     {
3197                         unsigned char *p = data[y2] + (3 * x1);
3198                         *(dst++) = *(p++);
3199                         *(dst++) = *(p++);
3200                         *(dst++) = *p;
3201
3202                         if (has_alpha)
3203                             *(alpha_dst++) = *(alpha[y2] + x1);
3204                     }
3205                     else
3206                     {
3207                         // weights for the weighted average are proportional to the inverse of the distance
3208                         unsigned char *v1 = data[y1] + (3 * x1);
3209                         unsigned char *v2 = data[y1] + (3 * x2);
3210                         unsigned char *v3 = data[y2] + (3 * x2);
3211                         unsigned char *v4 = data[y2] + (3 * x1);
3212
3213                         const double w1 = 1/d1, w2 = 1/d2, w3 = 1/d3, w4 = 1/d4;
3214
3215                         // GRG: Unrolled.
3216
3217                         *(dst++) = (unsigned char)
3218                             ( (w1 * *(v1++) + w2 * *(v2++) +
3219                                w3 * *(v3++) + w4 * *(v4++)) /
3220                               (w1 + w2 + w3 + w4) );
3221                         *(dst++) = (unsigned char)
3222                             ( (w1 * *(v1++) + w2 * *(v2++) +
3223                                w3 * *(v3++) + w4 * *(v4++)) /
3224                               (w1 + w2 + w3 + w4) );
3225                         *(dst++) = (unsigned char)
3226                             ( (w1 * *v1 + w2 * *v2 +
3227                                w3 * *v3 + w4 * *v4) /
3228                               (w1 + w2 + w3 + w4) );
3229
3230                         if (has_alpha)
3231                         {
3232                             v1 = alpha[y1] + (x1);
3233                             v2 = alpha[y1] + (x2);
3234                             v3 = alpha[y2] + (x2);
3235                             v4 = alpha[y2] + (x1);
3236
3237                             *(alpha_dst++) = (unsigned char)
3238                                 ( (w1 * *v1 + w2 * *v2 +
3239                                    w3 * *v3 + w4 * *v4) /
3240                                   (w1 + w2 + w3 + w4) );
3241                         }
3242                     }
3243                 }
3244                 else
3245                 {
3246                     *(dst++) = blank_r;
3247                     *(dst++) = blank_g;
3248                     *(dst++) = blank_b;
3249
3250                     if (has_alpha)
3251                         *(alpha_dst++) = 0;
3252                 }
3253             }
3254         }
3255     }
3256     else // not interpolating
3257     {
3258         for (int y = 0; y < rH; y++)
3259         {
3260             for (int x = 0; x < rW; x++)
3261             {
3262                 wxRealPoint src = wxRotatePoint (x + x1a, y + y1a, cos_angle, -sin_angle, p0);
3263
3264                 const int xs = wxRound (src.x);      // wxRound rounds to the
3265                 const int ys = wxRound (src.y);      // closest integer
3266
3267                 if (0 <= xs && xs < w && 0 <= ys && ys < h)
3268                 {
3269                     unsigned char *p = data[ys] + (3 * xs);
3270                     *(dst++) = *(p++);
3271                     *(dst++) = *(p++);
3272                     *(dst++) = *p;
3273
3274                     if (has_alpha)
3275                         *(alpha_dst++) = *(alpha[ys] + (xs));
3276                 }
3277                 else
3278                 {
3279                     *(dst++) = blank_r;
3280                     *(dst++) = blank_g;
3281                     *(dst++) = blank_b;
3282
3283                     if (has_alpha)
3284                         *(alpha_dst++) = 255;
3285                 }
3286             }
3287         }
3288     }
3289
3290     delete [] data;
3291     delete [] alpha;
3292
3293     return rotated;
3294 }
3295
3296
3297
3298
3299
3300 // A module to allow wxImage initialization/cleanup
3301 // without calling these functions from app.cpp or from
3302 // the user's application.
3303
3304 class wxImageModule: public wxModule
3305 {
3306 DECLARE_DYNAMIC_CLASS(wxImageModule)
3307 public:
3308     wxImageModule() {}
3309     bool OnInit() { wxImage::InitStandardHandlers(); return true; }
3310     void OnExit() { wxImage::CleanUpHandlers(); }
3311 };
3312
3313 IMPLEMENT_DYNAMIC_CLASS(wxImageModule, wxModule)
3314
3315
3316 #endif // wxUSE_IMAGE