1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Robert Roebling
6 // Copyright: (c) Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
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"
44 //-----------------------------------------------------------------------------
46 //-----------------------------------------------------------------------------
48 class wxImageRefData
: public wxObjectRefData
56 unsigned char *m_data
;
58 unsigned char m_maskRed
,m_maskGreen
,m_maskBlue
;
63 #endif // wxUSE_PALETTE
64 wxArrayString m_optionNames
;
65 wxArrayString m_optionValues
;
68 wxImageRefData::wxImageRefData()
72 m_data
= (unsigned char*) NULL
;
81 wxImageRefData::~wxImageRefData()
83 if (m_data
&& !m_static
)
87 wxList
wxImage::sm_handlers
;
91 //-----------------------------------------------------------------------------
93 #define M_IMGDATA ((wxImageRefData *)m_refData)
95 IMPLEMENT_DYNAMIC_CLASS(wxImage
, wxObject
)
101 wxImage::wxImage( int width
, int height
)
103 Create( width
, height
);
106 wxImage::wxImage( int width
, int height
, unsigned char* data
, bool static_data
)
108 Create( width
, height
, data
, static_data
);
111 wxImage::wxImage( const wxString
& name
, long type
, int index
)
113 LoadFile( name
, type
, index
);
116 wxImage::wxImage( const wxString
& name
, const wxString
& mimetype
, int index
)
118 LoadFile( name
, mimetype
, index
);
122 wxImage::wxImage( wxInputStream
& stream
, long type
, int index
)
124 LoadFile( stream
, type
, index
);
127 wxImage::wxImage( wxInputStream
& stream
, const wxString
& mimetype
, int index
)
129 LoadFile( stream
, mimetype
, index
);
131 #endif // wxUSE_STREAMS
133 wxImage::wxImage( const wxImage
& image
)
138 wxImage::wxImage( const wxImage
* image
)
140 if (image
) Ref(*image
);
143 void wxImage::Create( int width
, int height
)
147 m_refData
= new wxImageRefData();
149 M_IMGDATA
->m_data
= (unsigned char *) malloc( width
*height
*3 );
150 if (M_IMGDATA
->m_data
)
152 for (int l
= 0; l
< width
*height
*3; l
++) M_IMGDATA
->m_data
[l
] = 0;
154 M_IMGDATA
->m_width
= width
;
155 M_IMGDATA
->m_height
= height
;
156 M_IMGDATA
->m_ok
= TRUE
;
164 void wxImage::Create( int width
, int height
, unsigned char* data
, bool static_data
)
168 m_refData
= new wxImageRefData();
170 M_IMGDATA
->m_data
= data
;
171 if (M_IMGDATA
->m_data
)
173 M_IMGDATA
->m_width
= width
;
174 M_IMGDATA
->m_height
= height
;
175 M_IMGDATA
->m_ok
= TRUE
;
176 M_IMGDATA
->m_static
= static_data
;
184 void wxImage::Destroy()
189 wxImage
wxImage::Copy() const
193 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
195 image
.Create( M_IMGDATA
->m_width
, M_IMGDATA
->m_height
);
197 char unsigned *data
= image
.GetData();
199 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
201 if (M_IMGDATA
->m_hasMask
)
202 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
204 memcpy( data
, GetData(), M_IMGDATA
->m_width
*M_IMGDATA
->m_height
*3 );
209 wxImage
wxImage::Scale( int width
, int height
) const
213 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
215 // can't scale to/from 0 size
216 wxCHECK_MSG( (width
> 0) && (height
> 0), image
,
217 wxT("invalid new image size") );
219 long old_height
= M_IMGDATA
->m_height
,
220 old_width
= M_IMGDATA
->m_width
;
221 wxCHECK_MSG( (old_height
> 0) && (old_width
> 0), image
,
222 wxT("invalid old image size") );
224 image
.Create( width
, height
);
226 char unsigned *data
= image
.GetData();
228 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
230 if (M_IMGDATA
->m_hasMask
)
232 image
.SetMaskColour( M_IMGDATA
->m_maskRed
,
233 M_IMGDATA
->m_maskGreen
,
234 M_IMGDATA
->m_maskBlue
);
237 char unsigned *source_data
= M_IMGDATA
->m_data
;
238 char unsigned *target_data
= data
;
241 // This is nonsense, RR.
243 // We do (x, y) -> (x, y)*oldSize/newSize but the valid values of x and y
244 // are from 0 to size-1, hence all decrement the sizes
245 long old_old_width
= old_width
;
250 for ( long j
= 0; j
<= height
; j
++ )
252 // don't crash for images with height == 1
253 long y_offset
= height
? (j
* old_height
/ height
)* old_old_width
: 0;
255 for ( long i
= 0; i
<= width
; i
++ )
257 long x_offset
= width
? (i
* old_width
) / width
: 0;
259 memcpy( target_data
, source_data
+ 3*(y_offset
+ x_offset
), 3 );
264 for (long j
= 0; j
< height
; j
++)
266 long y_offset
= (j
* old_height
/ height
) * old_width
;
268 for (long i
= 0; i
< width
; i
++)
271 source_data
+ 3*(y_offset
+ ((i
* old_width
)/ width
)),
281 wxImage
wxImage::Rotate90( bool clockwise
) const
285 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
287 image
.Create( M_IMGDATA
->m_height
, M_IMGDATA
->m_width
);
289 char unsigned *data
= image
.GetData();
291 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
293 if (M_IMGDATA
->m_hasMask
)
294 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
296 long height
= M_IMGDATA
->m_height
;
297 long width
= M_IMGDATA
->m_width
;
299 char unsigned *source_data
= M_IMGDATA
->m_data
;
300 char unsigned *target_data
;
302 for (long j
= 0; j
< height
; j
++)
304 for (long i
= 0; i
< width
; i
++)
307 target_data
= data
+ (((i
+1)*height
) - j
- 1)*3;
309 target_data
= data
+ ((height
*(width
-1)) + j
- (i
*height
))*3;
310 memcpy( target_data
, source_data
, 3 );
318 wxImage
wxImage::Mirror( bool horizontally
) const
322 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
324 image
.Create( M_IMGDATA
->m_width
, M_IMGDATA
->m_height
);
326 char unsigned *data
= image
.GetData();
328 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
330 if (M_IMGDATA
->m_hasMask
)
331 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
333 long height
= M_IMGDATA
->m_height
;
334 long width
= M_IMGDATA
->m_width
;
336 char unsigned *source_data
= M_IMGDATA
->m_data
;
337 char unsigned *target_data
;
341 for (long j
= 0; j
< height
; j
++)
344 target_data
= data
-3;
345 for (long i
= 0; i
< width
; i
++)
347 memcpy( target_data
, source_data
, 3 );
355 for (long i
= 0; i
< height
; i
++)
357 target_data
= data
+ 3*width
*(height
-1-i
);
358 memcpy( target_data
, source_data
, (size_t)3*width
);
359 source_data
+= 3*width
;
366 wxImage
wxImage::GetSubImage( const wxRect
&rect
) const
370 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
372 wxCHECK_MSG( (rect
.GetLeft()>=0) && (rect
.GetTop()>=0) && (rect
.GetRight()<=GetWidth()) && (rect
.GetBottom()<=GetHeight()),
373 image
, wxT("invalid subimage size") );
375 int subwidth
=rect
.GetWidth();
376 const int subheight
=rect
.GetHeight();
378 image
.Create( subwidth
, subheight
);
380 char unsigned *subdata
= image
.GetData(), *data
=GetData();
382 wxCHECK_MSG( subdata
, image
, wxT("unable to create image") );
384 if (M_IMGDATA
->m_hasMask
)
385 image
.SetMaskColour( M_IMGDATA
->m_maskRed
, M_IMGDATA
->m_maskGreen
, M_IMGDATA
->m_maskBlue
);
387 const int subleft
=3*rect
.GetLeft();
388 const int width
=3*GetWidth();
391 data
+=rect
.GetTop()*width
+subleft
;
393 for (long j
= 0; j
< subheight
; ++j
)
395 memcpy( subdata
, data
, subwidth
);
403 void wxImage::Paste( const wxImage
&image
, int x
, int y
)
405 wxCHECK_RET( Ok(), wxT("invalid image") );
406 wxCHECK_RET( image
.Ok(), wxT("invalid image") );
410 int width
= image
.GetWidth();
411 int height
= image
.GetHeight();
424 if ((x
+xx
)+width
> M_IMGDATA
->m_width
)
425 width
= M_IMGDATA
->m_width
- (x
+xx
);
426 if ((y
+yy
)+height
> M_IMGDATA
->m_height
)
427 height
= M_IMGDATA
->m_height
- (y
+yy
);
429 if (width
< 1) return;
430 if (height
< 1) return;
432 if ((!HasMask() && !image
.HasMask()) ||
433 ((HasMask() && image
.HasMask() &&
434 (GetMaskRed()==image
.GetMaskRed()) &&
435 (GetMaskGreen()==image
.GetMaskGreen()) &&
436 (GetMaskBlue()==image
.GetMaskBlue()))))
439 unsigned char* source_data
= image
.GetData() + xx
*3 + yy
*3*image
.GetWidth();
440 int source_step
= image
.GetWidth()*3;
442 unsigned char* target_data
= GetData() + (x
+xx
)*3 + (y
+yy
)*3*M_IMGDATA
->m_width
;
443 int target_step
= M_IMGDATA
->m_width
*3;
444 for (int j
= 0; j
< height
; j
++)
446 memcpy( target_data
, source_data
, width
);
447 source_data
+= source_step
;
448 target_data
+= target_step
;
453 if (!HasMask() && image
.HasMask())
455 unsigned char r
= image
.GetMaskRed();
456 unsigned char g
= image
.GetMaskGreen();
457 unsigned char b
= image
.GetMaskBlue();
460 unsigned char* source_data
= image
.GetData() + xx
*3 + yy
*3*image
.GetWidth();
461 int source_step
= image
.GetWidth()*3;
463 unsigned char* target_data
= GetData() + (x
+xx
)*3 + (y
+yy
)*3*M_IMGDATA
->m_width
;
464 int target_step
= M_IMGDATA
->m_width
*3;
466 for (int j
= 0; j
< height
; j
++)
468 for (int i
= 0; i
< width
; i
+=3)
470 if ((source_data
[i
] != r
) &&
471 (source_data
[i
+1] != g
) &&
472 (source_data
[i
+2] != b
))
474 memcpy( target_data
+i
, source_data
+i
, 3 );
477 source_data
+= source_step
;
478 target_data
+= target_step
;
483 void wxImage::Replace( unsigned char r1
, unsigned char g1
, unsigned char b1
,
484 unsigned char r2
, unsigned char g2
, unsigned char b2
)
486 wxCHECK_RET( Ok(), wxT("invalid image") );
488 char unsigned *data
= GetData();
490 const int w
= GetWidth();
491 const int h
= GetHeight();
493 for (int j
= 0; j
< h
; j
++)
494 for (int i
= 0; i
< w
; i
++)
496 if ((data
[0] == r1
) && (data
[1] == g1
) && (data
[2] == b1
))
506 wxImage
wxImage::ConvertToMono( unsigned char r
, unsigned char g
, unsigned char b
) const
510 wxCHECK_MSG( Ok(), image
, wxT("invalid image") );
512 image
.Create( M_IMGDATA
->m_width
, M_IMGDATA
->m_height
);
514 char unsigned *data
= image
.GetData();
516 wxCHECK_MSG( data
, image
, wxT("unable to create image") );
518 if (M_IMGDATA
->m_hasMask
)
520 if (M_IMGDATA
->m_maskRed
== r
&& M_IMGDATA
->m_maskGreen
== g
&&
521 M_IMGDATA
->m_maskBlue
== b
)
522 image
.SetMaskColour( 255, 255, 255 );
524 image
.SetMaskColour( 0, 0, 0 );
527 long size
= M_IMGDATA
->m_height
* M_IMGDATA
->m_width
;
529 char unsigned *srcd
= M_IMGDATA
->m_data
;
530 char unsigned *tard
= image
.GetData();
532 for ( long i
= 0; i
< size
; i
++, srcd
+= 3, tard
+= 3 )
534 if (srcd
[0] == r
&& srcd
[1] == g
&& srcd
[2] == b
)
535 tard
[0] = tard
[1] = tard
[2] = 255;
537 tard
[0] = tard
[1] = tard
[2] = 0;
543 void wxImage::SetRGB( int x
, int y
, unsigned char r
, unsigned char g
, unsigned char b
)
545 wxCHECK_RET( Ok(), wxT("invalid image") );
547 int w
= M_IMGDATA
->m_width
;
548 int h
= M_IMGDATA
->m_height
;
550 wxCHECK_RET( (x
>=0) && (y
>=0) && (x
<w
) && (y
<h
), wxT("invalid image index") );
552 long pos
= (y
* w
+ x
) * 3;
554 M_IMGDATA
->m_data
[ pos
] = r
;
555 M_IMGDATA
->m_data
[ pos
+1 ] = g
;
556 M_IMGDATA
->m_data
[ pos
+2 ] = b
;
559 unsigned char wxImage::GetRed( int x
, int y
) const
561 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
563 int w
= M_IMGDATA
->m_width
;
564 int h
= M_IMGDATA
->m_height
;
566 wxCHECK_MSG( (x
>=0) && (y
>=0) && (x
<w
) && (y
<h
), 0, wxT("invalid image index") );
568 long pos
= (y
* w
+ x
) * 3;
570 return M_IMGDATA
->m_data
[pos
];
573 unsigned char wxImage::GetGreen( int x
, int y
) const
575 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
577 int w
= M_IMGDATA
->m_width
;
578 int h
= M_IMGDATA
->m_height
;
580 wxCHECK_MSG( (x
>=0) && (y
>=0) && (x
<w
) && (y
<h
), 0, wxT("invalid image index") );
582 long pos
= (y
* w
+ x
) * 3;
584 return M_IMGDATA
->m_data
[pos
+1];
587 unsigned char wxImage::GetBlue( int x
, int y
) const
589 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
591 int w
= M_IMGDATA
->m_width
;
592 int h
= M_IMGDATA
->m_height
;
594 wxCHECK_MSG( (x
>=0) && (y
>=0) && (x
<w
) && (y
<h
), 0, wxT("invalid image index") );
596 long pos
= (y
* w
+ x
) * 3;
598 return M_IMGDATA
->m_data
[pos
+2];
601 bool wxImage::Ok() const
603 // image of 0 width or height can't be considered ok - at least because it
604 // causes crashes in ConvertToBitmap() if we don't catch it in time
605 wxImageRefData
*data
= M_IMGDATA
;
606 return data
&& data
->m_ok
&& data
->m_width
&& data
->m_height
;
609 char unsigned *wxImage::GetData() const
611 wxCHECK_MSG( Ok(), (char unsigned *)NULL
, wxT("invalid image") );
613 return M_IMGDATA
->m_data
;
616 void wxImage::SetData( char unsigned *data
)
618 wxCHECK_RET( Ok(), wxT("invalid image") );
620 wxImageRefData
*newRefData
= new wxImageRefData();
622 newRefData
->m_width
= M_IMGDATA
->m_width
;
623 newRefData
->m_height
= M_IMGDATA
->m_height
;
624 newRefData
->m_data
= data
;
625 newRefData
->m_ok
= TRUE
;
626 newRefData
->m_maskRed
= M_IMGDATA
->m_maskRed
;
627 newRefData
->m_maskGreen
= M_IMGDATA
->m_maskGreen
;
628 newRefData
->m_maskBlue
= M_IMGDATA
->m_maskBlue
;
629 newRefData
->m_hasMask
= M_IMGDATA
->m_hasMask
;
633 m_refData
= newRefData
;
636 void wxImage::SetData( char unsigned *data
, int new_width
, int new_height
)
638 wxImageRefData
*newRefData
= new wxImageRefData();
642 newRefData
->m_width
= new_width
;
643 newRefData
->m_height
= new_height
;
644 newRefData
->m_data
= data
;
645 newRefData
->m_ok
= TRUE
;
646 newRefData
->m_maskRed
= M_IMGDATA
->m_maskRed
;
647 newRefData
->m_maskGreen
= M_IMGDATA
->m_maskGreen
;
648 newRefData
->m_maskBlue
= M_IMGDATA
->m_maskBlue
;
649 newRefData
->m_hasMask
= M_IMGDATA
->m_hasMask
;
653 newRefData
->m_width
= new_width
;
654 newRefData
->m_height
= new_height
;
655 newRefData
->m_data
= data
;
656 newRefData
->m_ok
= TRUE
;
661 m_refData
= newRefData
;
664 void wxImage::SetMaskColour( unsigned char r
, unsigned char g
, unsigned char b
)
666 wxCHECK_RET( Ok(), wxT("invalid image") );
668 M_IMGDATA
->m_maskRed
= r
;
669 M_IMGDATA
->m_maskGreen
= g
;
670 M_IMGDATA
->m_maskBlue
= b
;
671 M_IMGDATA
->m_hasMask
= TRUE
;
674 unsigned char wxImage::GetMaskRed() const
676 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
678 return M_IMGDATA
->m_maskRed
;
681 unsigned char wxImage::GetMaskGreen() const
683 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
685 return M_IMGDATA
->m_maskGreen
;
688 unsigned char wxImage::GetMaskBlue() const
690 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
692 return M_IMGDATA
->m_maskBlue
;
695 void wxImage::SetMask( bool mask
)
697 wxCHECK_RET( Ok(), wxT("invalid image") );
699 M_IMGDATA
->m_hasMask
= mask
;
702 bool wxImage::HasMask() const
704 wxCHECK_MSG( Ok(), FALSE
, wxT("invalid image") );
706 return M_IMGDATA
->m_hasMask
;
709 int wxImage::GetWidth() const
711 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
713 return M_IMGDATA
->m_width
;
716 int wxImage::GetHeight() const
718 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
720 return M_IMGDATA
->m_height
;
724 bool wxImage::FindFirstUnusedColour(
725 unsigned char *r
, unsigned char *g
, unsigned char *b
,
726 unsigned char startR
, unsigned char startG
, unsigned char startB
)
728 wxImageHistogram histogram
;
731 ComputeHistogram(histogram
);
733 unsigned char r2
= startR
;
734 unsigned char g2
= startG
;
735 unsigned char b2
= startB
;
737 key
= (r2
<< 16) | (g2
<< 8) | b2
;
739 while ( histogram
.find(key
) != histogram
.end() )
741 // color already used
753 wxLogError( _("GetUnusedColour:: No Unused Color in image ") );
759 key
= (r2
<< 16) | (g2
<< 8) | b2
;
770 bool wxImage::SetMaskFromImage(const wxImage
& mask
,
771 unsigned char mr
, unsigned char mg
, unsigned char mb
)
773 // check that the images are the same size
774 if ( (M_IMGDATA
->m_height
!= mask
.GetHeight() ) || (M_IMGDATA
->m_width
!= mask
.GetWidth () ) )
776 wxLogError( _("Image and Mask have different sizes") );
780 // find unused colour
781 unsigned char r
,g
,b
;
782 if (!FindFirstUnusedColour(&r
, &g
, &b
))
784 wxLogError( _("No Unused Color in image being masked") );
788 char unsigned *imgdata
= GetData();
789 char unsigned *maskdata
= mask
.GetData();
791 const int w
= GetWidth();
792 const int h
= GetHeight();
794 for (int j
= 0; j
< h
; j
++)
796 for (int i
= 0; i
< w
; i
++)
798 if ((maskdata
[0] == mr
) && (maskdata
[1] == mg
) && (maskdata
[2] == mb
))
809 SetMaskColour(r
, g
, b
);
819 bool wxImage::HasPalette() const
824 return M_IMGDATA
->m_palette
.Ok();
827 const wxPalette
& wxImage::GetPalette() const
829 wxCHECK_MSG( Ok(), wxNullPalette
, wxT("invalid image") );
831 return M_IMGDATA
->m_palette
;
834 void wxImage::SetPalette(const wxPalette
& palette
)
836 wxCHECK_RET( Ok(), wxT("invalid image") );
838 M_IMGDATA
->m_palette
= palette
;
841 #endif // wxUSE_PALETTE
843 // Option functions (arbitrary name/value mapping)
844 void wxImage::SetOption(const wxString
& name
, const wxString
& value
)
846 wxCHECK_RET( Ok(), wxT("invalid image") );
848 int idx
= M_IMGDATA
->m_optionNames
.Index(name
, FALSE
);
849 if (idx
== wxNOT_FOUND
)
851 M_IMGDATA
->m_optionNames
.Add(name
);
852 M_IMGDATA
->m_optionValues
.Add(value
);
856 M_IMGDATA
->m_optionNames
[idx
] = name
;
857 M_IMGDATA
->m_optionValues
[idx
] = value
;
861 void wxImage::SetOption(const wxString
& name
, int value
)
864 valStr
.Printf(wxT("%d"), value
);
865 SetOption(name
, valStr
);
868 wxString
wxImage::GetOption(const wxString
& name
) const
870 wxCHECK_MSG( Ok(), wxEmptyString
, wxT("invalid image") );
872 int idx
= M_IMGDATA
->m_optionNames
.Index(name
, FALSE
);
873 if (idx
== wxNOT_FOUND
)
874 return wxEmptyString
;
876 return M_IMGDATA
->m_optionValues
[idx
];
879 int wxImage::GetOptionInt(const wxString
& name
) const
881 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
883 return wxAtoi(GetOption(name
));
886 bool wxImage::HasOption(const wxString
& name
) const
888 wxCHECK_MSG( Ok(), FALSE
, wxT("invalid image") );
890 return (M_IMGDATA
->m_optionNames
.Index(name
, FALSE
) != wxNOT_FOUND
);
893 bool wxImage::LoadFile( const wxString
& filename
, long type
, int index
)
896 if (wxFileExists(filename
))
898 wxFileInputStream
stream(filename
);
899 wxBufferedInputStream
bstream( stream
);
900 return LoadFile(bstream
, type
, index
);
904 wxLogError( _("Can't load image from file '%s': file does not exist."), filename
.c_str() );
908 #else // !wxUSE_STREAMS
910 #endif // wxUSE_STREAMS
913 bool wxImage::LoadFile( const wxString
& filename
, const wxString
& mimetype
, int index
)
916 if (wxFileExists(filename
))
918 wxFileInputStream
stream(filename
);
919 wxBufferedInputStream
bstream( stream
);
920 return LoadFile(bstream
, mimetype
, index
);
924 wxLogError( _("Can't load image from file '%s': file does not exist."), filename
.c_str() );
928 #else // !wxUSE_STREAMS
930 #endif // wxUSE_STREAMS
933 bool wxImage::SaveFile( const wxString
& filename
, int type
)
936 wxFileOutputStream
stream(filename
);
938 if ( stream
.LastError() == wxStream_NOERROR
)
940 wxBufferedOutputStream
bstream( stream
);
941 return SaveFile(bstream
, type
);
943 #endif // wxUSE_STREAMS
948 bool wxImage::SaveFile( const wxString
& filename
, const wxString
& mimetype
)
951 wxFileOutputStream
stream(filename
);
953 if ( stream
.LastError() == wxStream_NOERROR
)
955 wxBufferedOutputStream
bstream( stream
);
956 return SaveFile(bstream
, mimetype
);
958 #endif // wxUSE_STREAMS
963 bool wxImage::CanRead( const wxString
&name
)
966 wxFileInputStream
stream(name
);
967 return CanRead(stream
);
973 int wxImage::GetImageCount( const wxString
&name
, long type
)
976 wxFileInputStream
stream(name
);
977 return GetImageCount(stream
, type
);
985 bool wxImage::CanRead( wxInputStream
&stream
)
987 wxList
&list
=GetHandlers();
989 for ( wxList::Node
*node
= list
.GetFirst(); node
; node
= node
->GetNext() )
991 wxImageHandler
*handler
=(wxImageHandler
*)node
->GetData();
992 if (handler
->CanRead( stream
))
999 int wxImage::GetImageCount( wxInputStream
&stream
, long type
)
1001 wxImageHandler
*handler
;
1003 if ( type
== wxBITMAP_TYPE_ANY
)
1005 wxList
&list
=GetHandlers();
1007 for (wxList::Node
*node
= list
.GetFirst(); node
; node
= node
->GetNext())
1009 handler
=(wxImageHandler
*)node
->GetData();
1010 if ( handler
->CanRead(stream
) )
1011 return handler
->GetImageCount(stream
);
1015 wxLogWarning(_("No handler found for image type."));
1019 handler
= FindHandler(type
);
1023 wxLogWarning(_("No image handler for type %d defined."), type
);
1027 if ( handler
->CanRead(stream
) )
1029 return handler
->GetImageCount(stream
);
1033 wxLogError(_("Image file is not of type %d."), type
);
1038 bool wxImage::LoadFile( wxInputStream
& stream
, long type
, int index
)
1042 m_refData
= new wxImageRefData
;
1044 wxImageHandler
*handler
;
1046 if ( type
== wxBITMAP_TYPE_ANY
)
1048 wxList
&list
=GetHandlers();
1050 for ( wxList::Node
*node
= list
.GetFirst(); node
; node
= node
->GetNext() )
1052 handler
=(wxImageHandler
*)node
->GetData();
1053 if ( handler
->CanRead(stream
) )
1054 return handler
->LoadFile(this, stream
, TRUE
/*verbose*/, index
);
1058 wxLogWarning( _("No handler found for image type.") );
1062 handler
= FindHandler(type
);
1064 if (handler
== NULL
)
1066 wxLogWarning( _("No image handler for type %d defined."), type
);
1071 return handler
->LoadFile(this, stream
, TRUE
/*verbose*/, index
);
1074 bool wxImage::LoadFile( wxInputStream
& stream
, const wxString
& mimetype
, int index
)
1078 m_refData
= new wxImageRefData
;
1080 wxImageHandler
*handler
= FindHandlerMime(mimetype
);
1082 if (handler
== NULL
)
1084 wxLogWarning( _("No image handler for type %s defined."), mimetype
.GetData() );
1089 return handler
->LoadFile( this, stream
, TRUE
/*verbose*/, index
);
1092 bool wxImage::SaveFile( wxOutputStream
& stream
, int type
)
1094 wxCHECK_MSG( Ok(), FALSE
, wxT("invalid image") );
1096 wxImageHandler
*handler
= FindHandler(type
);
1098 if (handler
== NULL
)
1100 wxLogWarning( _("No image handler for type %d defined."), type
);
1105 return handler
->SaveFile( this, stream
);
1108 bool wxImage::SaveFile( wxOutputStream
& stream
, const wxString
& mimetype
)
1110 wxCHECK_MSG( Ok(), FALSE
, wxT("invalid image") );
1112 wxImageHandler
*handler
= FindHandlerMime(mimetype
);
1114 if (handler
== NULL
)
1116 wxLogWarning( _("No image handler for type %s defined."), mimetype
.GetData() );
1121 return handler
->SaveFile( this, stream
);
1123 #endif // wxUSE_STREAMS
1125 void wxImage::AddHandler( wxImageHandler
*handler
)
1127 // make sure that the memory will be freed at the program end
1128 sm_handlers
.DeleteContents(TRUE
);
1130 sm_handlers
.Append( handler
);
1133 void wxImage::InsertHandler( wxImageHandler
*handler
)
1135 // make sure that the memory will be freed at the program end
1136 sm_handlers
.DeleteContents(TRUE
);
1138 sm_handlers
.Insert( handler
);
1141 bool wxImage::RemoveHandler( const wxString
& name
)
1143 wxImageHandler
*handler
= FindHandler(name
);
1146 sm_handlers
.DeleteObject(handler
);
1153 wxImageHandler
*wxImage::FindHandler( const wxString
& name
)
1155 wxNode
*node
= sm_handlers
.First();
1158 wxImageHandler
*handler
= (wxImageHandler
*)node
->Data();
1159 if (handler
->GetName().Cmp(name
) == 0) return handler
;
1161 node
= node
->Next();
1163 return (wxImageHandler
*)NULL
;
1166 wxImageHandler
*wxImage::FindHandler( const wxString
& extension
, long bitmapType
)
1168 wxNode
*node
= sm_handlers
.First();
1171 wxImageHandler
*handler
= (wxImageHandler
*)node
->Data();
1172 if ( (handler
->GetExtension().Cmp(extension
) == 0) &&
1173 (bitmapType
== -1 || handler
->GetType() == bitmapType
) )
1175 node
= node
->Next();
1177 return (wxImageHandler
*)NULL
;
1180 wxImageHandler
*wxImage::FindHandler( long bitmapType
)
1182 wxNode
*node
= sm_handlers
.First();
1185 wxImageHandler
*handler
= (wxImageHandler
*)node
->Data();
1186 if (handler
->GetType() == bitmapType
) return handler
;
1187 node
= node
->Next();
1192 wxImageHandler
*wxImage::FindHandlerMime( const wxString
& mimetype
)
1194 wxNode
*node
= sm_handlers
.First();
1197 wxImageHandler
*handler
= (wxImageHandler
*)node
->Data();
1198 if (handler
->GetMimeType().IsSameAs(mimetype
, FALSE
)) return handler
;
1199 node
= node
->Next();
1204 void wxImage::InitStandardHandlers()
1207 AddHandler(new wxBMPHandler
);
1208 #endif // wxUSE_STREAMS
1210 #if wxUSE_XPM && !defined(__WXGTK__) && !defined(__WXMOTIF__)
1211 AddHandler(new wxXPMHandler
);
1215 void wxImage::CleanUpHandlers()
1217 wxNode
*node
= sm_handlers
.First();
1220 wxImageHandler
*handler
= (wxImageHandler
*)node
->Data();
1221 wxNode
*next
= node
->Next();
1228 //-----------------------------------------------------------------------------
1230 //-----------------------------------------------------------------------------
1232 IMPLEMENT_ABSTRACT_CLASS(wxImageHandler
,wxObject
)
1235 bool wxImageHandler::LoadFile( wxImage
*WXUNUSED(image
), wxInputStream
& WXUNUSED(stream
), bool WXUNUSED(verbose
), int WXUNUSED(index
) )
1240 bool wxImageHandler::SaveFile( wxImage
*WXUNUSED(image
), wxOutputStream
& WXUNUSED(stream
), bool WXUNUSED(verbose
) )
1245 int wxImageHandler::GetImageCount( wxInputStream
& WXUNUSED(stream
) )
1250 bool wxImageHandler::CanRead( const wxString
& name
)
1252 if (wxFileExists(name
))
1254 wxFileInputStream
stream(name
);
1255 return CanRead(stream
);
1259 wxLogError( _("Can't check image format of file '%s': file does not exist."), name
.c_str() );
1266 #endif // wxUSE_STREAMS
1270 //-----------------------------------------------------------------------------
1271 // wxBitmap convertion routines
1272 //-----------------------------------------------------------------------------
1277 wxBitmap
wxImage::ConvertToMonoBitmap( unsigned char red
, unsigned char green
, unsigned char blue
) const
1279 wxImage mono
= this->ConvertToMono( red
, green
, blue
);
1280 wxBitmap
bitmap( mono
, 1 );
1285 wxBitmap
wxImage::ConvertToBitmap() const
1287 wxBitmap
bitmap( *this );
1291 wxImage::wxImage( const wxBitmap
&bitmap
)
1293 *this = bitmap
.ConvertToImage();
1300 // A module to allow wxImage initialization/cleanup
1301 // without calling these functions from app.cpp or from
1302 // the user's application.
1304 class wxImageModule
: public wxModule
1306 DECLARE_DYNAMIC_CLASS(wxImageModule
)
1309 bool OnInit() { wxImage::InitStandardHandlers(); return TRUE
; };
1310 void OnExit() { wxImage::CleanUpHandlers(); };
1313 IMPLEMENT_DYNAMIC_CLASS(wxImageModule
, wxModule
)
1316 //-----------------------------------------------------------------------------
1319 // Counts and returns the number of different colours. Optionally stops
1320 // when it exceeds 'stopafter' different colours. This is useful, for
1321 // example, to see if the image can be saved as 8-bit (256 colour or
1322 // less, in this case it would be invoked as CountColours(256)). Default
1323 // value for stopafter is -1 (don't care).
1325 unsigned long wxImage::CountColours( unsigned long stopafter
)
1329 unsigned char r
, g
, b
;
1331 unsigned long size
, nentries
, key
;
1334 size
= GetWidth() * GetHeight();
1337 for (unsigned long j
= 0; (j
< size
) && (nentries
<= stopafter
) ; j
++)
1342 key
= (r
<< 16) | (g
<< 8) | b
;
1344 if (h
.Get(key
) == NULL
)
1355 unsigned long wxImage::ComputeHistogram( wxImageHistogram
&h
)
1357 unsigned char r
, g
, b
;
1359 unsigned long size
, nentries
, key
;
1364 size
= GetWidth() * GetHeight();
1367 for (unsigned long j
= 0; j
< size
; j
++)
1372 key
= (r
<< 16) | (g
<< 8) | b
;
1374 wxImageHistogramEntry
& entry
= h
[key
];
1375 if ( entry
.value
++ == 0 )
1376 entry
.index
= nentries
++;
1383 * Rotation code by Carlos Moreno
1386 // GRG: I've removed wxRotationPoint - we already have wxRealPoint which
1387 // does exactly the same thing. And I also got rid of wxRotationPixel
1388 // bacause of potential problems in architectures where alignment
1389 // is an issue, so I had to rewrite parts of the code.
1391 static const double gs_Epsilon
= 1e-10;
1393 static inline int wxCint (double x
)
1395 return (x
> 0) ? (int) (x
+ 0.5) : (int) (x
- 0.5);
1399 // Auxiliary function to rotate a point (x,y) with respect to point p0
1400 // make it inline and use a straight return to facilitate optimization
1401 // also, the function receives the sine and cosine of the angle to avoid
1402 // repeating the time-consuming calls to these functions -- sin/cos can
1403 // be computed and stored in the calling function.
1405 inline wxRealPoint
rotated_point (const wxRealPoint
& p
, double cos_angle
, double sin_angle
, const wxRealPoint
& p0
)
1407 return wxRealPoint (p0
.x
+ (p
.x
- p0
.x
) * cos_angle
- (p
.y
- p0
.y
) * sin_angle
,
1408 p0
.y
+ (p
.y
- p0
.y
) * cos_angle
+ (p
.x
- p0
.x
) * sin_angle
);
1411 inline wxRealPoint
rotated_point (double x
, double y
, double cos_angle
, double sin_angle
, const wxRealPoint
& p0
)
1413 return rotated_point (wxRealPoint(x
,y
), cos_angle
, sin_angle
, p0
);
1416 wxImage
wxImage::Rotate(double angle
, const wxPoint
& centre_of_rotation
, bool interpolating
, wxPoint
* offset_after_rotation
) const
1419 angle
= -angle
; // screen coordinates are a mirror image of "real" coordinates
1421 // Create pointer-based array to accelerate access to wxImage's data
1422 unsigned char ** data
= new unsigned char * [GetHeight()];
1424 data
[0] = GetData();
1426 for (i
= 1; i
< GetHeight(); i
++)
1427 data
[i
] = data
[i
- 1] + (3 * GetWidth());
1429 // precompute coefficients for rotation formula
1430 // (sine and cosine of the angle)
1431 const double cos_angle
= cos(angle
);
1432 const double sin_angle
= sin(angle
);
1434 // Create new Image to store the result
1435 // First, find rectangle that covers the rotated image; to do that,
1436 // rotate the four corners
1438 const wxRealPoint
p0(centre_of_rotation
.x
, centre_of_rotation
.y
);
1440 wxRealPoint p1
= rotated_point (0, 0, cos_angle
, sin_angle
, p0
);
1441 wxRealPoint p2
= rotated_point (0, GetHeight(), cos_angle
, sin_angle
, p0
);
1442 wxRealPoint p3
= rotated_point (GetWidth(), 0, cos_angle
, sin_angle
, p0
);
1443 wxRealPoint p4
= rotated_point (GetWidth(), GetHeight(), cos_angle
, sin_angle
, p0
);
1445 int x1
= (int) floor (wxMin (wxMin(p1
.x
, p2
.x
), wxMin(p3
.x
, p4
.x
)));
1446 int y1
= (int) floor (wxMin (wxMin(p1
.y
, p2
.y
), wxMin(p3
.y
, p4
.y
)));
1447 int x2
= (int) ceil (wxMax (wxMax(p1
.x
, p2
.x
), wxMax(p3
.x
, p4
.x
)));
1448 int y2
= (int) ceil (wxMax (wxMax(p1
.y
, p2
.y
), wxMax(p3
.y
, p4
.y
)));
1450 wxImage
rotated (x2
- x1
+ 1, y2
- y1
+ 1);
1452 if (offset_after_rotation
!= NULL
)
1454 *offset_after_rotation
= wxPoint (x1
, y1
);
1457 // GRG: The rotated (destination) image is always accessed
1458 // sequentially, so there is no need for a pointer-based
1459 // array here (and in fact it would be slower).
1461 unsigned char * dst
= rotated
.GetData();
1463 // GRG: if the original image has a mask, use its RGB values
1464 // as the blank pixel, else, fall back to default (black).
1466 unsigned char blank_r
= 0;
1467 unsigned char blank_g
= 0;
1468 unsigned char blank_b
= 0;
1472 blank_r
= GetMaskRed();
1473 blank_g
= GetMaskGreen();
1474 blank_b
= GetMaskBlue();
1475 rotated
.SetMaskColour( blank_r
, blank_g
, blank_b
);
1478 // Now, for each point of the rotated image, find where it came from, by
1479 // performing an inverse rotation (a rotation of -angle) and getting the
1480 // pixel at those coordinates
1482 // GRG: I've taken the (interpolating) test out of the loops, so that
1483 // it is done only once, instead of repeating it for each pixel.
1488 for (int y
= 0; y
< rotated
.GetHeight(); y
++)
1490 for (x
= 0; x
< rotated
.GetWidth(); x
++)
1492 wxRealPoint src
= rotated_point (x
+ x1
, y
+ y1
, cos_angle
, -sin_angle
, p0
);
1494 if (-0.25 < src
.x
&& src
.x
< GetWidth() - 0.75 &&
1495 -0.25 < src
.y
&& src
.y
< GetHeight() - 0.75)
1497 // interpolate using the 4 enclosing grid-points. Those
1498 // points can be obtained using floor and ceiling of the
1499 // exact coordinates of the point
1500 // C.M. 2000-02-17: when the point is near the border, special care is required.
1504 if (0 < src
.x
&& src
.x
< GetWidth() - 1)
1506 x1
= wxCint(floor(src
.x
));
1507 x2
= wxCint(ceil(src
.x
));
1509 else // else means that x is near one of the borders (0 or width-1)
1511 x1
= x2
= wxCint (src
.x
);
1514 if (0 < src
.y
&& src
.y
< GetHeight() - 1)
1516 y1
= wxCint(floor(src
.y
));
1517 y2
= wxCint(ceil(src
.y
));
1521 y1
= y2
= wxCint (src
.y
);
1524 // get four points and the distances (square of the distance,
1525 // for efficiency reasons) for the interpolation formula
1527 // GRG: Do not calculate the points until they are
1528 // really needed -- this way we can calculate
1529 // just one, instead of four, if d1, d2, d3
1530 // or d4 are < gs_Epsilon
1532 const double d1
= (src
.x
- x1
) * (src
.x
- x1
) + (src
.y
- y1
) * (src
.y
- y1
);
1533 const double d2
= (src
.x
- x2
) * (src
.x
- x2
) + (src
.y
- y1
) * (src
.y
- y1
);
1534 const double d3
= (src
.x
- x2
) * (src
.x
- x2
) + (src
.y
- y2
) * (src
.y
- y2
);
1535 const double d4
= (src
.x
- x1
) * (src
.x
- x1
) + (src
.y
- y2
) * (src
.y
- y2
);
1537 // Now interpolate as a weighted average of the four surrounding
1538 // points, where the weights are the distances to each of those points
1540 // If the point is exactly at one point of the grid of the source
1541 // image, then don't interpolate -- just assign the pixel
1543 if (d1
< gs_Epsilon
) // d1,d2,d3,d4 are positive -- no need for abs()
1545 unsigned char *p
= data
[y1
] + (3 * x1
);
1550 else if (d2
< gs_Epsilon
)
1552 unsigned char *p
= data
[y1
] + (3 * x2
);
1557 else if (d3
< gs_Epsilon
)
1559 unsigned char *p
= data
[y2
] + (3 * x2
);
1564 else if (d4
< gs_Epsilon
)
1566 unsigned char *p
= data
[y2
] + (3 * x1
);
1573 // weights for the weighted average are proportional to the inverse of the distance
1574 unsigned char *v1
= data
[y1
] + (3 * x1
);
1575 unsigned char *v2
= data
[y1
] + (3 * x2
);
1576 unsigned char *v3
= data
[y2
] + (3 * x2
);
1577 unsigned char *v4
= data
[y2
] + (3 * x1
);
1579 const double w1
= 1/d1
, w2
= 1/d2
, w3
= 1/d3
, w4
= 1/d4
;
1583 *(dst
++) = (unsigned char)
1584 ( (w1
* *(v1
++) + w2
* *(v2
++) +
1585 w3
* *(v3
++) + w4
* *(v4
++)) /
1586 (w1
+ w2
+ w3
+ w4
) );
1587 *(dst
++) = (unsigned char)
1588 ( (w1
* *(v1
++) + w2
* *(v2
++) +
1589 w3
* *(v3
++) + w4
* *(v4
++)) /
1590 (w1
+ w2
+ w3
+ w4
) );
1591 *(dst
++) = (unsigned char)
1592 ( (w1
* *(v1
++) + w2
* *(v2
++) +
1593 w3
* *(v3
++) + w4
* *(v4
++)) /
1594 (w1
+ w2
+ w3
+ w4
) );
1606 else // not interpolating
1608 for (int y
= 0; y
< rotated
.GetHeight(); y
++)
1610 for (x
= 0; x
< rotated
.GetWidth(); x
++)
1612 wxRealPoint src
= rotated_point (x
+ x1
, y
+ y1
, cos_angle
, -sin_angle
, p0
);
1614 const int xs
= wxCint (src
.x
); // wxCint rounds to the
1615 const int ys
= wxCint (src
.y
); // closest integer
1617 if (0 <= xs
&& xs
< GetWidth() &&
1618 0 <= ys
&& ys
< GetHeight())
1620 unsigned char *p
= data
[ys
] + (3 * xs
);
1640 #endif // wxUSE_IMAGE