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
;
72 // if true, m_data is pointer to static data and shouldn't be freed
75 // same as m_static but for m_alpha
80 #endif // wxUSE_PALETTE
82 wxArrayString m_optionNames
;
83 wxArrayString m_optionValues
;
85 DECLARE_NO_COPY_CLASS(wxImageRefData
)
88 wxImageRefData::wxImageRefData()
93 m_alpha
= (unsigned char *) NULL
;
102 m_staticAlpha
= false;
105 wxImageRefData::~wxImageRefData()
109 if ( !m_staticAlpha
)
113 wxList
wxImage::sm_handlers
;
117 //-----------------------------------------------------------------------------
119 #define M_IMGDATA ((wxImageRefData *)m_refData)
121 IMPLEMENT_DYNAMIC_CLASS(wxImage
, wxObject
)
123 wxImage::wxImage( int width
, int height
, bool clear
)
125 Create( width
, height
, clear
);
128 wxImage::wxImage( int width
, int height
, unsigned char* data
, bool static_data
)
130 Create( width
, height
, data
, static_data
);
133 wxImage::wxImage( int width
, int height
, unsigned char* data
, unsigned char* alpha
, bool static_data
)
135 Create( width
, height
, data
, alpha
, static_data
);
138 wxImage::wxImage( const wxString
& name
, long type
, int index
)
140 LoadFile( name
, type
, index
);
143 wxImage::wxImage( const wxString
& name
, const wxString
& mimetype
, int index
)
145 LoadFile( name
, mimetype
, index
);
149 wxImage::wxImage( wxInputStream
& stream
, long type
, int index
)
151 LoadFile( stream
, type
, index
);
154 wxImage::wxImage( wxInputStream
& stream
, const wxString
& mimetype
, int index
)
156 LoadFile( stream
, mimetype
, index
);
158 #endif // wxUSE_STREAMS
160 wxImage::wxImage( const wxImage
& image
)
166 wxImage::wxImage( const wxImage
* image
)
168 if (image
) Ref(*image
);
171 wxImage::wxImage( const char** xpmData
)
176 wxImage::wxImage( char** xpmData
)
178 Create((const char**) xpmData
);
181 bool wxImage::Create( const char** xpmData
)
186 wxXPMDecoder decoder
;
187 (*this) = decoder
.ReadData(xpmData
);
194 bool wxImage::Create( int width
, int height
, bool clear
)
198 m_refData
= new wxImageRefData();
200 M_IMGDATA
->m_data
= (unsigned char *) malloc( width
*height
*3 );
201 if (!M_IMGDATA
->m_data
)
208 memset(M_IMGDATA
->m_data
, 0, width
*height
*3);
210 M_IMGDATA
->m_width
= width
;
211 M_IMGDATA
->m_height
= height
;
212 M_IMGDATA
->m_ok
= true;
217 bool wxImage::Create( int width
, int height
, unsigned char* data
, bool static_data
)
221 wxCHECK_MSG( data
, false, _T("NULL data in wxImage::Create") );
223 m_refData
= new wxImageRefData();
225 M_IMGDATA
->m_data
= data
;
226 M_IMGDATA
->m_width
= width
;
227 M_IMGDATA
->m_height
= height
;
228 M_IMGDATA
->m_ok
= true;
229 M_IMGDATA
->m_static
= static_data
;
234 bool wxImage::Create( int width
, int height
, unsigned char* data
, unsigned char* alpha
, bool static_data
)
238 wxCHECK_MSG( data
, false, _T("NULL data in wxImage::Create") );
240 m_refData
= new wxImageRefData();
242 M_IMGDATA
->m_data
= data
;
243 M_IMGDATA
->m_alpha
= alpha
;
244 M_IMGDATA
->m_width
= width
;
245 M_IMGDATA
->m_height
= height
;
246 M_IMGDATA
->m_ok
= true;
247 M_IMGDATA
->m_static
= static_data
;
252 void wxImage::Destroy()
257 wxImage
wxImage::Copy() const
261 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
263 image
.Create( M_IMGDATA
->m_width
, M_IMGDATA
->m_height
, false );
265 unsigned char *data
= image
.GetData();
267 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
269 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
270 image
.SetMask( M_IMGDATA
->m_hasMask
);
272 memcpy( data
, GetData(), M_IMGDATA
->m_width
*M_IMGDATA
->m_height
*3 );
274 // also copy the image options
275 wxImageRefData
*imgData
= (wxImageRefData
*)image
.m_refData
;
276 imgData
->m_optionNames
= M_IMGDATA
->m_optionNames
;
277 imgData
->m_optionValues
= M_IMGDATA
->m_optionValues
;
282 wxImage
wxImage::ShrinkBy( int xFactor
, int yFactor
) const
284 if( xFactor
== 1 && yFactor
== 1 )
289 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
291 // can't scale to/from 0 size
292 wxCHECK_MSG( (xFactor
> 0) && (yFactor
> 0), image
,
293 wxT("invalid new image size") );
295 long old_height
= M_IMGDATA
->m_height
,
296 old_width
= M_IMGDATA
->m_width
;
298 wxCHECK_MSG( (old_height
> 0) && (old_width
> 0), image
,
299 wxT("invalid old image size") );
301 long width
= old_width
/ xFactor
;
302 long height
= old_height
/ yFactor
;
304 image
.Create( width
, height
, false );
306 char unsigned *data
= image
.GetData();
308 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
310 bool hasMask
= false ;
311 unsigned char maskRed
= 0;
312 unsigned char maskGreen
= 0;
313 unsigned char maskBlue
=0 ;
315 unsigned char *source_data
= M_IMGDATA
->m_data
;
316 unsigned char *target_data
= data
;
317 unsigned char *source_alpha
= 0 ;
318 unsigned char *target_alpha
= 0 ;
319 if (M_IMGDATA
->m_hasMask
)
322 maskRed
= M_IMGDATA
->m_maskRed
;
323 maskGreen
= M_IMGDATA
->m_maskGreen
;
324 maskBlue
=M_IMGDATA
->m_maskBlue
;
326 image
.SetMaskColour( M_IMGDATA
->m_maskRed
,
327 M_IMGDATA
->m_maskGreen
,
328 M_IMGDATA
->m_maskBlue
);
332 source_alpha
= M_IMGDATA
->m_alpha
;
336 target_alpha
= image
.GetAlpha() ;
340 for (long y
= 0; y
< height
; y
++)
342 for (long x
= 0; x
< width
; x
++)
344 unsigned long avgRed
= 0 ;
345 unsigned long avgGreen
= 0;
346 unsigned long avgBlue
= 0;
347 unsigned long avgAlpha
= 0 ;
348 unsigned long counter
= 0 ;
350 for ( int y1
= 0 ; y1
< yFactor
; ++y1
)
352 long y_offset
= (y
* yFactor
+ y1
) * old_width
;
353 for ( int x1
= 0 ; x1
< xFactor
; ++x1
)
355 unsigned char *pixel
= source_data
+ 3 * ( y_offset
+ x
* xFactor
+ x1
) ;
356 unsigned char red
= pixel
[0] ;
357 unsigned char green
= pixel
[1] ;
358 unsigned char blue
= pixel
[2] ;
359 unsigned char alpha
= 255 ;
361 alpha
= *(source_alpha
+ y_offset
+ x
* xFactor
+ x1
) ;
362 if ( !hasMask
|| red
!= maskRed
|| green
!= maskGreen
|| blue
!= maskBlue
)
377 *(target_data
++) = M_IMGDATA
->m_maskRed
;
378 *(target_data
++) = M_IMGDATA
->m_maskGreen
;
379 *(target_data
++) = M_IMGDATA
->m_maskBlue
;
384 *(target_alpha
++) = (unsigned char)(avgAlpha
/ counter
) ;
385 *(target_data
++) = (unsigned char)(avgRed
/ counter
);
386 *(target_data
++) = (unsigned char)(avgGreen
/ counter
);
387 *(target_data
++) = (unsigned char)(avgBlue
/ counter
);
392 // In case this is a cursor, make sure the hotspot is scalled accordingly:
393 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
) )
394 image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
,
395 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X
))/xFactor
);
396 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
) )
397 image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
,
398 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y
))/yFactor
);
403 wxImage
wxImage::Scale( int width
, int height
) const
407 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
409 // can't scale to/from 0 size
410 wxCHECK_MSG( (width
> 0) && (height
> 0), image
,
411 wxT("invalid new image size") );
413 long old_height
= M_IMGDATA
->m_height
,
414 old_width
= M_IMGDATA
->m_width
;
415 wxCHECK_MSG( (old_height
> 0) && (old_width
> 0), image
,
416 wxT("invalid old image size") );
418 if ( old_width
% width
== 0 && old_width
>= width
&&
419 old_height
% height
== 0 && old_height
>= height
)
421 return ShrinkBy( old_width
/ width
, old_height
/ height
) ;
423 image
.Create( width
, height
, false );
425 unsigned char *data
= image
.GetData();
427 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
429 unsigned char *source_data
= M_IMGDATA
->m_data
;
430 unsigned char *target_data
= data
;
431 unsigned char *source_alpha
= 0 ;
432 unsigned char *target_alpha
= 0 ;
434 if (M_IMGDATA
->m_hasMask
)
436 image
.SetMaskColour( M_IMGDATA
->m_maskRed
,
437 M_IMGDATA
->m_maskGreen
,
438 M_IMGDATA
->m_maskBlue
);
442 source_alpha
= M_IMGDATA
->m_alpha
;
446 target_alpha
= image
.GetAlpha() ;
450 long x_delta
= (old_width
<<16) / width
;
451 long y_delta
= (old_height
<<16) / height
;
453 unsigned char* dest_pixel
= target_data
;
456 for ( long j
= 0; j
< height
; j
++ )
458 unsigned char* src_line
= &source_data
[(y
>>16)*old_width
*3];
459 unsigned char* src_alpha_line
= source_alpha
? &source_alpha
[(y
>>16)*old_width
] : 0 ;
462 for ( long i
= 0; i
< width
; i
++ )
464 unsigned char* src_pixel
= &src_line
[(x
>>16)*3];
465 unsigned char* src_alpha_pixel
= source_alpha
? &src_alpha_line
[(x
>>16)] : 0 ;
466 dest_pixel
[0] = src_pixel
[0];
467 dest_pixel
[1] = src_pixel
[1];
468 dest_pixel
[2] = src_pixel
[2];
471 *(target_alpha
++) = *src_alpha_pixel
;
478 // In case this is a cursor, make sure the hotspot is scalled accordingly:
479 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
) )
480 image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
,
481 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X
)*width
)/old_width
);
482 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
) )
483 image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
,
484 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y
)*height
)/old_height
);
489 wxImage
wxImage::Rotate90( bool clockwise
) const
493 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
495 image
.Create( M_IMGDATA
->m_height
, M_IMGDATA
->m_width
, false );
497 unsigned char *data
= image
.GetData();
499 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
501 if (M_IMGDATA
->m_hasMask
)
502 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
504 long height
= M_IMGDATA
->m_height
;
505 long width
= M_IMGDATA
->m_width
;
507 unsigned char *source_data
= M_IMGDATA
->m_data
;
508 unsigned char *target_data
;
510 for (long j
= 0; j
< height
; j
++)
512 for (long i
= 0; i
< width
; i
++)
515 target_data
= data
+ (((i
+1)*height
) - j
- 1)*3;
517 target_data
= data
+ ((height
*(width
-1)) + j
- (i
*height
))*3;
518 memcpy( target_data
, source_data
, 3 );
526 wxImage
wxImage::Mirror( bool horizontally
) const
530 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
532 image
.Create( M_IMGDATA
->m_width
, M_IMGDATA
->m_height
, false );
534 unsigned char *data
= image
.GetData();
536 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
538 if (M_IMGDATA
->m_hasMask
)
539 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
541 long height
= M_IMGDATA
->m_height
;
542 long width
= M_IMGDATA
->m_width
;
544 unsigned char *source_data
= M_IMGDATA
->m_data
;
545 unsigned char *target_data
;
549 for (long j
= 0; j
< height
; j
++)
552 target_data
= data
-3;
553 for (long i
= 0; i
< width
; i
++)
555 memcpy( target_data
, source_data
, 3 );
563 for (long i
= 0; i
< height
; i
++)
565 target_data
= data
+ 3*width
*(height
-1-i
);
566 memcpy( target_data
, source_data
, (size_t)3*width
);
567 source_data
+= 3*width
;
574 wxImage
wxImage::GetSubImage( const wxRect
&rect
) const
578 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
580 wxCHECK_MSG( (rect
.GetLeft()>=0) && (rect
.GetTop()>=0) && (rect
.GetRight()<=GetWidth()) && (rect
.GetBottom()<=GetHeight()),
581 image
, wxT("invalid subimage size") );
583 int subwidth
=rect
.GetWidth();
584 const int subheight
=rect
.GetHeight();
586 image
.Create( subwidth
, subheight
, false );
588 unsigned char *subdata
= image
.GetData(), *data
=GetData();
590 wxCHECK_MSG( subdata
, image
, wxT("unable to create image") );
592 if (M_IMGDATA
->m_hasMask
)
593 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
595 const int subleft
=3*rect
.GetLeft();
596 const int width
=3*GetWidth();
599 data
+=rect
.GetTop()*width
+subleft
;
601 for (long j
= 0; j
< subheight
; ++j
)
603 memcpy( subdata
, data
, subwidth
);
611 wxImage
wxImage::Size( const wxSize
& size
, const wxPoint
& pos
,
612 int r_
, int g_
, int b_
) const
616 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
617 wxCHECK_MSG( (size
.GetWidth() > 0) && (size
.GetHeight() > 0), image
, wxT("invalid size") );
619 int width
= GetWidth(), height
= GetHeight();
620 image
.Create(size
.GetWidth(), size
.GetHeight(), false);
622 unsigned char r
= (unsigned char)r_
;
623 unsigned char g
= (unsigned char)g_
;
624 unsigned char b
= (unsigned char)b_
;
625 if ((r_
== -1) && (g_
== -1) && (b_
== -1))
627 GetOrFindMaskColour( &r
, &g
, &b
);
628 image
.SetMaskColour(r
, g
, b
);
631 image
.SetRGB(wxRect(), r
, g
, b
);
633 wxRect
subRect(pos
.x
, pos
.y
, width
, height
);
634 wxRect
finalRect(0, 0, size
.GetWidth(), size
.GetHeight());
636 subRect
.Intersect(finalRect
);
638 if (!subRect
.IsEmpty())
640 if ((subRect
.GetWidth() == width
) && (subRect
.GetHeight() == height
))
641 image
.Paste(*this, pos
.x
, pos
.y
);
643 image
.Paste(GetSubImage(subRect
), pos
.x
, pos
.y
);
649 void wxImage::Paste( const wxImage
&image
, int x
, int y
)
651 wxCHECK_RET( Ok(), wxT("invalid image") );
652 wxCHECK_RET( image
.Ok(), wxT("invalid image") );
656 int width
= image
.GetWidth();
657 int height
= image
.GetHeight();
670 if ((x
+xx
)+width
> M_IMGDATA
->m_width
)
671 width
= M_IMGDATA
->m_width
- (x
+xx
);
672 if ((y
+yy
)+height
> M_IMGDATA
->m_height
)
673 height
= M_IMGDATA
->m_height
- (y
+yy
);
675 if (width
< 1) return;
676 if (height
< 1) return;
678 if ((!HasMask() && !image
.HasMask()) ||
679 (HasMask() && !image
.HasMask()) ||
680 ((HasMask() && image
.HasMask() &&
681 (GetMaskRed()==image
.GetMaskRed()) &&
682 (GetMaskGreen()==image
.GetMaskGreen()) &&
683 (GetMaskBlue()==image
.GetMaskBlue()))))
686 unsigned char* source_data
= image
.GetData() + xx
*3 + yy
*3*image
.GetWidth();
687 int source_step
= image
.GetWidth()*3;
689 unsigned char* target_data
= GetData() + (x
+xx
)*3 + (y
+yy
)*3*M_IMGDATA
->m_width
;
690 int target_step
= M_IMGDATA
->m_width
*3;
691 for (int j
= 0; j
< height
; j
++)
693 memcpy( target_data
, source_data
, width
);
694 source_data
+= source_step
;
695 target_data
+= target_step
;
700 if (!HasMask() && image
.HasMask())
702 unsigned char r
= image
.GetMaskRed();
703 unsigned char g
= image
.GetMaskGreen();
704 unsigned char b
= image
.GetMaskBlue();
707 unsigned char* source_data
= image
.GetData() + xx
*3 + yy
*3*image
.GetWidth();
708 int source_step
= image
.GetWidth()*3;
710 unsigned char* target_data
= GetData() + (x
+xx
)*3 + (y
+yy
)*3*M_IMGDATA
->m_width
;
711 int target_step
= M_IMGDATA
->m_width
*3;
713 for (int j
= 0; j
< height
; j
++)
715 for (int i
= 0; i
< width
; i
+=3)
717 if ((source_data
[i
] != r
) &&
718 (source_data
[i
+1] != g
) &&
719 (source_data
[i
+2] != b
))
721 memcpy( target_data
+i
, source_data
+i
, 3 );
724 source_data
+= source_step
;
725 target_data
+= target_step
;
730 void wxImage::Replace( unsigned char r1
, unsigned char g1
, unsigned char b1
,
731 unsigned char r2
, unsigned char g2
, unsigned char b2
)
733 wxCHECK_RET( Ok(), wxT("invalid image") );
735 unsigned char *data
= GetData();
737 const int w
= GetWidth();
738 const int h
= GetHeight();
740 for (int j
= 0; j
< h
; j
++)
741 for (int i
= 0; i
< w
; i
++)
743 if ((data
[0] == r1
) && (data
[1] == g1
) && (data
[2] == b1
))
753 wxImage
wxImage::ConvertToMono( unsigned char r
, unsigned char g
, unsigned char b
) const
757 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
759 image
.Create( M_IMGDATA
->m_width
, M_IMGDATA
->m_height
, false );
761 unsigned char *data
= image
.GetData();
763 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
765 if (M_IMGDATA
->m_hasMask
)
767 if (M_IMGDATA
->m_maskRed
== r
&& M_IMGDATA
->m_maskGreen
== g
&&
768 M_IMGDATA
->m_maskBlue
== b
)
769 image
.SetMaskColour( 255, 255, 255 );
771 image
.SetMaskColour( 0, 0, 0 );
774 long size
= M_IMGDATA
->m_height
* M_IMGDATA
->m_width
;
776 unsigned char *srcd
= M_IMGDATA
->m_data
;
777 unsigned char *tard
= image
.GetData();
779 for ( long i
= 0; i
< size
; i
++, srcd
+= 3, tard
+= 3 )
781 if (srcd
[0] == r
&& srcd
[1] == g
&& srcd
[2] == b
)
782 tard
[0] = tard
[1] = tard
[2] = 255;
784 tard
[0] = tard
[1] = tard
[2] = 0;
790 int wxImage::GetWidth() const
792 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
794 return M_IMGDATA
->m_width
;
797 int wxImage::GetHeight() const
799 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
801 return M_IMGDATA
->m_height
;
804 long wxImage::XYToIndex(int x
, int y
) const
808 x
< M_IMGDATA
->m_width
&& y
< M_IMGDATA
->m_height
)
810 return y
*M_IMGDATA
->m_width
+ x
;
816 void wxImage::SetRGB( int x
, int y
, unsigned char r
, unsigned char g
, unsigned char b
)
818 long pos
= XYToIndex(x
, y
);
819 wxCHECK_RET( pos
!= -1, wxT("invalid image coordinates") );
823 M_IMGDATA
->m_data
[ pos
] = r
;
824 M_IMGDATA
->m_data
[ pos
+1 ] = g
;
825 M_IMGDATA
->m_data
[ pos
+2 ] = b
;
828 void wxImage::SetRGB( const wxRect
& rect_
, unsigned char r
, unsigned char g
, unsigned char b
)
830 wxCHECK_RET( Ok(), wxT("invalid image") );
833 wxRect
imageRect(0, 0, GetWidth(), GetHeight());
834 if ( rect
== wxRect() )
840 wxCHECK_RET( imageRect
.Inside(rect
.GetTopLeft()) &&
841 imageRect
.Inside(rect
.GetBottomRight()),
842 wxT("invalid bounding rectangle") );
845 int x1
= rect
.GetLeft(),
847 x2
= rect
.GetRight() + 1,
848 y2
= rect
.GetBottom() + 1;
850 unsigned char *data
wxDUMMY_INITIALIZE(NULL
);
851 int x
, y
, width
= GetWidth();
852 for (y
= y1
; y
< y2
; y
++)
854 data
= M_IMGDATA
->m_data
+ (y
*width
+ x1
)*3;
855 for (x
= x1
; x
< x2
; x
++)
864 unsigned char wxImage::GetRed( int x
, int y
) const
866 long pos
= XYToIndex(x
, y
);
867 wxCHECK_MSG( pos
!= -1, 0, wxT("invalid image coordinates") );
871 return M_IMGDATA
->m_data
[pos
];
874 unsigned char wxImage::GetGreen( int x
, int y
) const
876 long pos
= XYToIndex(x
, y
);
877 wxCHECK_MSG( pos
!= -1, 0, wxT("invalid image coordinates") );
881 return M_IMGDATA
->m_data
[pos
+1];
884 unsigned char wxImage::GetBlue( int x
, int y
) const
886 long pos
= XYToIndex(x
, y
);
887 wxCHECK_MSG( pos
!= -1, 0, wxT("invalid image coordinates") );
891 return M_IMGDATA
->m_data
[pos
+2];
894 bool wxImage::Ok() const
896 // image of 0 width or height can't be considered ok - at least because it
897 // causes crashes in ConvertToBitmap() if we don't catch it in time
898 wxImageRefData
*data
= M_IMGDATA
;
899 return data
&& data
->m_ok
&& data
->m_width
&& data
->m_height
;
902 unsigned char *wxImage::GetData() const
904 wxCHECK_MSG( Ok(), (unsigned char *)NULL
, wxT("invalid image") );
906 return M_IMGDATA
->m_data
;
909 void wxImage::SetData( unsigned char *data
, bool static_data
)
911 wxCHECK_RET( Ok(), wxT("invalid image") );
913 wxImageRefData
*newRefData
= new wxImageRefData();
915 newRefData
->m_width
= M_IMGDATA
->m_width
;
916 newRefData
->m_height
= M_IMGDATA
->m_height
;
917 newRefData
->m_data
= data
;
918 newRefData
->m_ok
= true;
919 newRefData
->m_maskRed
= M_IMGDATA
->m_maskRed
;
920 newRefData
->m_maskGreen
= M_IMGDATA
->m_maskGreen
;
921 newRefData
->m_maskBlue
= M_IMGDATA
->m_maskBlue
;
922 newRefData
->m_hasMask
= M_IMGDATA
->m_hasMask
;
923 newRefData
->m_static
= static_data
;
927 m_refData
= newRefData
;
930 void wxImage::SetData( unsigned char *data
, int new_width
, int new_height
, bool static_data
)
932 wxImageRefData
*newRefData
= new wxImageRefData();
936 newRefData
->m_width
= new_width
;
937 newRefData
->m_height
= new_height
;
938 newRefData
->m_data
= data
;
939 newRefData
->m_ok
= true;
940 newRefData
->m_maskRed
= M_IMGDATA
->m_maskRed
;
941 newRefData
->m_maskGreen
= M_IMGDATA
->m_maskGreen
;
942 newRefData
->m_maskBlue
= M_IMGDATA
->m_maskBlue
;
943 newRefData
->m_hasMask
= M_IMGDATA
->m_hasMask
;
947 newRefData
->m_width
= new_width
;
948 newRefData
->m_height
= new_height
;
949 newRefData
->m_data
= data
;
950 newRefData
->m_ok
= true;
952 newRefData
->m_static
= static_data
;
956 m_refData
= newRefData
;
959 // ----------------------------------------------------------------------------
960 // alpha channel support
961 // ----------------------------------------------------------------------------
963 void wxImage::SetAlpha(int x
, int y
, unsigned char alpha
)
965 wxCHECK_RET( HasAlpha(), wxT("no alpha channel") );
967 long pos
= XYToIndex(x
, y
);
968 wxCHECK_RET( pos
!= -1, wxT("invalid image coordinates") );
970 M_IMGDATA
->m_alpha
[pos
] = alpha
;
973 unsigned char wxImage::GetAlpha(int x
, int y
) const
975 wxCHECK_MSG( HasAlpha(), 0, wxT("no alpha channel") );
977 long pos
= XYToIndex(x
, y
);
978 wxCHECK_MSG( pos
!= -1, 0, wxT("invalid image coordinates") );
980 return M_IMGDATA
->m_alpha
[pos
];
984 wxImage::ConvertColourToAlpha(unsigned char r
, unsigned char g
, unsigned char b
)
988 const int w
= M_IMGDATA
->m_width
;
989 const int h
= M_IMGDATA
->m_height
;
991 unsigned char *alpha
= GetAlpha();
992 unsigned char *data
= GetData();
994 for ( int y
= 0; y
< h
; y
++ )
996 for ( int x
= 0; x
< w
; x
++ )
1008 void wxImage::SetAlpha( unsigned char *alpha
, bool static_data
)
1010 wxCHECK_RET( Ok(), wxT("invalid image") );
1014 alpha
= (unsigned char *)malloc(M_IMGDATA
->m_width
*M_IMGDATA
->m_height
);
1017 free(M_IMGDATA
->m_alpha
);
1018 M_IMGDATA
->m_alpha
= alpha
;
1019 M_IMGDATA
->m_staticAlpha
= static_data
;
1022 unsigned char *wxImage::GetAlpha() const
1024 wxCHECK_MSG( Ok(), (unsigned char *)NULL
, wxT("invalid image") );
1026 return M_IMGDATA
->m_alpha
;
1029 void wxImage::InitAlpha()
1031 wxCHECK_RET( !HasAlpha(), wxT("image already has an alpha channel") );
1033 // initialize memory for alpha channel
1036 unsigned char *alpha
= M_IMGDATA
->m_alpha
;
1037 const size_t lenAlpha
= M_IMGDATA
->m_width
* M_IMGDATA
->m_height
;
1041 // use the mask to initialize the alpha channel.
1042 const unsigned char * const alphaEnd
= alpha
+ lenAlpha
;
1044 const unsigned char mr
= M_IMGDATA
->m_maskRed
;
1045 const unsigned char mg
= M_IMGDATA
->m_maskGreen
;
1046 const unsigned char mb
= M_IMGDATA
->m_maskBlue
;
1047 for ( unsigned char *src
= M_IMGDATA
->m_data
;
1051 *alpha
= (src
[0] == mr
&& src
[1] == mg
&& src
[2] == mb
)
1052 ? wxIMAGE_ALPHA_TRANSPARENT
1053 : wxIMAGE_ALPHA_OPAQUE
;
1056 M_IMGDATA
->m_hasMask
= false;
1060 // make the image fully opaque
1061 memset(alpha
, wxIMAGE_ALPHA_OPAQUE
, lenAlpha
);
1065 // ----------------------------------------------------------------------------
1067 // ----------------------------------------------------------------------------
1069 void wxImage::SetMaskColour( unsigned char r
, unsigned char g
, unsigned char b
)
1071 wxCHECK_RET( Ok(), wxT("invalid image") );
1073 M_IMGDATA
->m_maskRed
= r
;
1074 M_IMGDATA
->m_maskGreen
= g
;
1075 M_IMGDATA
->m_maskBlue
= b
;
1076 M_IMGDATA
->m_hasMask
= true;
1079 bool wxImage::GetOrFindMaskColour( unsigned char *r
, unsigned char *g
, unsigned char *b
) const
1081 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1083 if (M_IMGDATA
->m_hasMask
)
1085 if (r
) *r
= M_IMGDATA
->m_maskRed
;
1086 if (g
) *g
= M_IMGDATA
->m_maskGreen
;
1087 if (b
) *b
= M_IMGDATA
->m_maskBlue
;
1092 FindFirstUnusedColour(r
, g
, b
);
1097 unsigned char wxImage::GetMaskRed() const
1099 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1101 return M_IMGDATA
->m_maskRed
;
1104 unsigned char wxImage::GetMaskGreen() const
1106 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1108 return M_IMGDATA
->m_maskGreen
;
1111 unsigned char wxImage::GetMaskBlue() const
1113 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
1115 return M_IMGDATA
->m_maskBlue
;
1118 void wxImage::SetMask( bool mask
)
1120 wxCHECK_RET( Ok(), wxT("invalid image") );
1122 M_IMGDATA
->m_hasMask
= mask
;
1125 bool wxImage::HasMask() const
1127 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1129 return M_IMGDATA
->m_hasMask
;
1132 bool wxImage::IsTransparent(int x
, int y
, unsigned char threshold
) const
1134 long pos
= XYToIndex(x
, y
);
1135 wxCHECK_MSG( pos
!= -1, false, wxT("invalid image coordinates") );
1138 if ( M_IMGDATA
->m_hasMask
)
1140 const unsigned char *p
= M_IMGDATA
->m_data
+ 3*pos
;
1141 if ( p
[0] == M_IMGDATA
->m_maskRed
&&
1142 p
[1] == M_IMGDATA
->m_maskGreen
&&
1143 p
[2] == M_IMGDATA
->m_maskBlue
)
1150 if ( M_IMGDATA
->m_alpha
)
1152 if ( M_IMGDATA
->m_alpha
[pos
] < threshold
)
1154 // transparent enough
1163 bool wxImage::SetMaskFromImage(const wxImage
& mask
,
1164 unsigned char mr
, unsigned char mg
, unsigned char mb
)
1166 // check that the images are the same size
1167 if ( (M_IMGDATA
->m_height
!= mask
.GetHeight() ) || (M_IMGDATA
->m_width
!= mask
.GetWidth () ) )
1169 wxLogError( _("Image and mask have different sizes.") );
1173 // find unused colour
1174 unsigned char r
,g
,b
;
1175 if (!FindFirstUnusedColour(&r
, &g
, &b
))
1177 wxLogError( _("No unused colour in image being masked.") );
1181 unsigned char *imgdata
= GetData();
1182 unsigned char *maskdata
= mask
.GetData();
1184 const int w
= GetWidth();
1185 const int h
= GetHeight();
1187 for (int j
= 0; j
< h
; j
++)
1189 for (int i
= 0; i
< w
; i
++)
1191 if ((maskdata
[0] == mr
) && (maskdata
[1] == mg
) && (maskdata
[2] == mb
))
1202 SetMaskColour(r
, g
, b
);
1208 bool wxImage::ConvertAlphaToMask(unsigned char threshold
)
1213 unsigned char mr
, mg
, mb
;
1214 if (!FindFirstUnusedColour(&mr
, &mg
, &mb
))
1216 wxLogError( _("No unused colour in image being masked.") );
1221 SetMaskColour(mr
, mg
, mb
);
1223 unsigned char *imgdata
= GetData();
1224 unsigned char *alphadata
= GetAlpha();
1227 int h
= GetHeight();
1229 for (int y
= 0; y
< h
; y
++)
1231 for (int x
= 0; x
< w
; x
++, imgdata
+= 3, alphadata
++)
1233 if (*alphadata
< threshold
)
1242 free(M_IMGDATA
->m_alpha
);
1243 M_IMGDATA
->m_alpha
= NULL
;
1248 // ----------------------------------------------------------------------------
1249 // Palette functions
1250 // ----------------------------------------------------------------------------
1254 bool wxImage::HasPalette() const
1259 return M_IMGDATA
->m_palette
.Ok();
1262 const wxPalette
& wxImage::GetPalette() const
1264 wxCHECK_MSG( Ok(), wxNullPalette
, wxT("invalid image") );
1266 return M_IMGDATA
->m_palette
;
1269 void wxImage::SetPalette(const wxPalette
& palette
)
1271 wxCHECK_RET( Ok(), wxT("invalid image") );
1273 M_IMGDATA
->m_palette
= palette
;
1276 #endif // wxUSE_PALETTE
1278 // ----------------------------------------------------------------------------
1279 // Option functions (arbitrary name/value mapping)
1280 // ----------------------------------------------------------------------------
1282 void wxImage::SetOption(const wxString
& name
, const wxString
& value
)
1284 wxCHECK_RET( Ok(), wxT("invalid image") );
1286 int idx
= M_IMGDATA
->m_optionNames
.Index(name
, false);
1287 if (idx
== wxNOT_FOUND
)
1289 M_IMGDATA
->m_optionNames
.Add(name
);
1290 M_IMGDATA
->m_optionValues
.Add(value
);
1294 M_IMGDATA
->m_optionNames
[idx
] = name
;
1295 M_IMGDATA
->m_optionValues
[idx
] = value
;
1299 void wxImage::SetOption(const wxString
& name
, int value
)
1302 valStr
.Printf(wxT("%d"), value
);
1303 SetOption(name
, valStr
);
1306 wxString
wxImage::GetOption(const wxString
& name
) const
1308 wxCHECK_MSG( Ok(), wxEmptyString
, wxT("invalid image") );
1310 int idx
= M_IMGDATA
->m_optionNames
.Index(name
, false);
1311 if (idx
== wxNOT_FOUND
)
1312 return wxEmptyString
;
1314 return M_IMGDATA
->m_optionValues
[idx
];
1317 int wxImage::GetOptionInt(const wxString
& name
) const
1319 return wxAtoi(GetOption(name
));
1322 bool wxImage::HasOption(const wxString
& name
) const
1324 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1326 return (M_IMGDATA
->m_optionNames
.Index(name
, false) != wxNOT_FOUND
);
1329 // ----------------------------------------------------------------------------
1331 // ----------------------------------------------------------------------------
1333 bool wxImage::LoadFile( const wxString
& filename
, long type
, int index
)
1336 if (wxFileExists(filename
))
1338 wxFileInputStream
stream(filename
);
1339 wxBufferedInputStream
bstream( stream
);
1340 return LoadFile(bstream
, type
, index
);
1344 wxLogError( _("Can't load image from file '%s': file does not exist."), filename
.c_str() );
1348 #else // !wxUSE_STREAMS
1350 #endif // wxUSE_STREAMS
1353 bool wxImage::LoadFile( const wxString
& filename
, const wxString
& mimetype
, int index
)
1356 if (wxFileExists(filename
))
1358 wxFileInputStream
stream(filename
);
1359 wxBufferedInputStream
bstream( stream
);
1360 return LoadFile(bstream
, mimetype
, index
);
1364 wxLogError( _("Can't load image from file '%s': file does not exist."), filename
.c_str() );
1368 #else // !wxUSE_STREAMS
1370 #endif // wxUSE_STREAMS
1375 bool wxImage::SaveFile( const wxString
& filename
) const
1377 wxString ext
= filename
.AfterLast('.').Lower();
1379 wxImageHandler
* pHandler
= FindHandler(ext
, -1);
1382 SaveFile(filename
, pHandler
->GetType());
1386 wxLogError(_("Can't save image to file '%s': unknown extension."), filename
.c_str());
1391 bool wxImage::SaveFile( const wxString
& filename
, int type
) const
1394 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1396 ((wxImage
*)this)->SetOption(wxIMAGE_OPTION_FILENAME
, filename
);
1398 wxFileOutputStream
stream(filename
);
1400 if ( stream
.IsOk() )
1402 wxBufferedOutputStream
bstream( stream
);
1403 return SaveFile(bstream
, type
);
1405 #endif // wxUSE_STREAMS
1410 bool wxImage::SaveFile( const wxString
& filename
, const wxString
& mimetype
) const
1413 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1415 ((wxImage
*)this)->SetOption(wxIMAGE_OPTION_FILENAME
, filename
);
1417 wxFileOutputStream
stream(filename
);
1419 if ( stream
.IsOk() )
1421 wxBufferedOutputStream
bstream( stream
);
1422 return SaveFile(bstream
, mimetype
);
1424 #endif // wxUSE_STREAMS
1429 bool wxImage::CanRead( const wxString
&name
)
1432 wxFileInputStream
stream(name
);
1433 return CanRead(stream
);
1439 int wxImage::GetImageCount( const wxString
&name
, long type
)
1442 wxFileInputStream
stream(name
);
1444 return GetImageCount(stream
, type
);
1452 bool wxImage::CanRead( wxInputStream
&stream
)
1454 const wxList
& list
= GetHandlers();
1456 for ( wxList::compatibility_iterator node
= list
.GetFirst(); node
; node
= node
->GetNext() )
1458 wxImageHandler
*handler
=(wxImageHandler
*)node
->GetData();
1459 if (handler
->CanRead( stream
))
1466 int wxImage::GetImageCount( wxInputStream
&stream
, long type
)
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
->GetImageCount(stream
);
1482 wxLogWarning(_("No handler found for image type."));
1486 handler
= FindHandler(type
);
1490 wxLogWarning(_("No image handler for type %d defined."), type
);
1494 if ( handler
->CanRead(stream
) )
1496 return handler
->GetImageCount(stream
);
1500 wxLogError(_("Image file is not of type %d."), type
);
1505 bool wxImage::LoadFile( wxInputStream
& stream
, long type
, int index
)
1509 m_refData
= new wxImageRefData
;
1511 wxImageHandler
*handler
;
1513 if ( type
== wxBITMAP_TYPE_ANY
)
1515 wxList
&list
=GetHandlers();
1517 for ( wxList::compatibility_iterator node
= list
.GetFirst(); node
; node
= node
->GetNext() )
1519 handler
=(wxImageHandler
*)node
->GetData();
1520 if ( handler
->CanRead(stream
) )
1521 return handler
->LoadFile(this, stream
, true/*verbose*/, index
);
1525 wxLogWarning( _("No handler found for image type.") );
1529 handler
= FindHandler(type
);
1533 wxLogWarning( _("No image handler for type %d defined."), type
);
1538 return handler
->LoadFile(this, stream
, true/*verbose*/, index
);
1541 bool wxImage::LoadFile( wxInputStream
& stream
, const wxString
& mimetype
, int index
)
1545 m_refData
= new wxImageRefData
;
1547 wxImageHandler
*handler
= FindHandlerMime(mimetype
);
1551 wxLogWarning( _("No image handler for type %s defined."), mimetype
.GetData() );
1556 return handler
->LoadFile( this, stream
, true/*verbose*/, index
);
1559 bool wxImage::SaveFile( wxOutputStream
& stream
, int type
) const
1561 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1563 wxImageHandler
*handler
= FindHandler(type
);
1566 wxLogWarning( _("No image handler for type %d defined."), type
);
1571 return handler
->SaveFile( (wxImage
*)this, stream
);
1574 bool wxImage::SaveFile( wxOutputStream
& stream
, const wxString
& mimetype
) const
1576 wxCHECK_MSG( Ok(), false, wxT("invalid image") );
1578 wxImageHandler
*handler
= FindHandlerMime(mimetype
);
1581 wxLogWarning( _("No image handler for type %s defined."), mimetype
.GetData() );
1586 return handler
->SaveFile( (wxImage
*)this, stream
);
1588 #endif // wxUSE_STREAMS
1590 // ----------------------------------------------------------------------------
1591 // image I/O handlers
1592 // ----------------------------------------------------------------------------
1594 void wxImage::AddHandler( wxImageHandler
*handler
)
1596 // Check for an existing handler of the type being added.
1597 if (FindHandler( handler
->GetType() ) == 0)
1599 sm_handlers
.Append( handler
);
1603 // This is not documented behaviour, merely the simplest 'fix'
1604 // for preventing duplicate additions. If someone ever has
1605 // a good reason to add and remove duplicate handlers (and they
1606 // may) we should probably refcount the duplicates.
1607 // also an issue in InsertHandler below.
1609 wxLogDebug( _T("Adding duplicate image handler for '%s'"),
1610 handler
->GetName().c_str() );
1615 void wxImage::InsertHandler( wxImageHandler
*handler
)
1617 // Check for an existing handler of the type being added.
1618 if (FindHandler( handler
->GetType() ) == 0)
1620 sm_handlers
.Insert( handler
);
1624 // see AddHandler for additional comments.
1625 wxLogDebug( _T("Inserting duplicate image handler for '%s'"),
1626 handler
->GetName().c_str() );
1631 bool wxImage::RemoveHandler( const wxString
& name
)
1633 wxImageHandler
*handler
= FindHandler(name
);
1636 sm_handlers
.DeleteObject(handler
);
1644 wxImageHandler
*wxImage::FindHandler( const wxString
& name
)
1646 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
1649 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
1650 if (handler
->GetName().Cmp(name
) == 0) return handler
;
1652 node
= node
->GetNext();
1657 wxImageHandler
*wxImage::FindHandler( const wxString
& extension
, long bitmapType
)
1659 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
1662 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
1663 if ( (handler
->GetExtension().Cmp(extension
) == 0) &&
1664 (bitmapType
== -1 || handler
->GetType() == bitmapType
) )
1666 node
= node
->GetNext();
1671 wxImageHandler
*wxImage::FindHandler( long bitmapType
)
1673 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
1676 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
1677 if (handler
->GetType() == bitmapType
) return handler
;
1678 node
= node
->GetNext();
1683 wxImageHandler
*wxImage::FindHandlerMime( const wxString
& mimetype
)
1685 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
1688 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
1689 if (handler
->GetMimeType().IsSameAs(mimetype
, false)) return handler
;
1690 node
= node
->GetNext();
1695 void wxImage::InitStandardHandlers()
1698 AddHandler(new wxBMPHandler
);
1699 #endif // wxUSE_STREAMS
1702 void wxImage::CleanUpHandlers()
1704 wxList::compatibility_iterator node
= sm_handlers
.GetFirst();
1707 wxImageHandler
*handler
= (wxImageHandler
*)node
->GetData();
1708 wxList::compatibility_iterator next
= node
->GetNext();
1713 sm_handlers
.Clear();
1716 wxString
wxImage::GetImageExtWildcard()
1720 wxList
& Handlers
= wxImage::GetHandlers();
1721 wxList::compatibility_iterator Node
= Handlers
.GetFirst();
1724 wxImageHandler
* Handler
= (wxImageHandler
*)Node
->GetData();
1725 fmts
+= wxT("*.") + Handler
->GetExtension();
1726 Node
= Node
->GetNext();
1727 if ( Node
) fmts
+= wxT(";");
1730 return wxT("(") + fmts
+ wxT(")|") + fmts
;
1733 //-----------------------------------------------------------------------------
1735 //-----------------------------------------------------------------------------
1737 IMPLEMENT_ABSTRACT_CLASS(wxImageHandler
,wxObject
)
1740 bool wxImageHandler::LoadFile( wxImage
*WXUNUSED(image
), wxInputStream
& WXUNUSED(stream
), bool WXUNUSED(verbose
), int WXUNUSED(index
) )
1745 bool wxImageHandler::SaveFile( wxImage
*WXUNUSED(image
), wxOutputStream
& WXUNUSED(stream
), bool WXUNUSED(verbose
) )
1750 int wxImageHandler::GetImageCount( wxInputStream
& WXUNUSED(stream
) )
1755 bool wxImageHandler::CanRead( const wxString
& name
)
1757 if (wxFileExists(name
))
1759 wxFileInputStream
stream(name
);
1760 return CanRead(stream
);
1763 wxLogError( _("Can't check image format of file '%s': file does not exist."), name
.c_str() );
1768 bool wxImageHandler::CallDoCanRead(wxInputStream
& stream
)
1770 wxFileOffset posOld
= stream
.TellI();
1771 if ( posOld
== wxInvalidOffset
)
1773 // can't test unseekable stream
1777 bool ok
= DoCanRead(stream
);
1779 // restore the old position to be able to test other formats and so on
1780 if ( stream
.SeekI(posOld
) == wxInvalidOffset
)
1782 wxLogDebug(_T("Failed to rewind the stream in wxImageHandler!"));
1784 // reading would fail anyhow as we're not at the right position
1791 #endif // wxUSE_STREAMS
1793 // ----------------------------------------------------------------------------
1794 // image histogram stuff
1795 // ----------------------------------------------------------------------------
1798 wxImageHistogram::FindFirstUnusedColour(unsigned char *r
,
1803 unsigned char g2
) const
1805 unsigned long key
= MakeKey(r2
, g2
, b2
);
1807 while ( find(key
) != end() )
1809 // color already used
1821 wxLogError(_("No unused colour in image.") );
1827 key
= MakeKey(r2
, g2
, b2
);
1841 wxImage::FindFirstUnusedColour(unsigned char *r
,
1846 unsigned char g2
) const
1848 wxImageHistogram histogram
;
1850 ComputeHistogram(histogram
);
1852 return histogram
.FindFirstUnusedColour(r
, g
, b
, r2
, g2
, b2
);
1858 // Counts and returns the number of different colours. Optionally stops
1859 // when it exceeds 'stopafter' different colours. This is useful, for
1860 // example, to see if the image can be saved as 8-bit (256 colour or
1861 // less, in this case it would be invoked as CountColours(256)). Default
1862 // value for stopafter is -1 (don't care).
1864 unsigned long wxImage::CountColours( unsigned long stopafter
) const
1868 unsigned char r
, g
, b
;
1870 unsigned long size
, nentries
, key
;
1873 size
= GetWidth() * GetHeight();
1876 for (unsigned long j
= 0; (j
< size
) && (nentries
<= stopafter
) ; j
++)
1881 key
= wxImageHistogram::MakeKey(r
, g
, b
);
1883 if (h
.Get(key
) == NULL
)
1894 unsigned long wxImage::ComputeHistogram( wxImageHistogram
&h
) const
1896 unsigned char *p
= GetData();
1897 unsigned long nentries
= 0;
1901 const unsigned long size
= GetWidth() * GetHeight();
1903 unsigned char r
, g
, b
;
1904 for ( unsigned long n
= 0; n
< size
; n
++ )
1910 wxImageHistogramEntry
& entry
= h
[wxImageHistogram::MakeKey(r
, g
, b
)];
1912 if ( entry
.value
++ == 0 )
1913 entry
.index
= nentries
++;
1920 * Rotation code by Carlos Moreno
1923 // GRG: I've removed wxRotationPoint - we already have wxRealPoint which
1924 // does exactly the same thing. And I also got rid of wxRotationPixel
1925 // bacause of potential problems in architectures where alignment
1926 // is an issue, so I had to rewrite parts of the code.
1928 static const double gs_Epsilon
= 1e-10;
1930 static inline int wxCint (double x
)
1932 return (x
> 0) ? (int) (x
+ 0.5) : (int) (x
- 0.5);
1936 // Auxiliary function to rotate a point (x,y) with respect to point p0
1937 // make it inline and use a straight return to facilitate optimization
1938 // also, the function receives the sine and cosine of the angle to avoid
1939 // repeating the time-consuming calls to these functions -- sin/cos can
1940 // be computed and stored in the calling function.
1942 inline wxRealPoint
rotated_point (const wxRealPoint
& p
, double cos_angle
, double sin_angle
, const wxRealPoint
& p0
)
1944 return wxRealPoint (p0
.x
+ (p
.x
- p0
.x
) * cos_angle
- (p
.y
- p0
.y
) * sin_angle
,
1945 p0
.y
+ (p
.y
- p0
.y
) * cos_angle
+ (p
.x
- p0
.x
) * sin_angle
);
1948 inline wxRealPoint
rotated_point (double x
, double y
, double cos_angle
, double sin_angle
, const wxRealPoint
& p0
)
1950 return rotated_point (wxRealPoint(x
,y
), cos_angle
, sin_angle
, p0
);
1953 wxImage
wxImage::Rotate(double angle
, const wxPoint
& centre_of_rotation
, bool interpolating
, wxPoint
* offset_after_rotation
) const
1956 angle
= -angle
; // screen coordinates are a mirror image of "real" coordinates
1958 bool has_alpha
= HasAlpha();
1960 // Create pointer-based array to accelerate access to wxImage's data
1961 unsigned char ** data
= new unsigned char * [GetHeight()];
1962 data
[0] = GetData();
1963 for (i
= 1; i
< GetHeight(); i
++)
1964 data
[i
] = data
[i
- 1] + (3 * GetWidth());
1966 // Same for alpha channel
1967 unsigned char ** alpha
= NULL
;
1970 alpha
= new unsigned char * [GetHeight()];
1971 alpha
[0] = GetAlpha();
1972 for (i
= 1; i
< GetHeight(); i
++)
1973 alpha
[i
] = alpha
[i
- 1] + GetWidth();
1976 // precompute coefficients for rotation formula
1977 // (sine and cosine of the angle)
1978 const double cos_angle
= cos(angle
);
1979 const double sin_angle
= sin(angle
);
1981 // Create new Image to store the result
1982 // First, find rectangle that covers the rotated image; to do that,
1983 // rotate the four corners
1985 const wxRealPoint
p0(centre_of_rotation
.x
, centre_of_rotation
.y
);
1987 wxRealPoint p1
= rotated_point (0, 0, cos_angle
, sin_angle
, p0
);
1988 wxRealPoint p2
= rotated_point (0, GetHeight(), cos_angle
, sin_angle
, p0
);
1989 wxRealPoint p3
= rotated_point (GetWidth(), 0, cos_angle
, sin_angle
, p0
);
1990 wxRealPoint p4
= rotated_point (GetWidth(), GetHeight(), cos_angle
, sin_angle
, p0
);
1992 int x1
= (int) floor (wxMin (wxMin(p1
.x
, p2
.x
), wxMin(p3
.x
, p4
.x
)));
1993 int y1
= (int) floor (wxMin (wxMin(p1
.y
, p2
.y
), wxMin(p3
.y
, p4
.y
)));
1994 int x2
= (int) ceil (wxMax (wxMax(p1
.x
, p2
.x
), wxMax(p3
.x
, p4
.x
)));
1995 int y2
= (int) ceil (wxMax (wxMax(p1
.y
, p2
.y
), wxMax(p3
.y
, p4
.y
)));
1997 // Create rotated image
1998 wxImage
rotated (x2
- x1
+ 1, y2
- y1
+ 1, false);
1999 // With alpha channel
2003 if (offset_after_rotation
!= NULL
)
2005 *offset_after_rotation
= wxPoint (x1
, y1
);
2008 // GRG: The rotated (destination) image is always accessed
2009 // sequentially, so there is no need for a pointer-based
2010 // array here (and in fact it would be slower).
2012 unsigned char * dst
= rotated
.GetData();
2014 unsigned char * alpha_dst
= NULL
;
2016 alpha_dst
= rotated
.GetAlpha();
2018 // GRG: if the original image has a mask, use its RGB values
2019 // as the blank pixel, else, fall back to default (black).
2021 unsigned char blank_r
= 0;
2022 unsigned char blank_g
= 0;
2023 unsigned char blank_b
= 0;
2027 blank_r
= GetMaskRed();
2028 blank_g
= GetMaskGreen();
2029 blank_b
= GetMaskBlue();
2030 rotated
.SetMaskColour( blank_r
, blank_g
, blank_b
);
2033 // Now, for each point of the rotated image, find where it came from, by
2034 // performing an inverse rotation (a rotation of -angle) and getting the
2035 // pixel at those coordinates
2037 // GRG: I've taken the (interpolating) test out of the loops, so that
2038 // it is done only once, instead of repeating it for each pixel.
2043 for (int y
= 0; y
< rotated
.GetHeight(); y
++)
2045 for (x
= 0; x
< rotated
.GetWidth(); x
++)
2047 wxRealPoint src
= rotated_point (x
+ x1
, y
+ y1
, cos_angle
, -sin_angle
, p0
);
2049 if (-0.25 < src
.x
&& src
.x
< GetWidth() - 0.75 &&
2050 -0.25 < src
.y
&& src
.y
< GetHeight() - 0.75)
2052 // interpolate using the 4 enclosing grid-points. Those
2053 // points can be obtained using floor and ceiling of the
2054 // exact coordinates of the point
2055 // C.M. 2000-02-17: when the point is near the border, special care is required.
2059 if (0 < src
.x
&& src
.x
< GetWidth() - 1)
2061 x1
= wxCint(floor(src
.x
));
2062 x2
= wxCint(ceil(src
.x
));
2064 else // else means that x is near one of the borders (0 or width-1)
2066 x1
= x2
= wxCint (src
.x
);
2069 if (0 < src
.y
&& src
.y
< GetHeight() - 1)
2071 y1
= wxCint(floor(src
.y
));
2072 y2
= wxCint(ceil(src
.y
));
2076 y1
= y2
= wxCint (src
.y
);
2079 // get four points and the distances (square of the distance,
2080 // for efficiency reasons) for the interpolation formula
2082 // GRG: Do not calculate the points until they are
2083 // really needed -- this way we can calculate
2084 // just one, instead of four, if d1, d2, d3
2085 // or d4 are < gs_Epsilon
2087 const double d1
= (src
.x
- x1
) * (src
.x
- x1
) + (src
.y
- y1
) * (src
.y
- y1
);
2088 const double d2
= (src
.x
- x2
) * (src
.x
- x2
) + (src
.y
- y1
) * (src
.y
- y1
);
2089 const double d3
= (src
.x
- x2
) * (src
.x
- x2
) + (src
.y
- y2
) * (src
.y
- y2
);
2090 const double d4
= (src
.x
- x1
) * (src
.x
- x1
) + (src
.y
- y2
) * (src
.y
- y2
);
2092 // Now interpolate as a weighted average of the four surrounding
2093 // points, where the weights are the distances to each of those points
2095 // If the point is exactly at one point of the grid of the source
2096 // image, then don't interpolate -- just assign the pixel
2098 if (d1
< gs_Epsilon
) // d1,d2,d3,d4 are positive -- no need for abs()
2100 unsigned char *p
= data
[y1
] + (3 * x1
);
2107 unsigned char *p
= alpha
[y1
] + x1
;
2108 *(alpha_dst
++) = *p
;
2111 else if (d2
< gs_Epsilon
)
2113 unsigned char *p
= data
[y1
] + (3 * x2
);
2120 unsigned char *p
= alpha
[y1
] + x2
;
2121 *(alpha_dst
++) = *p
;
2124 else if (d3
< gs_Epsilon
)
2126 unsigned char *p
= data
[y2
] + (3 * x2
);
2133 unsigned char *p
= alpha
[y2
] + x2
;
2134 *(alpha_dst
++) = *p
;
2137 else if (d4
< gs_Epsilon
)
2139 unsigned char *p
= data
[y2
] + (3 * x1
);
2146 unsigned char *p
= alpha
[y2
] + x1
;
2147 *(alpha_dst
++) = *p
;
2152 // weights for the weighted average are proportional to the inverse of the distance
2153 unsigned char *v1
= data
[y1
] + (3 * x1
);
2154 unsigned char *v2
= data
[y1
] + (3 * x2
);
2155 unsigned char *v3
= data
[y2
] + (3 * x2
);
2156 unsigned char *v4
= data
[y2
] + (3 * x1
);
2158 const double w1
= 1/d1
, w2
= 1/d2
, w3
= 1/d3
, w4
= 1/d4
;
2162 *(dst
++) = (unsigned char)
2163 ( (w1
* *(v1
++) + w2
* *(v2
++) +
2164 w3
* *(v3
++) + w4
* *(v4
++)) /
2165 (w1
+ w2
+ w3
+ w4
) );
2166 *(dst
++) = (unsigned char)
2167 ( (w1
* *(v1
++) + w2
* *(v2
++) +
2168 w3
* *(v3
++) + w4
* *(v4
++)) /
2169 (w1
+ w2
+ w3
+ w4
) );
2170 *(dst
++) = (unsigned char)
2171 ( (w1
* *v1
+ w2
* *v2
+
2172 w3
* *v3
+ w4
* *v4
) /
2173 (w1
+ w2
+ w3
+ w4
) );
2177 unsigned char *v1
= alpha
[y1
] + (x1
);
2178 unsigned char *v2
= alpha
[y1
] + (x2
);
2179 unsigned char *v3
= alpha
[y2
] + (x2
);
2180 unsigned char *v4
= alpha
[y2
] + (x1
);
2182 *(alpha_dst
++) = (unsigned char)
2183 ( (w1
* *v1
+ w2
* *v2
+
2184 w3
* *v3
+ w4
* *v4
) /
2185 (w1
+ w2
+ w3
+ w4
) );
2201 else // not interpolating
2203 for (int y
= 0; y
< rotated
.GetHeight(); y
++)
2205 for (x
= 0; x
< rotated
.GetWidth(); x
++)
2207 wxRealPoint src
= rotated_point (x
+ x1
, y
+ y1
, cos_angle
, -sin_angle
, p0
);
2209 const int xs
= wxCint (src
.x
); // wxCint rounds to the
2210 const int ys
= wxCint (src
.y
); // closest integer
2212 if (0 <= xs
&& xs
< GetWidth() &&
2213 0 <= ys
&& ys
< GetHeight())
2215 unsigned char *p
= data
[ys
] + (3 * xs
);
2222 unsigned char *p
= alpha
[ys
] + (xs
);
2223 *(alpha_dst
++) = *p
;
2233 *(alpha_dst
++) = 255;
2251 // A module to allow wxImage initialization/cleanup
2252 // without calling these functions from app.cpp or from
2253 // the user's application.
2255 class wxImageModule
: public wxModule
2257 DECLARE_DYNAMIC_CLASS(wxImageModule
)
2260 bool OnInit() { wxImage::InitStandardHandlers(); return true; };
2261 void OnExit() { wxImage::CleanUpHandlers(); };
2264 IMPLEMENT_DYNAMIC_CLASS(wxImageModule
, wxModule
)
2267 #endif // wxUSE_IMAGE