]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/image.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Added wxSHOW_EFFECT_NONE.
[wxWidgets.git] / src / common / image.cpp
... / ...
CommitLineData
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
53IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxImage,WXDLLEXPORT)
54#endif
55
56//-----------------------------------------------------------------------------
57// global data
58//-----------------------------------------------------------------------------
59
60wxList wxImage::sm_handlers;
61wxImage wxNullImage;
62
63//-----------------------------------------------------------------------------
64// wxImageRefData
65//-----------------------------------------------------------------------------
66
67class wxImageRefData: public wxObjectRefData
68{
69public:
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
102wxImageRefData::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
120wxImageRefData::~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
135IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
136
137bool 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
150bool 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
175bool 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
192bool 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
211void wxImage::Destroy()
212{
213 UnRef();
214}
215
216void wxImage::Clear(unsigned char value)
217{
218 memset(M_IMGDATA->m_data, value, M_IMGDATA->m_width*M_IMGDATA->m_height*3);
219}
220
221wxObjectRefData* wxImage::CreateRefData() const
222{
223 return new wxImageRefData;
224}
225
226wxObjectRefData* 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
256wxImage 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
267wxImage 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
388wxImage
389wxImage::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
456wxImage 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
513wxImage 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
598wxImage 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] = r1 * dy1 + r2 * dy;
672 dst_data[1] = g1 * dy1 + g2 * dy;
673 dst_data[2] = b1 * dy1 + b2 * dy;
674 dst_data += 3;
675
676 if ( src_alpha )
677 *dst_alpha++ = 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
686static inline double spline_cube(double value)
687{
688 return value <= 0.0 ? 0.0 : value * value * value;
689}
690
691static 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
700wxImage 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
814wxImage 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
929wxImage 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
1044wxImage 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
1056wxImage 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 = 0 ;
1072 unsigned char *target_alpha = 0 ;
1073
1074 if (M_IMGDATA->m_hasMask)
1075 {
1076 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
1077 }
1078 else
1079 {
1080 source_alpha = M_IMGDATA->m_alpha ;
1081 if ( source_alpha )
1082 {
1083 image.SetAlpha() ;
1084 alpha_data = image.GetAlpha() ;
1085 }
1086 }
1087
1088 long height = M_IMGDATA->m_height;
1089 long width = M_IMGDATA->m_width;
1090
1091 for (long j = 0; j < height; j++)
1092 {
1093 for (long i = 0; i < width; i++)
1094 {
1095 if (clockwise)
1096 {
1097 target_data = data + (((i+1)*height) - j - 1)*3;
1098 if(source_alpha)
1099 target_alpha = alpha_data + (((i+1)*height) - j - 1);
1100 }
1101 else
1102 {
1103 target_data = data + ((height*(width-1)) + j - (i*height))*3;
1104 if(source_alpha)
1105 target_alpha = alpha_data + ((height*(width-1)) + j - (i*height));
1106 }
1107 memcpy( target_data, source_data, 3 );
1108 source_data += 3;
1109
1110 if(source_alpha)
1111 {
1112 memcpy( target_alpha, source_alpha, 1 );
1113 source_alpha += 1;
1114 }
1115 }
1116 }
1117
1118 return image;
1119}
1120
1121wxImage wxImage::Mirror( bool horizontally ) const
1122{
1123 wxImage image;
1124
1125 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1126
1127 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
1128
1129 unsigned char *data = image.GetData();
1130 unsigned char *alpha = NULL;
1131
1132 wxCHECK_MSG( data, image, wxT("unable to create image") );
1133
1134 if (M_IMGDATA->m_alpha != NULL) {
1135 image.SetAlpha();
1136 alpha = image.GetAlpha();
1137 wxCHECK_MSG( alpha, image, wxT("unable to create alpha channel") );
1138 }
1139
1140 if (M_IMGDATA->m_hasMask)
1141 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
1142
1143 long height = M_IMGDATA->m_height;
1144 long width = M_IMGDATA->m_width;
1145
1146 unsigned char *source_data = M_IMGDATA->m_data;
1147 unsigned char *target_data;
1148
1149 if (horizontally)
1150 {
1151 for (long j = 0; j < height; j++)
1152 {
1153 data += width*3;
1154 target_data = data-3;
1155 for (long i = 0; i < width; i++)
1156 {
1157 memcpy( target_data, source_data, 3 );
1158 source_data += 3;
1159 target_data -= 3;
1160 }
1161 }
1162
1163 if (alpha != NULL)
1164 {
1165 // src_alpha starts at the first pixel and increases by 1 after each step
1166 // (a step here is the copy of the alpha value of one pixel)
1167 const unsigned char *src_alpha = M_IMGDATA->m_alpha;
1168 // dest_alpha starts just beyond the first line, decreases before each step,
1169 // and after each line is finished, increases by 2 widths (skipping the line
1170 // just copied and the line that will be copied next)
1171 unsigned char *dest_alpha = alpha + width;
1172
1173 for (long jj = 0; jj < height; ++jj)
1174 {
1175 for (long i = 0; i < width; ++i) {
1176 *(--dest_alpha) = *(src_alpha++); // copy one pixel
1177 }
1178 dest_alpha += 2 * width; // advance beyond the end of the next line
1179 }
1180 }
1181 }
1182 else
1183 {
1184 for (long i = 0; i < height; i++)
1185 {
1186 target_data = data + 3*width*(height-1-i);
1187 memcpy( target_data, source_data, (size_t)3*width );
1188 source_data += 3*width;
1189 }
1190
1191 if (alpha != NULL)
1192 {
1193 // src_alpha starts at the first pixel and increases by 1 width after each step
1194 // (a step here is the copy of the alpha channel of an entire line)
1195 const unsigned char *src_alpha = M_IMGDATA->m_alpha;
1196 // dest_alpha starts just beyond the last line (beyond the whole image)
1197 // and decreases by 1 width before each step
1198 unsigned char *dest_alpha = alpha + width * height;
1199
1200 for (long jj = 0; jj < height; ++jj)
1201 {
1202 dest_alpha -= width;
1203 memcpy( dest_alpha, src_alpha, (size_t)width );
1204 src_alpha += width;
1205 }
1206 }
1207 }
1208
1209 return image;
1210}
1211
1212wxImage wxImage::GetSubImage( const wxRect &rect ) const
1213{
1214 wxImage image;
1215
1216 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1217
1218 wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) &&
1219 (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight()),
1220 image, wxT("invalid subimage size") );
1221
1222 const int subwidth = rect.GetWidth();
1223 const int subheight = rect.GetHeight();
1224
1225 image.Create( subwidth, subheight, false );
1226
1227 const unsigned char *src_data = GetData();
1228 const unsigned char *src_alpha = M_IMGDATA->m_alpha;
1229 unsigned char *subdata = image.GetData();
1230 unsigned char *subalpha = NULL;
1231
1232 wxCHECK_MSG( subdata, image, wxT("unable to create image") );
1233
1234 if (src_alpha != NULL) {
1235 image.SetAlpha();
1236 subalpha = image.GetAlpha();
1237 wxCHECK_MSG( subalpha, image, wxT("unable to create alpha channel"));
1238 }
1239
1240 if (M_IMGDATA->m_hasMask)
1241 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
1242
1243 const int width = GetWidth();
1244 const int pixsoff = rect.GetLeft() + width * rect.GetTop();
1245
1246 src_data += 3 * pixsoff;
1247 src_alpha += pixsoff; // won't be used if was NULL, so this is ok
1248
1249 for (long j = 0; j < subheight; ++j)
1250 {
1251 memcpy( subdata, src_data, 3 * subwidth );
1252 subdata += 3 * subwidth;
1253 src_data += 3 * width;
1254 if (subalpha != NULL) {
1255 memcpy( subalpha, src_alpha, subwidth );
1256 subalpha += subwidth;
1257 src_alpha += width;
1258 }
1259 }
1260
1261 return image;
1262}
1263
1264wxImage wxImage::Size( const wxSize& size, const wxPoint& pos,
1265 int r_, int g_, int b_ ) const
1266{
1267 wxImage image;
1268
1269 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1270 wxCHECK_MSG( (size.GetWidth() > 0) && (size.GetHeight() > 0), image, wxT("invalid size") );
1271
1272 int width = GetWidth(), height = GetHeight();
1273 image.Create(size.GetWidth(), size.GetHeight(), false);
1274
1275 unsigned char r = (unsigned char)r_;
1276 unsigned char g = (unsigned char)g_;
1277 unsigned char b = (unsigned char)b_;
1278 if ((r_ == -1) && (g_ == -1) && (b_ == -1))
1279 {
1280 GetOrFindMaskColour( &r, &g, &b );
1281 image.SetMaskColour(r, g, b);
1282 }
1283
1284 image.SetRGB(wxRect(), r, g, b);
1285
1286 // we have two coordinate systems:
1287 // source: starting at 0,0 of source image
1288 // destination starting at 0,0 of destination image
1289 // Documentation says:
1290 // "The image is pasted into a new image [...] at the position pos relative
1291 // to the upper left of the new image." this means the transition rule is:
1292 // "dest coord" = "source coord" + pos;
1293
1294 // calculate the intersection using source coordinates:
1295 wxRect srcRect(0, 0, width, height);
1296 wxRect dstRect(-pos, size);
1297
1298 srcRect.Intersect(dstRect);
1299
1300 if (!srcRect.IsEmpty())
1301 {
1302 // insertion point is needed in destination coordinates.
1303 // NB: it is not always "pos"!
1304 wxPoint ptInsert = srcRect.GetTopLeft() + pos;
1305
1306 if ((srcRect.GetWidth() == width) && (srcRect.GetHeight() == height))
1307 image.Paste(*this, ptInsert.x, ptInsert.y);
1308 else
1309 image.Paste(GetSubImage(srcRect), ptInsert.x, ptInsert.y);
1310 }
1311
1312 return image;
1313}
1314
1315void wxImage::Paste( const wxImage &image, int x, int y )
1316{
1317 wxCHECK_RET( Ok(), wxT("invalid image") );
1318 wxCHECK_RET( image.Ok(), wxT("invalid image") );
1319
1320 AllocExclusive();
1321
1322 int xx = 0;
1323 int yy = 0;
1324 int width = image.GetWidth();
1325 int height = image.GetHeight();
1326
1327 if (x < 0)
1328 {
1329 xx = -x;
1330 width += x;
1331 }
1332 if (y < 0)
1333 {
1334 yy = -y;
1335 height += y;
1336 }
1337
1338 if ((x+xx)+width > M_IMGDATA->m_width)
1339 width = M_IMGDATA->m_width - (x+xx);
1340 if ((y+yy)+height > M_IMGDATA->m_height)
1341 height = M_IMGDATA->m_height - (y+yy);
1342
1343 if (width < 1) return;
1344 if (height < 1) return;
1345
1346 if ((!HasMask() && !image.HasMask()) ||
1347 (HasMask() && !image.HasMask()) ||
1348 ((HasMask() && image.HasMask() &&
1349 (GetMaskRed()==image.GetMaskRed()) &&
1350 (GetMaskGreen()==image.GetMaskGreen()) &&
1351 (GetMaskBlue()==image.GetMaskBlue()))))
1352 {
1353 unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
1354 int source_step = image.GetWidth()*3;
1355
1356 unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
1357 int target_step = M_IMGDATA->m_width*3;
1358 for (int j = 0; j < height; j++)
1359 {
1360 memcpy( target_data, source_data, width*3 );
1361 source_data += source_step;
1362 target_data += target_step;
1363 }
1364 }
1365
1366 // Copy over the alpha channel from the original image
1367 if ( image.HasAlpha() )
1368 {
1369 if ( !HasAlpha() )
1370 InitAlpha();
1371
1372 unsigned char* source_data = image.GetAlpha() + xx + yy*image.GetWidth();
1373 int source_step = image.GetWidth();
1374
1375 unsigned char* target_data = GetAlpha() + (x+xx) + (y+yy)*M_IMGDATA->m_width;
1376 int target_step = M_IMGDATA->m_width;
1377
1378 for (int j = 0; j < height; j++,
1379 source_data += source_step,
1380 target_data += target_step)
1381 {
1382 memcpy( target_data, source_data, width );
1383 }
1384 }
1385
1386 if (!HasMask() && image.HasMask())
1387 {
1388 unsigned char r = image.GetMaskRed();
1389 unsigned char g = image.GetMaskGreen();
1390 unsigned char b = image.GetMaskBlue();
1391
1392 unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
1393 int source_step = image.GetWidth()*3;
1394
1395 unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
1396 int target_step = M_IMGDATA->m_width*3;
1397
1398 for (int j = 0; j < height; j++)
1399 {
1400 for (int i = 0; i < width*3; i+=3)
1401 {
1402 if ((source_data[i] != r) ||
1403 (source_data[i+1] != g) ||
1404 (source_data[i+2] != b))
1405 {
1406 memcpy( target_data+i, source_data+i, 3 );
1407 }
1408 }
1409 source_data += source_step;
1410 target_data += target_step;
1411 }
1412 }
1413}
1414
1415void wxImage::Replace( unsigned char r1, unsigned char g1, unsigned char b1,
1416 unsigned char r2, unsigned char g2, unsigned char b2 )
1417{
1418 wxCHECK_RET( Ok(), wxT("invalid image") );
1419
1420 AllocExclusive();
1421
1422 unsigned char *data = GetData();
1423
1424 const int w = GetWidth();
1425 const int h = GetHeight();
1426
1427 for (int j = 0; j < h; j++)
1428 for (int i = 0; i < w; i++)
1429 {
1430 if ((data[0] == r1) && (data[1] == g1) && (data[2] == b1))
1431 {
1432 data[0] = r2;
1433 data[1] = g2;
1434 data[2] = b2;
1435 }
1436 data += 3;
1437 }
1438}
1439
1440wxImage wxImage::ConvertToGreyscale(void) const
1441{
1442 return ConvertToGreyscale(0.299, 0.587, 0.114);
1443}
1444
1445wxImage wxImage::ConvertToGreyscale(double weight_r, double weight_g, double weight_b) const
1446{
1447 wxImage image;
1448
1449 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1450
1451 image.Create(M_IMGDATA->m_width, M_IMGDATA->m_height, false);
1452
1453 unsigned char *dest = image.GetData();
1454
1455 wxCHECK_MSG( dest, image, wxT("unable to create image") );
1456
1457 unsigned char *src = M_IMGDATA->m_data;
1458 bool hasMask = M_IMGDATA->m_hasMask;
1459 unsigned char maskRed = M_IMGDATA->m_maskRed;
1460 unsigned char maskGreen = M_IMGDATA->m_maskGreen;
1461 unsigned char maskBlue = M_IMGDATA->m_maskBlue;
1462
1463 if ( hasMask )
1464 image.SetMaskColour(maskRed, maskGreen, maskBlue);
1465
1466 const long size = M_IMGDATA->m_width * M_IMGDATA->m_height;
1467 for ( long i = 0; i < size; i++, src += 3, dest += 3 )
1468 {
1469 memcpy(dest, src, 3);
1470 // don't modify the mask
1471 if ( hasMask && src[0] == maskRed && src[1] == maskGreen && src[2] == maskBlue )
1472 {
1473 }
1474 else
1475 {
1476 wxColour::MakeGrey(dest + 0, dest + 1, dest + 2, weight_r, weight_g, weight_b);
1477 }
1478 }
1479
1480 // copy the alpha channel, if any
1481 if (HasAlpha())
1482 {
1483 const size_t alphaSize = GetWidth() * GetHeight();
1484 unsigned char *alpha = (unsigned char*)malloc(alphaSize);
1485 memcpy(alpha, GetAlpha(), alphaSize);
1486 image.InitAlpha();
1487 image.SetAlpha(alpha);
1488 }
1489
1490 return image;
1491}
1492
1493wxImage wxImage::ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const
1494{
1495 wxImage image;
1496
1497 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
1498
1499 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height, false );
1500
1501 unsigned char *data = image.GetData();
1502
1503 wxCHECK_MSG( data, image, wxT("unable to create image") );
1504
1505 if (M_IMGDATA->m_hasMask)
1506 {
1507 if (M_IMGDATA->m_maskRed == r && M_IMGDATA->m_maskGreen == g &&
1508 M_IMGDATA->m_maskBlue == b)
1509 image.SetMaskColour( 255, 255, 255 );
1510 else
1511 image.SetMaskColour( 0, 0, 0 );
1512 }
1513
1514 long size = M_IMGDATA->m_height * M_IMGDATA->m_width;
1515
1516 unsigned char *srcd = M_IMGDATA->m_data;
1517 unsigned char *tard = image.GetData();
1518
1519 for ( long i = 0; i < size; i++, srcd += 3, tard += 3 )
1520 {
1521 bool on = (srcd[0] == r) && (srcd[1] == g) && (srcd[2] == b);
1522 wxColourBase::MakeMono(tard + 0, tard + 1, tard + 2, on);
1523 }
1524
1525 return image;
1526}
1527
1528wxImage wxImage::ConvertToDisabled(unsigned char brightness) const
1529{
1530 wxImage image = *this;
1531
1532 unsigned char mr = image.GetMaskRed();
1533 unsigned char mg = image.GetMaskGreen();
1534 unsigned char mb = image.GetMaskBlue();
1535
1536 int width = image.GetWidth();
1537 int height = image.GetHeight();
1538 bool has_mask = image.HasMask();
1539
1540 for (int y = height-1; y >= 0; --y)
1541 {
1542 for (int x = width-1; x >= 0; --x)
1543 {
1544 unsigned char* data = image.GetData() + (y*(width*3))+(x*3);
1545 unsigned char* r = data;
1546 unsigned char* g = data+1;
1547 unsigned char* b = data+2;
1548
1549 if (has_mask && (*r == mr) && (*g == mg) && (*b == mb))
1550 continue;
1551
1552 wxColour::MakeDisabled(r, g, b, brightness);
1553 }
1554 }
1555 return image;
1556}
1557
1558int wxImage::GetWidth() const
1559{
1560 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1561
1562 return M_IMGDATA->m_width;
1563}
1564
1565int wxImage::GetHeight() const
1566{
1567 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1568
1569 return M_IMGDATA->m_height;
1570}
1571
1572wxBitmapType wxImage::GetType() const
1573{
1574 wxCHECK_MSG( IsOk(), wxBITMAP_TYPE_INVALID, wxT("invalid image") );
1575
1576 return M_IMGDATA->m_type;
1577}
1578
1579void wxImage::SetType(wxBitmapType type)
1580{
1581 wxCHECK_RET( IsOk(), "must create the image before setting its type");
1582
1583 // type can be wxBITMAP_TYPE_INVALID to reset the image type to default
1584 wxASSERT_MSG( type != wxBITMAP_TYPE_MAX, "invalid bitmap type" );
1585
1586 M_IMGDATA->m_type = type;
1587}
1588
1589long wxImage::XYToIndex(int x, int y) const
1590{
1591 if ( Ok() &&
1592 x >= 0 && y >= 0 &&
1593 x < M_IMGDATA->m_width && y < M_IMGDATA->m_height )
1594 {
1595 return y*M_IMGDATA->m_width + x;
1596 }
1597
1598 return -1;
1599}
1600
1601void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
1602{
1603 long pos = XYToIndex(x, y);
1604 wxCHECK_RET( pos != -1, wxT("invalid image coordinates") );
1605
1606 AllocExclusive();
1607
1608 pos *= 3;
1609
1610 M_IMGDATA->m_data[ pos ] = r;
1611 M_IMGDATA->m_data[ pos+1 ] = g;
1612 M_IMGDATA->m_data[ pos+2 ] = b;
1613}
1614
1615void wxImage::SetRGB( const wxRect& rect_, unsigned char r, unsigned char g, unsigned char b )
1616{
1617 wxCHECK_RET( Ok(), wxT("invalid image") );
1618
1619 AllocExclusive();
1620
1621 wxRect rect(rect_);
1622 wxRect imageRect(0, 0, GetWidth(), GetHeight());
1623 if ( rect == wxRect() )
1624 {
1625 rect = imageRect;
1626 }
1627 else
1628 {
1629 wxCHECK_RET( imageRect.Contains(rect.GetTopLeft()) &&
1630 imageRect.Contains(rect.GetBottomRight()),
1631 wxT("invalid bounding rectangle") );
1632 }
1633
1634 int x1 = rect.GetLeft(),
1635 y1 = rect.GetTop(),
1636 x2 = rect.GetRight() + 1,
1637 y2 = rect.GetBottom() + 1;
1638
1639 unsigned char *data wxDUMMY_INITIALIZE(NULL);
1640 int x, y, width = GetWidth();
1641 for (y = y1; y < y2; y++)
1642 {
1643 data = M_IMGDATA->m_data + (y*width + x1)*3;
1644 for (x = x1; x < x2; x++)
1645 {
1646 *data++ = r;
1647 *data++ = g;
1648 *data++ = b;
1649 }
1650 }
1651}
1652
1653unsigned char wxImage::GetRed( int x, int y ) const
1654{
1655 long pos = XYToIndex(x, y);
1656 wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") );
1657
1658 pos *= 3;
1659
1660 return M_IMGDATA->m_data[pos];
1661}
1662
1663unsigned char wxImage::GetGreen( 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+1];
1671}
1672
1673unsigned char wxImage::GetBlue( 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+2];
1681}
1682
1683bool wxImage::IsOk() const
1684{
1685 // image of 0 width or height can't be considered ok - at least because it
1686 // causes crashes in ConvertToBitmap() if we don't catch it in time
1687 wxImageRefData *data = M_IMGDATA;
1688 return data && data->m_ok && data->m_width && data->m_height;
1689}
1690
1691unsigned char *wxImage::GetData() const
1692{
1693 wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") );
1694
1695 return M_IMGDATA->m_data;
1696}
1697
1698void wxImage::SetData( unsigned char *data, bool static_data )
1699{
1700 wxCHECK_RET( Ok(), wxT("invalid image") );
1701
1702 wxImageRefData *newRefData = new wxImageRefData();
1703
1704 newRefData->m_width = M_IMGDATA->m_width;
1705 newRefData->m_height = M_IMGDATA->m_height;
1706 newRefData->m_data = data;
1707 newRefData->m_ok = true;
1708 newRefData->m_maskRed = M_IMGDATA->m_maskRed;
1709 newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
1710 newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
1711 newRefData->m_hasMask = M_IMGDATA->m_hasMask;
1712 newRefData->m_static = static_data;
1713
1714 UnRef();
1715
1716 m_refData = newRefData;
1717}
1718
1719void wxImage::SetData( unsigned char *data, int new_width, int new_height, bool static_data )
1720{
1721 wxImageRefData *newRefData = new wxImageRefData();
1722
1723 if (m_refData)
1724 {
1725 newRefData->m_width = new_width;
1726 newRefData->m_height = new_height;
1727 newRefData->m_data = data;
1728 newRefData->m_ok = true;
1729 newRefData->m_maskRed = M_IMGDATA->m_maskRed;
1730 newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
1731 newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
1732 newRefData->m_hasMask = M_IMGDATA->m_hasMask;
1733 }
1734 else
1735 {
1736 newRefData->m_width = new_width;
1737 newRefData->m_height = new_height;
1738 newRefData->m_data = data;
1739 newRefData->m_ok = true;
1740 }
1741 newRefData->m_static = static_data;
1742
1743 UnRef();
1744
1745 m_refData = newRefData;
1746}
1747
1748// ----------------------------------------------------------------------------
1749// alpha channel support
1750// ----------------------------------------------------------------------------
1751
1752void wxImage::SetAlpha(int x, int y, unsigned char alpha)
1753{
1754 wxCHECK_RET( HasAlpha(), wxT("no alpha channel") );
1755
1756 long pos = XYToIndex(x, y);
1757 wxCHECK_RET( pos != -1, wxT("invalid image coordinates") );
1758
1759 AllocExclusive();
1760
1761 M_IMGDATA->m_alpha[pos] = alpha;
1762}
1763
1764unsigned char wxImage::GetAlpha(int x, int y) const
1765{
1766 wxCHECK_MSG( HasAlpha(), 0, wxT("no alpha channel") );
1767
1768 long pos = XYToIndex(x, y);
1769 wxCHECK_MSG( pos != -1, 0, wxT("invalid image coordinates") );
1770
1771 return M_IMGDATA->m_alpha[pos];
1772}
1773
1774bool
1775wxImage::ConvertColourToAlpha(unsigned char r, unsigned char g, unsigned char b)
1776{
1777 SetAlpha(NULL);
1778
1779 const int w = M_IMGDATA->m_width;
1780 const int h = M_IMGDATA->m_height;
1781
1782 unsigned char *alpha = GetAlpha();
1783 unsigned char *data = GetData();
1784
1785 for ( int y = 0; y < h; y++ )
1786 {
1787 for ( int x = 0; x < w; x++ )
1788 {
1789 *alpha++ = *data;
1790 *data++ = r;
1791 *data++ = g;
1792 *data++ = b;
1793 }
1794 }
1795
1796 return true;
1797}
1798
1799void wxImage::SetAlpha( unsigned char *alpha, bool static_data )
1800{
1801 wxCHECK_RET( Ok(), wxT("invalid image") );
1802
1803 AllocExclusive();
1804
1805 if ( !alpha )
1806 {
1807 alpha = (unsigned char *)malloc(M_IMGDATA->m_width*M_IMGDATA->m_height);
1808 }
1809
1810 if( !M_IMGDATA->m_staticAlpha )
1811 free(M_IMGDATA->m_alpha);
1812
1813 M_IMGDATA->m_alpha = alpha;
1814 M_IMGDATA->m_staticAlpha = static_data;
1815}
1816
1817unsigned char *wxImage::GetAlpha() const
1818{
1819 wxCHECK_MSG( Ok(), (unsigned char *)NULL, wxT("invalid image") );
1820
1821 return M_IMGDATA->m_alpha;
1822}
1823
1824void wxImage::InitAlpha()
1825{
1826 wxCHECK_RET( !HasAlpha(), wxT("image already has an alpha channel") );
1827
1828 // initialize memory for alpha channel
1829 SetAlpha();
1830
1831 unsigned char *alpha = M_IMGDATA->m_alpha;
1832 const size_t lenAlpha = M_IMGDATA->m_width * M_IMGDATA->m_height;
1833
1834 if ( HasMask() )
1835 {
1836 // use the mask to initialize the alpha channel.
1837 const unsigned char * const alphaEnd = alpha + lenAlpha;
1838
1839 const unsigned char mr = M_IMGDATA->m_maskRed;
1840 const unsigned char mg = M_IMGDATA->m_maskGreen;
1841 const unsigned char mb = M_IMGDATA->m_maskBlue;
1842 for ( unsigned char *src = M_IMGDATA->m_data;
1843 alpha < alphaEnd;
1844 src += 3, alpha++ )
1845 {
1846 *alpha = (src[0] == mr && src[1] == mg && src[2] == mb)
1847 ? wxIMAGE_ALPHA_TRANSPARENT
1848 : wxIMAGE_ALPHA_OPAQUE;
1849 }
1850
1851 M_IMGDATA->m_hasMask = false;
1852 }
1853 else // no mask
1854 {
1855 // make the image fully opaque
1856 memset(alpha, wxIMAGE_ALPHA_OPAQUE, lenAlpha);
1857 }
1858}
1859
1860// ----------------------------------------------------------------------------
1861// mask support
1862// ----------------------------------------------------------------------------
1863
1864void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
1865{
1866 wxCHECK_RET( Ok(), wxT("invalid image") );
1867
1868 AllocExclusive();
1869
1870 M_IMGDATA->m_maskRed = r;
1871 M_IMGDATA->m_maskGreen = g;
1872 M_IMGDATA->m_maskBlue = b;
1873 M_IMGDATA->m_hasMask = true;
1874}
1875
1876bool wxImage::GetOrFindMaskColour( unsigned char *r, unsigned char *g, unsigned char *b ) const
1877{
1878 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1879
1880 if (M_IMGDATA->m_hasMask)
1881 {
1882 if (r) *r = M_IMGDATA->m_maskRed;
1883 if (g) *g = M_IMGDATA->m_maskGreen;
1884 if (b) *b = M_IMGDATA->m_maskBlue;
1885 return true;
1886 }
1887 else
1888 {
1889 FindFirstUnusedColour(r, g, b);
1890 return false;
1891 }
1892}
1893
1894unsigned char wxImage::GetMaskRed() const
1895{
1896 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1897
1898 return M_IMGDATA->m_maskRed;
1899}
1900
1901unsigned char wxImage::GetMaskGreen() const
1902{
1903 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1904
1905 return M_IMGDATA->m_maskGreen;
1906}
1907
1908unsigned char wxImage::GetMaskBlue() const
1909{
1910 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1911
1912 return M_IMGDATA->m_maskBlue;
1913}
1914
1915void wxImage::SetMask( bool mask )
1916{
1917 wxCHECK_RET( Ok(), wxT("invalid image") );
1918
1919 AllocExclusive();
1920
1921 M_IMGDATA->m_hasMask = mask;
1922}
1923
1924bool wxImage::HasMask() const
1925{
1926 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1927
1928 return M_IMGDATA->m_hasMask;
1929}
1930
1931bool wxImage::IsTransparent(int x, int y, unsigned char threshold) const
1932{
1933 long pos = XYToIndex(x, y);
1934 wxCHECK_MSG( pos != -1, false, wxT("invalid image coordinates") );
1935
1936 // check mask
1937 if ( M_IMGDATA->m_hasMask )
1938 {
1939 const unsigned char *p = M_IMGDATA->m_data + 3*pos;
1940 if ( p[0] == M_IMGDATA->m_maskRed &&
1941 p[1] == M_IMGDATA->m_maskGreen &&
1942 p[2] == M_IMGDATA->m_maskBlue )
1943 {
1944 return true;
1945 }
1946 }
1947
1948 // then check alpha
1949 if ( M_IMGDATA->m_alpha )
1950 {
1951 if ( M_IMGDATA->m_alpha[pos] < threshold )
1952 {
1953 // transparent enough
1954 return true;
1955 }
1956 }
1957
1958 // not transparent
1959 return false;
1960}
1961
1962bool wxImage::SetMaskFromImage(const wxImage& mask,
1963 unsigned char mr, unsigned char mg, unsigned char mb)
1964{
1965 // check that the images are the same size
1966 if ( (M_IMGDATA->m_height != mask.GetHeight() ) || (M_IMGDATA->m_width != mask.GetWidth () ) )
1967 {
1968 wxLogError( _("Image and mask have different sizes.") );
1969 return false;
1970 }
1971
1972 // find unused colour
1973 unsigned char r,g,b ;
1974 if (!FindFirstUnusedColour(&r, &g, &b))
1975 {
1976 wxLogError( _("No unused colour in image being masked.") );
1977 return false ;
1978 }
1979
1980 AllocExclusive();
1981
1982 unsigned char *imgdata = GetData();
1983 unsigned char *maskdata = mask.GetData();
1984
1985 const int w = GetWidth();
1986 const int h = GetHeight();
1987
1988 for (int j = 0; j < h; j++)
1989 {
1990 for (int i = 0; i < w; i++)
1991 {
1992 if ((maskdata[0] == mr) && (maskdata[1] == mg) && (maskdata[2] == mb))
1993 {
1994 imgdata[0] = r;
1995 imgdata[1] = g;
1996 imgdata[2] = b;
1997 }
1998 imgdata += 3;
1999 maskdata += 3;
2000 }
2001 }
2002
2003 SetMaskColour(r, g, b);
2004 SetMask(true);
2005
2006 return true;
2007}
2008
2009bool wxImage::ConvertAlphaToMask(unsigned char threshold)
2010{
2011 if ( !HasAlpha() )
2012 return true;
2013
2014 unsigned char mr, mg, mb;
2015 if ( !FindFirstUnusedColour(&mr, &mg, &mb) )
2016 {
2017 wxLogError( _("No unused colour in image being masked.") );
2018 return false;
2019 }
2020
2021 ConvertAlphaToMask(mr, mg, mb, threshold);
2022 return true;
2023}
2024
2025void wxImage::ConvertAlphaToMask(unsigned char mr,
2026 unsigned char mg,
2027 unsigned char mb,
2028 unsigned char threshold)
2029{
2030 if ( !HasAlpha() )
2031 return;
2032
2033 AllocExclusive();
2034
2035 SetMask(true);
2036 SetMaskColour(mr, mg, mb);
2037
2038 unsigned char *imgdata = GetData();
2039 unsigned char *alphadata = GetAlpha();
2040
2041 int w = GetWidth();
2042 int h = GetHeight();
2043
2044 for (int y = 0; y < h; y++)
2045 {
2046 for (int x = 0; x < w; x++, imgdata += 3, alphadata++)
2047 {
2048 if (*alphadata < threshold)
2049 {
2050 imgdata[0] = mr;
2051 imgdata[1] = mg;
2052 imgdata[2] = mb;
2053 }
2054 }
2055 }
2056
2057 if ( !M_IMGDATA->m_staticAlpha )
2058 free(M_IMGDATA->m_alpha);
2059
2060 M_IMGDATA->m_alpha = NULL;
2061 M_IMGDATA->m_staticAlpha = false;
2062}
2063
2064// ----------------------------------------------------------------------------
2065// Palette functions
2066// ----------------------------------------------------------------------------
2067
2068#if wxUSE_PALETTE
2069
2070bool wxImage::HasPalette() const
2071{
2072 if (!Ok())
2073 return false;
2074
2075 return M_IMGDATA->m_palette.Ok();
2076}
2077
2078const wxPalette& wxImage::GetPalette() const
2079{
2080 wxCHECK_MSG( Ok(), wxNullPalette, wxT("invalid image") );
2081
2082 return M_IMGDATA->m_palette;
2083}
2084
2085void wxImage::SetPalette(const wxPalette& palette)
2086{
2087 wxCHECK_RET( Ok(), wxT("invalid image") );
2088
2089 AllocExclusive();
2090
2091 M_IMGDATA->m_palette = palette;
2092}
2093
2094#endif // wxUSE_PALETTE
2095
2096// ----------------------------------------------------------------------------
2097// Option functions (arbitrary name/value mapping)
2098// ----------------------------------------------------------------------------
2099
2100void wxImage::SetOption(const wxString& name, const wxString& value)
2101{
2102 AllocExclusive();
2103
2104 int idx = M_IMGDATA->m_optionNames.Index(name, false);
2105 if ( idx == wxNOT_FOUND )
2106 {
2107 M_IMGDATA->m_optionNames.Add(name);
2108 M_IMGDATA->m_optionValues.Add(value);
2109 }
2110 else
2111 {
2112 M_IMGDATA->m_optionNames[idx] = name;
2113 M_IMGDATA->m_optionValues[idx] = value;
2114 }
2115}
2116
2117void wxImage::SetOption(const wxString& name, int value)
2118{
2119 wxString valStr;
2120 valStr.Printf(wxT("%d"), value);
2121 SetOption(name, valStr);
2122}
2123
2124wxString wxImage::GetOption(const wxString& name) const
2125{
2126 if ( !M_IMGDATA )
2127 return wxEmptyString;
2128
2129 int idx = M_IMGDATA->m_optionNames.Index(name, false);
2130 if ( idx == wxNOT_FOUND )
2131 return wxEmptyString;
2132 else
2133 return M_IMGDATA->m_optionValues[idx];
2134}
2135
2136int wxImage::GetOptionInt(const wxString& name) const
2137{
2138 return wxAtoi(GetOption(name));
2139}
2140
2141bool wxImage::HasOption(const wxString& name) const
2142{
2143 return M_IMGDATA ? M_IMGDATA->m_optionNames.Index(name, false) != wxNOT_FOUND
2144 : false;
2145}
2146
2147// ----------------------------------------------------------------------------
2148// image I/O
2149// ----------------------------------------------------------------------------
2150
2151bool wxImage::LoadFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
2152 wxBitmapType WXUNUSED_UNLESS_STREAMS(type),
2153 int WXUNUSED_UNLESS_STREAMS(index) )
2154{
2155#if HAS_FILE_STREAMS
2156 if (wxFileExists(filename))
2157 {
2158 wxImageFileInputStream stream(filename);
2159 wxBufferedInputStream bstream( stream );
2160 return LoadFile(bstream, type, index);
2161 }
2162 else
2163 {
2164 wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
2165
2166 return false;
2167 }
2168#else // !HAS_FILE_STREAMS
2169 return false;
2170#endif // HAS_FILE_STREAMS
2171}
2172
2173bool wxImage::LoadFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
2174 const wxString& WXUNUSED_UNLESS_STREAMS(mimetype),
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, mimetype, 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
2196bool wxImage::SaveFile( const wxString& filename ) const
2197{
2198 wxString ext = filename.AfterLast('.').Lower();
2199
2200 wxImageHandler *handler = FindHandler(ext, wxBITMAP_TYPE_ANY);
2201 if ( !handler)
2202 {
2203 wxLogError(_("Can't save image to file '%s': unknown extension."),
2204 filename);
2205 return false;
2206 }
2207
2208 return SaveFile(filename, handler->GetType());
2209}
2210
2211bool wxImage::SaveFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
2212 wxBitmapType WXUNUSED_UNLESS_STREAMS(type) ) const
2213{
2214#if HAS_FILE_STREAMS
2215 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2216
2217 ((wxImage*)this)->SetOption(wxIMAGE_OPTION_FILENAME, filename);
2218
2219 wxImageFileOutputStream stream(filename);
2220
2221 if ( stream.IsOk() )
2222 {
2223 wxBufferedOutputStream bstream( stream );
2224 return SaveFile(bstream, type);
2225 }
2226#endif // HAS_FILE_STREAMS
2227
2228 return false;
2229}
2230
2231bool wxImage::SaveFile( const wxString& WXUNUSED_UNLESS_STREAMS(filename),
2232 const wxString& WXUNUSED_UNLESS_STREAMS(mimetype) ) const
2233{
2234#if HAS_FILE_STREAMS
2235 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2236
2237 ((wxImage*)this)->SetOption(wxIMAGE_OPTION_FILENAME, filename);
2238
2239 wxImageFileOutputStream stream(filename);
2240
2241 if ( stream.IsOk() )
2242 {
2243 wxBufferedOutputStream bstream( stream );
2244 return SaveFile(bstream, mimetype);
2245 }
2246#endif // HAS_FILE_STREAMS
2247
2248 return false;
2249}
2250
2251bool wxImage::CanRead( const wxString& WXUNUSED_UNLESS_STREAMS(name) )
2252{
2253#if HAS_FILE_STREAMS
2254 wxImageFileInputStream stream(name);
2255 return CanRead(stream);
2256#else
2257 return false;
2258#endif
2259}
2260
2261int wxImage::GetImageCount( const wxString& WXUNUSED_UNLESS_STREAMS(name),
2262 wxBitmapType WXUNUSED_UNLESS_STREAMS(type) )
2263{
2264#if HAS_FILE_STREAMS
2265 wxImageFileInputStream stream(name);
2266 if (stream.Ok())
2267 return GetImageCount(stream, type);
2268#endif
2269
2270 return 0;
2271}
2272
2273#if wxUSE_STREAMS
2274
2275bool wxImage::CanRead( wxInputStream &stream )
2276{
2277 const wxList& list = GetHandlers();
2278
2279 for ( wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext() )
2280 {
2281 wxImageHandler *handler=(wxImageHandler*)node->GetData();
2282 if (handler->CanRead( stream ))
2283 return true;
2284 }
2285
2286 return false;
2287}
2288
2289int wxImage::GetImageCount( wxInputStream &stream, wxBitmapType type )
2290{
2291 wxImageHandler *handler;
2292
2293 if ( type == wxBITMAP_TYPE_ANY )
2294 {
2295 const wxList& list = GetHandlers();
2296
2297 for ( wxList::compatibility_iterator node = list.GetFirst();
2298 node;
2299 node = node->GetNext() )
2300 {
2301 handler = (wxImageHandler*)node->GetData();
2302 if ( handler->CanRead(stream) )
2303 {
2304 const int count = handler->GetImageCount(stream);
2305 if ( count >= 0 )
2306 return count;
2307 }
2308
2309 }
2310
2311 wxLogWarning(_("No handler found for image type."));
2312 return 0;
2313 }
2314
2315 handler = FindHandler(type);
2316
2317 if ( !handler )
2318 {
2319 wxLogWarning(_("No image handler for type %ld defined."), type);
2320 return false;
2321 }
2322
2323 if ( handler->CanRead(stream) )
2324 {
2325 return handler->GetImageCount(stream);
2326 }
2327 else
2328 {
2329 wxLogError(_("Image file is not of type %ld."), type);
2330 return 0;
2331 }
2332}
2333
2334bool wxImage::DoLoad(wxImageHandler& handler, wxInputStream& stream, int index)
2335{
2336 // save the options values which can be clobbered by the handler (e.g. many
2337 // of them call Destroy() before trying to load the file)
2338 const unsigned maxWidth = GetOptionInt(wxIMAGE_OPTION_MAX_WIDTH),
2339 maxHeight = GetOptionInt(wxIMAGE_OPTION_MAX_HEIGHT);
2340
2341 if ( !handler.LoadFile(this, stream, true/*verbose*/, index) )
2342 return false;
2343
2344 M_IMGDATA->m_type = handler.GetType();
2345
2346 // rescale the image to the specified size if needed
2347 if ( maxWidth || maxHeight )
2348 {
2349 const unsigned widthOrig = GetWidth(),
2350 heightOrig = GetHeight();
2351
2352 // this uses the same (trivial) algorithm as the JPEG handler
2353 unsigned width = widthOrig,
2354 height = heightOrig;
2355 while ( (maxWidth && width > maxWidth) ||
2356 (maxHeight && height > maxHeight) )
2357 {
2358 width /= 2;
2359 height /= 2;
2360 }
2361
2362 if ( width != widthOrig || height != heightOrig )
2363 Rescale(width, height, wxIMAGE_QUALITY_HIGH);
2364 }
2365
2366 return true;
2367}
2368
2369bool wxImage::LoadFile( wxInputStream& stream, wxBitmapType type, int index )
2370{
2371 AllocExclusive();
2372
2373 wxImageHandler *handler;
2374
2375 if ( type == wxBITMAP_TYPE_ANY )
2376 {
2377 const wxList& list = GetHandlers();
2378 for ( wxList::compatibility_iterator node = list.GetFirst();
2379 node;
2380 node = node->GetNext() )
2381 {
2382 handler = (wxImageHandler*)node->GetData();
2383 if ( handler->CanRead(stream) && DoLoad(*handler, stream, index) )
2384 return true;
2385 }
2386
2387 wxLogWarning( _("No handler found for image type.") );
2388
2389 return false;
2390 }
2391 //else: have specific type
2392
2393 handler = FindHandler(type);
2394 if ( !handler )
2395 {
2396 wxLogWarning( _("No image handler for type %ld defined."), type );
2397 return false;
2398 }
2399
2400 if ( stream.IsSeekable() && !handler->CanRead(stream) )
2401 {
2402 wxLogError(_("Image file is not of type %ld."), type);
2403 return false;
2404 }
2405
2406 return DoLoad(*handler, stream, index);
2407}
2408
2409bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype, int index )
2410{
2411 UnRef();
2412
2413 m_refData = new wxImageRefData;
2414
2415 wxImageHandler *handler = FindHandlerMime(mimetype);
2416
2417 if ( !handler )
2418 {
2419 wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
2420 return false;
2421 }
2422
2423 if ( stream.IsSeekable() && !handler->CanRead(stream) )
2424 {
2425 wxLogError(_("Image file is not of type %s."), mimetype);
2426 return false;
2427 }
2428
2429 return DoLoad(*handler, stream, index);
2430}
2431
2432bool wxImage::DoSave(wxImageHandler& handler, wxOutputStream& stream) const
2433{
2434 wxImage * const self = const_cast<wxImage *>(this);
2435 if ( !handler.SaveFile(self, stream) )
2436 return false;
2437
2438 M_IMGDATA->m_type = handler.GetType();
2439 return true;
2440}
2441
2442bool wxImage::SaveFile( wxOutputStream& stream, wxBitmapType type ) const
2443{
2444 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2445
2446 wxImageHandler *handler = FindHandler(type);
2447 if ( !handler )
2448 {
2449 wxLogWarning( _("No image handler for type %d defined."), type );
2450 return false;
2451 }
2452
2453 return DoSave(*handler, stream);
2454}
2455
2456bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype ) const
2457{
2458 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2459
2460 wxImageHandler *handler = FindHandlerMime(mimetype);
2461 if ( !handler )
2462 {
2463 wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
2464 }
2465
2466 return DoSave(*handler, stream);
2467}
2468
2469#endif // wxUSE_STREAMS
2470
2471// ----------------------------------------------------------------------------
2472// image I/O handlers
2473// ----------------------------------------------------------------------------
2474
2475void wxImage::AddHandler( wxImageHandler *handler )
2476{
2477 // Check for an existing handler of the type being added.
2478 if (FindHandler( handler->GetType() ) == 0)
2479 {
2480 sm_handlers.Append( handler );
2481 }
2482 else
2483 {
2484 // This is not documented behaviour, merely the simplest 'fix'
2485 // for preventing duplicate additions. If someone ever has
2486 // a good reason to add and remove duplicate handlers (and they
2487 // may) we should probably refcount the duplicates.
2488 // also an issue in InsertHandler below.
2489
2490 wxLogDebug( wxT("Adding duplicate image handler for '%s'"),
2491 handler->GetName().c_str() );
2492 delete handler;
2493 }
2494}
2495
2496void wxImage::InsertHandler( wxImageHandler *handler )
2497{
2498 // Check for an existing handler of the type being added.
2499 if (FindHandler( handler->GetType() ) == 0)
2500 {
2501 sm_handlers.Insert( handler );
2502 }
2503 else
2504 {
2505 // see AddHandler for additional comments.
2506 wxLogDebug( wxT("Inserting duplicate image handler for '%s'"),
2507 handler->GetName().c_str() );
2508 delete handler;
2509 }
2510}
2511
2512bool wxImage::RemoveHandler( const wxString& name )
2513{
2514 wxImageHandler *handler = FindHandler(name);
2515 if (handler)
2516 {
2517 sm_handlers.DeleteObject(handler);
2518 delete handler;
2519 return true;
2520 }
2521 else
2522 return false;
2523}
2524
2525wxImageHandler *wxImage::FindHandler( const wxString& name )
2526{
2527 wxList::compatibility_iterator node = sm_handlers.GetFirst();
2528 while (node)
2529 {
2530 wxImageHandler *handler = (wxImageHandler*)node->GetData();
2531 if (handler->GetName().Cmp(name) == 0) return handler;
2532
2533 node = node->GetNext();
2534 }
2535 return NULL;
2536}
2537
2538wxImageHandler *wxImage::FindHandler( const wxString& extension, wxBitmapType bitmapType )
2539{
2540 wxList::compatibility_iterator node = sm_handlers.GetFirst();
2541 while (node)
2542 {
2543 wxImageHandler *handler = (wxImageHandler*)node->GetData();
2544 if ((bitmapType == wxBITMAP_TYPE_ANY) || (handler->GetType() == bitmapType))
2545 {
2546 if (handler->GetExtension() == extension)
2547 return handler;
2548 if (handler->GetAltExtensions().Index(extension, false) != wxNOT_FOUND)
2549 return handler;
2550 }
2551 node = node->GetNext();
2552 }
2553 return NULL;
2554}
2555
2556wxImageHandler *wxImage::FindHandler(wxBitmapType bitmapType )
2557{
2558 wxList::compatibility_iterator node = sm_handlers.GetFirst();
2559 while (node)
2560 {
2561 wxImageHandler *handler = (wxImageHandler *)node->GetData();
2562 if (handler->GetType() == bitmapType) return handler;
2563 node = node->GetNext();
2564 }
2565 return NULL;
2566}
2567
2568wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype )
2569{
2570 wxList::compatibility_iterator node = sm_handlers.GetFirst();
2571 while (node)
2572 {
2573 wxImageHandler *handler = (wxImageHandler *)node->GetData();
2574 if (handler->GetMimeType().IsSameAs(mimetype, false)) return handler;
2575 node = node->GetNext();
2576 }
2577 return NULL;
2578}
2579
2580void wxImage::InitStandardHandlers()
2581{
2582#if wxUSE_STREAMS
2583 AddHandler(new wxBMPHandler);
2584#endif // wxUSE_STREAMS
2585}
2586
2587void wxImage::CleanUpHandlers()
2588{
2589 wxList::compatibility_iterator node = sm_handlers.GetFirst();
2590 while (node)
2591 {
2592 wxImageHandler *handler = (wxImageHandler *)node->GetData();
2593 wxList::compatibility_iterator next = node->GetNext();
2594 delete handler;
2595 node = next;
2596 }
2597
2598 sm_handlers.Clear();
2599}
2600
2601wxString wxImage::GetImageExtWildcard()
2602{
2603 wxString fmts;
2604
2605 wxList& Handlers = wxImage::GetHandlers();
2606 wxList::compatibility_iterator Node = Handlers.GetFirst();
2607 while ( Node )
2608 {
2609 wxImageHandler* Handler = (wxImageHandler*)Node->GetData();
2610 fmts += wxT("*.") + Handler->GetExtension();
2611 for (size_t i = 0; i < Handler->GetAltExtensions().size(); i++)
2612 fmts += wxT(";*.") + Handler->GetAltExtensions()[i];
2613 Node = Node->GetNext();
2614 if ( Node ) fmts += wxT(";");
2615 }
2616
2617 return wxT("(") + fmts + wxT(")|") + fmts;
2618}
2619
2620wxImage::HSVValue wxImage::RGBtoHSV(const RGBValue& rgb)
2621{
2622 const double red = rgb.red / 255.0,
2623 green = rgb.green / 255.0,
2624 blue = rgb.blue / 255.0;
2625
2626 // find the min and max intensity (and remember which one was it for the
2627 // latter)
2628 double minimumRGB = red;
2629 if ( green < minimumRGB )
2630 minimumRGB = green;
2631 if ( blue < minimumRGB )
2632 minimumRGB = blue;
2633
2634 enum { RED, GREEN, BLUE } chMax = RED;
2635 double maximumRGB = red;
2636 if ( green > maximumRGB )
2637 {
2638 chMax = GREEN;
2639 maximumRGB = green;
2640 }
2641 if ( blue > maximumRGB )
2642 {
2643 chMax = BLUE;
2644 maximumRGB = blue;
2645 }
2646
2647 const double value = maximumRGB;
2648
2649 double hue = 0.0, saturation;
2650 const double deltaRGB = maximumRGB - minimumRGB;
2651 if ( wxIsNullDouble(deltaRGB) )
2652 {
2653 // Gray has no color
2654 hue = 0.0;
2655 saturation = 0.0;
2656 }
2657 else
2658 {
2659 switch ( chMax )
2660 {
2661 case RED:
2662 hue = (green - blue) / deltaRGB;
2663 break;
2664
2665 case GREEN:
2666 hue = 2.0 + (blue - red) / deltaRGB;
2667 break;
2668
2669 case BLUE:
2670 hue = 4.0 + (red - green) / deltaRGB;
2671 break;
2672
2673 default:
2674 wxFAIL_MSG(wxT("hue not specified"));
2675 break;
2676 }
2677
2678 hue /= 6.0;
2679
2680 if ( hue < 0.0 )
2681 hue += 1.0;
2682
2683 saturation = deltaRGB / maximumRGB;
2684 }
2685
2686 return HSVValue(hue, saturation, value);
2687}
2688
2689wxImage::RGBValue wxImage::HSVtoRGB(const HSVValue& hsv)
2690{
2691 double red, green, blue;
2692
2693 if ( wxIsNullDouble(hsv.saturation) )
2694 {
2695 // Grey
2696 red = hsv.value;
2697 green = hsv.value;
2698 blue = hsv.value;
2699 }
2700 else // not grey
2701 {
2702 double hue = hsv.hue * 6.0; // sector 0 to 5
2703 int i = (int)floor(hue);
2704 double f = hue - i; // fractional part of h
2705 double p = hsv.value * (1.0 - hsv.saturation);
2706
2707 switch (i)
2708 {
2709 case 0:
2710 red = hsv.value;
2711 green = hsv.value * (1.0 - hsv.saturation * (1.0 - f));
2712 blue = p;
2713 break;
2714
2715 case 1:
2716 red = hsv.value * (1.0 - hsv.saturation * f);
2717 green = hsv.value;
2718 blue = p;
2719 break;
2720
2721 case 2:
2722 red = p;
2723 green = hsv.value;
2724 blue = hsv.value * (1.0 - hsv.saturation * (1.0 - f));
2725 break;
2726
2727 case 3:
2728 red = p;
2729 green = hsv.value * (1.0 - hsv.saturation * f);
2730 blue = hsv.value;
2731 break;
2732
2733 case 4:
2734 red = hsv.value * (1.0 - hsv.saturation * (1.0 - f));
2735 green = p;
2736 blue = hsv.value;
2737 break;
2738
2739 default: // case 5:
2740 red = hsv.value;
2741 green = p;
2742 blue = hsv.value * (1.0 - hsv.saturation * f);
2743 break;
2744 }
2745 }
2746
2747 return RGBValue((unsigned char)(red * 255.0),
2748 (unsigned char)(green * 255.0),
2749 (unsigned char)(blue * 255.0));
2750}
2751
2752/*
2753 * Rotates the hue of each pixel of the image. angle is a double in the range
2754 * -1.0..1.0 where -1.0 is -360 degrees and 1.0 is 360 degrees
2755 */
2756void wxImage::RotateHue(double angle)
2757{
2758 AllocExclusive();
2759
2760 unsigned char *srcBytePtr;
2761 unsigned char *dstBytePtr;
2762 unsigned long count;
2763 wxImage::HSVValue hsv;
2764 wxImage::RGBValue rgb;
2765
2766 wxASSERT (angle >= -1.0 && angle <= 1.0);
2767 count = M_IMGDATA->m_width * M_IMGDATA->m_height;
2768 if ( count > 0 && !wxIsNullDouble(angle) )
2769 {
2770 srcBytePtr = M_IMGDATA->m_data;
2771 dstBytePtr = srcBytePtr;
2772 do
2773 {
2774 rgb.red = *srcBytePtr++;
2775 rgb.green = *srcBytePtr++;
2776 rgb.blue = *srcBytePtr++;
2777 hsv = RGBtoHSV(rgb);
2778
2779 hsv.hue = hsv.hue + angle;
2780 if (hsv.hue > 1.0)
2781 hsv.hue = hsv.hue - 1.0;
2782 else if (hsv.hue < 0.0)
2783 hsv.hue = hsv.hue + 1.0;
2784
2785 rgb = HSVtoRGB(hsv);
2786 *dstBytePtr++ = rgb.red;
2787 *dstBytePtr++ = rgb.green;
2788 *dstBytePtr++ = rgb.blue;
2789 } while (--count != 0);
2790 }
2791}
2792
2793//-----------------------------------------------------------------------------
2794// wxImageHandler
2795//-----------------------------------------------------------------------------
2796
2797IMPLEMENT_ABSTRACT_CLASS(wxImageHandler,wxObject)
2798
2799#if wxUSE_STREAMS
2800int wxImageHandler::GetImageCount( wxInputStream& stream )
2801{
2802 // NOTE: this code is the same of wxAnimationDecoder::CanRead and
2803 // wxImageHandler::CallDoCanRead
2804
2805 if ( !stream.IsSeekable() )
2806 return false; // can't test unseekable stream
2807
2808 wxFileOffset posOld = stream.TellI();
2809 int n = DoGetImageCount(stream);
2810
2811 // restore the old position to be able to test other formats and so on
2812 if ( stream.SeekI(posOld) == wxInvalidOffset )
2813 {
2814 wxLogDebug(wxT("Failed to rewind the stream in wxImageHandler!"));
2815
2816 // reading would fail anyhow as we're not at the right position
2817 return false;
2818 }
2819
2820 return n;
2821}
2822
2823bool wxImageHandler::CanRead( const wxString& name )
2824{
2825 if (wxFileExists(name))
2826 {
2827 wxImageFileInputStream stream(name);
2828 return CanRead(stream);
2829 }
2830
2831 wxLogError( _("Can't check image format of file '%s': file does not exist."), name.c_str() );
2832
2833 return false;
2834}
2835
2836bool wxImageHandler::CallDoCanRead(wxInputStream& stream)
2837{
2838 // NOTE: this code is the same of wxAnimationDecoder::CanRead and
2839 // wxImageHandler::GetImageCount
2840
2841 if ( !stream.IsSeekable() )
2842 return false; // can't test unseekable stream
2843
2844 wxFileOffset posOld = stream.TellI();
2845 bool ok = DoCanRead(stream);
2846
2847 // restore the old position to be able to test other formats and so on
2848 if ( stream.SeekI(posOld) == wxInvalidOffset )
2849 {
2850 wxLogDebug(wxT("Failed to rewind the stream in wxImageHandler!"));
2851
2852 // reading would fail anyhow as we're not at the right position
2853 return false;
2854 }
2855
2856 return ok;
2857}
2858
2859#endif // wxUSE_STREAMS
2860
2861/* static */
2862wxImageResolution
2863wxImageHandler::GetResolutionFromOptions(const wxImage& image, int *x, int *y)
2864{
2865 wxCHECK_MSG( x && y, wxIMAGE_RESOLUTION_NONE, wxT("NULL pointer") );
2866
2867 if ( image.HasOption(wxIMAGE_OPTION_RESOLUTIONX) &&
2868 image.HasOption(wxIMAGE_OPTION_RESOLUTIONY) )
2869 {
2870 *x = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONX);
2871 *y = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONY);
2872 }
2873 else if ( image.HasOption(wxIMAGE_OPTION_RESOLUTION) )
2874 {
2875 *x =
2876 *y = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTION);
2877 }
2878 else // no resolution options specified
2879 {
2880 *x =
2881 *y = 0;
2882
2883 return wxIMAGE_RESOLUTION_NONE;
2884 }
2885
2886 // get the resolution unit too
2887 int resUnit = image.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONUNIT);
2888 if ( !resUnit )
2889 {
2890 // this is the default
2891 resUnit = wxIMAGE_RESOLUTION_INCHES;
2892 }
2893
2894 return (wxImageResolution)resUnit;
2895}
2896
2897// ----------------------------------------------------------------------------
2898// image histogram stuff
2899// ----------------------------------------------------------------------------
2900
2901bool
2902wxImageHistogram::FindFirstUnusedColour(unsigned char *r,
2903 unsigned char *g,
2904 unsigned char *b,
2905 unsigned char r2,
2906 unsigned char b2,
2907 unsigned char g2) const
2908{
2909 unsigned long key = MakeKey(r2, g2, b2);
2910
2911 while ( find(key) != end() )
2912 {
2913 // color already used
2914 r2++;
2915 if ( r2 >= 255 )
2916 {
2917 r2 = 0;
2918 g2++;
2919 if ( g2 >= 255 )
2920 {
2921 g2 = 0;
2922 b2++;
2923 if ( b2 >= 255 )
2924 {
2925 wxLogError(_("No unused colour in image.") );
2926 return false;
2927 }
2928 }
2929 }
2930
2931 key = MakeKey(r2, g2, b2);
2932 }
2933
2934 if ( r )
2935 *r = r2;
2936 if ( g )
2937 *g = g2;
2938 if ( b )
2939 *b = b2;
2940
2941 return true;
2942}
2943
2944bool
2945wxImage::FindFirstUnusedColour(unsigned char *r,
2946 unsigned char *g,
2947 unsigned char *b,
2948 unsigned char r2,
2949 unsigned char b2,
2950 unsigned char g2) const
2951{
2952 wxImageHistogram histogram;
2953
2954 ComputeHistogram(histogram);
2955
2956 return histogram.FindFirstUnusedColour(r, g, b, r2, g2, b2);
2957}
2958
2959
2960
2961// GRG, Dic/99
2962// Counts and returns the number of different colours. Optionally stops
2963// when it exceeds 'stopafter' different colours. This is useful, for
2964// example, to see if the image can be saved as 8-bit (256 colour or
2965// less, in this case it would be invoked as CountColours(256)). Default
2966// value for stopafter is -1 (don't care).
2967//
2968unsigned long wxImage::CountColours( unsigned long stopafter ) const
2969{
2970 wxHashTable h;
2971 wxObject dummy;
2972 unsigned char r, g, b;
2973 unsigned char *p;
2974 unsigned long size, nentries, key;
2975
2976 p = GetData();
2977 size = GetWidth() * GetHeight();
2978 nentries = 0;
2979
2980 for (unsigned long j = 0; (j < size) && (nentries <= stopafter) ; j++)
2981 {
2982 r = *(p++);
2983 g = *(p++);
2984 b = *(p++);
2985 key = wxImageHistogram::MakeKey(r, g, b);
2986
2987 if (h.Get(key) == NULL)
2988 {
2989 h.Put(key, &dummy);
2990 nentries++;
2991 }
2992 }
2993
2994 return nentries;
2995}
2996
2997
2998unsigned long wxImage::ComputeHistogram( wxImageHistogram &h ) const
2999{
3000 unsigned char *p = GetData();
3001 unsigned long nentries = 0;
3002
3003 h.clear();
3004
3005 const unsigned long size = GetWidth() * GetHeight();
3006
3007 unsigned char r, g, b;
3008 for ( unsigned long n = 0; n < size; n++ )
3009 {
3010 r = *p++;
3011 g = *p++;
3012 b = *p++;
3013
3014 wxImageHistogramEntry& entry = h[wxImageHistogram::MakeKey(r, g, b)];
3015
3016 if ( entry.value++ == 0 )
3017 entry.index = nentries++;
3018 }
3019
3020 return nentries;
3021}
3022
3023/*
3024 * Rotation code by Carlos Moreno
3025 */
3026
3027static const double wxROTATE_EPSILON = 1e-10;
3028
3029// Auxiliary function to rotate a point (x,y) with respect to point p0
3030// make it inline and use a straight return to facilitate optimization
3031// also, the function receives the sine and cosine of the angle to avoid
3032// repeating the time-consuming calls to these functions -- sin/cos can
3033// be computed and stored in the calling function.
3034
3035static inline wxRealPoint
3036wxRotatePoint(const wxRealPoint& p, double cos_angle, double sin_angle,
3037 const wxRealPoint& p0)
3038{
3039 return wxRealPoint(p0.x + (p.x - p0.x) * cos_angle - (p.y - p0.y) * sin_angle,
3040 p0.y + (p.y - p0.y) * cos_angle + (p.x - p0.x) * sin_angle);
3041}
3042
3043static inline wxRealPoint
3044wxRotatePoint(double x, double y, double cos_angle, double sin_angle,
3045 const wxRealPoint & p0)
3046{
3047 return wxRotatePoint (wxRealPoint(x,y), cos_angle, sin_angle, p0);
3048}
3049
3050wxImage wxImage::Rotate(double angle,
3051 const wxPoint& centre_of_rotation,
3052 bool interpolating,
3053 wxPoint *offset_after_rotation) const
3054{
3055 // screen coordinates are a mirror image of "real" coordinates
3056 angle = -angle;
3057
3058 const bool has_alpha = HasAlpha();
3059
3060 const int w = GetWidth();
3061 const int h = GetHeight();
3062
3063 int i;
3064
3065 // Create pointer-based array to accelerate access to wxImage's data
3066 unsigned char ** data = new unsigned char * [h];
3067 data[0] = GetData();
3068 for (i = 1; i < h; i++)
3069 data[i] = data[i - 1] + (3 * w);
3070
3071 // Same for alpha channel
3072 unsigned char ** alpha = NULL;
3073 if (has_alpha)
3074 {
3075 alpha = new unsigned char * [h];
3076 alpha[0] = GetAlpha();
3077 for (i = 1; i < h; i++)
3078 alpha[i] = alpha[i - 1] + w;
3079 }
3080
3081 // precompute coefficients for rotation formula
3082 const double cos_angle = cos(angle);
3083 const double sin_angle = sin(angle);
3084
3085 // Create new Image to store the result
3086 // First, find rectangle that covers the rotated image; to do that,
3087 // rotate the four corners
3088
3089 const wxRealPoint p0(centre_of_rotation.x, centre_of_rotation.y);
3090
3091 wxRealPoint p1 = wxRotatePoint (0, 0, cos_angle, sin_angle, p0);
3092 wxRealPoint p2 = wxRotatePoint (0, h, cos_angle, sin_angle, p0);
3093 wxRealPoint p3 = wxRotatePoint (w, 0, cos_angle, sin_angle, p0);
3094 wxRealPoint p4 = wxRotatePoint (w, h, cos_angle, sin_angle, p0);
3095
3096 int x1a = (int) floor (wxMin (wxMin(p1.x, p2.x), wxMin(p3.x, p4.x)));
3097 int y1a = (int) floor (wxMin (wxMin(p1.y, p2.y), wxMin(p3.y, p4.y)));
3098 int x2a = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x)));
3099 int y2a = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y)));
3100
3101 // Create rotated image
3102 wxImage rotated (x2a - x1a + 1, y2a - y1a + 1, false);
3103 // With alpha channel
3104 if (has_alpha)
3105 rotated.SetAlpha();
3106
3107 if (offset_after_rotation != NULL)
3108 {
3109 *offset_after_rotation = wxPoint (x1a, y1a);
3110 }
3111
3112 // the rotated (destination) image is always accessed sequentially via this
3113 // pointer, there is no need for pointer-based arrays here
3114 unsigned char *dst = rotated.GetData();
3115
3116 unsigned char *alpha_dst = has_alpha ? rotated.GetAlpha() : NULL;
3117
3118 // if the original image has a mask, use its RGB values as the blank pixel,
3119 // else, fall back to default (black).
3120 unsigned char blank_r = 0;
3121 unsigned char blank_g = 0;
3122 unsigned char blank_b = 0;
3123
3124 if (HasMask())
3125 {
3126 blank_r = GetMaskRed();
3127 blank_g = GetMaskGreen();
3128 blank_b = GetMaskBlue();
3129 rotated.SetMaskColour( blank_r, blank_g, blank_b );
3130 }
3131
3132 // Now, for each point of the rotated image, find where it came from, by
3133 // performing an inverse rotation (a rotation of -angle) and getting the
3134 // pixel at those coordinates
3135
3136 const int rH = rotated.GetHeight();
3137 const int rW = rotated.GetWidth();
3138
3139 // do the (interpolating) test outside of the loops, so that it is done
3140 // only once, instead of repeating it for each pixel.
3141 if (interpolating)
3142 {
3143 for (int y = 0; y < rH; y++)
3144 {
3145 for (int x = 0; x < rW; x++)
3146 {
3147 wxRealPoint src = wxRotatePoint (x + x1a, y + y1a, cos_angle, -sin_angle, p0);
3148
3149 if (-0.25 < src.x && src.x < w - 0.75 &&
3150 -0.25 < src.y && src.y < h - 0.75)
3151 {
3152 // interpolate using the 4 enclosing grid-points. Those
3153 // points can be obtained using floor and ceiling of the
3154 // exact coordinates of the point
3155 int x1, y1, x2, y2;
3156
3157 if (0 < src.x && src.x < w - 1)
3158 {
3159 x1 = wxRound(floor(src.x));
3160 x2 = wxRound(ceil(src.x));
3161 }
3162 else // else means that x is near one of the borders (0 or width-1)
3163 {
3164 x1 = x2 = wxRound (src.x);
3165 }
3166
3167 if (0 < src.y && src.y < h - 1)
3168 {
3169 y1 = wxRound(floor(src.y));
3170 y2 = wxRound(ceil(src.y));
3171 }
3172 else
3173 {
3174 y1 = y2 = wxRound (src.y);
3175 }
3176
3177 // get four points and the distances (square of the distance,
3178 // for efficiency reasons) for the interpolation formula
3179
3180 // GRG: Do not calculate the points until they are
3181 // really needed -- this way we can calculate
3182 // just one, instead of four, if d1, d2, d3
3183 // or d4 are < wxROTATE_EPSILON
3184
3185 const double d1 = (src.x - x1) * (src.x - x1) + (src.y - y1) * (src.y - y1);
3186 const double d2 = (src.x - x2) * (src.x - x2) + (src.y - y1) * (src.y - y1);
3187 const double d3 = (src.x - x2) * (src.x - x2) + (src.y - y2) * (src.y - y2);
3188 const double d4 = (src.x - x1) * (src.x - x1) + (src.y - y2) * (src.y - y2);
3189
3190 // Now interpolate as a weighted average of the four surrounding
3191 // points, where the weights are the distances to each of those points
3192
3193 // If the point is exactly at one point of the grid of the source
3194 // image, then don't interpolate -- just assign the pixel
3195
3196 // d1,d2,d3,d4 are positive -- no need for abs()
3197 if (d1 < wxROTATE_EPSILON)
3198 {
3199 unsigned char *p = data[y1] + (3 * x1);
3200 *(dst++) = *(p++);
3201 *(dst++) = *(p++);
3202 *(dst++) = *p;
3203
3204 if (has_alpha)
3205 *(alpha_dst++) = *(alpha[y1] + x1);
3206 }
3207 else if (d2 < wxROTATE_EPSILON)
3208 {
3209 unsigned char *p = data[y1] + (3 * x2);
3210 *(dst++) = *(p++);
3211 *(dst++) = *(p++);
3212 *(dst++) = *p;
3213
3214 if (has_alpha)
3215 *(alpha_dst++) = *(alpha[y1] + x2);
3216 }
3217 else if (d3 < wxROTATE_EPSILON)
3218 {
3219 unsigned char *p = data[y2] + (3 * x2);
3220 *(dst++) = *(p++);
3221 *(dst++) = *(p++);
3222 *(dst++) = *p;
3223
3224 if (has_alpha)
3225 *(alpha_dst++) = *(alpha[y2] + x2);
3226 }
3227 else if (d4 < wxROTATE_EPSILON)
3228 {
3229 unsigned char *p = data[y2] + (3 * x1);
3230 *(dst++) = *(p++);
3231 *(dst++) = *(p++);
3232 *(dst++) = *p;
3233
3234 if (has_alpha)
3235 *(alpha_dst++) = *(alpha[y2] + x1);
3236 }
3237 else
3238 {
3239 // weights for the weighted average are proportional to the inverse of the distance
3240 unsigned char *v1 = data[y1] + (3 * x1);
3241 unsigned char *v2 = data[y1] + (3 * x2);
3242 unsigned char *v3 = data[y2] + (3 * x2);
3243 unsigned char *v4 = data[y2] + (3 * x1);
3244
3245 const double w1 = 1/d1, w2 = 1/d2, w3 = 1/d3, w4 = 1/d4;
3246
3247 // GRG: Unrolled.
3248
3249 *(dst++) = (unsigned char)
3250 ( (w1 * *(v1++) + w2 * *(v2++) +
3251 w3 * *(v3++) + w4 * *(v4++)) /
3252 (w1 + w2 + w3 + w4) );
3253 *(dst++) = (unsigned char)
3254 ( (w1 * *(v1++) + w2 * *(v2++) +
3255 w3 * *(v3++) + w4 * *(v4++)) /
3256 (w1 + w2 + w3 + w4) );
3257 *(dst++) = (unsigned char)
3258 ( (w1 * *v1 + w2 * *v2 +
3259 w3 * *v3 + w4 * *v4) /
3260 (w1 + w2 + w3 + w4) );
3261
3262 if (has_alpha)
3263 {
3264 v1 = alpha[y1] + (x1);
3265 v2 = alpha[y1] + (x2);
3266 v3 = alpha[y2] + (x2);
3267 v4 = alpha[y2] + (x1);
3268
3269 *(alpha_dst++) = (unsigned char)
3270 ( (w1 * *v1 + w2 * *v2 +
3271 w3 * *v3 + w4 * *v4) /
3272 (w1 + w2 + w3 + w4) );
3273 }
3274 }
3275 }
3276 else
3277 {
3278 *(dst++) = blank_r;
3279 *(dst++) = blank_g;
3280 *(dst++) = blank_b;
3281
3282 if (has_alpha)
3283 *(alpha_dst++) = 0;
3284 }
3285 }
3286 }
3287 }
3288 else // not interpolating
3289 {
3290 for (int y = 0; y < rH; y++)
3291 {
3292 for (int x = 0; x < rW; x++)
3293 {
3294 wxRealPoint src = wxRotatePoint (x + x1a, y + y1a, cos_angle, -sin_angle, p0);
3295
3296 const int xs = wxRound (src.x); // wxRound rounds to the
3297 const int ys = wxRound (src.y); // closest integer
3298
3299 if (0 <= xs && xs < w && 0 <= ys && ys < h)
3300 {
3301 unsigned char *p = data[ys] + (3 * xs);
3302 *(dst++) = *(p++);
3303 *(dst++) = *(p++);
3304 *(dst++) = *p;
3305
3306 if (has_alpha)
3307 *(alpha_dst++) = *(alpha[ys] + (xs));
3308 }
3309 else
3310 {
3311 *(dst++) = blank_r;
3312 *(dst++) = blank_g;
3313 *(dst++) = blank_b;
3314
3315 if (has_alpha)
3316 *(alpha_dst++) = 255;
3317 }
3318 }
3319 }
3320 }
3321
3322 delete [] data;
3323 delete [] alpha;
3324
3325 return rotated;
3326}
3327
3328
3329
3330
3331
3332// A module to allow wxImage initialization/cleanup
3333// without calling these functions from app.cpp or from
3334// the user's application.
3335
3336class wxImageModule: public wxModule
3337{
3338DECLARE_DYNAMIC_CLASS(wxImageModule)
3339public:
3340 wxImageModule() {}
3341 bool OnInit() { wxImage::InitStandardHandlers(); return true; }
3342 void OnExit() { wxImage::CleanUpHandlers(); }
3343};
3344
3345IMPLEMENT_DYNAMIC_CLASS(wxImageModule, wxModule)
3346
3347
3348#endif // wxUSE_IMAGE
wxWidgets (Impactor)