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