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