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