1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Robert Roebling
6 // Copyright: (c) Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
10 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
11 #pragma implementation "image.h"
14 // For compilers that support precompilation, includes "wx.h".
15 #include "wx/wxprec.h"
26 #include "wx/bitmap.h"
30 #include "wx/filefn.h"
31 #include "wx/wfstream.h"
33 #include "wx/module.h"
39 #include "wx/xpmdecod.h"
50 //-----------------------------------------------------------------------------
52 //-----------------------------------------------------------------------------
54 class wxImageRefData
: public wxObjectRefData
58 virtual ~wxImageRefData();
62 unsigned char *m_data
;
65 unsigned char m_maskRed
,m_maskGreen
,m_maskBlue
;
67 // alpha channel data, may be NULL for the formats without alpha support
68 unsigned char *m_alpha
;
75 #endif // wxUSE_PALETTE
77 wxArrayString m_optionNames
;
78 wxArrayString m_optionValues
;
80 DECLARE_NO_COPY_CLASS(wxImageRefData
)
83 wxImageRefData
::wxImageRefData()
88 m_alpha
= (unsigned char *) NULL
;
99 wxImageRefData
::~wxImageRefData()
108 wxList wxImage
::sm_handlers
;
112 //-----------------------------------------------------------------------------
114 #define M_IMGDATA ((wxImageRefData *)m_refData)
116 IMPLEMENT_DYNAMIC_CLASS(wxImage
, wxObject
)
118 wxImage
::wxImage( int width
, int height
, bool clear
)
120 Create( width
, height
, clear
);
123 wxImage
::wxImage( int width
, int height
, unsigned char* data
, bool static_data
)
125 Create( width
, height
, data
, static_data
);
128 wxImage
::wxImage( int width
, int height
, unsigned char* data
, unsigned char* alpha
, bool static_data
)
130 Create( width
, height
, data
, alpha
, static_data
);
133 wxImage
::wxImage( const wxString
& name
, long type
, int index
)
135 LoadFile( name
, type
, index
);
138 wxImage
::wxImage( const wxString
& name
, const wxString
& mimetype
, int index
)
140 LoadFile( name
, mimetype
, index
);
144 wxImage
::wxImage( wxInputStream
& stream
, long type
, int index
)
146 LoadFile( stream
, type
, index
);
149 wxImage
::wxImage( wxInputStream
& stream
, const wxString
& mimetype
, int index
)
151 LoadFile( stream
, mimetype
, index
);
153 #endif // wxUSE_STREAMS
155 wxImage
::wxImage( const wxImage
& image
)
161 wxImage
::wxImage( const wxImage
* image
)
163 if (image
) Ref(*image
);
166 wxImage
::wxImage( const char** xpmData
)
171 wxImage
::wxImage( char** xpmData
)
173 Create((const char**) xpmData
);
176 bool wxImage
::Create( const char** xpmData
)
181 wxXPMDecoder decoder
;
182 (*this) = decoder
.ReadData(xpmData
);
189 bool wxImage
::Create( int width
, int height
, bool clear
)
193 m_refData
= new wxImageRefData();
195 M_IMGDATA
->m_data
= (unsigned char *) malloc( width
*height
*3 );
196 if (!M_IMGDATA
->m_data
)
203 memset(M_IMGDATA
->m_data
, 0, width
*height
*3);
205 M_IMGDATA
->m_width
= width
;
206 M_IMGDATA
->m_height
= height
;
207 M_IMGDATA
->m_ok
= true;
212 bool wxImage
::Create( int width
, int height
, unsigned char* data
, bool static_data
)
216 wxCHECK_MSG( data
, false, _T("NULL data in wxImage::Create") );
218 m_refData
= new wxImageRefData();
220 M_IMGDATA
->m_data
= data
;
221 M_IMGDATA
->m_width
= width
;
222 M_IMGDATA
->m_height
= height
;
223 M_IMGDATA
->m_ok
= true;
224 M_IMGDATA
->m_static
= static_data
;
229 bool wxImage
::Create( int width
, int height
, unsigned char* data
, unsigned char* alpha
, bool static_data
)
233 wxCHECK_MSG( data
, false, _T("NULL data in wxImage::Create") );
235 m_refData
= new wxImageRefData();
237 M_IMGDATA
->m_data
= data
;
238 M_IMGDATA
->m_alpha
= alpha
;
239 M_IMGDATA
->m_width
= width
;
240 M_IMGDATA
->m_height
= height
;
241 M_IMGDATA
->m_ok
= true;
242 M_IMGDATA
->m_static
= static_data
;
247 void wxImage
::Destroy()
252 wxImage wxImage
::Copy() const
256 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
258 image
.Create( M_IMGDATA
->m_width
, M_IMGDATA
->m_height
, false );
260 unsigned char *data
= image
.GetData();
262 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
264 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
265 image
.SetMask( M_IMGDATA
->m_hasMask
);
267 memcpy( data
, GetData(), M_IMGDATA
->m_width
*M_IMGDATA
->m_height
*3 );
269 // also copy the image options
270 wxImageRefData
*imgData
= (wxImageRefData
*)image
.m_refData
;
271 imgData
->m_optionNames
= M_IMGDATA
->m_optionNames
;
272 imgData
->m_optionValues
= M_IMGDATA
->m_optionValues
;
277 wxImage wxImage
::ShrinkBy( int xFactor
, int yFactor
) const
279 if( xFactor
== 1 && yFactor
== 1 )
284 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
286 // can't scale to/from 0 size
287 wxCHECK_MSG( (xFactor
> 0) && (yFactor
> 0), image
,
288 wxT("invalid new image size") );
290 long old_height
= M_IMGDATA
->m_height
,
291 old_width
= M_IMGDATA
->m_width
;
293 wxCHECK_MSG( (old_height
> 0) && (old_width
> 0), image
,
294 wxT("invalid old image size") );
296 long width
= old_width
/ xFactor
;
297 long height
= old_height
/ yFactor
;
299 image
.Create( width
, height
, false );
301 char unsigned *data
= image
.GetData();
303 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
305 bool hasMask
= false ;
306 unsigned char maskRed
= 0;
307 unsigned char maskGreen
= 0;
308 unsigned char maskBlue
=0 ;
310 unsigned char *source_data
= M_IMGDATA
->m_data
;
311 unsigned char *target_data
= data
;
312 unsigned char *source_alpha
= 0 ;
313 unsigned char *target_alpha
= 0 ;
314 if (M_IMGDATA
->m_hasMask
)
317 maskRed
= M_IMGDATA
->m_maskRed
;
318 maskGreen
= M_IMGDATA
->m_maskGreen
;
319 maskBlue
=M_IMGDATA
->m_maskBlue
;
321 image
.SetMaskColour( M_IMGDATA
->m_maskRed
,
322 M_IMGDATA
->m_maskGreen
,
323 M_IMGDATA
->m_maskBlue
);
327 source_alpha
= M_IMGDATA
->m_alpha
;
331 target_alpha
= image
.GetAlpha() ;
335 for (long y
= 0; y
< height
; y
++)
337 for (long x
= 0; x
< width
; x
++)
339 unsigned long avgRed
= 0 ;
340 unsigned long avgGreen
= 0;
341 unsigned long avgBlue
= 0;
342 unsigned long avgAlpha
= 0 ;
343 unsigned long counter
= 0 ;
345 for ( int y1
= 0 ; y1
< yFactor
; ++y1
)
347 long y_offset
= (y
* yFactor
+ y1
) * old_width
;
348 for ( int x1
= 0 ; x1
< xFactor
; ++x1
)
350 unsigned char *pixel
= source_data
+ 3 * ( y_offset
+ x
* xFactor
+ x1
) ;
351 unsigned char red
= pixel
[0] ;
352 unsigned char green
= pixel
[1] ;
353 unsigned char blue
= pixel
[2] ;
354 unsigned char alpha
= 255 ;
356 alpha
= *(source_alpha
+ y_offset
+ x
* xFactor
+ x1
) ;
357 if ( !hasMask
|| red
!= maskRed
|| green
!= maskGreen
|| blue
!= maskBlue
)
372 *(target_data
++) = M_IMGDATA
->m_maskRed
;
373 *(target_data
++) = M_IMGDATA
->m_maskGreen
;
374 *(target_data
++) = M_IMGDATA
->m_maskBlue
;
379 *(target_alpha
++) = (unsigned char)(avgAlpha
/ counter
) ;
380 *(target_data
++) = (unsigned char)(avgRed
/ counter
);
381 *(target_data
++) = (unsigned char)(avgGreen
/ counter
);
382 *(target_data
++) = (unsigned char)(avgBlue
/ counter
);
387 // In case this is a cursor, make sure the hotspot is scalled accordingly:
388 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
) )
389 image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
,
390 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X
))/xFactor
);
391 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
) )
392 image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
,
393 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y
))/yFactor
);
398 wxImage wxImage
::Scale( int width
, int height
) const
402 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
404 // can't scale to/from 0 size
405 wxCHECK_MSG( (width
> 0) && (height
> 0), image
,
406 wxT("invalid new image size") );
408 long old_height
= M_IMGDATA
->m_height
,
409 old_width
= M_IMGDATA
->m_width
;
410 wxCHECK_MSG( (old_height
> 0) && (old_width
> 0), image
,
411 wxT("invalid old image size") );
413 if ( old_width
% width
== 0 && old_width
>= width
&&
414 old_height
% height
== 0 && old_height
>= height
)
416 return ShrinkBy( old_width
/ width
, old_height
/ height
) ;
418 image
.Create( width
, height
, false );
420 unsigned char *data
= image
.GetData();
422 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
424 unsigned char *source_data
= M_IMGDATA
->m_data
;
425 unsigned char *target_data
= data
;
426 unsigned char *source_alpha
= 0 ;
427 unsigned char *target_alpha
= 0 ;
429 if (M_IMGDATA
->m_hasMask
)
431 image
.SetMaskColour( M_IMGDATA
->m_maskRed
,
432 M_IMGDATA
->m_maskGreen
,
433 M_IMGDATA
->m_maskBlue
);
437 source_alpha
= M_IMGDATA
->m_alpha
;
441 target_alpha
= image
.GetAlpha() ;
445 long x_delta
= (old_width
<<16) / width
;
446 long y_delta
= (old_height
<<16) / height
;
448 unsigned char* dest_pixel
= target_data
;
451 for ( long j
= 0; j
< height
; j
++ )
453 unsigned char* src_line
= &source_data
[(y
>>16)*old_width
*3];
454 unsigned char* src_alpha_line
= source_alpha ?
&source_alpha
[(y
>>16)*old_width
] : 0 ;
457 for ( long i
= 0; i
< width
; i
++ )
459 unsigned char* src_pixel
= &src_line
[(x
>>16)*3];
460 unsigned char* src_alpha_pixel
= source_alpha ?
&src_alpha_line
[(x
>>16)] : 0 ;
461 dest_pixel
[0] = src_pixel
[0];
462 dest_pixel
[1] = src_pixel
[1];
463 dest_pixel
[2] = src_pixel
[2];
466 *(target_alpha
++) = *src_alpha_pixel
;
473 // In case this is a cursor, make sure the hotspot is scalled accordingly:
474 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
) )
475 image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
,
476 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X
)*width
)/old_width
);
477 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
) )
478 image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
,
479 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y
)*height
)/old_height
);
484 wxImage wxImage
::Rotate90( bool clockwise
) const
488 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
490 image
.Create( M_IMGDATA
->m_height
, M_IMGDATA
->m_width
, false );
492 unsigned char *data
= image
.GetData();
494 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
496 if (M_IMGDATA
->m_hasMask
)
497 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
499 long height
= M_IMGDATA
->m_height
;
500 long width
= M_IMGDATA
->m_width
;
502 unsigned char *source_data
= M_IMGDATA
->m_data
;
503 unsigned char *target_data
;
505 for (long j
= 0; j
< height
; j
++)
507 for (long i
= 0; i
< width
; i
++)
510 target_data
= data
+ (((i
+1)*height
) - j
- 1)*3;
512 target_data
= data
+ ((height
*(width
-1)) + j
- (i
*height
))*3;
513 memcpy( target_data
, source_data
, 3 );
521 wxImage wxImage
::Mirror( bool horizontally
) const
525 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
527 image
.Create( M_IMGDATA
->m_width
, M_IMGDATA
->m_height
, false );
529 unsigned char *data
= image
.GetData();
531 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
533 if (M_IMGDATA
->m_hasMask
)
534 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
536 long height
= M_IMGDATA
->m_height
;
537 long width
= M_IMGDATA
->m_width
;
539 unsigned char *source_data
= M_IMGDATA
->m_data
;
540 unsigned char *target_data
;
544 for (long j
= 0; j
< height
; j
++)
547 target_data
= data
-3;
548 for (long i
= 0; i
< width
; i
++)
550 memcpy( target_data
, source_data
, 3 );
558 for (long i
= 0; i
< height
; i
++)
560 target_data
= data
+ 3*width
*(height
-1-i
);
561 memcpy( target_data
, source_data
, (size_t)3*width
);
562 source_data
+= 3*width
;
569 wxImage wxImage
::GetSubImage( const wxRect
&rect
) const
573 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
575 wxCHECK_MSG( (rect
.GetLeft()>=0) && (rect
.GetTop()>=0) && (rect
.GetRight()<=GetWidth()) && (rect
.GetBottom()<=GetHeight()),
576 image
, wxT("invalid subimage size") );
578 int subwidth
=rect
.GetWidth();
579 const int subheight
=rect
.GetHeight();
581 image
.Create( subwidth
, subheight
, false );
583 unsigned char *subdata
= image
.GetData(), *data
=GetData();
585 wxCHECK_MSG( subdata
, image
, wxT("unable to create image") );
587 if (M_IMGDATA
->m_hasMask
)
588 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
590 const int subleft
=3*rect
.GetLeft();
591 const int width
=3*GetWidth();
594 data
+=rect
.GetTop()*width
+subleft
;
596 for (long j
= 0; j
< subheight
; ++j
)
598 memcpy( subdata
, data
, subwidth
);
606 wxImage wxImage
::Size( const wxSize
& size
, const wxPoint
& pos
,
607 int r_
, int g_
, int b_
) const
611 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
612 wxCHECK_MSG( (size
.GetWidth() > 0) && (size
.GetHeight() > 0), image
, wxT("invalid size") );
614 int width
= GetWidth(), height
= GetHeight();
615 image
.Create(size
.GetWidth(), size
.GetHeight(), false);
617 unsigned char r
= (unsigned char)r_
;
618 unsigned char g
= (unsigned char)g_
;
619 unsigned char b
= (unsigned char)b_
;
620 if ((r_
== -1) && (g_
== -1) && (b_
== -1))
622 GetOrFindMaskColour( &r
, &g
, &b
);
623 image
.SetMaskColour(r
, g
, b
);
626 image
.SetRGB(wxRect(), r
, g
, b
);
628 wxRect
subRect(pos
.x
, pos
.y
, width
, height
);
629 wxRect
finalRect(0, 0, size
.GetWidth(), size
.GetHeight());
631 subRect
.Intersect(finalRect
);
633 if (!subRect
.IsEmpty())
635 if ((subRect
.GetWidth() == width
) && (subRect
.GetHeight() == height
))
636 image
.Paste(*this, pos
.x
, pos
.y
);
638 image
.Paste(GetSubImage(subRect
), pos
.x
, pos
.y
);
644 void wxImage
::Paste( const wxImage
&image
, int x
, int y
)
646 wxCHECK_RET( Ok(), wxT("invalid image") );
647 wxCHECK_RET( image
.Ok(), wxT("invalid image") );
651 int width
= image
.GetWidth();
652 int height
= image
.GetHeight();
665 if ((x
+xx
)+width
> M_IMGDATA
->m_width
)
666 width
= M_IMGDATA
->m_width
- (x
+xx
);
667 if ((y
+yy
)+height
> M_IMGDATA
->m_height
)
668 height
= M_IMGDATA
->m_height
- (y
+yy
);
670 if (width
< 1) return;
671 if (height
< 1) return;
673 if ((!HasMask() && !image
.HasMask()) ||
674 (HasMask() && !image
.HasMask()) ||
675 ((HasMask() && image
.HasMask() &&
676 (GetMaskRed()==image
.GetMaskRed()) &&
677 (GetMaskGreen()==image
.GetMaskGreen()) &&
678 (GetMaskBlue()==image
.GetMaskBlue()))))
681 unsigned char* source_data
= image
.GetData() + xx
*3 + yy
*3*image
.GetWidth();
682 int source_step
= image
.GetWidth()*3;
684 unsigned char* target_data
= GetData() + (x
+xx
)*3 + (y
+yy
)*3*M_IMGDATA
->m_width
;
685 int target_step
= M_IMGDATA
->m_width
*3;
686 for (int j
= 0; j
< height
; j
++)
688 memcpy( target_data
, source_data
, width
);
689 source_data
+= source_step
;
690 target_data
+= target_step
;
695 if (!HasMask() && image
.HasMask())
697 unsigned char r
= image
.GetMaskRed();
698 unsigned char g
= image
.GetMaskGreen();
699 unsigned char b
= image
.GetMaskBlue();
702 unsigned char* source_data
= image
.GetData() + xx
*3 + yy
*3*image
.GetWidth();
703 int source_step
= image
.GetWidth()*3;
705 unsigned char* target_data
= GetData() + (x
+xx
)*3 + (y
+yy
)*3*M_IMGDATA
->m_width
;
706 int target_step
= M_IMGDATA
->m_width
*3;
708 for (int j
= 0; j
< height
; j
++)
710 for (int i
= 0; i
< width
; i
+=3)
712 if ((source_data
[i
] != r
) &&
713 (source_data
[i
+1] != g
) &&
714 (source_data
[i
+2] != b
))
716 memcpy( target_data
+i
, source_data
+i
, 3 );
719 source_data
+= source_step
;
720 target_data
+= target_step
;
725 void wxImage
::Replace( unsigned char r1
, unsigned char g1
, unsigned char b1
,
726 unsigned char r2
, unsigned char g2
, unsigned char b2
)
728 wxCHECK_RET( Ok(), wxT("invalid image") );
730 unsigned char *data
= GetData();
732 const int w
= GetWidth();
733 const int h
= GetHeight();
735 for (int j
= 0; j
< h
; j
++)
736 for (int i
= 0; i
< w
; i
++)
738 if ((data
[0] == r1
) && (data
[1] == g1
) && (data
[2] == b1
))
748 wxImage wxImage
::ConvertToMono( unsigned char r
, unsigned char g
, unsigned char b
) const
752 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
754 image
.Create( M_IMGDATA
->m_width
, M_IMGDATA
->m_height
, false );
756 unsigned char *data
= image
.GetData();
758 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
760 if (M_IMGDATA
->m_hasMask
)
762 if (M_IMGDATA
->m_maskRed
== r
&& M_IMGDATA
->m_maskGreen
== g
&&
763 M_IMGDATA
->m_maskBlue
== b
)
764 image
.SetMaskColour( 255, 255, 255 );
766 image
.SetMaskColour( 0, 0, 0 );
769 long size
= M_IMGDATA
->m_height
* M_IMGDATA
->m_width
;
771 unsigned char *srcd
= M_IMGDATA
->m_data
;
772 unsigned char *tard
= image
.GetData();
774 for ( long i
= 0; i
< size
; i
++, srcd
+= 3, tard
+= 3 )
776 if (srcd
[0] == r
&& srcd
[1] == g
&& srcd
[2] == b
)
777 tard
[0] = tard
[1] = tard
[2] = 255;
779 tard
[0] = tard
[1] = tard
[2] = 0;
785 long wxImage
::XYToIndex(int x
, int y
) const
789 x
< M_IMGDATA
->m_width
&& y
< M_IMGDATA
->m_height
)
791 return y
*M_IMGDATA
->m_width
+ x
;
797 void wxImage
::SetRGB( int x
, int y
, unsigned char r
, unsigned char g
, unsigned char b
)
799 long pos
= XYToIndex(x
, y
);
800 wxCHECK_RET( pos
!= -1, wxT("invalid image coordinates") );
804 M_IMGDATA
->m_data
[ pos
] = r
;
805 M_IMGDATA
->m_data
[ pos
+1 ] = g
;
806 M_IMGDATA
->m_data
[ pos
+2 ] = b
;
809 void wxImage
::SetRGB( const wxRect
& rect_
, unsigned char r
, unsigned char g
, unsigned char b
)
811 wxCHECK_RET( Ok(), wxT("invalid image") );
814 wxRect
imageRect(0, 0, GetWidth(), GetHeight());
815 if ( rect
== wxRect() )
821 wxCHECK_RET( imageRect
.Inside(rect
.GetTopLeft()) &&
822 imageRect
.Inside(rect
.GetBottomRight()),
823 wxT("invalid bounding rectangle") );
826 int x1
= rect
.GetLeft(),
828 x2
= rect
.GetRight() + 1,
829 y2
= rect
.GetBottom() + 1;
831 unsigned char *data
wxDUMMY_INITIALIZE(NULL
);
832 int x
, y
, width
= GetWidth();
833 for (y
= y1
; y
< y2
; y
++)
835 data
= M_IMGDATA
->m_data
+ (y
*width
+ x1
)*3;
836 for (x
= x1
; x
< x2
; x
++)
845 unsigned char wxImage
::GetRed( int x
, int y
) const
847 long pos
= XYToIndex(x
, y
);
848 wxCHECK_MSG( pos
!= -1, 0, wxT("invalid image coordinates") );
852 return M_IMGDATA
->m_data
[pos
];
855 unsigned char wxImage
::GetGreen( int x
, int y
) const
857 long pos
= XYToIndex(x
, y
);
858 wxCHECK_MSG( pos
!= -1, 0, wxT("invalid image coordinates") );
862 return M_IMGDATA
->m_data
[pos
+1];
865 unsigned char wxImage
::GetBlue( int x
, int y
) const
867 long pos
= XYToIndex(x
, y
);
868 wxCHECK_MSG( pos
!= -1, 0, wxT("invalid image coordinates") );
872 return M_IMGDATA
->m_data
[pos
+2];
875 bool wxImage
::Ok() const
877 // image of 0 width or height can't be considered ok - at least because it
878 // causes crashes in ConvertToBitmap() if we don't catch it in time
879 wxImageRefData
*data
= M_IMGDATA
;
880 return data
&& data
->m_ok
&& data
->m_width
&& data
->m_height
;
883 unsigned char *wxImage
::GetData() const
885 wxCHECK_MSG( Ok(), (unsigned char *)NULL
, wxT("invalid image") );
887 return M_IMGDATA
->m_data
;
890 void wxImage
::SetData( unsigned char *data
, bool static_data
)
892 wxCHECK_RET( Ok(), wxT("invalid image") );
894 wxImageRefData
*newRefData
= new wxImageRefData();
896 newRefData
->m_width
= M_IMGDATA
->m_width
;
897 newRefData
->m_height
= M_IMGDATA
->m_height
;
898 newRefData
->m_data
= data
;
899 newRefData
->m_ok
= true;
900 newRefData
->m_maskRed
= M_IMGDATA
->m_maskRed
;
901 newRefData
->m_maskGreen
= M_IMGDATA
->m_maskGreen
;
902 newRefData
->m_maskBlue
= M_IMGDATA
->m_maskBlue
;
903 newRefData
->m_hasMask
= M_IMGDATA
->m_hasMask
;
904 newRefData
->m_static
= static_data
;
908 m_refData
= newRefData
;
911 void wxImage
::SetData( unsigned char *data
, int new_width
, int new_height
, bool static_data
)
913 wxImageRefData
*newRefData
= new wxImageRefData();
917 newRefData
->m_width
= new_width
;
918 newRefData
->m_height
= new_height
;
919 newRefData
->m_data
= data
;
920 newRefData
->m_ok
= true;
921 newRefData
->m_maskRed
= M_IMGDATA
->m_maskRed
;
922 newRefData
->m_maskGreen
= M_IMGDATA
->m_maskGreen
;
923 newRefData
->m_maskBlue
= M_IMGDATA
->m_maskBlue
;
924 newRefData
->m_hasMask
= M_IMGDATA
->m_hasMask
;
928 newRefData
->m_width
= new_width
;
929 newRefData
->m_height
= new_height
;
930 newRefData
->m_data
= data
;
931 newRefData
->m_ok
= true;
933 newRefData
->m_static
= static_data
;
937 m_refData
= newRefData
;
940 // ----------------------------------------------------------------------------
941 // alpha channel support
942 // ----------------------------------------------------------------------------
944 void wxImage
::SetAlpha(int x
, int y
, unsigned char alpha
)
946 wxCHECK_RET( HasAlpha(), wxT("no alpha channel") );
948 long pos
= XYToIndex(x
, y
);
949 wxCHECK_RET( pos
!= -1, wxT("invalid image coordinates") );
951 M_IMGDATA
->m_alpha
[pos
] = alpha
;
954 unsigned char wxImage
::GetAlpha(int x
, int y
) const
956 wxCHECK_MSG( HasAlpha(), 0, wxT("no alpha channel") );
958 long pos
= XYToIndex(x
, y
);
959 wxCHECK_MSG( pos
!= -1, 0, wxT("invalid image coordinates") );
961 return M_IMGDATA
->m_alpha
[pos
];
965 wxImage
::ConvertColourToAlpha(unsigned char r
, unsigned char g
, unsigned char b
)
969 const int w
= M_IMGDATA
->m_width
;
970 const int h
= M_IMGDATA
->m_height
;
972 unsigned char *alpha
= GetAlpha();
973 unsigned char *data
= GetData();
975 for ( int y
= 0; y
< h
; y
++ )
977 for ( int x
= 0; x
< w
; x
++ )
989 void wxImage
::SetAlpha( unsigned char *alpha
, bool static_data
)
991 wxCHECK_RET( Ok(), wxT("invalid image") );
995 alpha
= (unsigned char *)malloc(M_IMGDATA
->m_width
*M_IMGDATA
->m_height
);
998 free(M_IMGDATA
->m_alpha
);
999 M_IMGDATA
->m_alpha
= alpha
;
1000 M_IMGDATA
->m_static
= static_data
;
1003 unsigned char *wxImage
::GetAlpha() const
1005 wxCHECK_MSG( Ok(), (unsigned char *)NULL
, wxT("invalid image") );
1007 return M_IMGDATA
->m_alpha
;
1010 void wxImage
::InitAlpha()
1012 wxCHECK_RET( !HasAlpha(), wxT("image already has an alpha channel") );
1014 // initialize memory for alpha channel
1017 unsigned char *alpha
= M_IMGDATA
->m_alpha
;
1018 const size_t lenAlpha
= M_IMGDATA
->m_width
* M_IMGDATA
->m_height
;
1020 static const unsigned char ALPHA_TRANSPARENT
= 0;
1021 static const unsigned char ALPHA_OPAQUE
= 0xff;
1024 // use the mask to initialize the alpha channel.
1025 const unsigned char * const alphaEnd
= alpha
+ lenAlpha
;
1027 const unsigned char mr
= M_IMGDATA
->m_maskRed
;
1028 const unsigned char mg
= M_IMGDATA
->m_maskGreen
;
1029 const unsigned char mb
= M_IMGDATA
->m_maskBlue
;
1030 for ( unsigned char *src
= M_IMGDATA
->m_data
;
1034 *alpha
= (src
[0] == mr
&& src
[1] == mg
&& src
[2] == mb
)
1039 M_IMGDATA
->m_hasMask
= false;
1043 // make the image fully opaque
1044 memset(alpha
, ALPHA_OPAQUE
, lenAlpha
);
1048 // ----------------------------------------------------------------------------
1050 // ----------------------------------------------------------------------------
1052 void wxImage
::SetMaskColour( unsigned char r
, unsigned char g
, unsigned char b
)
1054 wxCHECK_RET( Ok(), wxT("invalid image") );
1056 M_IMGDATA
->m_maskRed
= r
;
1057 M_IMGDATA
->m_maskGreen
= g
;
1058 M_IMGDATA
->m_maskBlue
= b
;
1059 M_IMGDATA
->m_hasMask
= true;
1062 bool wxImage
::GetOrFindMaskColour( unsigned char *r
, unsigned char *g
, unsigned char *b
) const
1064 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1066 if (M_IMGDATA
->m_hasMask
)
1068 if (r
) *r
= M_IMGDATA
->m_maskRed
;
1069 if (g
) *g
= M_IMGDATA
->m_maskGreen
;
1070 if (b
) *b
= M_IMGDATA
->m_maskBlue
;
1075 FindFirstUnusedColour(r
, g
, b
);
1080 unsigned char wxImage
::GetMaskRed() const
1082 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1084 return M_IMGDATA
->m_maskRed
;
1087 unsigned char wxImage
::GetMaskGreen() const
1089 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1091 return M_IMGDATA
->m_maskGreen
;
1094 unsigned char wxImage
::GetMaskBlue() const
1096 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1098 return M_IMGDATA
->m_maskBlue
;
1101 void wxImage
::SetMask( bool mask
)
1103 wxCHECK_RET( Ok(), wxT("invalid image") );
1105 M_IMGDATA
->m_hasMask
= mask
;
1108 bool wxImage
::HasMask() const
1110 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1112 return M_IMGDATA
->m_hasMask
;
1115 int wxImage
::GetWidth() const
1117 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1119 return M_IMGDATA
->m_width
;
1122 int wxImage
::GetHeight() const
1124 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1126 return M_IMGDATA
->m_height
;
1129 bool wxImage
::SetMaskFromImage(const wxImage
& mask
,
1130 unsigned char mr
, unsigned char mg
, unsigned char mb
)
1132 // check that the images are the same size
1133 if ( (M_IMGDATA
->m_height
!= mask
.GetHeight() ) || (M_IMGDATA
->m_width
!= mask
.GetWidth () ) )
1135 wxLogError( _("Image and mask have different sizes.") );
1139 // find unused colour
1140 unsigned char r
,g
,b
;
1141 if (!FindFirstUnusedColour(&r
, &g
, &b
))
1143 wxLogError( _("No unused colour in image being masked.") );
1147 unsigned char *imgdata
= GetData();
1148 unsigned char *maskdata
= mask
.GetData();
1150 const int w
= GetWidth();
1151 const int h
= GetHeight();
1153 for (int j
= 0; j
< h
; j
++)
1155 for (int i
= 0; i
< w
; i
++)
1157 if ((maskdata
[0] == mr
) && (maskdata
[1] == mg
) && (maskdata
[2] == mb
))
1168 SetMaskColour(r
, g
, b
);
1174 bool wxImage
::ConvertAlphaToMask(unsigned char threshold
)
1179 unsigned char mr
, mg
, mb
;
1180 if (!FindFirstUnusedColour(&mr
, &mg
, &mb
))
1182 wxLogError( _("No unused colour in image being masked.") );
1187 SetMaskColour(mr
, mg
, mb
);
1189 unsigned char *imgdata
= GetData();
1190 unsigned char *alphadata
= GetAlpha();
1193 int h
= GetHeight();
1195 for (int y
= 0; y
< h
; y
++)
1197 for (int x
= 0; x
< w
; x
++, imgdata
+= 3, alphadata
++)
1199 if (*alphadata
< threshold
)
1208 free(M_IMGDATA
->m_alpha
);
1209 M_IMGDATA
->m_alpha
= NULL
;
1216 // Palette functions
1218 bool wxImage
::HasPalette() const
1223 return M_IMGDATA
->m_palette
.Ok();
1226 const wxPalette
& wxImage
::GetPalette() const
1228 wxCHECK_MSG( Ok(), wxNullPalette
, wxT("invalid image") );
1230 return M_IMGDATA
->m_palette
;
1233 void wxImage
::SetPalette(const wxPalette
& palette
)
1235 wxCHECK_RET( Ok(), wxT("invalid image") );
1237 M_IMGDATA
->m_palette
= palette
;
1240 #endif // wxUSE_PALETTE
1242 // Option functions (arbitrary name/value mapping)
1243 void wxImage
::SetOption(const wxString
& name
, const wxString
& value
)
1245 wxCHECK_RET( Ok(), wxT("invalid image") );
1247 int idx
= M_IMGDATA
->m_optionNames
.Index(name
, false);
1248 if (idx
== wxNOT_FOUND
)
1250 M_IMGDATA
->m_optionNames
.Add(name
);
1251 M_IMGDATA
->m_optionValues
.Add(value
);
1255 M_IMGDATA
->m_optionNames
[idx
] = name
;
1256 M_IMGDATA
->m_optionValues
[idx
] = value
;
1260 void wxImage
::SetOption(const wxString
& name
, int value
)
1263 valStr
.Printf(wxT("%d"), value
);
1264 SetOption(name
, valStr
);
1267 wxString wxImage
::GetOption(const wxString
& name
) const
1269 wxCHECK_MSG( Ok(), wxEmptyString
, wxT("invalid image") );
1271 int idx
= M_IMGDATA
->m_optionNames
.Index(name
, false);
1272 if (idx
== wxNOT_FOUND
)
1273 return wxEmptyString
;
1275 return M_IMGDATA
->m_optionValues
[idx
];
1278 int wxImage
::GetOptionInt(const wxString
& name
) const
1280 return wxAtoi(GetOption(name
));
1283 bool wxImage
::HasOption(const wxString
& name
) const
1285 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1287 return (M_IMGDATA
->m_optionNames
.Index(name
, false) != wxNOT_FOUND
);
1290 bool wxImage
::LoadFile( const wxString
& filename
, long type
, int index
)
1293 if (wxFileExists(filename
))
1295 wxFileInputStream
stream(filename
);
1296 wxBufferedInputStream
bstream( stream
);
1297 return LoadFile(bstream
, type
, index
);
1301 wxLogError( _("Can't load image from file '%s': file does not exist."), filename
.c_str() );
1305 #else // !wxUSE_STREAMS
1307 #endif // wxUSE_STREAMS
1310 bool wxImage
::LoadFile( const wxString
& filename
, const wxString
& mimetype
, int index
)
1313 if (wxFileExists(filename
))
1315 wxFileInputStream
stream(filename
);
1316 wxBufferedInputStream
bstream( stream
);
1317 return LoadFile(bstream
, mimetype
, index
);
1321 wxLogError( _("Can't load image from file '%s': file does not exist."), filename
.c_str() );
1325 #else // !wxUSE_STREAMS
1327 #endif // wxUSE_STREAMS
1332 bool wxImage
::SaveFile( const wxString
& filename
) const
1334 wxString ext
= filename
.AfterLast('.').Lower();
1336 wxImageHandler
* pHandler
= FindHandler(ext
, -1);
1339 SaveFile(filename
, pHandler
->GetType());
1343 wxLogError(_("Can't save image to file '%s': unknown extension."), filename
.c_str());
1348 bool wxImage
::SaveFile( const wxString
& filename
, int type
) const
1351 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1353 ((wxImage
*)this)->SetOption(wxIMAGE_OPTION_FILENAME
, filename
);
1355 wxFileOutputStream
stream(filename
);
1357 if ( stream
.IsOk() )
1359 wxBufferedOutputStream
bstream( stream
);
1360 return SaveFile(bstream
, type
);
1362 #endif // wxUSE_STREAMS
1367 bool wxImage
::SaveFile( const wxString
& filename
, const wxString
& mimetype
) const
1370 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1372 ((wxImage
*)this)->SetOption(wxIMAGE_OPTION_FILENAME
, filename
);
1374 wxFileOutputStream
stream(filename
);
1376 if ( stream
.IsOk() )
1378 wxBufferedOutputStream
bstream( stream
);
1379 return SaveFile(bstream
, mimetype
);
1381 #endif // wxUSE_STREAMS
1386 bool wxImage
::CanRead( const wxString
&name
)
1389 wxFileInputStream
stream(name
);
1390 return CanRead(stream
);
1396 int wxImage
::GetImageCount( const wxString
&name
, long type
)
1399 wxFileInputStream
stream(name
);
1401 return GetImageCount(stream
, type
);
1409 bool wxImage
::CanRead( wxInputStream
&stream
)
1411 const wxList
& list
= GetHandlers();
1413 for ( wxList
::compatibility_iterator node
= list
.GetFirst(); node
; node
= node
->GetNext() )
1415 wxImageHandler
*handler
=(wxImageHandler
*)node
->GetData();
1416 if (handler
->CanRead( stream
))
1423 int wxImage
::GetImageCount( wxInputStream
&stream
, long type
)
1425 wxImageHandler
*handler
;
1427 if ( type
== wxBITMAP_TYPE_ANY
)
1429 wxList
&list
=GetHandlers();
1431 for (wxList
::compatibility_iterator node
= list
.GetFirst(); node
; node
= node
->GetNext())
1433 handler
=(wxImageHandler
*)node
->GetData();
1434 if ( handler
->CanRead(stream
) )
1435 return handler
->GetImageCount(stream
);
1439 wxLogWarning(_("No handler found for image type."));
1443 handler
= FindHandler(type
);
1447 wxLogWarning(_("No image handler for type %d defined."), type
);
1451 if ( handler
->CanRead(stream
) )
1453 return handler
->GetImageCount(stream
);
1457 wxLogError(_("Image file is not of type %d."), type
);
1462 bool wxImage
::LoadFile( wxInputStream
& stream
, long type
, int index
)
1466 m_refData
= new wxImageRefData
;
1468 wxImageHandler
*handler
;
1470 if ( type
== wxBITMAP_TYPE_ANY
)
1472 wxList
&list
=GetHandlers();
1474 for ( wxList
::compatibility_iterator node
= list
.GetFirst(); node
; node
= node
->GetNext() )
1476 handler
=(wxImageHandler
*)node
->GetData();
1477 if ( handler
->CanRead(stream
) )
1478 return handler
->LoadFile(this, stream
, true/*verbose*/, index
);
1482 wxLogWarning( _("No handler found for image type.") );
1486 handler
= FindHandler(type
);
1490 wxLogWarning( _("No image handler for type %d defined."), type
);
1495 return handler
->LoadFile(this, stream
, true/*verbose*/, index
);
1498 bool wxImage
::LoadFile( wxInputStream
& stream
, const wxString
& mimetype
, int index
)
1502 m_refData
= new wxImageRefData
;
1504 wxImageHandler
*handler
= FindHandlerMime(mimetype
);
1508 wxLogWarning( _("No image handler for type %s defined."), mimetype
.GetData() );
1513 return handler
->LoadFile( this, stream
, true/*verbose*/, index
);
1516 bool wxImage
::SaveFile( wxOutputStream
& stream
, int type
) const
1518 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1520 wxImageHandler
*handler
= FindHandler(type
);
1523 wxLogWarning( _("No image handler for type %d defined."), type
);
1528 return handler
->SaveFile( (wxImage
*)this, stream
);
1531 bool wxImage
::SaveFile( wxOutputStream
& stream
, const wxString
& mimetype
) const
1533 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1535 wxImageHandler
*handler
= FindHandlerMime(mimetype
);
1538 wxLogWarning( _("No image handler for type %s defined."), mimetype
.GetData() );
1543 return handler
->SaveFile( (wxImage
*)this, stream
);
1545 #endif // wxUSE_STREAMS
1547 void wxImage
::AddHandler( wxImageHandler
*handler
)
1549 // Check for an existing handler of the type being added.
1550 if (FindHandler( handler
->GetType() ) == 0)
1552 sm_handlers
.Append( handler
);
1556 // This is not documented behaviour, merely the simplest 'fix'
1557 // for preventing duplicate additions. If someone ever has
1558 // a good reason to add and remove duplicate handlers (and they
1559 // may) we should probably refcount the duplicates.
1560 // also an issue in InsertHandler below.
1562 wxLogDebug( _T("Adding duplicate image handler for '%s'"),
1563 handler
->GetName().c_str() );
1568 void wxImage
::InsertHandler( wxImageHandler
*handler
)
1570 // Check for an existing handler of the type being added.
1571 if (FindHandler( handler
->GetType() ) == 0)
1573 sm_handlers
.Insert( handler
);
1577 // see AddHandler for additional comments.
1578 wxLogDebug( _T("Inserting duplicate image handler for '%s'"),
1579 handler
->GetName().c_str() );
1584 bool wxImage
::RemoveHandler( const wxString
& name
)
1586 wxImageHandler
*handler
= FindHandler(name
);
1589 sm_handlers
.DeleteObject(handler
);
1597 wxImageHandler
*wxImage
::FindHandler( const wxString
& name
)
1599 wxList
::compatibility_iterator node
= sm_handlers
.GetFirst();
1602 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
1603 if (handler
->GetName().Cmp(name
) == 0) return handler
;
1605 node
= node
->GetNext();
1610 wxImageHandler
*wxImage
::FindHandler( const wxString
& extension
, long bitmapType
)
1612 wxList
::compatibility_iterator node
= sm_handlers
.GetFirst();
1615 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
1616 if ( (handler
->GetExtension().Cmp(extension
) == 0) &&
1617 (bitmapType
== -1 || handler
->GetType() == bitmapType
) )
1619 node
= node
->GetNext();
1624 wxImageHandler
*wxImage
::FindHandler( long bitmapType
)
1626 wxList
::compatibility_iterator node
= sm_handlers
.GetFirst();
1629 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
1630 if (handler
->GetType() == bitmapType
) return handler
;
1631 node
= node
->GetNext();
1636 wxImageHandler
*wxImage
::FindHandlerMime( const wxString
& mimetype
)
1638 wxList
::compatibility_iterator node
= sm_handlers
.GetFirst();
1641 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
1642 if (handler
->GetMimeType().IsSameAs(mimetype
, false)) return handler
;
1643 node
= node
->GetNext();
1648 void wxImage
::InitStandardHandlers()
1651 AddHandler(new wxBMPHandler
);
1652 #endif // wxUSE_STREAMS
1655 void wxImage
::CleanUpHandlers()
1657 wxList
::compatibility_iterator node
= sm_handlers
.GetFirst();
1660 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
1661 wxList
::compatibility_iterator next
= node
->GetNext();
1666 sm_handlers
.Clear();
1669 wxString wxImage
::GetImageExtWildcard()
1673 wxList
& Handlers
= wxImage
::GetHandlers();
1674 wxList
::compatibility_iterator Node
= Handlers
.GetFirst();
1677 wxImageHandler
* Handler
= (wxImageHandler
*)Node
->GetData();
1678 fmts
+= wxT("*.") + Handler
->GetExtension();
1679 Node
= Node
->GetNext();
1680 if ( Node
) fmts
+= wxT(";");
1683 return wxT("(") + fmts
+ wxT(")|") + fmts
;
1686 //-----------------------------------------------------------------------------
1688 //-----------------------------------------------------------------------------
1690 IMPLEMENT_ABSTRACT_CLASS(wxImageHandler
,wxObject
)
1693 bool wxImageHandler
::LoadFile( wxImage
*WXUNUSED(image
), wxInputStream
& WXUNUSED(stream
), bool WXUNUSED(verbose
), int WXUNUSED(index
) )
1698 bool wxImageHandler
::SaveFile( wxImage
*WXUNUSED(image
), wxOutputStream
& WXUNUSED(stream
), bool WXUNUSED(verbose
) )
1703 int wxImageHandler
::GetImageCount( wxInputStream
& WXUNUSED(stream
) )
1708 bool wxImageHandler
::CanRead( const wxString
& name
)
1710 if (wxFileExists(name
))
1712 wxFileInputStream
stream(name
);
1713 return CanRead(stream
);
1716 wxLogError( _("Can't check image format of file '%s': file does not exist."), name
.c_str() );
1721 bool wxImageHandler
::CallDoCanRead(wxInputStream
& stream
)
1723 wxFileOffset posOld
= stream
.TellI();
1724 if ( posOld
== wxInvalidOffset
)
1726 // can't test unseekable stream
1730 bool ok
= DoCanRead(stream
);
1732 // restore the old position to be able to test other formats and so on
1733 if ( stream
.SeekI(posOld
) == wxInvalidOffset
)
1735 wxLogDebug(_T("Failed to rewind the stream in wxImageHandler!"));
1737 // reading would fail anyhow as we're not at the right position
1744 #endif // wxUSE_STREAMS
1746 // ----------------------------------------------------------------------------
1747 // image histogram stuff
1748 // ----------------------------------------------------------------------------
1751 wxImageHistogram
::FindFirstUnusedColour(unsigned char *r
,
1756 unsigned char g2
) const
1758 unsigned long key
= MakeKey(r2
, g2
, b2
);
1760 while ( find(key
) != end() )
1762 // color already used
1774 wxLogError(_("No unused colour in image.") );
1780 key
= MakeKey(r2
, g2
, b2
);
1794 wxImage
::FindFirstUnusedColour(unsigned char *r
,
1799 unsigned char g2
) const
1801 wxImageHistogram histogram
;
1803 ComputeHistogram(histogram
);
1805 return histogram
.FindFirstUnusedColour(r
, g
, b
, r2
, g2
, b2
);
1811 // Counts and returns the number of different colours. Optionally stops
1812 // when it exceeds 'stopafter' different colours. This is useful, for
1813 // example, to see if the image can be saved as 8-bit (256 colour or
1814 // less, in this case it would be invoked as CountColours(256)). Default
1815 // value for stopafter is -1 (don't care).
1817 unsigned long wxImage
::CountColours( unsigned long stopafter
) const
1821 unsigned char r
, g
, b
;
1823 unsigned long size
, nentries
, key
;
1826 size
= GetWidth() * GetHeight();
1829 for (unsigned long j
= 0; (j
< size
) && (nentries
<= stopafter
) ; j
++)
1834 key
= wxImageHistogram
::MakeKey(r
, g
, b
);
1836 if (h
.Get(key
) == NULL
)
1847 unsigned long wxImage
::ComputeHistogram( wxImageHistogram
&h
) const
1849 unsigned char *p
= GetData();
1850 unsigned long nentries
= 0;
1854 const unsigned long size
= GetWidth() * GetHeight();
1856 unsigned char r
, g
, b
;
1857 for ( unsigned long n
= 0; n
< size
; n
++ )
1863 wxImageHistogramEntry
& entry
= h
[wxImageHistogram
::MakeKey(r
, g
, b
)];
1865 if ( entry
.value
++ == 0 )
1866 entry
.index
= nentries
++;
1873 * Rotation code by Carlos Moreno
1876 // GRG: I've removed wxRotationPoint - we already have wxRealPoint which
1877 // does exactly the same thing. And I also got rid of wxRotationPixel
1878 // bacause of potential problems in architectures where alignment
1879 // is an issue, so I had to rewrite parts of the code.
1881 static const double gs_Epsilon
= 1e-10;
1883 static inline int wxCint (double x
)
1885 return (x
> 0) ?
(int) (x
+ 0.5) : (int) (x
- 0.5);
1889 // Auxiliary function to rotate a point (x,y) with respect to point p0
1890 // make it inline and use a straight return to facilitate optimization
1891 // also, the function receives the sine and cosine of the angle to avoid
1892 // repeating the time-consuming calls to these functions -- sin/cos can
1893 // be computed and stored in the calling function.
1895 inline wxRealPoint
rotated_point (const wxRealPoint
& p
, double cos_angle
, double sin_angle
, const wxRealPoint
& p0
)
1897 return wxRealPoint (p0
.x
+ (p
.x
- p0
.x
) * cos_angle
- (p
.y
- p0
.y
) * sin_angle
,
1898 p0
.y
+ (p
.y
- p0
.y
) * cos_angle
+ (p
.x
- p0
.x
) * sin_angle
);
1901 inline wxRealPoint
rotated_point (double x
, double y
, double cos_angle
, double sin_angle
, const wxRealPoint
& p0
)
1903 return rotated_point (wxRealPoint(x
,y
), cos_angle
, sin_angle
, p0
);
1906 wxImage wxImage
::Rotate(double angle
, const wxPoint
& centre_of_rotation
, bool interpolating
, wxPoint
* offset_after_rotation
) const
1909 angle
= -angle
; // screen coordinates are a mirror image of "real" coordinates
1911 bool has_alpha
= HasAlpha();
1913 // Create pointer-based array to accelerate access to wxImage's data
1914 unsigned char ** data
= new unsigned char * [GetHeight()];
1915 data
[0] = GetData();
1916 for (i
= 1; i
< GetHeight(); i
++)
1917 data
[i
] = data
[i
- 1] + (3 * GetWidth());
1919 // Same for alpha channel
1920 unsigned char ** alpha
= NULL
;
1923 alpha
= new unsigned char * [GetHeight()];
1924 alpha
[0] = GetAlpha();
1925 for (i
= 1; i
< GetHeight(); i
++)
1926 alpha
[i
] = alpha
[i
- 1] + GetWidth();
1929 // precompute coefficients for rotation formula
1930 // (sine and cosine of the angle)
1931 const double cos_angle
= cos(angle
);
1932 const double sin_angle
= sin(angle
);
1934 // Create new Image to store the result
1935 // First, find rectangle that covers the rotated image; to do that,
1936 // rotate the four corners
1938 const wxRealPoint
p0(centre_of_rotation
.x
, centre_of_rotation
.y
);
1940 wxRealPoint p1
= rotated_point (0, 0, cos_angle
, sin_angle
, p0
);
1941 wxRealPoint p2
= rotated_point (0, GetHeight(), cos_angle
, sin_angle
, p0
);
1942 wxRealPoint p3
= rotated_point (GetWidth(), 0, cos_angle
, sin_angle
, p0
);
1943 wxRealPoint p4
= rotated_point (GetWidth(), GetHeight(), cos_angle
, sin_angle
, p0
);
1945 int x1
= (int) floor (wxMin (wxMin(p1
.x
, p2
.x
), wxMin(p3
.x
, p4
.x
)));
1946 int y1
= (int) floor (wxMin (wxMin(p1
.y
, p2
.y
), wxMin(p3
.y
, p4
.y
)));
1947 int x2
= (int) ceil (wxMax (wxMax(p1
.x
, p2
.x
), wxMax(p3
.x
, p4
.x
)));
1948 int y2
= (int) ceil (wxMax (wxMax(p1
.y
, p2
.y
), wxMax(p3
.y
, p4
.y
)));
1950 // Create rotated image
1951 wxImage
rotated (x2
- x1
+ 1, y2
- y1
+ 1, false);
1952 // With alpha channel
1956 if (offset_after_rotation
!= NULL
)
1958 *offset_after_rotation
= wxPoint (x1
, y1
);
1961 // GRG: The rotated (destination) image is always accessed
1962 // sequentially, so there is no need for a pointer-based
1963 // array here (and in fact it would be slower).
1965 unsigned char * dst
= rotated
.GetData();
1967 unsigned char * alpha_dst
= NULL
;
1969 alpha_dst
= rotated
.GetAlpha();
1971 // GRG: if the original image has a mask, use its RGB values
1972 // as the blank pixel, else, fall back to default (black).
1974 unsigned char blank_r
= 0;
1975 unsigned char blank_g
= 0;
1976 unsigned char blank_b
= 0;
1980 blank_r
= GetMaskRed();
1981 blank_g
= GetMaskGreen();
1982 blank_b
= GetMaskBlue();
1983 rotated
.SetMaskColour( blank_r
, blank_g
, blank_b
);
1986 // Now, for each point of the rotated image, find where it came from, by
1987 // performing an inverse rotation (a rotation of -angle) and getting the
1988 // pixel at those coordinates
1990 // GRG: I've taken the (interpolating) test out of the loops, so that
1991 // it is done only once, instead of repeating it for each pixel.
1996 for (int y
= 0; y
< rotated
.GetHeight(); y
++)
1998 for (x
= 0; x
< rotated
.GetWidth(); x
++)
2000 wxRealPoint src
= rotated_point (x
+ x1
, y
+ y1
, cos_angle
, -sin_angle
, p0
);
2002 if (-0.25 < src
.x
&& src
.x
< GetWidth() - 0.75 &&
2003 -0.25 < src
.y
&& src
.y
< GetHeight() - 0.75)
2005 // interpolate using the 4 enclosing grid-points. Those
2006 // points can be obtained using floor and ceiling of the
2007 // exact coordinates of the point
2008 // C.M. 2000-02-17: when the point is near the border, special care is required.
2012 if (0 < src
.x
&& src
.x
< GetWidth() - 1)
2014 x1
= wxCint(floor(src
.x
));
2015 x2
= wxCint(ceil(src
.x
));
2017 else // else means that x is near one of the borders (0 or width-1)
2019 x1
= x2
= wxCint (src
.x
);
2022 if (0 < src
.y
&& src
.y
< GetHeight() - 1)
2024 y1
= wxCint(floor(src
.y
));
2025 y2
= wxCint(ceil(src
.y
));
2029 y1
= y2
= wxCint (src
.y
);
2032 // get four points and the distances (square of the distance,
2033 // for efficiency reasons) for the interpolation formula
2035 // GRG: Do not calculate the points until they are
2036 // really needed -- this way we can calculate
2037 // just one, instead of four, if d1, d2, d3
2038 // or d4 are < gs_Epsilon
2040 const double d1
= (src
.x
- x1
) * (src
.x
- x1
) + (src
.y
- y1
) * (src
.y
- y1
);
2041 const double d2
= (src
.x
- x2
) * (src
.x
- x2
) + (src
.y
- y1
) * (src
.y
- y1
);
2042 const double d3
= (src
.x
- x2
) * (src
.x
- x2
) + (src
.y
- y2
) * (src
.y
- y2
);
2043 const double d4
= (src
.x
- x1
) * (src
.x
- x1
) + (src
.y
- y2
) * (src
.y
- y2
);
2045 // Now interpolate as a weighted average of the four surrounding
2046 // points, where the weights are the distances to each of those points
2048 // If the point is exactly at one point of the grid of the source
2049 // image, then don't interpolate -- just assign the pixel
2051 if (d1
< gs_Epsilon
) // d1,d2,d3,d4 are positive -- no need for abs()
2053 unsigned char *p
= data
[y1
] + (3 * x1
);
2060 unsigned char *p
= alpha
[y1
] + x1
;
2061 *(alpha_dst
++) = *p
;
2064 else if (d2
< gs_Epsilon
)
2066 unsigned char *p
= data
[y1
] + (3 * x2
);
2073 unsigned char *p
= alpha
[y1
] + x2
;
2074 *(alpha_dst
++) = *p
;
2077 else if (d3
< gs_Epsilon
)
2079 unsigned char *p
= data
[y2
] + (3 * x2
);
2086 unsigned char *p
= alpha
[y2
] + x2
;
2087 *(alpha_dst
++) = *p
;
2090 else if (d4
< gs_Epsilon
)
2092 unsigned char *p
= data
[y2
] + (3 * x1
);
2099 unsigned char *p
= alpha
[y2
] + x1
;
2100 *(alpha_dst
++) = *p
;
2105 // weights for the weighted average are proportional to the inverse of the distance
2106 unsigned char *v1
= data
[y1
] + (3 * x1
);
2107 unsigned char *v2
= data
[y1
] + (3 * x2
);
2108 unsigned char *v3
= data
[y2
] + (3 * x2
);
2109 unsigned char *v4
= data
[y2
] + (3 * x1
);
2111 const double w1
= 1/d1
, w2
= 1/d2
, w3
= 1/d3
, w4
= 1/d4
;
2115 *(dst
++) = (unsigned char)
2116 ( (w1
* *(v1
++) + w2
* *(v2
++) +
2117 w3
* *(v3
++) + w4
* *(v4
++)) /
2118 (w1
+ w2
+ w3
+ w4
) );
2119 *(dst
++) = (unsigned char)
2120 ( (w1
* *(v1
++) + w2
* *(v2
++) +
2121 w3
* *(v3
++) + w4
* *(v4
++)) /
2122 (w1
+ w2
+ w3
+ w4
) );
2123 *(dst
++) = (unsigned char)
2124 ( (w1
* *v1
+ w2
* *v2
+
2125 w3
* *v3
+ w4
* *v4
) /
2126 (w1
+ w2
+ w3
+ w4
) );
2130 unsigned char *v1
= alpha
[y1
] + (x1
);
2131 unsigned char *v2
= alpha
[y1
] + (x2
);
2132 unsigned char *v3
= alpha
[y2
] + (x2
);
2133 unsigned char *v4
= alpha
[y2
] + (x1
);
2135 *(alpha_dst
++) = (unsigned char)
2136 ( (w1
* *v1
+ w2
* *v2
+
2137 w3
* *v3
+ w4
* *v4
) /
2138 (w1
+ w2
+ w3
+ w4
) );
2154 else // not interpolating
2156 for (int y
= 0; y
< rotated
.GetHeight(); y
++)
2158 for (x
= 0; x
< rotated
.GetWidth(); x
++)
2160 wxRealPoint src
= rotated_point (x
+ x1
, y
+ y1
, cos_angle
, -sin_angle
, p0
);
2162 const int xs
= wxCint (src
.x
); // wxCint rounds to the
2163 const int ys
= wxCint (src
.y
); // closest integer
2165 if (0 <= xs
&& xs
< GetWidth() &&
2166 0 <= ys
&& ys
< GetHeight())
2168 unsigned char *p
= data
[ys
] + (3 * xs
);
2175 unsigned char *p
= alpha
[ys
] + (xs
);
2176 *(alpha_dst
++) = *p
;
2186 *(alpha_dst
++) = 255;
2204 // A module to allow wxImage initialization/cleanup
2205 // without calling these functions from app.cpp or from
2206 // the user's application.
2208 class wxImageModule
: public wxModule
2210 DECLARE_DYNAMIC_CLASS(wxImageModule
)
2213 bool OnInit() { wxImage
::InitStandardHandlers(); return true; };
2214 void OnExit() { wxImage
::CleanUpHandlers(); };
2217 IMPLEMENT_DYNAMIC_CLASS(wxImageModule
, wxModule
)
2220 #endif // wxUSE_IMAGE