1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/image.cpp
4 // Author: Robert Roebling
6 // Copyright: (c) Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
26 #include "wx/module.h"
27 #include "wx/palette.h"
29 #include "wx/colour.h"
32 #include "wx/filefn.h"
33 #include "wx/wfstream.h"
34 #include "wx/xpmdecod.h"
39 // make the code compile with either wxFile*Stream or wxFFile*Stream:
40 #define HAS_FILE_STREAMS (wxUSE_STREAMS && (wxUSE_FILE || wxUSE_FFILE))
44 typedef wxFFileInputStream wxImageFileInputStream
;
45 typedef wxFFileOutputStream wxImageFileOutputStream
;
47 typedef wxFileInputStream wxImageFileInputStream
;
48 typedef wxFileOutputStream wxImageFileOutputStream
;
49 #endif // wxUSE_FILE/wxUSE_FFILE
50 #endif // HAS_FILE_STREAMS
53 IMPLEMENT_VARIANT_OBJECT_EXPORTED_SHALLOWCMP(wxImage
,WXDLLEXPORT
)
56 //-----------------------------------------------------------------------------
58 //-----------------------------------------------------------------------------
60 wxList
wxImage::sm_handlers
;
63 //-----------------------------------------------------------------------------
65 //-----------------------------------------------------------------------------
67 class wxImageRefData
: public wxObjectRefData
71 virtual ~wxImageRefData();
76 unsigned char *m_data
;
79 unsigned char m_maskRed
,m_maskGreen
,m_maskBlue
;
81 // alpha channel data, may be NULL for the formats without alpha support
82 unsigned char *m_alpha
;
86 // if true, m_data is pointer to static data and shouldn't be freed
89 // same as m_static but for m_alpha
94 #endif // wxUSE_PALETTE
96 wxArrayString m_optionNames
;
97 wxArrayString m_optionValues
;
99 wxDECLARE_NO_COPY_CLASS(wxImageRefData
);
102 wxImageRefData::wxImageRefData()
106 m_type
= wxBITMAP_TYPE_INVALID
;
108 m_alpha
= (unsigned char *) NULL
;
117 m_staticAlpha
= false;
120 wxImageRefData::~wxImageRefData()
124 if ( !m_staticAlpha
)
129 //-----------------------------------------------------------------------------
131 //-----------------------------------------------------------------------------
133 #define M_IMGDATA static_cast<wxImageRefData*>(m_refData)
135 IMPLEMENT_DYNAMIC_CLASS(wxImage
, wxObject
)
137 bool wxImage::Create(const char* const* xpmData
)
142 wxXPMDecoder decoder
;
143 (*this) = decoder
.ReadData(xpmData
);
150 bool wxImage::Create( int width
, int height
, bool clear
)
154 m_refData
= new wxImageRefData();
156 M_IMGDATA
->m_data
= (unsigned char *) malloc( width
*height
*3 );
157 if (!M_IMGDATA
->m_data
)
163 M_IMGDATA
->m_width
= width
;
164 M_IMGDATA
->m_height
= height
;
165 M_IMGDATA
->m_ok
= true;
175 bool wxImage::Create( int width
, int height
, unsigned char* data
, bool static_data
)
179 wxCHECK_MSG( data
, false, wxT("NULL data in wxImage::Create") );
181 m_refData
= new wxImageRefData();
183 M_IMGDATA
->m_data
= data
;
184 M_IMGDATA
->m_width
= width
;
185 M_IMGDATA
->m_height
= height
;
186 M_IMGDATA
->m_ok
= true;
187 M_IMGDATA
->m_static
= static_data
;
192 bool wxImage::Create( int width
, int height
, unsigned char* data
, unsigned char* alpha
, bool static_data
)
196 wxCHECK_MSG( data
, false, wxT("NULL data in wxImage::Create") );
198 m_refData
= new wxImageRefData();
200 M_IMGDATA
->m_data
= data
;
201 M_IMGDATA
->m_alpha
= alpha
;
202 M_IMGDATA
->m_width
= width
;
203 M_IMGDATA
->m_height
= height
;
204 M_IMGDATA
->m_ok
= true;
205 M_IMGDATA
->m_static
= static_data
;
206 M_IMGDATA
->m_staticAlpha
= static_data
;
211 void wxImage::Destroy()
216 void wxImage::Clear(unsigned char value
)
218 memset(M_IMGDATA
->m_data
, value
, M_IMGDATA
->m_width
*M_IMGDATA
->m_height
*3);
221 wxObjectRefData
* wxImage::CreateRefData() const
223 return new wxImageRefData
;
226 wxObjectRefData
* wxImage::CloneRefData(const wxObjectRefData
* that
) const
228 const wxImageRefData
* refData
= static_cast<const wxImageRefData
*>(that
);
229 wxCHECK_MSG(refData
->m_ok
, NULL
, wxT("invalid image") );
231 wxImageRefData
* refData_new
= new wxImageRefData
;
232 refData_new
->m_width
= refData
->m_width
;
233 refData_new
->m_height
= refData
->m_height
;
234 refData_new
->m_maskRed
= refData
->m_maskRed
;
235 refData_new
->m_maskGreen
= refData
->m_maskGreen
;
236 refData_new
->m_maskBlue
= refData
->m_maskBlue
;
237 refData_new
->m_hasMask
= refData
->m_hasMask
;
238 refData_new
->m_ok
= true;
239 unsigned size
= unsigned(refData
->m_width
) * unsigned(refData
->m_height
);
240 if (refData
->m_alpha
!= NULL
)
242 refData_new
->m_alpha
= (unsigned char*)malloc(size
);
243 memcpy(refData_new
->m_alpha
, refData
->m_alpha
, size
);
246 refData_new
->m_data
= (unsigned char*)malloc(size
);
247 memcpy(refData_new
->m_data
, refData
->m_data
, size
);
249 refData_new
->m_palette
= refData
->m_palette
;
251 refData_new
->m_optionNames
= refData
->m_optionNames
;
252 refData_new
->m_optionValues
= refData
->m_optionValues
;
256 wxImage
wxImage::Copy() const
260 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
262 image
.m_refData
= CloneRefData(m_refData
);
267 wxImage
wxImage::ShrinkBy( int xFactor
, int yFactor
) const
269 if( xFactor
== 1 && yFactor
== 1 )
274 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
276 // can't scale to/from 0 size
277 wxCHECK_MSG( (xFactor
> 0) && (yFactor
> 0), image
,
278 wxT("invalid new image size") );
280 long old_height
= M_IMGDATA
->m_height
,
281 old_width
= M_IMGDATA
->m_width
;
283 wxCHECK_MSG( (old_height
> 0) && (old_width
> 0), image
,
284 wxT("invalid old image size") );
286 long width
= old_width
/ xFactor
;
287 long height
= old_height
/ yFactor
;
289 image
.Create( width
, height
, false );
291 char unsigned *data
= image
.GetData();
293 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
295 bool hasMask
= false ;
296 unsigned char maskRed
= 0;
297 unsigned char maskGreen
= 0;
298 unsigned char maskBlue
=0 ;
300 unsigned char *source_data
= M_IMGDATA
->m_data
;
301 unsigned char *target_data
= data
;
302 unsigned char *source_alpha
= 0 ;
303 unsigned char *target_alpha
= 0 ;
304 if (M_IMGDATA
->m_hasMask
)
307 maskRed
= M_IMGDATA
->m_maskRed
;
308 maskGreen
= M_IMGDATA
->m_maskGreen
;
309 maskBlue
=M_IMGDATA
->m_maskBlue
;
311 image
.SetMaskColour( M_IMGDATA
->m_maskRed
,
312 M_IMGDATA
->m_maskGreen
,
313 M_IMGDATA
->m_maskBlue
);
317 source_alpha
= M_IMGDATA
->m_alpha
;
321 target_alpha
= image
.GetAlpha() ;
325 for (long y
= 0; y
< height
; y
++)
327 for (long x
= 0; x
< width
; x
++)
329 unsigned long avgRed
= 0 ;
330 unsigned long avgGreen
= 0;
331 unsigned long avgBlue
= 0;
332 unsigned long avgAlpha
= 0 ;
333 unsigned long counter
= 0 ;
335 for ( int y1
= 0 ; y1
< yFactor
; ++y1
)
337 long y_offset
= (y
* yFactor
+ y1
) * old_width
;
338 for ( int x1
= 0 ; x1
< xFactor
; ++x1
)
340 unsigned char *pixel
= source_data
+ 3 * ( y_offset
+ x
* xFactor
+ x1
) ;
341 unsigned char red
= pixel
[0] ;
342 unsigned char green
= pixel
[1] ;
343 unsigned char blue
= pixel
[2] ;
344 unsigned char alpha
= 255 ;
346 alpha
= *(source_alpha
+ y_offset
+ x
* xFactor
+ x1
) ;
347 if ( !hasMask
|| red
!= maskRed
|| green
!= maskGreen
|| blue
!= maskBlue
)
362 *(target_data
++) = M_IMGDATA
->m_maskRed
;
363 *(target_data
++) = M_IMGDATA
->m_maskGreen
;
364 *(target_data
++) = M_IMGDATA
->m_maskBlue
;
369 *(target_alpha
++) = (unsigned char)(avgAlpha
/ counter
) ;
370 *(target_data
++) = (unsigned char)(avgRed
/ counter
);
371 *(target_data
++) = (unsigned char)(avgGreen
/ counter
);
372 *(target_data
++) = (unsigned char)(avgBlue
/ counter
);
377 // In case this is a cursor, make sure the hotspot is scaled accordingly:
378 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
) )
379 image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
,
380 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X
))/xFactor
);
381 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
) )
382 image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
,
383 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y
))/yFactor
);
389 wxImage::Scale( int width
, int height
, wxImageResizeQuality quality
) const
393 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
395 // can't scale to/from 0 size
396 wxCHECK_MSG( (width
> 0) && (height
> 0), image
,
397 wxT("invalid new image size") );
399 long old_height
= M_IMGDATA
->m_height
,
400 old_width
= M_IMGDATA
->m_width
;
401 wxCHECK_MSG( (old_height
> 0) && (old_width
> 0), image
,
402 wxT("invalid old image size") );
404 // If the image's new width and height are the same as the original, no
405 // need to waste time or CPU cycles
406 if ( old_width
== width
&& old_height
== height
)
409 // resample the image using either the nearest neighbourhood, bilinear or
410 // bicubic method as specified
413 case wxIMAGE_QUALITY_BICUBIC
:
414 case wxIMAGE_QUALITY_BILINEAR
:
415 // both of these algorithms should be used for up-sampling the
416 // image only, when down-sampling always use box averaging for best
418 if ( width
< old_width
&& height
< old_height
)
419 image
= ResampleBox(width
, height
);
420 else if ( quality
== wxIMAGE_QUALITY_BILINEAR
)
421 image
= ResampleBilinear(width
, height
);
422 else if ( quality
== wxIMAGE_QUALITY_BICUBIC
)
423 image
= ResampleBicubic(width
, height
);
426 case wxIMAGE_QUALITY_NEAREST
:
427 if ( old_width
% width
== 0 && old_width
>= width
&&
428 old_height
% height
== 0 && old_height
>= height
)
430 return ShrinkBy( old_width
/ width
, old_height
/ height
);
433 image
= ResampleNearest(width
, height
);
437 // If the original image has a mask, apply the mask to the new image
438 if (M_IMGDATA
->m_hasMask
)
440 image
.SetMaskColour( M_IMGDATA
->m_maskRed
,
441 M_IMGDATA
->m_maskGreen
,
442 M_IMGDATA
->m_maskBlue
);
445 // In case this is a cursor, make sure the hotspot is scaled accordingly:
446 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
) )
447 image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
,
448 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X
)*width
)/old_width
);
449 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
) )
450 image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
,
451 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y
)*height
)/old_height
);
456 wxImage
wxImage::ResampleNearest(int width
, int height
) const
459 image
.Create( width
, height
, false );
461 unsigned char *data
= image
.GetData();
463 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
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 ;
470 if ( !M_IMGDATA
->m_hasMask
)
472 source_alpha
= M_IMGDATA
->m_alpha
;
476 target_alpha
= image
.GetAlpha() ;
480 long old_height
= M_IMGDATA
->m_height
,
481 old_width
= M_IMGDATA
->m_width
;
482 long x_delta
= (old_width
<<16) / width
;
483 long y_delta
= (old_height
<<16) / height
;
485 unsigned char* dest_pixel
= target_data
;
488 for ( long j
= 0; j
< height
; j
++ )
490 unsigned char* src_line
= &source_data
[(y
>>16)*old_width
*3];
491 unsigned char* src_alpha_line
= source_alpha
? &source_alpha
[(y
>>16)*old_width
] : 0 ;
494 for ( long i
= 0; i
< width
; i
++ )
496 unsigned char* src_pixel
= &src_line
[(x
>>16)*3];
497 unsigned char* src_alpha_pixel
= source_alpha
? &src_alpha_line
[(x
>>16)] : 0 ;
498 dest_pixel
[0] = src_pixel
[0];
499 dest_pixel
[1] = src_pixel
[1];
500 dest_pixel
[2] = src_pixel
[2];
503 *(target_alpha
++) = *src_alpha_pixel
;
513 wxImage
wxImage::ResampleBox(int width
, int height
) const
515 // This function implements a simple pre-blur/box averaging method for
516 // downsampling that gives reasonably smooth results To scale the image
517 // down we will need to gather a grid of pixels of the size of the scale
518 // factor in each direction and then do an averaging of the pixels.
520 wxImage
ret_image(width
, height
, false);
522 const double scale_factor_x
= double(M_IMGDATA
->m_width
) / width
;
523 const double scale_factor_y
= double(M_IMGDATA
->m_height
) / height
;
525 const int scale_factor_x_2
= (int)(scale_factor_x
/ 2);
526 const int scale_factor_y_2
= (int)(scale_factor_y
/ 2);
528 unsigned char* src_data
= M_IMGDATA
->m_data
;
529 unsigned char* src_alpha
= M_IMGDATA
->m_alpha
;
530 unsigned char* dst_data
= ret_image
.GetData();
531 unsigned char* dst_alpha
= NULL
;
535 ret_image
.SetAlpha();
536 dst_alpha
= ret_image
.GetAlpha();
539 int averaged_pixels
, src_pixel_index
;
540 double sum_r
, sum_g
, sum_b
, sum_a
;
542 for ( int y
= 0; y
< height
; y
++ ) // Destination image - Y direction
544 // Source pixel in the Y direction
545 int src_y
= (int)(y
* scale_factor_y
);
547 for ( int x
= 0; x
< width
; x
++ ) // Destination image - X direction
549 // Source pixel in the X direction
550 int src_x
= (int)(x
* scale_factor_x
);
552 // Box of pixels to average
554 sum_r
= sum_g
= sum_b
= sum_a
= 0.0;
556 for ( int j
= int(src_y
- scale_factor_y
/2.0 + 1);
557 j
<= int(src_y
+ scale_factor_y_2
);
560 // We don't care to average pixels that don't exist (edges)
561 if ( j
< 0 || j
> M_IMGDATA
->m_height
- 1 )
564 for ( int i
= int(src_x
- scale_factor_x
/2.0 + 1);
565 i
<= src_x
+ scale_factor_x_2
;
568 // Don't average edge pixels
569 if ( i
< 0 || i
> M_IMGDATA
->m_width
- 1 )
572 // Calculate the actual index in our source pixels
573 src_pixel_index
= j
* M_IMGDATA
->m_width
+ i
;
575 sum_r
+= src_data
[src_pixel_index
* 3 + 0];
576 sum_g
+= src_data
[src_pixel_index
* 3 + 1];
577 sum_b
+= src_data
[src_pixel_index
* 3 + 2];
579 sum_a
+= src_alpha
[src_pixel_index
];
585 // Calculate the average from the sum and number of averaged pixels
586 dst_data
[0] = (unsigned char)(sum_r
/ averaged_pixels
);
587 dst_data
[1] = (unsigned char)(sum_g
/ averaged_pixels
);
588 dst_data
[2] = (unsigned char)(sum_b
/ averaged_pixels
);
591 *dst_alpha
++ = (unsigned char)(sum_a
/ averaged_pixels
);
598 wxImage
wxImage::ResampleBilinear(int width
, int height
) const
600 // This function implements a Bilinear algorithm for resampling.
601 wxImage
ret_image(width
, height
, false);
602 unsigned char* src_data
= M_IMGDATA
->m_data
;
603 unsigned char* src_alpha
= M_IMGDATA
->m_alpha
;
604 unsigned char* dst_data
= ret_image
.GetData();
605 unsigned char* dst_alpha
= NULL
;
609 ret_image
.SetAlpha();
610 dst_alpha
= ret_image
.GetAlpha();
612 double HFactor
= double(M_IMGDATA
->m_height
) / height
;
613 double WFactor
= double(M_IMGDATA
->m_width
) / width
;
615 int srcpixymax
= M_IMGDATA
->m_height
- 1;
616 int srcpixxmax
= M_IMGDATA
->m_width
- 1;
618 double srcpixy
, srcpixy1
, srcpixy2
, dy
, dy1
;
619 double srcpixx
, srcpixx1
, srcpixx2
, dx
, dx1
;
621 // initialize alpha values to avoid g++ warnings about possibly
622 // uninitialized variables
623 double r1
, g1
, b1
, a1
= 0;
624 double r2
, g2
, b2
, a2
= 0;
626 for ( int dsty
= 0; dsty
< height
; dsty
++ )
628 // We need to calculate the source pixel to interpolate from - Y-axis
629 srcpixy
= double(dsty
) * HFactor
;
630 srcpixy1
= int(srcpixy
);
631 srcpixy2
= ( srcpixy1
== srcpixymax
) ? srcpixy1
: srcpixy1
+ 1.0;
632 dy
= srcpixy
- (int)srcpixy
;
636 for ( int dstx
= 0; dstx
< width
; dstx
++ )
638 // X-axis of pixel to interpolate from
639 srcpixx
= double(dstx
) * WFactor
;
640 srcpixx1
= int(srcpixx
);
641 srcpixx2
= ( srcpixx1
== srcpixxmax
) ? srcpixx1
: srcpixx1
+ 1.0;
642 dx
= srcpixx
- (int)srcpixx
;
645 int x_offset1
= srcpixx1
< 0.0 ? 0 : srcpixx1
> srcpixxmax
? srcpixxmax
: (int)srcpixx1
;
646 int x_offset2
= srcpixx2
< 0.0 ? 0 : srcpixx2
> srcpixxmax
? srcpixxmax
: (int)srcpixx2
;
647 int y_offset1
= srcpixy1
< 0.0 ? 0 : srcpixy1
> srcpixymax
? srcpixymax
: (int)srcpixy1
;
648 int y_offset2
= srcpixy2
< 0.0 ? 0 : srcpixy2
> srcpixymax
? srcpixymax
: (int)srcpixy2
;
650 int src_pixel_index00
= y_offset1
* M_IMGDATA
->m_width
+ x_offset1
;
651 int src_pixel_index01
= y_offset1
* M_IMGDATA
->m_width
+ x_offset2
;
652 int src_pixel_index10
= y_offset2
* M_IMGDATA
->m_width
+ x_offset1
;
653 int src_pixel_index11
= y_offset2
* M_IMGDATA
->m_width
+ x_offset2
;
656 r1
= src_data
[src_pixel_index00
* 3 + 0] * dx1
+ src_data
[src_pixel_index01
* 3 + 0] * dx
;
657 g1
= src_data
[src_pixel_index00
* 3 + 1] * dx1
+ src_data
[src_pixel_index01
* 3 + 1] * dx
;
658 b1
= src_data
[src_pixel_index00
* 3 + 2] * dx1
+ src_data
[src_pixel_index01
* 3 + 2] * dx
;
660 a1
= src_alpha
[src_pixel_index00
] * dx1
+ src_alpha
[src_pixel_index01
] * dx
;
663 r2
= src_data
[src_pixel_index10
* 3 + 0] * dx1
+ src_data
[src_pixel_index11
* 3 + 0] * dx
;
664 g2
= src_data
[src_pixel_index10
* 3 + 1] * dx1
+ src_data
[src_pixel_index11
* 3 + 1] * dx
;
665 b2
= src_data
[src_pixel_index10
* 3 + 2] * dx1
+ src_data
[src_pixel_index11
* 3 + 2] * dx
;
667 a2
= src_alpha
[src_pixel_index10
] * dx1
+ src_alpha
[src_pixel_index11
] * dx
;
671 dst_data
[0] = static_cast<unsigned char>(r1
* dy1
+ r2
* dy
);
672 dst_data
[1] = static_cast<unsigned char>(g1
* dy1
+ g2
* dy
);
673 dst_data
[2] = static_cast<unsigned char>(b1
* dy1
+ b2
* dy
);
677 *dst_alpha
++ = static_cast<unsigned char>(a1
* dy1
+ a2
* dy
);
684 // The following two local functions are for the B-spline weighting of the
685 // bicubic sampling algorithm
686 static inline double spline_cube(double value
)
688 return value
<= 0.0 ? 0.0 : value
* value
* value
;
691 static inline double spline_weight(double value
)
693 return (spline_cube(value
+ 2) -
694 4 * spline_cube(value
+ 1) +
695 6 * spline_cube(value
) -
696 4 * spline_cube(value
- 1)) / 6;
699 // This is the bicubic resampling algorithm
700 wxImage
wxImage::ResampleBicubic(int width
, int height
) const
702 // This function implements a Bicubic B-Spline algorithm for resampling.
703 // This method is certainly a little slower than wxImage's default pixel
704 // replication method, however for most reasonably sized images not being
705 // upsampled too much on a fairly average CPU this difference is hardly
706 // noticeable and the results are far more pleasing to look at.
708 // This particular bicubic algorithm does pixel weighting according to a
709 // B-Spline that basically implements a Gaussian bell-like weighting
710 // kernel. Because of this method the results may appear a bit blurry when
711 // upsampling by large factors. This is basically because a slight
712 // gaussian blur is being performed to get the smooth look of the upsampled
715 // Edge pixels: 3-4 possible solutions
716 // - (Wrap/tile) Wrap the image, take the color value from the opposite
717 // side of the image.
718 // - (Mirror) Duplicate edge pixels, so that pixel at coordinate (2, n),
719 // where n is nonpositive, will have the value of (2, 1).
720 // - (Ignore) Simply ignore the edge pixels and apply the kernel only to
721 // pixels which do have all neighbours.
722 // - (Clamp) Choose the nearest pixel along the border. This takes the
723 // border pixels and extends them out to infinity.
725 // NOTE: below the y_offset and x_offset variables are being set for edge
726 // pixels using the "Mirror" method mentioned above
730 ret_image
.Create(width
, height
, false);
732 unsigned char* src_data
= M_IMGDATA
->m_data
;
733 unsigned char* src_alpha
= M_IMGDATA
->m_alpha
;
734 unsigned char* dst_data
= ret_image
.GetData();
735 unsigned char* dst_alpha
= NULL
;
739 ret_image
.SetAlpha();
740 dst_alpha
= ret_image
.GetAlpha();
743 for ( int dsty
= 0; dsty
< height
; dsty
++ )
745 // We need to calculate the source pixel to interpolate from - Y-axis
746 double srcpixy
= double(dsty
* M_IMGDATA
->m_height
) / height
;
747 double dy
= srcpixy
- (int)srcpixy
;
749 for ( int dstx
= 0; dstx
< width
; dstx
++ )
751 // X-axis of pixel to interpolate from
752 double srcpixx
= double(dstx
* M_IMGDATA
->m_width
) / width
;
753 double dx
= srcpixx
- (int)srcpixx
;
755 // Sums for each color channel
756 double sum_r
= 0, sum_g
= 0, sum_b
= 0, sum_a
= 0;
758 // Here we actually determine the RGBA values for the destination pixel
759 for ( int k
= -1; k
<= 2; k
++ )
762 int y_offset
= srcpixy
+ k
< 0.0
764 : srcpixy
+ k
>= M_IMGDATA
->m_height
765 ? M_IMGDATA
->m_height
- 1
766 : (int)(srcpixy
+ k
);
768 // Loop across the X axis
769 for ( int i
= -1; i
<= 2; i
++ )
772 int x_offset
= srcpixx
+ i
< 0.0
774 : srcpixx
+ i
>= M_IMGDATA
->m_width
775 ? M_IMGDATA
->m_width
- 1
776 : (int)(srcpixx
+ i
);
778 // Calculate the exact position where the source data
779 // should be pulled from based on the x_offset and y_offset
780 int src_pixel_index
= y_offset
*M_IMGDATA
->m_width
+ x_offset
;
782 // Calculate the weight for the specified pixel according
783 // to the bicubic b-spline kernel we're using for
786 pixel_weight
= spline_weight(i
- dx
)*spline_weight(k
- dy
);
788 // Create a sum of all velues for each color channel
789 // adjusted for the pixel's calculated weight
790 sum_r
+= src_data
[src_pixel_index
* 3 + 0] * pixel_weight
;
791 sum_g
+= src_data
[src_pixel_index
* 3 + 1] * pixel_weight
;
792 sum_b
+= src_data
[src_pixel_index
* 3 + 2] * pixel_weight
;
794 sum_a
+= src_alpha
[src_pixel_index
] * pixel_weight
;
798 // Put the data into the destination image. The summed values are
799 // of double data type and are rounded here for accuracy
800 dst_data
[0] = (unsigned char)(sum_r
+ 0.5);
801 dst_data
[1] = (unsigned char)(sum_g
+ 0.5);
802 dst_data
[2] = (unsigned char)(sum_b
+ 0.5);
806 *dst_alpha
++ = (unsigned char)sum_a
;
813 // Blur in the horizontal direction
814 wxImage
wxImage::BlurHorizontal(int blurRadius
) const
817 ret_image
.Create(M_IMGDATA
->m_width
, M_IMGDATA
->m_height
, false);
819 unsigned char* src_data
= M_IMGDATA
->m_data
;
820 unsigned char* dst_data
= ret_image
.GetData();
821 unsigned char* src_alpha
= M_IMGDATA
->m_alpha
;
822 unsigned char* dst_alpha
= NULL
;
824 // Check for a mask or alpha
827 ret_image
.SetAlpha();
828 dst_alpha
= ret_image
.GetAlpha();
830 else if ( M_IMGDATA
->m_hasMask
)
832 ret_image
.SetMaskColour(M_IMGDATA
->m_maskRed
,
833 M_IMGDATA
->m_maskGreen
,
834 M_IMGDATA
->m_maskBlue
);
837 // number of pixels we average over
838 const int blurArea
= blurRadius
*2 + 1;
840 // Horizontal blurring algorithm - average all pixels in the specified blur
841 // radius in the X or horizontal direction
842 for ( int y
= 0; y
< M_IMGDATA
->m_height
; y
++ )
844 // Variables used in the blurring algorithm
851 const unsigned char *src
;
854 // Calculate the average of all pixels in the blur radius for the first
856 for ( int kernel_x
= -blurRadius
; kernel_x
<= blurRadius
; kernel_x
++ )
858 // To deal with the pixels at the start of a row so it's not
859 // grabbing GOK values from memory at negative indices of the
860 // image's data or grabbing from the previous row
862 pixel_idx
= y
* M_IMGDATA
->m_width
;
864 pixel_idx
= kernel_x
+ y
* M_IMGDATA
->m_width
;
866 src
= src_data
+ pixel_idx
*3;
871 sum_a
+= src_alpha
[pixel_idx
];
874 dst
= dst_data
+ y
* M_IMGDATA
->m_width
*3;
875 dst
[0] = (unsigned char)(sum_r
/ blurArea
);
876 dst
[1] = (unsigned char)(sum_g
/ blurArea
);
877 dst
[2] = (unsigned char)(sum_b
/ blurArea
);
879 dst_alpha
[y
* M_IMGDATA
->m_width
] = (unsigned char)(sum_a
/ blurArea
);
881 // Now average the values of the rest of the pixels by just moving the
882 // blur radius box along the row
883 for ( int x
= 1; x
< M_IMGDATA
->m_width
; x
++ )
885 // Take care of edge pixels on the left edge by essentially
886 // duplicating the edge pixel
887 if ( x
- blurRadius
- 1 < 0 )
888 pixel_idx
= y
* M_IMGDATA
->m_width
;
890 pixel_idx
= (x
- blurRadius
- 1) + y
* M_IMGDATA
->m_width
;
892 // Subtract the value of the pixel at the left side of the blur
894 src
= src_data
+ pixel_idx
*3;
899 sum_a
-= src_alpha
[pixel_idx
];
901 // Take care of edge pixels on the right edge
902 if ( x
+ blurRadius
> M_IMGDATA
->m_width
- 1 )
903 pixel_idx
= M_IMGDATA
->m_width
- 1 + y
* M_IMGDATA
->m_width
;
905 pixel_idx
= x
+ blurRadius
+ y
* M_IMGDATA
->m_width
;
907 // Add the value of the pixel being added to the end of our box
908 src
= src_data
+ pixel_idx
*3;
913 sum_a
+= src_alpha
[pixel_idx
];
915 // Save off the averaged data
916 dst
= dst_data
+ x
*3 + y
*M_IMGDATA
->m_width
*3;
917 dst
[0] = (unsigned char)(sum_r
/ blurArea
);
918 dst
[1] = (unsigned char)(sum_g
/ blurArea
);
919 dst
[2] = (unsigned char)(sum_b
/ blurArea
);
921 dst_alpha
[x
+ y
* M_IMGDATA
->m_width
] = (unsigned char)(sum_a
/ blurArea
);
928 // Blur in the vertical direction
929 wxImage
wxImage::BlurVertical(int blurRadius
) const
932 ret_image
.Create(M_IMGDATA
->m_width
, M_IMGDATA
->m_height
, false);
934 unsigned char* src_data
= M_IMGDATA
->m_data
;
935 unsigned char* dst_data
= ret_image
.GetData();
936 unsigned char* src_alpha
= M_IMGDATA
->m_alpha
;
937 unsigned char* dst_alpha
= NULL
;
939 // Check for a mask or alpha
942 ret_image
.SetAlpha();
943 dst_alpha
= ret_image
.GetAlpha();
945 else if ( M_IMGDATA
->m_hasMask
)
947 ret_image
.SetMaskColour(M_IMGDATA
->m_maskRed
,
948 M_IMGDATA
->m_maskGreen
,
949 M_IMGDATA
->m_maskBlue
);
952 // number of pixels we average over
953 const int blurArea
= blurRadius
*2 + 1;
955 // Vertical blurring algorithm - same as horizontal but switched the
956 // opposite direction
957 for ( int x
= 0; x
< M_IMGDATA
->m_width
; x
++ )
959 // Variables used in the blurring algorithm
966 const unsigned char *src
;
969 // Calculate the average of all pixels in our blur radius box for the
970 // first pixel of the column
971 for ( int kernel_y
= -blurRadius
; kernel_y
<= blurRadius
; kernel_y
++ )
973 // To deal with the pixels at the start of a column so it's not
974 // grabbing GOK values from memory at negative indices of the
975 // image's data or grabbing from the previous column
979 pixel_idx
= x
+ kernel_y
* M_IMGDATA
->m_width
;
981 src
= src_data
+ pixel_idx
*3;
986 sum_a
+= src_alpha
[pixel_idx
];
989 dst
= dst_data
+ x
*3;
990 dst
[0] = (unsigned char)(sum_r
/ blurArea
);
991 dst
[1] = (unsigned char)(sum_g
/ blurArea
);
992 dst
[2] = (unsigned char)(sum_b
/ blurArea
);
994 dst_alpha
[x
] = (unsigned char)(sum_a
/ blurArea
);
996 // Now average the values of the rest of the pixels by just moving the
997 // box along the column from top to bottom
998 for ( int y
= 1; y
< M_IMGDATA
->m_height
; y
++ )
1000 // Take care of pixels that would be beyond the top edge by
1001 // duplicating the top edge pixel for the column
1002 if ( y
- blurRadius
- 1 < 0 )
1005 pixel_idx
= x
+ (y
- blurRadius
- 1) * M_IMGDATA
->m_width
;
1007 // Subtract the value of the pixel at the top of our blur radius box
1008 src
= src_data
+ pixel_idx
*3;
1013 sum_a
-= src_alpha
[pixel_idx
];
1015 // Take care of the pixels that would be beyond the bottom edge of
1016 // the image similar to the top edge
1017 if ( y
+ blurRadius
> M_IMGDATA
->m_height
- 1 )
1018 pixel_idx
= x
+ (M_IMGDATA
->m_height
- 1) * M_IMGDATA
->m_width
;
1020 pixel_idx
= x
+ (blurRadius
+ y
) * M_IMGDATA
->m_width
;
1022 // Add the value of the pixel being added to the end of our box
1023 src
= src_data
+ pixel_idx
*3;
1028 sum_a
+= src_alpha
[pixel_idx
];
1030 // Save off the averaged data
1031 dst
= dst_data
+ (x
+ y
* M_IMGDATA
->m_width
) * 3;
1032 dst
[0] = (unsigned char)(sum_r
/ blurArea
);
1033 dst
[1] = (unsigned char)(sum_g
/ blurArea
);
1034 dst
[2] = (unsigned char)(sum_b
/ blurArea
);
1036 dst_alpha
[x
+ y
* M_IMGDATA
->m_width
] = (unsigned char)(sum_a
/ blurArea
);
1043 // The new blur function
1044 wxImage
wxImage::Blur(int blurRadius
) const
1047 ret_image
.Create(M_IMGDATA
->m_width
, M_IMGDATA
->m_height
, false);
1049 // Blur the image in each direction
1050 ret_image
= BlurHorizontal(blurRadius
);
1051 ret_image
= ret_image
.BlurVertical(blurRadius
);
1056 wxImage
wxImage::Rotate90( bool clockwise
) const
1060 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
1062 image
.Create( M_IMGDATA
->m_height
, M_IMGDATA
->m_width
, false );
1064 unsigned char *data
= image
.GetData();
1066 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
1068 unsigned char *source_data
= M_IMGDATA
->m_data
;
1069 unsigned char *target_data
;
1070 unsigned char *alpha_data
= 0 ;
1071 unsigned char *source_alpha
= 0 ;
1072 unsigned char *target_alpha
= 0 ;
1074 if (M_IMGDATA
->m_hasMask
)
1076 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
1080 source_alpha
= M_IMGDATA
->m_alpha
;
1084 alpha_data
= image
.GetAlpha() ;
1088 long height
= M_IMGDATA
->m_height
;
1089 long width
= M_IMGDATA
->m_width
;
1091 for (long j
= 0; j
< height
; j
++)
1093 for (long i
= 0; i
< width
; i
++)
1097 target_data
= data
+ (((i
+1)*height
) - j
- 1)*3;
1099 target_alpha
= alpha_data
+ (((i
+1)*height
) - j
- 1);
1103 target_data
= data
+ ((height
*(width
-1)) + j
- (i
*height
))*3;
1105 target_alpha
= alpha_data
+ ((height
*(width
-1)) + j
- (i
*height
));
1107 memcpy( target_data
, source_data
, 3 );
1112 memcpy( target_alpha
, source_alpha
, 1 );
1121 wxImage
wxImage::Mirror( bool horizontally
) const
1125 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
1127 image
.Create( M_IMGDATA
->m_width
, M_IMGDATA
->m_height
, false );
1129 unsigned char *data
= image
.GetData();
1130 unsigned char *alpha
= NULL
;
1132 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
1134 if (M_IMGDATA
->m_alpha
!= NULL
) {
1136 alpha
= image
.GetAlpha();
1137 wxCHECK_MSG( alpha
, image
, wxT("unable to create alpha channel") );
1140 if (M_IMGDATA
->m_hasMask
)
1141 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
1143 long height
= M_IMGDATA
->m_height
;
1144 long width
= M_IMGDATA
->m_width
;
1146 unsigned char *source_data
= M_IMGDATA
->m_data
;
1147 unsigned char *target_data
;
1151 for (long j
= 0; j
< height
; j
++)
1154 target_data
= data
-3;
1155 for (long i
= 0; i
< width
; i
++)
1157 memcpy( target_data
, source_data
, 3 );
1165 // src_alpha starts at the first pixel and increases by 1 after each step
1166 // (a step here is the copy of the alpha value of one pixel)
1167 const unsigned char *src_alpha
= M_IMGDATA
->m_alpha
;
1168 // dest_alpha starts just beyond the first line, decreases before each step,
1169 // and after each line is finished, increases by 2 widths (skipping the line
1170 // just copied and the line that will be copied next)
1171 unsigned char *dest_alpha
= alpha
+ width
;
1173 for (long jj
= 0; jj
< height
; ++jj
)
1175 for (long i
= 0; i
< width
; ++i
) {
1176 *(--dest_alpha
) = *(src_alpha
++); // copy one pixel
1178 dest_alpha
+= 2 * width
; // advance beyond the end of the next line
1184 for (long i
= 0; i
< height
; i
++)
1186 target_data
= data
+ 3*width
*(height
-1-i
);
1187 memcpy( target_data
, source_data
, (size_t)3*width
);
1188 source_data
+= 3*width
;
1193 // src_alpha starts at the first pixel and increases by 1 width after each step
1194 // (a step here is the copy of the alpha channel of an entire line)
1195 const unsigned char *src_alpha
= M_IMGDATA
->m_alpha
;
1196 // dest_alpha starts just beyond the last line (beyond the whole image)
1197 // and decreases by 1 width before each step
1198 unsigned char *dest_alpha
= alpha
+ width
* height
;
1200 for (long jj
= 0; jj
< height
; ++jj
)
1202 dest_alpha
-= width
;
1203 memcpy( dest_alpha
, src_alpha
, (size_t)width
);
1212 wxImage
wxImage::GetSubImage( const wxRect
&rect
) const
1216 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
1218 wxCHECK_MSG( (rect
.GetLeft()>=0) && (rect
.GetTop()>=0) &&
1219 (rect
.GetRight()<=GetWidth()) && (rect
.GetBottom()<=GetHeight()),
1220 image
, wxT("invalid subimage size") );
1222 const int subwidth
= rect
.GetWidth();
1223 const int subheight
= rect
.GetHeight();
1225 image
.Create( subwidth
, subheight
, false );
1227 const unsigned char *src_data
= GetData();
1228 const unsigned char *src_alpha
= M_IMGDATA
->m_alpha
;
1229 unsigned char *subdata
= image
.GetData();
1230 unsigned char *subalpha
= NULL
;
1232 wxCHECK_MSG( subdata
, image
, wxT("unable to create image") );
1234 if (src_alpha
!= NULL
) {
1236 subalpha
= image
.GetAlpha();
1237 wxCHECK_MSG( subalpha
, image
, wxT("unable to create alpha channel"));
1240 if (M_IMGDATA
->m_hasMask
)
1241 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
1243 const int width
= GetWidth();
1244 const int pixsoff
= rect
.GetLeft() + width
* rect
.GetTop();
1246 src_data
+= 3 * pixsoff
;
1247 src_alpha
+= pixsoff
; // won't be used if was NULL, so this is ok
1249 for (long j
= 0; j
< subheight
; ++j
)
1251 memcpy( subdata
, src_data
, 3 * subwidth
);
1252 subdata
+= 3 * subwidth
;
1253 src_data
+= 3 * width
;
1254 if (subalpha
!= NULL
) {
1255 memcpy( subalpha
, src_alpha
, subwidth
);
1256 subalpha
+= subwidth
;
1264 wxImage
wxImage::Size( const wxSize
& size
, const wxPoint
& pos
,
1265 int r_
, int g_
, int b_
) const
1269 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
1270 wxCHECK_MSG( (size
.GetWidth() > 0) && (size
.GetHeight() > 0), image
, wxT("invalid size") );
1272 int width
= GetWidth(), height
= GetHeight();
1273 image
.Create(size
.GetWidth(), size
.GetHeight(), false);
1275 unsigned char r
= (unsigned char)r_
;
1276 unsigned char g
= (unsigned char)g_
;
1277 unsigned char b
= (unsigned char)b_
;
1278 if ((r_
== -1) && (g_
== -1) && (b_
== -1))
1280 GetOrFindMaskColour( &r
, &g
, &b
);
1281 image
.SetMaskColour(r
, g
, b
);
1284 image
.SetRGB(wxRect(), r
, g
, b
);
1286 // we have two coordinate systems:
1287 // source: starting at 0,0 of source image
1288 // destination starting at 0,0 of destination image
1289 // Documentation says:
1290 // "The image is pasted into a new image [...] at the position pos relative
1291 // to the upper left of the new image." this means the transition rule is:
1292 // "dest coord" = "source coord" + pos;
1294 // calculate the intersection using source coordinates:
1295 wxRect
srcRect(0, 0, width
, height
);
1296 wxRect
dstRect(-pos
, size
);
1298 srcRect
.Intersect(dstRect
);
1300 if (!srcRect
.IsEmpty())
1302 // insertion point is needed in destination coordinates.
1303 // NB: it is not always "pos"!
1304 wxPoint ptInsert
= srcRect
.GetTopLeft() + pos
;
1306 if ((srcRect
.GetWidth() == width
) && (srcRect
.GetHeight() == height
))
1307 image
.Paste(*this, ptInsert
.x
, ptInsert
.y
);
1309 image
.Paste(GetSubImage(srcRect
), ptInsert
.x
, ptInsert
.y
);
1315 void wxImage::Paste( const wxImage
&image
, int x
, int y
)
1317 wxCHECK_RET( Ok(), wxT("invalid image") );
1318 wxCHECK_RET( image
.Ok(), wxT("invalid image") );
1324 int width
= image
.GetWidth();
1325 int height
= image
.GetHeight();
1338 if ((x
+xx
)+width
> M_IMGDATA
->m_width
)
1339 width
= M_IMGDATA
->m_width
- (x
+xx
);
1340 if ((y
+yy
)+height
> M_IMGDATA
->m_height
)
1341 height
= M_IMGDATA
->m_height
- (y
+yy
);
1343 if (width
< 1) return;
1344 if (height
< 1) return;
1346 if ((!HasMask() && !image
.HasMask()) ||
1347 (HasMask() && !image
.HasMask()) ||
1348 ((HasMask() && image
.HasMask() &&
1349 (GetMaskRed()==image
.GetMaskRed()) &&
1350 (GetMaskGreen()==image
.GetMaskGreen()) &&
1351 (GetMaskBlue()==image
.GetMaskBlue()))))
1353 unsigned char* source_data
= image
.GetData() + xx
*3 + yy
*3*image
.GetWidth();
1354 int source_step
= image
.GetWidth()*3;
1356 unsigned char* target_data
= GetData() + (x
+xx
)*3 + (y
+yy
)*3*M_IMGDATA
->m_width
;
1357 int target_step
= M_IMGDATA
->m_width
*3;
1358 for (int j
= 0; j
< height
; j
++)
1360 memcpy( target_data
, source_data
, width
*3 );
1361 source_data
+= source_step
;
1362 target_data
+= target_step
;
1366 // Copy over the alpha channel from the original image
1367 if ( image
.HasAlpha() )
1372 unsigned char* source_data
= image
.GetAlpha() + xx
+ yy
*image
.GetWidth();
1373 int source_step
= image
.GetWidth();
1375 unsigned char* target_data
= GetAlpha() + (x
+xx
) + (y
+yy
)*M_IMGDATA
->m_width
;
1376 int target_step
= M_IMGDATA
->m_width
;
1378 for (int j
= 0; j
< height
; j
++,
1379 source_data
+= source_step
,
1380 target_data
+= target_step
)
1382 memcpy( target_data
, source_data
, width
);
1386 if (!HasMask() && image
.HasMask())
1388 unsigned char r
= image
.GetMaskRed();
1389 unsigned char g
= image
.GetMaskGreen();
1390 unsigned char b
= image
.GetMaskBlue();
1392 unsigned char* source_data
= image
.GetData() + xx
*3 + yy
*3*image
.GetWidth();
1393 int source_step
= image
.GetWidth()*3;
1395 unsigned char* target_data
= GetData() + (x
+xx
)*3 + (y
+yy
)*3*M_IMGDATA
->m_width
;
1396 int target_step
= M_IMGDATA
->m_width
*3;
1398 for (int j
= 0; j
< height
; j
++)
1400 for (int i
= 0; i
< width
*3; i
+=3)
1402 if ((source_data
[i
] != r
) ||
1403 (source_data
[i
+1] != g
) ||
1404 (source_data
[i
+2] != b
))
1406 memcpy( target_data
+i
, source_data
+i
, 3 );
1409 source_data
+= source_step
;
1410 target_data
+= target_step
;
1415 void wxImage::Replace( unsigned char r1
, unsigned char g1
, unsigned char b1
,
1416 unsigned char r2
, unsigned char g2
, unsigned char b2
)
1418 wxCHECK_RET( Ok(), wxT("invalid image") );
1422 unsigned char *data
= GetData();
1424 const int w
= GetWidth();
1425 const int h
= GetHeight();
1427 for (int j
= 0; j
< h
; j
++)
1428 for (int i
= 0; i
< w
; i
++)
1430 if ((data
[0] == r1
) && (data
[1] == g1
) && (data
[2] == b1
))
1440 wxImage
wxImage::ConvertToGreyscale(void) const
1442 return ConvertToGreyscale(0.299, 0.587, 0.114);
1445 wxImage
wxImage::ConvertToGreyscale(double weight_r
, double weight_g
, double weight_b
) const
1449 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
1451 image
.Create(M_IMGDATA
->m_width
, M_IMGDATA
->m_height
, false);
1453 unsigned char *dest
= image
.GetData();
1455 wxCHECK_MSG( dest
, image
, wxT("unable to create image") );
1457 unsigned char *src
= M_IMGDATA
->m_data
;
1458 bool hasMask
= M_IMGDATA
->m_hasMask
;
1459 unsigned char maskRed
= M_IMGDATA
->m_maskRed
;
1460 unsigned char maskGreen
= M_IMGDATA
->m_maskGreen
;
1461 unsigned char maskBlue
= M_IMGDATA
->m_maskBlue
;
1464 image
.SetMaskColour(maskRed
, maskGreen
, maskBlue
);
1466 const long size
= M_IMGDATA
->m_width
* M_IMGDATA
->m_height
;
1467 for ( long i
= 0; i
< size
; i
++, src
+= 3, dest
+= 3 )
1469 memcpy(dest
, src
, 3);
1470 // don't modify the mask
1471 if ( hasMask
&& src
[0] == maskRed
&& src
[1] == maskGreen
&& src
[2] == maskBlue
)
1476 wxColour::MakeGrey(dest
+ 0, dest
+ 1, dest
+ 2, weight_r
, weight_g
, weight_b
);
1480 // copy the alpha channel, if any
1483 const size_t alphaSize
= GetWidth() * GetHeight();
1484 unsigned char *alpha
= (unsigned char*)malloc(alphaSize
);
1485 memcpy(alpha
, GetAlpha(), alphaSize
);
1487 image
.SetAlpha(alpha
);
1493 wxImage
wxImage::ConvertToMono( unsigned char r
, unsigned char g
, unsigned char b
) const
1497 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
1499 image
.Create( M_IMGDATA
->m_width
, M_IMGDATA
->m_height
, false );
1501 unsigned char *data
= image
.GetData();
1503 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
1505 if (M_IMGDATA
->m_hasMask
)
1507 if (M_IMGDATA
->m_maskRed
== r
&& M_IMGDATA
->m_maskGreen
== g
&&
1508 M_IMGDATA
->m_maskBlue
== b
)
1509 image
.SetMaskColour( 255, 255, 255 );
1511 image
.SetMaskColour( 0, 0, 0 );
1514 long size
= M_IMGDATA
->m_height
* M_IMGDATA
->m_width
;
1516 unsigned char *srcd
= M_IMGDATA
->m_data
;
1517 unsigned char *tard
= image
.GetData();
1519 for ( long i
= 0; i
< size
; i
++, srcd
+= 3, tard
+= 3 )
1521 bool on
= (srcd
[0] == r
) && (srcd
[1] == g
) && (srcd
[2] == b
);
1522 wxColourBase::MakeMono(tard
+ 0, tard
+ 1, tard
+ 2, on
);
1528 wxImage
wxImage::ConvertToDisabled(unsigned char brightness
) const
1530 wxImage image
= *this;
1532 unsigned char mr
= image
.GetMaskRed();
1533 unsigned char mg
= image
.GetMaskGreen();
1534 unsigned char mb
= image
.GetMaskBlue();
1536 int width
= image
.GetWidth();
1537 int height
= image
.GetHeight();
1538 bool has_mask
= image
.HasMask();
1540 for (int y
= height
-1; y
>= 0; --y
)
1542 for (int x
= width
-1; x
>= 0; --x
)
1544 unsigned char* data
= image
.GetData() + (y
*(width
*3))+(x
*3);
1545 unsigned char* r
= data
;
1546 unsigned char* g
= data
+1;
1547 unsigned char* b
= data
+2;
1549 if (has_mask
&& (*r
== mr
) && (*g
== mg
) && (*b
== mb
))
1552 wxColour::MakeDisabled(r
, g
, b
, brightness
);
1558 int wxImage::GetWidth() const
1560 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1562 return M_IMGDATA
->m_width
;
1565 int wxImage::GetHeight() const
1567 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1569 return M_IMGDATA
->m_height
;
1572 wxBitmapType
wxImage::GetType() const
1574 wxCHECK_MSG( IsOk(), wxBITMAP_TYPE_INVALID
, wxT("invalid image") );
1576 return M_IMGDATA
->m_type
;
1579 void wxImage::SetType(wxBitmapType type
)
1581 wxCHECK_RET( IsOk(), "must create the image before setting its type");
1583 // type can be wxBITMAP_TYPE_INVALID to reset the image type to default
1584 wxASSERT_MSG( type
!= wxBITMAP_TYPE_MAX
, "invalid bitmap type" );
1586 M_IMGDATA
->m_type
= type
;
1589 long wxImage::XYToIndex(int x
, int y
) const
1593 x
< M_IMGDATA
->m_width
&& y
< M_IMGDATA
->m_height
)
1595 return y
*M_IMGDATA
->m_width
+ x
;
1601 void wxImage::SetRGB( int x
, int y
, unsigned char r
, unsigned char g
, unsigned char b
)
1603 long pos
= XYToIndex(x
, y
);
1604 wxCHECK_RET( pos
!= -1, wxT("invalid image coordinates") );
1610 M_IMGDATA
->m_data
[ pos
] = r
;
1611 M_IMGDATA
->m_data
[ pos
+1 ] = g
;
1612 M_IMGDATA
->m_data
[ pos
+2 ] = b
;
1615 void wxImage::SetRGB( const wxRect
& rect_
, unsigned char r
, unsigned char g
, unsigned char b
)
1617 wxCHECK_RET( Ok(), wxT("invalid image") );
1622 wxRect
imageRect(0, 0, GetWidth(), GetHeight());
1623 if ( rect
== wxRect() )
1629 wxCHECK_RET( imageRect
.Contains(rect
.GetTopLeft()) &&
1630 imageRect
.Contains(rect
.GetBottomRight()),
1631 wxT("invalid bounding rectangle") );
1634 int x1
= rect
.GetLeft(),
1636 x2
= rect
.GetRight() + 1,
1637 y2
= rect
.GetBottom() + 1;
1639 unsigned char *data
wxDUMMY_INITIALIZE(NULL
);
1640 int x
, y
, width
= GetWidth();
1641 for (y
= y1
; y
< y2
; y
++)
1643 data
= M_IMGDATA
->m_data
+ (y
*width
+ x1
)*3;
1644 for (x
= x1
; x
< x2
; x
++)
1653 unsigned char wxImage::GetRed( int x
, int y
) const
1655 long pos
= XYToIndex(x
, y
);
1656 wxCHECK_MSG( pos
!= -1, 0, wxT("invalid image coordinates") );
1660 return M_IMGDATA
->m_data
[pos
];
1663 unsigned char wxImage::GetGreen( int x
, int y
) const
1665 long pos
= XYToIndex(x
, y
);
1666 wxCHECK_MSG( pos
!= -1, 0, wxT("invalid image coordinates") );
1670 return M_IMGDATA
->m_data
[pos
+1];
1673 unsigned char wxImage::GetBlue( int x
, int y
) const
1675 long pos
= XYToIndex(x
, y
);
1676 wxCHECK_MSG( pos
!= -1, 0, wxT("invalid image coordinates") );
1680 return M_IMGDATA
->m_data
[pos
+2];
1683 bool wxImage::IsOk() const
1685 // image of 0 width or height can't be considered ok - at least because it
1686 // causes crashes in ConvertToBitmap() if we don't catch it in time
1687 wxImageRefData
*data
= M_IMGDATA
;
1688 return data
&& data
->m_ok
&& data
->m_width
&& data
->m_height
;
1691 unsigned char *wxImage::GetData() const
1693 wxCHECK_MSG( Ok(), (unsigned char *)NULL
, wxT("invalid image") );
1695 return M_IMGDATA
->m_data
;
1698 void wxImage::SetData( unsigned char *data
, bool static_data
)
1700 wxCHECK_RET( Ok(), wxT("invalid image") );
1702 wxImageRefData
*newRefData
= new wxImageRefData();
1704 newRefData
->m_width
= M_IMGDATA
->m_width
;
1705 newRefData
->m_height
= M_IMGDATA
->m_height
;
1706 newRefData
->m_data
= data
;
1707 newRefData
->m_ok
= true;
1708 newRefData
->m_maskRed
= M_IMGDATA
->m_maskRed
;
1709 newRefData
->m_maskGreen
= M_IMGDATA
->m_maskGreen
;
1710 newRefData
->m_maskBlue
= M_IMGDATA
->m_maskBlue
;
1711 newRefData
->m_hasMask
= M_IMGDATA
->m_hasMask
;
1712 newRefData
->m_static
= static_data
;
1716 m_refData
= newRefData
;
1719 void wxImage::SetData( unsigned char *data
, int new_width
, int new_height
, bool static_data
)
1721 wxImageRefData
*newRefData
= new wxImageRefData();
1725 newRefData
->m_width
= new_width
;
1726 newRefData
->m_height
= new_height
;
1727 newRefData
->m_data
= data
;
1728 newRefData
->m_ok
= true;
1729 newRefData
->m_maskRed
= M_IMGDATA
->m_maskRed
;
1730 newRefData
->m_maskGreen
= M_IMGDATA
->m_maskGreen
;
1731 newRefData
->m_maskBlue
= M_IMGDATA
->m_maskBlue
;
1732 newRefData
->m_hasMask
= M_IMGDATA
->m_hasMask
;
1736 newRefData
->m_width
= new_width
;
1737 newRefData
->m_height
= new_height
;
1738 newRefData
->m_data
= data
;
1739 newRefData
->m_ok
= true;
1741 newRefData
->m_static
= static_data
;
1745 m_refData
= newRefData
;
1748 // ----------------------------------------------------------------------------
1749 // alpha channel support
1750 // ----------------------------------------------------------------------------
1752 void wxImage::SetAlpha(int x
, int y
, unsigned char alpha
)
1754 wxCHECK_RET( HasAlpha(), wxT("no alpha channel") );
1756 long pos
= XYToIndex(x
, y
);
1757 wxCHECK_RET( pos
!= -1, wxT("invalid image coordinates") );
1761 M_IMGDATA
->m_alpha
[pos
] = alpha
;
1764 unsigned char wxImage::GetAlpha(int x
, int y
) const
1766 wxCHECK_MSG( HasAlpha(), 0, wxT("no alpha channel") );
1768 long pos
= XYToIndex(x
, y
);
1769 wxCHECK_MSG( pos
!= -1, 0, wxT("invalid image coordinates") );
1771 return M_IMGDATA
->m_alpha
[pos
];
1775 wxImage::ConvertColourToAlpha(unsigned char r
, unsigned char g
, unsigned char b
)
1779 const int w
= M_IMGDATA
->m_width
;
1780 const int h
= M_IMGDATA
->m_height
;
1782 unsigned char *alpha
= GetAlpha();
1783 unsigned char *data
= GetData();
1785 for ( int y
= 0; y
< h
; y
++ )
1787 for ( int x
= 0; x
< w
; x
++ )
1799 void wxImage::SetAlpha( unsigned char *alpha
, bool static_data
)
1801 wxCHECK_RET( Ok(), wxT("invalid image") );
1807 alpha
= (unsigned char *)malloc(M_IMGDATA
->m_width
*M_IMGDATA
->m_height
);
1810 if( !M_IMGDATA
->m_staticAlpha
)
1811 free(M_IMGDATA
->m_alpha
);
1813 M_IMGDATA
->m_alpha
= alpha
;
1814 M_IMGDATA
->m_staticAlpha
= static_data
;
1817 unsigned char *wxImage::GetAlpha() const
1819 wxCHECK_MSG( Ok(), (unsigned char *)NULL
, wxT("invalid image") );
1821 return M_IMGDATA
->m_alpha
;
1824 void wxImage::InitAlpha()
1826 wxCHECK_RET( !HasAlpha(), wxT("image already has an alpha channel") );
1828 // initialize memory for alpha channel
1831 unsigned char *alpha
= M_IMGDATA
->m_alpha
;
1832 const size_t lenAlpha
= M_IMGDATA
->m_width
* M_IMGDATA
->m_height
;
1836 // use the mask to initialize the alpha channel.
1837 const unsigned char * const alphaEnd
= alpha
+ lenAlpha
;
1839 const unsigned char mr
= M_IMGDATA
->m_maskRed
;
1840 const unsigned char mg
= M_IMGDATA
->m_maskGreen
;
1841 const unsigned char mb
= M_IMGDATA
->m_maskBlue
;
1842 for ( unsigned char *src
= M_IMGDATA
->m_data
;
1846 *alpha
= (src
[0] == mr
&& src
[1] == mg
&& src
[2] == mb
)
1847 ? wxIMAGE_ALPHA_TRANSPARENT
1848 : wxIMAGE_ALPHA_OPAQUE
;
1851 M_IMGDATA
->m_hasMask
= false;
1855 // make the image fully opaque
1856 memset(alpha
, wxIMAGE_ALPHA_OPAQUE
, lenAlpha
);
1860 // ----------------------------------------------------------------------------
1862 // ----------------------------------------------------------------------------
1864 void wxImage::SetMaskColour( unsigned char r
, unsigned char g
, unsigned char b
)
1866 wxCHECK_RET( Ok(), wxT("invalid image") );
1870 M_IMGDATA
->m_maskRed
= r
;
1871 M_IMGDATA
->m_maskGreen
= g
;
1872 M_IMGDATA
->m_maskBlue
= b
;
1873 M_IMGDATA
->m_hasMask
= true;
1876 bool wxImage::GetOrFindMaskColour( unsigned char *r
, unsigned char *g
, unsigned char *b
) const
1878 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1880 if (M_IMGDATA
->m_hasMask
)
1882 if (r
) *r
= M_IMGDATA
->m_maskRed
;
1883 if (g
) *g
= M_IMGDATA
->m_maskGreen
;
1884 if (b
) *b
= M_IMGDATA
->m_maskBlue
;
1889 FindFirstUnusedColour(r
, g
, b
);
1894 unsigned char wxImage::GetMaskRed() const
1896 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1898 return M_IMGDATA
->m_maskRed
;
1901 unsigned char wxImage::GetMaskGreen() const
1903 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1905 return M_IMGDATA
->m_maskGreen
;
1908 unsigned char wxImage::GetMaskBlue() const
1910 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1912 return M_IMGDATA
->m_maskBlue
;
1915 void wxImage::SetMask( bool mask
)
1917 wxCHECK_RET( Ok(), wxT("invalid image") );
1921 M_IMGDATA
->m_hasMask
= mask
;
1924 bool wxImage::HasMask() const
1926 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1928 return M_IMGDATA
->m_hasMask
;
1931 bool wxImage::IsTransparent(int x
, int y
, unsigned char threshold
) const
1933 long pos
= XYToIndex(x
, y
);
1934 wxCHECK_MSG( pos
!= -1, false, wxT("invalid image coordinates") );
1937 if ( M_IMGDATA
->m_hasMask
)
1939 const unsigned char *p
= M_IMGDATA
->m_data
+ 3*pos
;
1940 if ( p
[0] == M_IMGDATA
->m_maskRed
&&
1941 p
[1] == M_IMGDATA
->m_maskGreen
&&
1942 p
[2] == M_IMGDATA
->m_maskBlue
)
1949 if ( M_IMGDATA
->m_alpha
)
1951 if ( M_IMGDATA
->m_alpha
[pos
] < threshold
)
1953 // transparent enough
1962 bool wxImage::SetMaskFromImage(const wxImage
& mask
,
1963 unsigned char mr
, unsigned char mg
, unsigned char mb
)
1965 // check that the images are the same size
1966 if ( (M_IMGDATA
->m_height
!= mask
.GetHeight() ) || (M_IMGDATA
->m_width
!= mask
.GetWidth () ) )
1968 wxLogError( _("Image and mask have different sizes.") );
1972 // find unused colour
1973 unsigned char r
,g
,b
;
1974 if (!FindFirstUnusedColour(&r
, &g
, &b
))
1976 wxLogError( _("No unused colour in image being masked.") );
1982 unsigned char *imgdata
= GetData();
1983 unsigned char *maskdata
= mask
.GetData();
1985 const int w
= GetWidth();
1986 const int h
= GetHeight();
1988 for (int j
= 0; j
< h
; j
++)
1990 for (int i
= 0; i
< w
; i
++)
1992 if ((maskdata
[0] == mr
) && (maskdata
[1] == mg
) && (maskdata
[2] == mb
))
2003 SetMaskColour(r
, g
, b
);
2009 bool wxImage::ConvertAlphaToMask(unsigned char threshold
)
2014 unsigned char mr
, mg
, mb
;
2015 if ( !FindFirstUnusedColour(&mr
, &mg
, &mb
) )
2017 wxLogError( _("No unused colour in image being masked.") );
2021 ConvertAlphaToMask(mr
, mg
, mb
, threshold
);
2025 void wxImage::ConvertAlphaToMask(unsigned char mr
,
2028 unsigned char threshold
)
2036 SetMaskColour(mr
, mg
, mb
);
2038 unsigned char *imgdata
= GetData();
2039 unsigned char *alphadata
= GetAlpha();
2042 int h
= GetHeight();
2044 for (int y
= 0; y
< h
; y
++)
2046 for (int x
= 0; x
< w
; x
++, imgdata
+= 3, alphadata
++)
2048 if (*alphadata
< threshold
)
2057 if ( !M_IMGDATA
->m_staticAlpha
)
2058 free(M_IMGDATA
->m_alpha
);
2060 M_IMGDATA
->m_alpha
= NULL
;
2061 M_IMGDATA
->m_staticAlpha
= false;
2064 // ----------------------------------------------------------------------------
2065 // Palette functions
2066 // ----------------------------------------------------------------------------
2070 bool wxImage::HasPalette() const
2075 return M_IMGDATA
->m_palette
.Ok();
2078 const wxPalette
& wxImage::GetPalette() const
2080 wxCHECK_MSG( Ok(), wxNullPalette
, wxT("invalid image") );
2082 return M_IMGDATA
->m_palette
;
2085 void wxImage::SetPalette(const wxPalette
& palette
)
2087 wxCHECK_RET( Ok(), wxT("invalid image") );
2091 M_IMGDATA
->m_palette
= palette
;
2094 #endif // wxUSE_PALETTE
2096 // ----------------------------------------------------------------------------
2097 // Option functions (arbitrary name/value mapping)
2098 // ----------------------------------------------------------------------------
2100 void wxImage::SetOption(const wxString
& name
, const wxString
& value
)
2104 int idx
= M_IMGDATA
->m_optionNames
.Index(name
, false);
2105 if ( idx
== wxNOT_FOUND
)
2107 M_IMGDATA
->m_optionNames
.Add(name
);
2108 M_IMGDATA
->m_optionValues
.Add(value
);
2112 M_IMGDATA
->m_optionNames
[idx
] = name
;
2113 M_IMGDATA
->m_optionValues
[idx
] = value
;
2117 void wxImage::SetOption(const wxString
& name
, int value
)
2120 valStr
.Printf(wxT("%d"), value
);
2121 SetOption(name
, valStr
);
2124 wxString
wxImage::GetOption(const wxString
& name
) const
2127 return wxEmptyString
;
2129 int idx
= M_IMGDATA
->m_optionNames
.Index(name
, false);
2130 if ( idx
== wxNOT_FOUND
)
2131 return wxEmptyString
;
2133 return M_IMGDATA
->m_optionValues
[idx
];
2136 int wxImage::GetOptionInt(const wxString
& name
) const
2138 return wxAtoi(GetOption(name
));
2141 bool wxImage::HasOption(const wxString
& name
) const
2143 return M_IMGDATA
? M_IMGDATA
->m_optionNames
.Index(name
, false) != wxNOT_FOUND
2147 // ----------------------------------------------------------------------------
2149 // ----------------------------------------------------------------------------
2151 bool wxImage::LoadFile( const wxString
& WXUNUSED_UNLESS_STREAMS(filename
),
2152 wxBitmapType
WXUNUSED_UNLESS_STREAMS(type
),
2153 int WXUNUSED_UNLESS_STREAMS(index
) )
2155 #if HAS_FILE_STREAMS
2156 if (wxFileExists(filename
))
2158 wxImageFileInputStream
stream(filename
);
2159 wxBufferedInputStream
bstream( stream
);
2160 return LoadFile(bstream
, type
, index
);
2164 wxLogError( _("Can't load image from file '%s': file does not exist."), filename
.c_str() );
2168 #else // !HAS_FILE_STREAMS
2170 #endif // HAS_FILE_STREAMS
2173 bool wxImage::LoadFile( const wxString
& WXUNUSED_UNLESS_STREAMS(filename
),
2174 const wxString
& WXUNUSED_UNLESS_STREAMS(mimetype
),
2175 int WXUNUSED_UNLESS_STREAMS(index
) )
2177 #if HAS_FILE_STREAMS
2178 if (wxFileExists(filename
))
2180 wxImageFileInputStream
stream(filename
);
2181 wxBufferedInputStream
bstream( stream
);
2182 return LoadFile(bstream
, mimetype
, index
);
2186 wxLogError( _("Can't load image from file '%s': file does not exist."), filename
.c_str() );
2190 #else // !HAS_FILE_STREAMS
2192 #endif // HAS_FILE_STREAMS
2196 bool wxImage::SaveFile( const wxString
& filename
) const
2198 wxString ext
= filename
.AfterLast('.').Lower();
2200 wxImageHandler
*handler
= FindHandler(ext
, wxBITMAP_TYPE_ANY
);
2203 wxLogError(_("Can't save image to file '%s': unknown extension."),
2208 return SaveFile(filename
, handler
->GetType());
2211 bool wxImage::SaveFile( const wxString
& WXUNUSED_UNLESS_STREAMS(filename
),
2212 wxBitmapType
WXUNUSED_UNLESS_STREAMS(type
) ) const
2214 #if HAS_FILE_STREAMS
2215 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2217 ((wxImage
*)this)->SetOption(wxIMAGE_OPTION_FILENAME
, filename
);
2219 wxImageFileOutputStream
stream(filename
);
2221 if ( stream
.IsOk() )
2223 wxBufferedOutputStream
bstream( stream
);
2224 return SaveFile(bstream
, type
);
2226 #endif // HAS_FILE_STREAMS
2231 bool wxImage::SaveFile( const wxString
& WXUNUSED_UNLESS_STREAMS(filename
),
2232 const wxString
& WXUNUSED_UNLESS_STREAMS(mimetype
) ) const
2234 #if HAS_FILE_STREAMS
2235 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2237 ((wxImage
*)this)->SetOption(wxIMAGE_OPTION_FILENAME
, filename
);
2239 wxImageFileOutputStream
stream(filename
);
2241 if ( stream
.IsOk() )
2243 wxBufferedOutputStream
bstream( stream
);
2244 return SaveFile(bstream
, mimetype
);
2246 #endif // HAS_FILE_STREAMS
2251 bool wxImage::CanRead( const wxString
& WXUNUSED_UNLESS_STREAMS(name
) )
2253 #if HAS_FILE_STREAMS
2254 wxImageFileInputStream
stream(name
);
2255 return CanRead(stream
);
2261 int wxImage::GetImageCount( const wxString
& WXUNUSED_UNLESS_STREAMS(name
),
2262 wxBitmapType
WXUNUSED_UNLESS_STREAMS(type
) )
2264 #if HAS_FILE_STREAMS
2265 wxImageFileInputStream
stream(name
);
2267 return GetImageCount(stream
, type
);
2275 bool wxImage::CanRead( wxInputStream
&stream
)
2277 const wxList
& list
= GetHandlers();
2279 for ( wxList::compatibility_iterator node
= list
.GetFirst(); node
; node
= node
->GetNext() )
2281 wxImageHandler
*handler
=(wxImageHandler
*)node
->GetData();
2282 if (handler
->CanRead( stream
))
2289 int wxImage::GetImageCount( wxInputStream
&stream
, wxBitmapType type
)
2291 wxImageHandler
*handler
;
2293 if ( type
== wxBITMAP_TYPE_ANY
)
2295 const wxList
& list
= GetHandlers();
2297 for ( wxList::compatibility_iterator node
= list
.GetFirst();
2299 node
= node
->GetNext() )
2301 handler
= (wxImageHandler
*)node
->GetData();
2302 if ( handler
->CanRead(stream
) )
2304 const int count
= handler
->GetImageCount(stream
);
2311 wxLogWarning(_("No handler found for image type."));
2315 handler
= FindHandler(type
);
2319 wxLogWarning(_("No image handler for type %ld defined."), type
);
2323 if ( handler
->CanRead(stream
) )
2325 return handler
->GetImageCount(stream
);
2329 wxLogError(_("Image file is not of type %ld."), type
);
2334 bool wxImage::DoLoad(wxImageHandler
& handler
, wxInputStream
& stream
, int index
)
2336 // save the options values which can be clobbered by the handler (e.g. many
2337 // of them call Destroy() before trying to load the file)
2338 const unsigned maxWidth
= GetOptionInt(wxIMAGE_OPTION_MAX_WIDTH
),
2339 maxHeight
= GetOptionInt(wxIMAGE_OPTION_MAX_HEIGHT
);
2341 if ( !handler
.LoadFile(this, stream
, true/*verbose*/, index
) )
2344 M_IMGDATA
->m_type
= handler
.GetType();
2346 // rescale the image to the specified size if needed
2347 if ( maxWidth
|| maxHeight
)
2349 const unsigned widthOrig
= GetWidth(),
2350 heightOrig
= GetHeight();
2352 // this uses the same (trivial) algorithm as the JPEG handler
2353 unsigned width
= widthOrig
,
2354 height
= heightOrig
;
2355 while ( (maxWidth
&& width
> maxWidth
) ||
2356 (maxHeight
&& height
> maxHeight
) )
2362 if ( width
!= widthOrig
|| height
!= heightOrig
)
2363 Rescale(width
, height
, wxIMAGE_QUALITY_HIGH
);
2369 bool wxImage::LoadFile( wxInputStream
& stream
, wxBitmapType type
, int index
)
2373 wxImageHandler
*handler
;
2375 if ( type
== wxBITMAP_TYPE_ANY
)
2377 const wxList
& list
= GetHandlers();
2378 for ( wxList::compatibility_iterator node
= list
.GetFirst();
2380 node
= node
->GetNext() )
2382 handler
= (wxImageHandler
*)node
->GetData();
2383 if ( handler
->CanRead(stream
) && DoLoad(*handler
, stream
, index
) )
2387 wxLogWarning( _("No handler found for image type.") );
2391 //else: have specific type
2393 handler
= FindHandler(type
);
2396 wxLogWarning( _("No image handler for type %ld defined."), type
);
2400 if ( stream
.IsSeekable() && !handler
->CanRead(stream
) )
2402 wxLogError(_("Image file is not of type %ld."), type
);
2406 return DoLoad(*handler
, stream
, index
);
2409 bool wxImage::LoadFile( wxInputStream
& stream
, const wxString
& mimetype
, int index
)
2413 m_refData
= new wxImageRefData
;
2415 wxImageHandler
*handler
= FindHandlerMime(mimetype
);
2419 wxLogWarning( _("No image handler for type %s defined."), mimetype
.GetData() );
2423 if ( stream
.IsSeekable() && !handler
->CanRead(stream
) )
2425 wxLogError(_("Image file is not of type %s."), mimetype
);
2429 return DoLoad(*handler
, stream
, index
);
2432 bool wxImage::DoSave(wxImageHandler
& handler
, wxOutputStream
& stream
) const
2434 wxImage
* const self
= const_cast<wxImage
*>(this);
2435 if ( !handler
.SaveFile(self
, stream
) )
2438 M_IMGDATA
->m_type
= handler
.GetType();
2442 bool wxImage::SaveFile( wxOutputStream
& stream
, wxBitmapType type
) const
2444 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2446 wxImageHandler
*handler
= FindHandler(type
);
2449 wxLogWarning( _("No image handler for type %d defined."), type
);
2453 return DoSave(*handler
, stream
);
2456 bool wxImage::SaveFile( wxOutputStream
& stream
, const wxString
& mimetype
) const
2458 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
2460 wxImageHandler
*handler
= FindHandlerMime(mimetype
);
2463 wxLogWarning( _("No image handler for type %s defined."), mimetype
.GetData() );
2466 return DoSave(*handler
, stream
);
2469 #endif // wxUSE_STREAMS
2471 // ----------------------------------------------------------------------------
2472 // image I/O handlers
2473 // ----------------------------------------------------------------------------
2475 void wxImage::AddHandler( wxImageHandler
*handler
)
2477 // Check for an existing handler of the type being added.
2478 if (FindHandler( handler
->GetType() ) == 0)
2480 sm_handlers
.Append( handler
);
2484 // This is not documented behaviour, merely the simplest 'fix'
2485 // for preventing duplicate additions. If someone ever has
2486 // a good reason to add and remove duplicate handlers (and they
2487 // may) we should probably refcount the duplicates.
2488 // also an issue in InsertHandler below.
2490 wxLogDebug( wxT("Adding duplicate image handler for '%s'"),
2491 handler
->GetName().c_str() );
2496 void wxImage::InsertHandler( wxImageHandler
*handler
)
2498 // Check for an existing handler of the type being added.
2499 if (FindHandler( handler
->GetType() ) == 0)
2501 sm_handlers
.Insert( handler
);
2505 // see AddHandler for additional comments.
2506 wxLogDebug( wxT("Inserting duplicate image handler for '%s'"),
2507 handler
->GetName().c_str() );
2512 bool wxImage::RemoveHandler( const wxString
& name
)
2514 wxImageHandler
*handler
= FindHandler(name
);
2517 sm_handlers
.DeleteObject(handler
);
2525 wxImageHandler
*wxImage::FindHandler( const wxString
& name
)
2527 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
2530 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
2531 if (handler
->GetName().Cmp(name
) == 0) return handler
;
2533 node
= node
->GetNext();
2538 wxImageHandler
*wxImage::FindHandler( const wxString
& extension
, wxBitmapType bitmapType
)
2540 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
2543 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
2544 if ((bitmapType
== wxBITMAP_TYPE_ANY
) || (handler
->GetType() == bitmapType
))
2546 if (handler
->GetExtension() == extension
)
2548 if (handler
->GetAltExtensions().Index(extension
, false) != wxNOT_FOUND
)
2551 node
= node
->GetNext();
2556 wxImageHandler
*wxImage::FindHandler(wxBitmapType bitmapType
)
2558 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
2561 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
2562 if (handler
->GetType() == bitmapType
) return handler
;
2563 node
= node
->GetNext();
2568 wxImageHandler
*wxImage::FindHandlerMime( const wxString
& mimetype
)
2570 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
2573 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
2574 if (handler
->GetMimeType().IsSameAs(mimetype
, false)) return handler
;
2575 node
= node
->GetNext();
2580 void wxImage::InitStandardHandlers()
2583 AddHandler(new wxBMPHandler
);
2584 #endif // wxUSE_STREAMS
2587 void wxImage::CleanUpHandlers()
2589 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
2592 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
2593 wxList::compatibility_iterator next
= node
->GetNext();
2598 sm_handlers
.Clear();
2601 wxString
wxImage::GetImageExtWildcard()
2605 wxList
& Handlers
= wxImage::GetHandlers();
2606 wxList::compatibility_iterator Node
= Handlers
.GetFirst();
2609 wxImageHandler
* Handler
= (wxImageHandler
*)Node
->GetData();
2610 fmts
+= wxT("*.") + Handler
->GetExtension();
2611 for (size_t i
= 0; i
< Handler
->GetAltExtensions().size(); i
++)
2612 fmts
+= wxT(";*.") + Handler
->GetAltExtensions()[i
];
2613 Node
= Node
->GetNext();
2614 if ( Node
) fmts
+= wxT(";");
2617 return wxT("(") + fmts
+ wxT(")|") + fmts
;
2620 wxImage::HSVValue
wxImage::RGBtoHSV(const RGBValue
& rgb
)
2622 const double red
= rgb
.red
/ 255.0,
2623 green
= rgb
.green
/ 255.0,
2624 blue
= rgb
.blue
/ 255.0;
2626 // find the min and max intensity (and remember which one was it for the
2628 double minimumRGB
= red
;
2629 if ( green
< minimumRGB
)
2631 if ( blue
< minimumRGB
)
2634 enum { RED
, GREEN
, BLUE
} chMax
= RED
;
2635 double maximumRGB
= red
;
2636 if ( green
> maximumRGB
)
2641 if ( blue
> maximumRGB
)
2647 const double value
= maximumRGB
;
2649 double hue
= 0.0, saturation
;
2650 const double deltaRGB
= maximumRGB
- minimumRGB
;
2651 if ( wxIsNullDouble(deltaRGB
) )
2653 // Gray has no color
2662 hue
= (green
- blue
) / deltaRGB
;
2666 hue
= 2.0 + (blue
- red
) / deltaRGB
;
2670 hue
= 4.0 + (red
- green
) / deltaRGB
;
2674 wxFAIL_MSG(wxT("hue not specified"));
2683 saturation
= deltaRGB
/ maximumRGB
;
2686 return HSVValue(hue
, saturation
, value
);
2689 wxImage::RGBValue
wxImage::HSVtoRGB(const HSVValue
& hsv
)
2691 double red
, green
, blue
;
2693 if ( wxIsNullDouble(hsv
.saturation
) )
2702 double hue
= hsv
.hue
* 6.0; // sector 0 to 5
2703 int i
= (int)floor(hue
);
2704 double f
= hue
- i
; // fractional part of h
2705 double p
= hsv
.value
* (1.0 - hsv
.saturation
);
2711 green
= hsv
.value
* (1.0 - hsv
.saturation
* (1.0 - f
));
2716 red
= hsv
.value
* (1.0 - hsv
.saturation
* f
);
2724 blue
= hsv
.value
* (1.0 - hsv
.saturation
* (1.0 - f
));
2729 green
= hsv
.value
* (1.0 - hsv
.saturation
* f
);
2734 red
= hsv
.value
* (1.0 - hsv
.saturation
* (1.0 - f
));
2742 blue
= hsv
.value
* (1.0 - hsv
.saturation
* f
);
2747 return RGBValue((unsigned char)(red
* 255.0),
2748 (unsigned char)(green
* 255.0),
2749 (unsigned char)(blue
* 255.0));
2753 * Rotates the hue of each pixel of the image. angle is a double in the range
2754 * -1.0..1.0 where -1.0 is -360 degrees and 1.0 is 360 degrees
2756 void wxImage::RotateHue(double angle
)
2760 unsigned char *srcBytePtr
;
2761 unsigned char *dstBytePtr
;
2762 unsigned long count
;
2763 wxImage::HSVValue hsv
;
2764 wxImage::RGBValue rgb
;
2766 wxASSERT (angle
>= -1.0 && angle
<= 1.0);
2767 count
= M_IMGDATA
->m_width
* M_IMGDATA
->m_height
;
2768 if ( count
> 0 && !wxIsNullDouble(angle
) )
2770 srcBytePtr
= M_IMGDATA
->m_data
;
2771 dstBytePtr
= srcBytePtr
;
2774 rgb
.red
= *srcBytePtr
++;
2775 rgb
.green
= *srcBytePtr
++;
2776 rgb
.blue
= *srcBytePtr
++;
2777 hsv
= RGBtoHSV(rgb
);
2779 hsv
.hue
= hsv
.hue
+ angle
;
2781 hsv
.hue
= hsv
.hue
- 1.0;
2782 else if (hsv
.hue
< 0.0)
2783 hsv
.hue
= hsv
.hue
+ 1.0;
2785 rgb
= HSVtoRGB(hsv
);
2786 *dstBytePtr
++ = rgb
.red
;
2787 *dstBytePtr
++ = rgb
.green
;
2788 *dstBytePtr
++ = rgb
.blue
;
2789 } while (--count
!= 0);
2793 //-----------------------------------------------------------------------------
2795 //-----------------------------------------------------------------------------
2797 IMPLEMENT_ABSTRACT_CLASS(wxImageHandler
,wxObject
)
2800 int wxImageHandler::GetImageCount( wxInputStream
& stream
)
2802 // NOTE: this code is the same of wxAnimationDecoder::CanRead and
2803 // wxImageHandler::CallDoCanRead
2805 if ( !stream
.IsSeekable() )
2806 return false; // can't test unseekable stream
2808 wxFileOffset posOld
= stream
.TellI();
2809 int n
= DoGetImageCount(stream
);
2811 // restore the old position to be able to test other formats and so on
2812 if ( stream
.SeekI(posOld
) == wxInvalidOffset
)
2814 wxLogDebug(wxT("Failed to rewind the stream in wxImageHandler!"));
2816 // reading would fail anyhow as we're not at the right position
2823 bool wxImageHandler::CanRead( const wxString
& name
)
2825 if (wxFileExists(name
))
2827 wxImageFileInputStream
stream(name
);
2828 return CanRead(stream
);
2831 wxLogError( _("Can't check image format of file '%s': file does not exist."), name
.c_str() );
2836 bool wxImageHandler::CallDoCanRead(wxInputStream
& stream
)
2838 // NOTE: this code is the same of wxAnimationDecoder::CanRead and
2839 // wxImageHandler::GetImageCount
2841 if ( !stream
.IsSeekable() )
2842 return false; // can't test unseekable stream
2844 wxFileOffset posOld
= stream
.TellI();
2845 bool ok
= DoCanRead(stream
);
2847 // restore the old position to be able to test other formats and so on
2848 if ( stream
.SeekI(posOld
) == wxInvalidOffset
)
2850 wxLogDebug(wxT("Failed to rewind the stream in wxImageHandler!"));
2852 // reading would fail anyhow as we're not at the right position
2859 #endif // wxUSE_STREAMS
2863 wxImageHandler::GetResolutionFromOptions(const wxImage
& image
, int *x
, int *y
)
2865 wxCHECK_MSG( x
&& y
, wxIMAGE_RESOLUTION_NONE
, wxT("NULL pointer") );
2867 if ( image
.HasOption(wxIMAGE_OPTION_RESOLUTIONX
) &&
2868 image
.HasOption(wxIMAGE_OPTION_RESOLUTIONY
) )
2870 *x
= image
.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONX
);
2871 *y
= image
.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONY
);
2873 else if ( image
.HasOption(wxIMAGE_OPTION_RESOLUTION
) )
2876 *y
= image
.GetOptionInt(wxIMAGE_OPTION_RESOLUTION
);
2878 else // no resolution options specified
2883 return wxIMAGE_RESOLUTION_NONE
;
2886 // get the resolution unit too
2887 int resUnit
= image
.GetOptionInt(wxIMAGE_OPTION_RESOLUTIONUNIT
);
2890 // this is the default
2891 resUnit
= wxIMAGE_RESOLUTION_INCHES
;
2894 return (wxImageResolution
)resUnit
;
2897 // ----------------------------------------------------------------------------
2898 // image histogram stuff
2899 // ----------------------------------------------------------------------------
2902 wxImageHistogram::FindFirstUnusedColour(unsigned char *r
,
2907 unsigned char g2
) const
2909 unsigned long key
= MakeKey(r2
, g2
, b2
);
2911 while ( find(key
) != end() )
2913 // color already used
2925 wxLogError(_("No unused colour in image.") );
2931 key
= MakeKey(r2
, g2
, b2
);
2945 wxImage::FindFirstUnusedColour(unsigned char *r
,
2950 unsigned char g2
) const
2952 wxImageHistogram histogram
;
2954 ComputeHistogram(histogram
);
2956 return histogram
.FindFirstUnusedColour(r
, g
, b
, r2
, g2
, b2
);
2962 // Counts and returns the number of different colours. Optionally stops
2963 // when it exceeds 'stopafter' different colours. This is useful, for
2964 // example, to see if the image can be saved as 8-bit (256 colour or
2965 // less, in this case it would be invoked as CountColours(256)). Default
2966 // value for stopafter is -1 (don't care).
2968 unsigned long wxImage::CountColours( unsigned long stopafter
) const
2972 unsigned char r
, g
, b
;
2974 unsigned long size
, nentries
, key
;
2977 size
= GetWidth() * GetHeight();
2980 for (unsigned long j
= 0; (j
< size
) && (nentries
<= stopafter
) ; j
++)
2985 key
= wxImageHistogram::MakeKey(r
, g
, b
);
2987 if (h
.Get(key
) == NULL
)
2998 unsigned long wxImage::ComputeHistogram( wxImageHistogram
&h
) const
3000 unsigned char *p
= GetData();
3001 unsigned long nentries
= 0;
3005 const unsigned long size
= GetWidth() * GetHeight();
3007 unsigned char r
, g
, b
;
3008 for ( unsigned long n
= 0; n
< size
; n
++ )
3014 wxImageHistogramEntry
& entry
= h
[wxImageHistogram::MakeKey(r
, g
, b
)];
3016 if ( entry
.value
++ == 0 )
3017 entry
.index
= nentries
++;
3024 * Rotation code by Carlos Moreno
3027 static const double wxROTATE_EPSILON
= 1e-10;
3029 // Auxiliary function to rotate a point (x,y) with respect to point p0
3030 // make it inline and use a straight return to facilitate optimization
3031 // also, the function receives the sine and cosine of the angle to avoid
3032 // repeating the time-consuming calls to these functions -- sin/cos can
3033 // be computed and stored in the calling function.
3035 static inline wxRealPoint
3036 wxRotatePoint(const wxRealPoint
& p
, double cos_angle
, double sin_angle
,
3037 const wxRealPoint
& p0
)
3039 return wxRealPoint(p0
.x
+ (p
.x
- p0
.x
) * cos_angle
- (p
.y
- p0
.y
) * sin_angle
,
3040 p0
.y
+ (p
.y
- p0
.y
) * cos_angle
+ (p
.x
- p0
.x
) * sin_angle
);
3043 static inline wxRealPoint
3044 wxRotatePoint(double x
, double y
, double cos_angle
, double sin_angle
,
3045 const wxRealPoint
& p0
)
3047 return wxRotatePoint (wxRealPoint(x
,y
), cos_angle
, sin_angle
, p0
);
3050 wxImage
wxImage::Rotate(double angle
,
3051 const wxPoint
& centre_of_rotation
,
3053 wxPoint
*offset_after_rotation
) const
3055 // screen coordinates are a mirror image of "real" coordinates
3058 const bool has_alpha
= HasAlpha();
3060 const int w
= GetWidth();
3061 const int h
= GetHeight();
3065 // Create pointer-based array to accelerate access to wxImage's data
3066 unsigned char ** data
= new unsigned char * [h
];
3067 data
[0] = GetData();
3068 for (i
= 1; i
< h
; i
++)
3069 data
[i
] = data
[i
- 1] + (3 * w
);
3071 // Same for alpha channel
3072 unsigned char ** alpha
= NULL
;
3075 alpha
= new unsigned char * [h
];
3076 alpha
[0] = GetAlpha();
3077 for (i
= 1; i
< h
; i
++)
3078 alpha
[i
] = alpha
[i
- 1] + w
;
3081 // precompute coefficients for rotation formula
3082 const double cos_angle
= cos(angle
);
3083 const double sin_angle
= sin(angle
);
3085 // Create new Image to store the result
3086 // First, find rectangle that covers the rotated image; to do that,
3087 // rotate the four corners
3089 const wxRealPoint
p0(centre_of_rotation
.x
, centre_of_rotation
.y
);
3091 wxRealPoint p1
= wxRotatePoint (0, 0, cos_angle
, sin_angle
, p0
);
3092 wxRealPoint p2
= wxRotatePoint (0, h
, cos_angle
, sin_angle
, p0
);
3093 wxRealPoint p3
= wxRotatePoint (w
, 0, cos_angle
, sin_angle
, p0
);
3094 wxRealPoint p4
= wxRotatePoint (w
, h
, cos_angle
, sin_angle
, p0
);
3096 int x1a
= (int) floor (wxMin (wxMin(p1
.x
, p2
.x
), wxMin(p3
.x
, p4
.x
)));
3097 int y1a
= (int) floor (wxMin (wxMin(p1
.y
, p2
.y
), wxMin(p3
.y
, p4
.y
)));
3098 int x2a
= (int) ceil (wxMax (wxMax(p1
.x
, p2
.x
), wxMax(p3
.x
, p4
.x
)));
3099 int y2a
= (int) ceil (wxMax (wxMax(p1
.y
, p2
.y
), wxMax(p3
.y
, p4
.y
)));
3101 // Create rotated image
3102 wxImage
rotated (x2a
- x1a
+ 1, y2a
- y1a
+ 1, false);
3103 // With alpha channel
3107 if (offset_after_rotation
!= NULL
)
3109 *offset_after_rotation
= wxPoint (x1a
, y1a
);
3112 // the rotated (destination) image is always accessed sequentially via this
3113 // pointer, there is no need for pointer-based arrays here
3114 unsigned char *dst
= rotated
.GetData();
3116 unsigned char *alpha_dst
= has_alpha
? rotated
.GetAlpha() : NULL
;
3118 // if the original image has a mask, use its RGB values as the blank pixel,
3119 // else, fall back to default (black).
3120 unsigned char blank_r
= 0;
3121 unsigned char blank_g
= 0;
3122 unsigned char blank_b
= 0;
3126 blank_r
= GetMaskRed();
3127 blank_g
= GetMaskGreen();
3128 blank_b
= GetMaskBlue();
3129 rotated
.SetMaskColour( blank_r
, blank_g
, blank_b
);
3132 // Now, for each point of the rotated image, find where it came from, by
3133 // performing an inverse rotation (a rotation of -angle) and getting the
3134 // pixel at those coordinates
3136 const int rH
= rotated
.GetHeight();
3137 const int rW
= rotated
.GetWidth();
3139 // do the (interpolating) test outside of the loops, so that it is done
3140 // only once, instead of repeating it for each pixel.
3143 for (int y
= 0; y
< rH
; y
++)
3145 for (int x
= 0; x
< rW
; x
++)
3147 wxRealPoint src
= wxRotatePoint (x
+ x1a
, y
+ y1a
, cos_angle
, -sin_angle
, p0
);
3149 if (-0.25 < src
.x
&& src
.x
< w
- 0.75 &&
3150 -0.25 < src
.y
&& src
.y
< h
- 0.75)
3152 // interpolate using the 4 enclosing grid-points. Those
3153 // points can be obtained using floor and ceiling of the
3154 // exact coordinates of the point
3157 if (0 < src
.x
&& src
.x
< w
- 1)
3159 x1
= wxRound(floor(src
.x
));
3160 x2
= wxRound(ceil(src
.x
));
3162 else // else means that x is near one of the borders (0 or width-1)
3164 x1
= x2
= wxRound (src
.x
);
3167 if (0 < src
.y
&& src
.y
< h
- 1)
3169 y1
= wxRound(floor(src
.y
));
3170 y2
= wxRound(ceil(src
.y
));
3174 y1
= y2
= wxRound (src
.y
);
3177 // get four points and the distances (square of the distance,
3178 // for efficiency reasons) for the interpolation formula
3180 // GRG: Do not calculate the points until they are
3181 // really needed -- this way we can calculate
3182 // just one, instead of four, if d1, d2, d3
3183 // or d4 are < wxROTATE_EPSILON
3185 const double d1
= (src
.x
- x1
) * (src
.x
- x1
) + (src
.y
- y1
) * (src
.y
- y1
);
3186 const double d2
= (src
.x
- x2
) * (src
.x
- x2
) + (src
.y
- y1
) * (src
.y
- y1
);
3187 const double d3
= (src
.x
- x2
) * (src
.x
- x2
) + (src
.y
- y2
) * (src
.y
- y2
);
3188 const double d4
= (src
.x
- x1
) * (src
.x
- x1
) + (src
.y
- y2
) * (src
.y
- y2
);
3190 // Now interpolate as a weighted average of the four surrounding
3191 // points, where the weights are the distances to each of those points
3193 // If the point is exactly at one point of the grid of the source
3194 // image, then don't interpolate -- just assign the pixel
3196 // d1,d2,d3,d4 are positive -- no need for abs()
3197 if (d1
< wxROTATE_EPSILON
)
3199 unsigned char *p
= data
[y1
] + (3 * x1
);
3205 *(alpha_dst
++) = *(alpha
[y1
] + x1
);
3207 else if (d2
< wxROTATE_EPSILON
)
3209 unsigned char *p
= data
[y1
] + (3 * x2
);
3215 *(alpha_dst
++) = *(alpha
[y1
] + x2
);
3217 else if (d3
< wxROTATE_EPSILON
)
3219 unsigned char *p
= data
[y2
] + (3 * x2
);
3225 *(alpha_dst
++) = *(alpha
[y2
] + x2
);
3227 else if (d4
< wxROTATE_EPSILON
)
3229 unsigned char *p
= data
[y2
] + (3 * x1
);
3235 *(alpha_dst
++) = *(alpha
[y2
] + x1
);
3239 // weights for the weighted average are proportional to the inverse of the distance
3240 unsigned char *v1
= data
[y1
] + (3 * x1
);
3241 unsigned char *v2
= data
[y1
] + (3 * x2
);
3242 unsigned char *v3
= data
[y2
] + (3 * x2
);
3243 unsigned char *v4
= data
[y2
] + (3 * x1
);
3245 const double w1
= 1/d1
, w2
= 1/d2
, w3
= 1/d3
, w4
= 1/d4
;
3249 *(dst
++) = (unsigned char)
3250 ( (w1
* *(v1
++) + w2
* *(v2
++) +
3251 w3
* *(v3
++) + w4
* *(v4
++)) /
3252 (w1
+ w2
+ w3
+ w4
) );
3253 *(dst
++) = (unsigned char)
3254 ( (w1
* *(v1
++) + w2
* *(v2
++) +
3255 w3
* *(v3
++) + w4
* *(v4
++)) /
3256 (w1
+ w2
+ w3
+ w4
) );
3257 *(dst
++) = (unsigned char)
3258 ( (w1
* *v1
+ w2
* *v2
+
3259 w3
* *v3
+ w4
* *v4
) /
3260 (w1
+ w2
+ w3
+ w4
) );
3264 v1
= alpha
[y1
] + (x1
);
3265 v2
= alpha
[y1
] + (x2
);
3266 v3
= alpha
[y2
] + (x2
);
3267 v4
= alpha
[y2
] + (x1
);
3269 *(alpha_dst
++) = (unsigned char)
3270 ( (w1
* *v1
+ w2
* *v2
+
3271 w3
* *v3
+ w4
* *v4
) /
3272 (w1
+ w2
+ w3
+ w4
) );
3288 else // not interpolating
3290 for (int y
= 0; y
< rH
; y
++)
3292 for (int x
= 0; x
< rW
; x
++)
3294 wxRealPoint src
= wxRotatePoint (x
+ x1a
, y
+ y1a
, cos_angle
, -sin_angle
, p0
);
3296 const int xs
= wxRound (src
.x
); // wxRound rounds to the
3297 const int ys
= wxRound (src
.y
); // closest integer
3299 if (0 <= xs
&& xs
< w
&& 0 <= ys
&& ys
< h
)
3301 unsigned char *p
= data
[ys
] + (3 * xs
);
3307 *(alpha_dst
++) = *(alpha
[ys
] + (xs
));
3316 *(alpha_dst
++) = 255;
3332 // A module to allow wxImage initialization/cleanup
3333 // without calling these functions from app.cpp or from
3334 // the user's application.
3336 class wxImageModule
: public wxModule
3338 DECLARE_DYNAMIC_CLASS(wxImageModule
)
3341 bool OnInit() { wxImage::InitStandardHandlers(); return true; }
3342 void OnExit() { wxImage::CleanUpHandlers(); }
3345 IMPLEMENT_DYNAMIC_CLASS(wxImageModule
, wxModule
)
3348 #endif // wxUSE_IMAGE