]> git.saurik.com Git - wxWidgets.git/blob - src/common/image.cpp
corrected direction when sending events
[wxWidgets.git] / src / common / image.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: image.cpp
3 // Purpose: wxImage
4 // Author: Robert Roebling
5 // RCS-ID: $Id$
6 // Copyright: (c) Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #ifdef __GNUG__
11 #pragma implementation "image.h"
12 #endif
13
14 // For compilers that support precompilation, includes "wx.h".
15 #include "wx/wxprec.h"
16
17 #ifdef __BORLANDC__
18 #pragma hdrstop
19 #endif
20
21 #include "wx/defs.h"
22
23 #if wxUSE_IMAGE
24
25 #include "wx/image.h"
26 #include "wx/bitmap.h"
27 #include "wx/debug.h"
28 #include "wx/log.h"
29 #include "wx/app.h"
30 #include "wx/filefn.h"
31 #include "wx/wfstream.h"
32 #include "wx/intl.h"
33 #include "wx/module.h"
34
35 // For memcpy
36 #include <string.h>
37 #include <math.h>
38
39 #ifdef __SALFORDC__
40 #undef FAR
41 #endif
42
43
44 //-----------------------------------------------------------------------------
45 // wxImage
46 //-----------------------------------------------------------------------------
47
48 class wxImageRefData: public wxObjectRefData
49 {
50 public:
51 wxImageRefData();
52 ~wxImageRefData();
53
54 int m_width;
55 int m_height;
56 unsigned char *m_data;
57 bool m_hasMask;
58 unsigned char m_maskRed,m_maskGreen,m_maskBlue;
59 bool m_ok;
60 bool m_static;
61 #if wxUSE_PALETTE
62 wxPalette m_palette;
63 #endif // wxUSE_PALETTE
64 wxArrayString m_optionNames;
65 wxArrayString m_optionValues;
66 };
67
68 wxImageRefData::wxImageRefData()
69 {
70 m_width = 0;
71 m_height = 0;
72 m_data = (unsigned char*) NULL;
73 m_ok = FALSE;
74 m_maskRed = 0;
75 m_maskGreen = 0;
76 m_maskBlue = 0;
77 m_hasMask = FALSE;
78 m_static = FALSE;
79 }
80
81 wxImageRefData::~wxImageRefData()
82 {
83 if (m_data && !m_static)
84 free( m_data );
85 }
86
87 wxList wxImage::sm_handlers;
88
89 wxImage wxNullImage;
90
91 //-----------------------------------------------------------------------------
92
93 #define M_IMGDATA ((wxImageRefData *)m_refData)
94
95 IMPLEMENT_DYNAMIC_CLASS(wxImage, wxObject)
96
97 wxImage::wxImage()
98 {
99 }
100
101 wxImage::wxImage( int width, int height )
102 {
103 Create( width, height );
104 }
105
106 wxImage::wxImage( int width, int height, unsigned char* data, bool static_data )
107 {
108 Create( width, height, data, static_data );
109 }
110
111 wxImage::wxImage( const wxString& name, long type, int index )
112 {
113 LoadFile( name, type, index );
114 }
115
116 wxImage::wxImage( const wxString& name, const wxString& mimetype, int index )
117 {
118 LoadFile( name, mimetype, index );
119 }
120
121 #if wxUSE_STREAMS
122 wxImage::wxImage( wxInputStream& stream, long type, int index )
123 {
124 LoadFile( stream, type, index );
125 }
126
127 wxImage::wxImage( wxInputStream& stream, const wxString& mimetype, int index )
128 {
129 LoadFile( stream, mimetype, index );
130 }
131 #endif // wxUSE_STREAMS
132
133 wxImage::wxImage( const wxImage& image )
134 : wxObject()
135 {
136 Ref(image);
137 }
138
139 wxImage::wxImage( const wxImage* image )
140 {
141 if (image) Ref(*image);
142 }
143
144 void wxImage::Create( int width, int height )
145 {
146 UnRef();
147
148 m_refData = new wxImageRefData();
149
150 M_IMGDATA->m_data = (unsigned char *) malloc( width*height*3 );
151 if (M_IMGDATA->m_data)
152 {
153 for (int l = 0; l < width*height*3; l++) M_IMGDATA->m_data[l] = 0;
154
155 M_IMGDATA->m_width = width;
156 M_IMGDATA->m_height = height;
157 M_IMGDATA->m_ok = TRUE;
158 }
159 else
160 {
161 UnRef();
162 }
163 }
164
165 void wxImage::Create( int width, int height, unsigned char* data, bool static_data )
166 {
167 UnRef();
168
169 m_refData = new wxImageRefData();
170
171 M_IMGDATA->m_data = data;
172 if (M_IMGDATA->m_data)
173 {
174 M_IMGDATA->m_width = width;
175 M_IMGDATA->m_height = height;
176 M_IMGDATA->m_ok = TRUE;
177 M_IMGDATA->m_static = static_data;
178 }
179 else
180 {
181 UnRef();
182 }
183 }
184
185 void wxImage::Destroy()
186 {
187 UnRef();
188 }
189
190 wxImage wxImage::Copy() const
191 {
192 wxImage image;
193
194 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
195
196 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
197
198 char unsigned *data = image.GetData();
199
200 wxCHECK_MSG( data, image, wxT("unable to create image") );
201
202 if (M_IMGDATA->m_hasMask)
203 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
204
205 memcpy( data, GetData(), M_IMGDATA->m_width*M_IMGDATA->m_height*3 );
206
207 return image;
208 }
209
210 wxImage wxImage::Scale( int width, int height ) const
211 {
212 wxImage image;
213
214 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
215
216 // can't scale to/from 0 size
217 wxCHECK_MSG( (width > 0) && (height > 0), image,
218 wxT("invalid new image size") );
219
220 long old_height = M_IMGDATA->m_height,
221 old_width = M_IMGDATA->m_width;
222 wxCHECK_MSG( (old_height > 0) && (old_width > 0), image,
223 wxT("invalid old image size") );
224
225 image.Create( width, height );
226
227 char unsigned *data = image.GetData();
228
229 wxCHECK_MSG( data, image, wxT("unable to create image") );
230
231 if (M_IMGDATA->m_hasMask)
232 {
233 image.SetMaskColour( M_IMGDATA->m_maskRed,
234 M_IMGDATA->m_maskGreen,
235 M_IMGDATA->m_maskBlue );
236 }
237
238 char unsigned *source_data = M_IMGDATA->m_data;
239 char unsigned *target_data = data;
240
241 #if 0
242 // This is nonsense, RR.
243
244 // We do (x, y) -> (x, y)*oldSize/newSize but the valid values of x and y
245 // are from 0 to size-1, hence all decrement the sizes
246 long old_old_width = old_width;
247 old_height--;
248 old_width--;
249 height--;
250 width--;
251 for ( long j = 0; j <= height; j++ )
252 {
253 // don't crash for images with height == 1
254 long y_offset = height ? (j * old_height / height)* old_old_width : 0;
255
256 for ( long i = 0; i <= width; i++ )
257 {
258 long x_offset = width ? (i * old_width) / width : 0;
259
260 memcpy( target_data, source_data + 3*(y_offset + x_offset), 3 );
261 target_data += 3;
262 }
263 }
264 #else
265 for (long j = 0; j < height; j++)
266 {
267 long y_offset = (j * old_height / height) * old_width;
268
269 for (long i = 0; i < width; i++)
270 {
271 memcpy( target_data,
272 source_data + 3*(y_offset + ((i * old_width )/ width)),
273 3 );
274 target_data += 3;
275 }
276 }
277 #endif
278
279 // In case this is a cursor, make sure the hotspot is scalled accordingly:
280 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_X) )
281 image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X,
282 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_X)*width)/old_width);
283 if ( HasOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y) )
284 image.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y,
285 (GetOptionInt(wxIMAGE_OPTION_CUR_HOTSPOT_Y)*height)/old_height);
286
287 return image;
288 }
289
290 wxImage wxImage::Rotate90( bool clockwise ) const
291 {
292 wxImage image;
293
294 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
295
296 image.Create( M_IMGDATA->m_height, M_IMGDATA->m_width );
297
298 char unsigned *data = image.GetData();
299
300 wxCHECK_MSG( data, image, wxT("unable to create image") );
301
302 if (M_IMGDATA->m_hasMask)
303 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
304
305 long height = M_IMGDATA->m_height;
306 long width = M_IMGDATA->m_width;
307
308 char unsigned *source_data = M_IMGDATA->m_data;
309 char unsigned *target_data;
310
311 for (long j = 0; j < height; j++)
312 {
313 for (long i = 0; i < width; i++)
314 {
315 if (clockwise)
316 target_data = data + (((i+1)*height) - j - 1)*3;
317 else
318 target_data = data + ((height*(width-1)) + j - (i*height))*3;
319 memcpy( target_data, source_data, 3 );
320 source_data += 3;
321 }
322 }
323
324 return image;
325 }
326
327 wxImage wxImage::Mirror( bool horizontally ) const
328 {
329 wxImage image;
330
331 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
332
333 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
334
335 char unsigned *data = image.GetData();
336
337 wxCHECK_MSG( data, image, wxT("unable to create image") );
338
339 if (M_IMGDATA->m_hasMask)
340 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
341
342 long height = M_IMGDATA->m_height;
343 long width = M_IMGDATA->m_width;
344
345 char unsigned *source_data = M_IMGDATA->m_data;
346 char unsigned *target_data;
347
348 if (horizontally)
349 {
350 for (long j = 0; j < height; j++)
351 {
352 data += width*3;
353 target_data = data-3;
354 for (long i = 0; i < width; i++)
355 {
356 memcpy( target_data, source_data, 3 );
357 source_data += 3;
358 target_data -= 3;
359 }
360 }
361 }
362 else
363 {
364 for (long i = 0; i < height; i++)
365 {
366 target_data = data + 3*width*(height-1-i);
367 memcpy( target_data, source_data, (size_t)3*width );
368 source_data += 3*width;
369 }
370 }
371
372 return image;
373 }
374
375 wxImage wxImage::GetSubImage( const wxRect &rect ) const
376 {
377 wxImage image;
378
379 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
380
381 wxCHECK_MSG( (rect.GetLeft()>=0) && (rect.GetTop()>=0) && (rect.GetRight()<=GetWidth()) && (rect.GetBottom()<=GetHeight()),
382 image, wxT("invalid subimage size") );
383
384 int subwidth=rect.GetWidth();
385 const int subheight=rect.GetHeight();
386
387 image.Create( subwidth, subheight );
388
389 char unsigned *subdata = image.GetData(), *data=GetData();
390
391 wxCHECK_MSG( subdata, image, wxT("unable to create image") );
392
393 if (M_IMGDATA->m_hasMask)
394 image.SetMaskColour( M_IMGDATA->m_maskRed, M_IMGDATA->m_maskGreen, M_IMGDATA->m_maskBlue );
395
396 const int subleft=3*rect.GetLeft();
397 const int width=3*GetWidth();
398 subwidth*=3;
399
400 data+=rect.GetTop()*width+subleft;
401
402 for (long j = 0; j < subheight; ++j)
403 {
404 memcpy( subdata, data, subwidth);
405 subdata+=subwidth;
406 data+=width;
407 }
408
409 return image;
410 }
411
412 void wxImage::Paste( const wxImage &image, int x, int y )
413 {
414 wxCHECK_RET( Ok(), wxT("invalid image") );
415 wxCHECK_RET( image.Ok(), wxT("invalid image") );
416
417 int xx = 0;
418 int yy = 0;
419 int width = image.GetWidth();
420 int height = image.GetHeight();
421
422 if (x < 0)
423 {
424 xx = -x;
425 width += x;
426 }
427 if (y < 0)
428 {
429 yy = -y;
430 height += y;
431 }
432
433 if ((x+xx)+width > M_IMGDATA->m_width)
434 width = M_IMGDATA->m_width - (x+xx);
435 if ((y+yy)+height > M_IMGDATA->m_height)
436 height = M_IMGDATA->m_height - (y+yy);
437
438 if (width < 1) return;
439 if (height < 1) return;
440
441 if ((!HasMask() && !image.HasMask()) ||
442 ((HasMask() && image.HasMask() &&
443 (GetMaskRed()==image.GetMaskRed()) &&
444 (GetMaskGreen()==image.GetMaskGreen()) &&
445 (GetMaskBlue()==image.GetMaskBlue()))))
446 {
447 width *= 3;
448 unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
449 int source_step = image.GetWidth()*3;
450
451 unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
452 int target_step = M_IMGDATA->m_width*3;
453 for (int j = 0; j < height; j++)
454 {
455 memcpy( target_data, source_data, width );
456 source_data += source_step;
457 target_data += target_step;
458 }
459 return;
460 }
461
462 if (!HasMask() && image.HasMask())
463 {
464 unsigned char r = image.GetMaskRed();
465 unsigned char g = image.GetMaskGreen();
466 unsigned char b = image.GetMaskBlue();
467
468 width *= 3;
469 unsigned char* source_data = image.GetData() + xx*3 + yy*3*image.GetWidth();
470 int source_step = image.GetWidth()*3;
471
472 unsigned char* target_data = GetData() + (x+xx)*3 + (y+yy)*3*M_IMGDATA->m_width;
473 int target_step = M_IMGDATA->m_width*3;
474
475 for (int j = 0; j < height; j++)
476 {
477 for (int i = 0; i < width; i+=3)
478 {
479 if ((source_data[i] != r) &&
480 (source_data[i+1] != g) &&
481 (source_data[i+2] != b))
482 {
483 memcpy( target_data+i, source_data+i, 3 );
484 }
485 }
486 source_data += source_step;
487 target_data += target_step;
488 }
489 }
490 }
491
492 void wxImage::Replace( unsigned char r1, unsigned char g1, unsigned char b1,
493 unsigned char r2, unsigned char g2, unsigned char b2 )
494 {
495 wxCHECK_RET( Ok(), wxT("invalid image") );
496
497 char unsigned *data = GetData();
498
499 const int w = GetWidth();
500 const int h = GetHeight();
501
502 for (int j = 0; j < h; j++)
503 for (int i = 0; i < w; i++)
504 {
505 if ((data[0] == r1) && (data[1] == g1) && (data[2] == b1))
506 {
507 data[0] = r2;
508 data[1] = g2;
509 data[2] = b2;
510 }
511 data += 3;
512 }
513 }
514
515 wxImage wxImage::ConvertToMono( unsigned char r, unsigned char g, unsigned char b ) const
516 {
517 wxImage image;
518
519 wxCHECK_MSG( Ok(), image, wxT("invalid image") );
520
521 image.Create( M_IMGDATA->m_width, M_IMGDATA->m_height );
522
523 char unsigned *data = image.GetData();
524
525 wxCHECK_MSG( data, image, wxT("unable to create image") );
526
527 if (M_IMGDATA->m_hasMask)
528 {
529 if (M_IMGDATA->m_maskRed == r && M_IMGDATA->m_maskGreen == g &&
530 M_IMGDATA->m_maskBlue == b)
531 image.SetMaskColour( 255, 255, 255 );
532 else
533 image.SetMaskColour( 0, 0, 0 );
534 }
535
536 long size = M_IMGDATA->m_height * M_IMGDATA->m_width;
537
538 char unsigned *srcd = M_IMGDATA->m_data;
539 char unsigned *tard = image.GetData();
540
541 for ( long i = 0; i < size; i++, srcd += 3, tard += 3 )
542 {
543 if (srcd[0] == r && srcd[1] == g && srcd[2] == b)
544 tard[0] = tard[1] = tard[2] = 255;
545 else
546 tard[0] = tard[1] = tard[2] = 0;
547 }
548
549 return image;
550 }
551
552 void wxImage::SetRGB( int x, int y, unsigned char r, unsigned char g, unsigned char b )
553 {
554 wxCHECK_RET( Ok(), wxT("invalid image") );
555
556 int w = M_IMGDATA->m_width;
557 int h = M_IMGDATA->m_height;
558
559 wxCHECK_RET( (x>=0) && (y>=0) && (x<w) && (y<h), wxT("invalid image index") );
560
561 long pos = (y * w + x) * 3;
562
563 M_IMGDATA->m_data[ pos ] = r;
564 M_IMGDATA->m_data[ pos+1 ] = g;
565 M_IMGDATA->m_data[ pos+2 ] = b;
566 }
567
568 unsigned char wxImage::GetRed( int x, int y ) const
569 {
570 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
571
572 int w = M_IMGDATA->m_width;
573 int h = M_IMGDATA->m_height;
574
575 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
576
577 long pos = (y * w + x) * 3;
578
579 return M_IMGDATA->m_data[pos];
580 }
581
582 unsigned char wxImage::GetGreen( int x, int y ) const
583 {
584 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
585
586 int w = M_IMGDATA->m_width;
587 int h = M_IMGDATA->m_height;
588
589 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
590
591 long pos = (y * w + x) * 3;
592
593 return M_IMGDATA->m_data[pos+1];
594 }
595
596 unsigned char wxImage::GetBlue( int x, int y ) const
597 {
598 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
599
600 int w = M_IMGDATA->m_width;
601 int h = M_IMGDATA->m_height;
602
603 wxCHECK_MSG( (x>=0) && (y>=0) && (x<w) && (y<h), 0, wxT("invalid image index") );
604
605 long pos = (y * w + x) * 3;
606
607 return M_IMGDATA->m_data[pos+2];
608 }
609
610 bool wxImage::Ok() const
611 {
612 // image of 0 width or height can't be considered ok - at least because it
613 // causes crashes in ConvertToBitmap() if we don't catch it in time
614 wxImageRefData *data = M_IMGDATA;
615 return data && data->m_ok && data->m_width && data->m_height;
616 }
617
618 char unsigned *wxImage::GetData() const
619 {
620 wxCHECK_MSG( Ok(), (char unsigned *)NULL, wxT("invalid image") );
621
622 return M_IMGDATA->m_data;
623 }
624
625 void wxImage::SetData( char unsigned *data )
626 {
627 wxCHECK_RET( Ok(), wxT("invalid image") );
628
629 wxImageRefData *newRefData = new wxImageRefData();
630
631 newRefData->m_width = M_IMGDATA->m_width;
632 newRefData->m_height = M_IMGDATA->m_height;
633 newRefData->m_data = data;
634 newRefData->m_ok = TRUE;
635 newRefData->m_maskRed = M_IMGDATA->m_maskRed;
636 newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
637 newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
638 newRefData->m_hasMask = M_IMGDATA->m_hasMask;
639
640 UnRef();
641
642 m_refData = newRefData;
643 }
644
645 void wxImage::SetData( char unsigned *data, int new_width, int new_height )
646 {
647 wxImageRefData *newRefData = new wxImageRefData();
648
649 if (m_refData)
650 {
651 newRefData->m_width = new_width;
652 newRefData->m_height = new_height;
653 newRefData->m_data = data;
654 newRefData->m_ok = TRUE;
655 newRefData->m_maskRed = M_IMGDATA->m_maskRed;
656 newRefData->m_maskGreen = M_IMGDATA->m_maskGreen;
657 newRefData->m_maskBlue = M_IMGDATA->m_maskBlue;
658 newRefData->m_hasMask = M_IMGDATA->m_hasMask;
659 }
660 else
661 {
662 newRefData->m_width = new_width;
663 newRefData->m_height = new_height;
664 newRefData->m_data = data;
665 newRefData->m_ok = TRUE;
666 }
667
668 UnRef();
669
670 m_refData = newRefData;
671 }
672
673 void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b )
674 {
675 wxCHECK_RET( Ok(), wxT("invalid image") );
676
677 M_IMGDATA->m_maskRed = r;
678 M_IMGDATA->m_maskGreen = g;
679 M_IMGDATA->m_maskBlue = b;
680 M_IMGDATA->m_hasMask = TRUE;
681 }
682
683 unsigned char wxImage::GetMaskRed() const
684 {
685 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
686
687 return M_IMGDATA->m_maskRed;
688 }
689
690 unsigned char wxImage::GetMaskGreen() const
691 {
692 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
693
694 return M_IMGDATA->m_maskGreen;
695 }
696
697 unsigned char wxImage::GetMaskBlue() const
698 {
699 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
700
701 return M_IMGDATA->m_maskBlue;
702 }
703
704 void wxImage::SetMask( bool mask )
705 {
706 wxCHECK_RET( Ok(), wxT("invalid image") );
707
708 M_IMGDATA->m_hasMask = mask;
709 }
710
711 bool wxImage::HasMask() const
712 {
713 wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
714
715 return M_IMGDATA->m_hasMask;
716 }
717
718 int wxImage::GetWidth() const
719 {
720 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
721
722 return M_IMGDATA->m_width;
723 }
724
725 int wxImage::GetHeight() const
726 {
727 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
728
729 return M_IMGDATA->m_height;
730 }
731
732
733 bool wxImage::FindFirstUnusedColour(
734 unsigned char *r, unsigned char *g, unsigned char *b,
735 unsigned char startR, unsigned char startG, unsigned char startB) const
736 {
737 wxImageHistogram histogram;
738 unsigned long key;
739
740 ComputeHistogram(histogram);
741
742 unsigned char r2 = startR;
743 unsigned char g2 = startG;
744 unsigned char b2 = startB;
745
746 key = (r2 << 16) | (g2 << 8) | b2;
747
748 while ( histogram.find(key) != histogram.end() )
749 {
750 // color already used
751 r2++;
752 if ( r2 >= 255 )
753 {
754 r2 = 0;
755 g2++;
756 if ( g2 >= 255 )
757 {
758 g2 = 0;
759 b2++;
760 if ( b2 >= 255 )
761 {
762 wxLogError( _("GetUnusedColour:: No Unused Color in image ") );
763 return FALSE;
764 }
765 }
766 }
767
768 key = (r2 << 16) | (g2 << 8) | b2;
769 }
770
771 if (r) *r = r2;
772 if (g) *g = g2;
773 if (b) *b = b2;
774
775 return TRUE;
776 }
777
778
779 bool wxImage::SetMaskFromImage(const wxImage& mask,
780 unsigned char mr, unsigned char mg, unsigned char mb)
781 {
782 // check that the images are the same size
783 if ( (M_IMGDATA->m_height != mask.GetHeight() ) || (M_IMGDATA->m_width != mask.GetWidth () ) )
784 {
785 wxLogError( _("Image and Mask have different sizes") );
786 return FALSE;
787 }
788
789 // find unused colour
790 unsigned char r,g,b ;
791 if (!FindFirstUnusedColour(&r, &g, &b))
792 {
793 wxLogError( _("No Unused Color in image being masked") );
794 return FALSE ;
795 }
796
797 char unsigned *imgdata = GetData();
798 char unsigned *maskdata = mask.GetData();
799
800 const int w = GetWidth();
801 const int h = GetHeight();
802
803 for (int j = 0; j < h; j++)
804 {
805 for (int i = 0; i < w; i++)
806 {
807 if ((maskdata[0] == mr) && (maskdata[1] == mg) && (maskdata[2] == mb))
808 {
809 imgdata[0] = r;
810 imgdata[1] = g;
811 imgdata[2] = b;
812 }
813 imgdata += 3;
814 maskdata += 3;
815 }
816 }
817
818 SetMaskColour(r, g, b);
819 SetMask(TRUE);
820
821 return TRUE;
822 }
823
824 #if wxUSE_PALETTE
825
826 // Palette functions
827
828 bool wxImage::HasPalette() const
829 {
830 if (!Ok())
831 return FALSE;
832
833 return M_IMGDATA->m_palette.Ok();
834 }
835
836 const wxPalette& wxImage::GetPalette() const
837 {
838 wxCHECK_MSG( Ok(), wxNullPalette, wxT("invalid image") );
839
840 return M_IMGDATA->m_palette;
841 }
842
843 void wxImage::SetPalette(const wxPalette& palette)
844 {
845 wxCHECK_RET( Ok(), wxT("invalid image") );
846
847 M_IMGDATA->m_palette = palette;
848 }
849
850 #endif // wxUSE_PALETTE
851
852 // Option functions (arbitrary name/value mapping)
853 void wxImage::SetOption(const wxString& name, const wxString& value)
854 {
855 wxCHECK_RET( Ok(), wxT("invalid image") );
856
857 int idx = M_IMGDATA->m_optionNames.Index(name, FALSE);
858 if (idx == wxNOT_FOUND)
859 {
860 M_IMGDATA->m_optionNames.Add(name);
861 M_IMGDATA->m_optionValues.Add(value);
862 }
863 else
864 {
865 M_IMGDATA->m_optionNames[idx] = name;
866 M_IMGDATA->m_optionValues[idx] = value;
867 }
868 }
869
870 void wxImage::SetOption(const wxString& name, int value)
871 {
872 wxString valStr;
873 valStr.Printf(wxT("%d"), value);
874 SetOption(name, valStr);
875 }
876
877 wxString wxImage::GetOption(const wxString& name) const
878 {
879 wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid image") );
880
881 int idx = M_IMGDATA->m_optionNames.Index(name, FALSE);
882 if (idx == wxNOT_FOUND)
883 return wxEmptyString;
884 else
885 return M_IMGDATA->m_optionValues[idx];
886 }
887
888 int wxImage::GetOptionInt(const wxString& name) const
889 {
890 wxCHECK_MSG( Ok(), 0, wxT("invalid image") );
891
892 return wxAtoi(GetOption(name));
893 }
894
895 bool wxImage::HasOption(const wxString& name) const
896 {
897 wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
898
899 return (M_IMGDATA->m_optionNames.Index(name, FALSE) != wxNOT_FOUND);
900 }
901
902 bool wxImage::LoadFile( const wxString& filename, long type, int index )
903 {
904 #if wxUSE_STREAMS
905 if (wxFileExists(filename))
906 {
907 wxFileInputStream stream(filename);
908 wxBufferedInputStream bstream( stream );
909 return LoadFile(bstream, type, index);
910 }
911 else
912 {
913 wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
914
915 return FALSE;
916 }
917 #else // !wxUSE_STREAMS
918 return FALSE;
919 #endif // wxUSE_STREAMS
920 }
921
922 bool wxImage::LoadFile( const wxString& filename, const wxString& mimetype, int index )
923 {
924 #if wxUSE_STREAMS
925 if (wxFileExists(filename))
926 {
927 wxFileInputStream stream(filename);
928 wxBufferedInputStream bstream( stream );
929 return LoadFile(bstream, mimetype, index);
930 }
931 else
932 {
933 wxLogError( _("Can't load image from file '%s': file does not exist."), filename.c_str() );
934
935 return FALSE;
936 }
937 #else // !wxUSE_STREAMS
938 return FALSE;
939 #endif // wxUSE_STREAMS
940 }
941
942
943
944 bool wxImage::SaveFile( const wxString& filename ) const
945 {
946 wxString ext = filename.AfterLast('.').Lower();
947
948 wxImageHandler * pHandler = FindHandler(ext, -1);
949 if (pHandler)
950 {
951 SaveFile(filename, pHandler->GetType());
952 return TRUE;
953 }
954
955 wxLogError(_("Can't save image to file '%s': unknown extension."), filename.c_str());
956
957 return FALSE;
958 }
959
960 bool wxImage::SaveFile( const wxString& filename, int type ) const
961 {
962 #if wxUSE_STREAMS
963 ((wxImage*)this)->SetOption(wxIMAGE_OPTION_FILENAME, filename);
964
965 wxFileOutputStream stream(filename);
966
967 if ( stream.LastError() == wxStream_NOERROR )
968 {
969 wxBufferedOutputStream bstream( stream );
970 return SaveFile(bstream, type);
971 }
972 #endif // wxUSE_STREAMS
973
974 return FALSE;
975 }
976
977 bool wxImage::SaveFile( const wxString& filename, const wxString& mimetype ) const
978 {
979 #if wxUSE_STREAMS
980 ((wxImage*)this)->SetOption(wxIMAGE_OPTION_FILENAME, filename);
981
982 wxFileOutputStream stream(filename);
983
984 if ( stream.LastError() == wxStream_NOERROR )
985 {
986 wxBufferedOutputStream bstream( stream );
987 return SaveFile(bstream, mimetype);
988 }
989 #endif // wxUSE_STREAMS
990
991 return FALSE;
992 }
993
994 bool wxImage::CanRead( const wxString &name )
995 {
996 #if wxUSE_STREAMS
997 wxFileInputStream stream(name);
998 return CanRead(stream);
999 #else
1000 return FALSE;
1001 #endif
1002 }
1003
1004 int wxImage::GetImageCount( const wxString &name, long type )
1005 {
1006 #if wxUSE_STREAMS
1007 wxFileInputStream stream(name);
1008 return GetImageCount(stream, type);
1009 #else
1010 return 0;
1011 #endif
1012 }
1013
1014 #if wxUSE_STREAMS
1015
1016 bool wxImage::CanRead( wxInputStream &stream )
1017 {
1018 const wxList& list = GetHandlers();
1019
1020 for ( wxList::Node *node = list.GetFirst(); node; node = node->GetNext() )
1021 {
1022 wxImageHandler *handler=(wxImageHandler*)node->GetData();
1023 if (handler->CanRead( stream ))
1024 return TRUE;
1025 }
1026
1027 return FALSE;
1028 }
1029
1030 int wxImage::GetImageCount( wxInputStream &stream, long type )
1031 {
1032 wxImageHandler *handler;
1033
1034 if ( type == wxBITMAP_TYPE_ANY )
1035 {
1036 wxList &list=GetHandlers();
1037
1038 for (wxList::Node *node = list.GetFirst(); node; node = node->GetNext())
1039 {
1040 handler=(wxImageHandler*)node->GetData();
1041 if ( handler->CanRead(stream) )
1042 return handler->GetImageCount(stream);
1043
1044 }
1045
1046 wxLogWarning(_("No handler found for image type."));
1047 return 0;
1048 }
1049
1050 handler = FindHandler(type);
1051
1052 if ( !handler )
1053 {
1054 wxLogWarning(_("No image handler for type %d defined."), type);
1055 return FALSE;
1056 }
1057
1058 if ( handler->CanRead(stream) )
1059 {
1060 return handler->GetImageCount(stream);
1061 }
1062 else
1063 {
1064 wxLogError(_("Image file is not of type %d."), type);
1065 return 0;
1066 }
1067 }
1068
1069 bool wxImage::LoadFile( wxInputStream& stream, long type, int index )
1070 {
1071 UnRef();
1072
1073 m_refData = new wxImageRefData;
1074
1075 wxImageHandler *handler;
1076
1077 if ( type == wxBITMAP_TYPE_ANY )
1078 {
1079 wxList &list=GetHandlers();
1080
1081 for ( wxList::Node *node = list.GetFirst(); node; node = node->GetNext() )
1082 {
1083 handler=(wxImageHandler*)node->GetData();
1084 if ( handler->CanRead(stream) )
1085 return handler->LoadFile(this, stream, TRUE/*verbose*/, index);
1086
1087 }
1088
1089 wxLogWarning( _("No handler found for image type.") );
1090 return FALSE;
1091 }
1092
1093 handler = FindHandler(type);
1094
1095 if (handler == NULL)
1096 {
1097 wxLogWarning( _("No image handler for type %d defined."), type );
1098
1099 return FALSE;
1100 }
1101
1102 return handler->LoadFile(this, stream, TRUE/*verbose*/, index);
1103 }
1104
1105 bool wxImage::LoadFile( wxInputStream& stream, const wxString& mimetype, int index )
1106 {
1107 UnRef();
1108
1109 m_refData = new wxImageRefData;
1110
1111 wxImageHandler *handler = FindHandlerMime(mimetype);
1112
1113 if (handler == NULL)
1114 {
1115 wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
1116
1117 return FALSE;
1118 }
1119
1120 return handler->LoadFile( this, stream, TRUE/*verbose*/, index );
1121 }
1122
1123 bool wxImage::SaveFile( wxOutputStream& stream, int type ) const
1124 {
1125 wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
1126
1127 wxImageHandler *handler = FindHandler(type);
1128
1129 if (handler == NULL)
1130 {
1131 wxLogWarning( _("No image handler for type %d defined."), type );
1132
1133 return FALSE;
1134 }
1135
1136 return handler->SaveFile( (wxImage*)this, stream );
1137 }
1138
1139 bool wxImage::SaveFile( wxOutputStream& stream, const wxString& mimetype ) const
1140 {
1141 wxCHECK_MSG( Ok(), FALSE, wxT("invalid image") );
1142
1143 wxImageHandler *handler = FindHandlerMime(mimetype);
1144
1145 if (handler == NULL)
1146 {
1147 wxLogWarning( _("No image handler for type %s defined."), mimetype.GetData() );
1148
1149 return FALSE;
1150 }
1151
1152 return handler->SaveFile( (wxImage*)this, stream );
1153 }
1154 #endif // wxUSE_STREAMS
1155
1156 void wxImage::AddHandler( wxImageHandler *handler )
1157 {
1158 // make sure that the memory will be freed at the program end
1159 sm_handlers.DeleteContents(TRUE);
1160
1161 sm_handlers.Append( handler );
1162 }
1163
1164 void wxImage::InsertHandler( wxImageHandler *handler )
1165 {
1166 // make sure that the memory will be freed at the program end
1167 sm_handlers.DeleteContents(TRUE);
1168
1169 sm_handlers.Insert( handler );
1170 }
1171
1172 bool wxImage::RemoveHandler( const wxString& name )
1173 {
1174 wxImageHandler *handler = FindHandler(name);
1175 if (handler)
1176 {
1177 sm_handlers.DeleteObject(handler);
1178 return TRUE;
1179 }
1180 else
1181 return FALSE;
1182 }
1183
1184 wxImageHandler *wxImage::FindHandler( const wxString& name )
1185 {
1186 wxNode *node = sm_handlers.First();
1187 while (node)
1188 {
1189 wxImageHandler *handler = (wxImageHandler*)node->Data();
1190 if (handler->GetName().Cmp(name) == 0) return handler;
1191
1192 node = node->Next();
1193 }
1194 return (wxImageHandler *)NULL;
1195 }
1196
1197 wxImageHandler *wxImage::FindHandler( const wxString& extension, long bitmapType )
1198 {
1199 wxNode *node = sm_handlers.First();
1200 while (node)
1201 {
1202 wxImageHandler *handler = (wxImageHandler*)node->Data();
1203 if ( (handler->GetExtension().Cmp(extension) == 0) &&
1204 (bitmapType == -1 || handler->GetType() == bitmapType) )
1205 return handler;
1206 node = node->Next();
1207 }
1208 return (wxImageHandler*)NULL;
1209 }
1210
1211 wxImageHandler *wxImage::FindHandler( long bitmapType )
1212 {
1213 wxNode *node = sm_handlers.First();
1214 while (node)
1215 {
1216 wxImageHandler *handler = (wxImageHandler *)node->Data();
1217 if (handler->GetType() == bitmapType) return handler;
1218 node = node->Next();
1219 }
1220 return NULL;
1221 }
1222
1223 wxImageHandler *wxImage::FindHandlerMime( const wxString& mimetype )
1224 {
1225 wxNode *node = sm_handlers.First();
1226 while (node)
1227 {
1228 wxImageHandler *handler = (wxImageHandler *)node->Data();
1229 if (handler->GetMimeType().IsSameAs(mimetype, FALSE)) return handler;
1230 node = node->Next();
1231 }
1232 return NULL;
1233 }
1234
1235 void wxImage::InitStandardHandlers()
1236 {
1237 #if wxUSE_STREAMS
1238 AddHandler(new wxBMPHandler);
1239 #endif // wxUSE_STREAMS
1240
1241 #if wxUSE_XPM && !defined(__WXGTK__) && !defined(__WXMOTIF__)
1242 AddHandler(new wxXPMHandler);
1243 #endif
1244 }
1245
1246 void wxImage::CleanUpHandlers()
1247 {
1248 wxNode *node = sm_handlers.First();
1249 while (node)
1250 {
1251 wxImageHandler *handler = (wxImageHandler *)node->Data();
1252 wxNode *next = node->Next();
1253 delete handler;
1254 delete node;
1255 node = next;
1256 }
1257 }
1258
1259 //-----------------------------------------------------------------------------
1260 // wxImageHandler
1261 //-----------------------------------------------------------------------------
1262
1263 IMPLEMENT_ABSTRACT_CLASS(wxImageHandler,wxObject)
1264
1265 #if wxUSE_STREAMS
1266 bool wxImageHandler::LoadFile( wxImage *WXUNUSED(image), wxInputStream& WXUNUSED(stream), bool WXUNUSED(verbose), int WXUNUSED(index) )
1267 {
1268 return FALSE;
1269 }
1270
1271 bool wxImageHandler::SaveFile( wxImage *WXUNUSED(image), wxOutputStream& WXUNUSED(stream), bool WXUNUSED(verbose) )
1272 {
1273 return FALSE;
1274 }
1275
1276 int wxImageHandler::GetImageCount( wxInputStream& WXUNUSED(stream) )
1277 {
1278 return 1;
1279 }
1280
1281 bool wxImageHandler::CanRead( const wxString& name )
1282 {
1283 if (wxFileExists(name))
1284 {
1285 wxFileInputStream stream(name);
1286 return CanRead(stream);
1287 }
1288
1289 else {
1290 wxLogError( _("Can't check image format of file '%s': file does not exist."), name.c_str() );
1291
1292 return FALSE;
1293 }
1294 // return FALSE;
1295 }
1296
1297 #endif // wxUSE_STREAMS
1298
1299
1300
1301 //-----------------------------------------------------------------------------
1302 // Deprecated wxBitmap convertion routines
1303 //-----------------------------------------------------------------------------
1304
1305 #if WXWIN_COMPATIBILITY_2_2 && wxUSE_GUI
1306
1307 #ifdef __WXGTK__
1308 wxBitmap wxImage::ConvertToMonoBitmap( unsigned char red, unsigned char green, unsigned char blue ) const
1309 {
1310 wxImage mono = this->ConvertToMono( red, green, blue );
1311 wxBitmap bitmap( mono, 1 );
1312 return bitmap;
1313 }
1314 #endif
1315
1316 wxBitmap wxImage::ConvertToBitmap() const
1317 {
1318 wxBitmap bitmap( *this );
1319 return bitmap;
1320 }
1321
1322 wxImage::wxImage( const wxBitmap &bitmap )
1323 {
1324 *this = bitmap.ConvertToImage();
1325 }
1326
1327 #endif // WXWIN_COMPATIBILITY_2_2 && wxUSE_GUI
1328
1329
1330 //-----------------------------------------------------------------------------
1331
1332 // GRG, Dic/99
1333 // Counts and returns the number of different colours. Optionally stops
1334 // when it exceeds 'stopafter' different colours. This is useful, for
1335 // example, to see if the image can be saved as 8-bit (256 colour or
1336 // less, in this case it would be invoked as CountColours(256)). Default
1337 // value for stopafter is -1 (don't care).
1338 //
1339 unsigned long wxImage::CountColours( unsigned long stopafter ) const
1340 {
1341 wxHashTable h;
1342 wxObject dummy;
1343 unsigned char r, g, b;
1344 unsigned char *p;
1345 unsigned long size, nentries, key;
1346
1347 p = GetData();
1348 size = GetWidth() * GetHeight();
1349 nentries = 0;
1350
1351 for (unsigned long j = 0; (j < size) && (nentries <= stopafter) ; j++)
1352 {
1353 r = *(p++);
1354 g = *(p++);
1355 b = *(p++);
1356 key = (r << 16) | (g << 8) | b;
1357
1358 if (h.Get(key) == NULL)
1359 {
1360 h.Put(key, &dummy);
1361 nentries++;
1362 }
1363 }
1364
1365 return nentries;
1366 }
1367
1368
1369 unsigned long wxImage::ComputeHistogram( wxImageHistogram &h ) const
1370 {
1371 unsigned char r, g, b;
1372 unsigned char *p;
1373 unsigned long size, nentries, key;
1374
1375 h.clear();
1376
1377 p = GetData();
1378 size = GetWidth() * GetHeight();
1379 nentries = 0;
1380
1381 for (unsigned long j = 0; j < size; j++)
1382 {
1383 r = *(p++);
1384 g = *(p++);
1385 b = *(p++);
1386 key = (r << 16) | (g << 8) | b;
1387
1388 wxImageHistogramEntry& entry = h[key];
1389 if ( entry.value++ == 0 )
1390 entry.index = nentries++;
1391 }
1392
1393 return nentries;
1394 }
1395
1396 /*
1397 * Rotation code by Carlos Moreno
1398 */
1399
1400 // GRG: I've removed wxRotationPoint - we already have wxRealPoint which
1401 // does exactly the same thing. And I also got rid of wxRotationPixel
1402 // bacause of potential problems in architectures where alignment
1403 // is an issue, so I had to rewrite parts of the code.
1404
1405 static const double gs_Epsilon = 1e-10;
1406
1407 static inline int wxCint (double x)
1408 {
1409 return (x > 0) ? (int) (x + 0.5) : (int) (x - 0.5);
1410 }
1411
1412
1413 // Auxiliary function to rotate a point (x,y) with respect to point p0
1414 // make it inline and use a straight return to facilitate optimization
1415 // also, the function receives the sine and cosine of the angle to avoid
1416 // repeating the time-consuming calls to these functions -- sin/cos can
1417 // be computed and stored in the calling function.
1418
1419 inline wxRealPoint rotated_point (const wxRealPoint & p, double cos_angle, double sin_angle, const wxRealPoint & p0)
1420 {
1421 return wxRealPoint (p0.x + (p.x - p0.x) * cos_angle - (p.y - p0.y) * sin_angle,
1422 p0.y + (p.y - p0.y) * cos_angle + (p.x - p0.x) * sin_angle);
1423 }
1424
1425 inline wxRealPoint rotated_point (double x, double y, double cos_angle, double sin_angle, const wxRealPoint & p0)
1426 {
1427 return rotated_point (wxRealPoint(x,y), cos_angle, sin_angle, p0);
1428 }
1429
1430 wxImage wxImage::Rotate(double angle, const wxPoint & centre_of_rotation, bool interpolating, wxPoint * offset_after_rotation) const
1431 {
1432 int i;
1433 angle = -angle; // screen coordinates are a mirror image of "real" coordinates
1434
1435 // Create pointer-based array to accelerate access to wxImage's data
1436 unsigned char ** data = new unsigned char * [GetHeight()];
1437
1438 data[0] = GetData();
1439
1440 for (i = 1; i < GetHeight(); i++)
1441 data[i] = data[i - 1] + (3 * GetWidth());
1442
1443 // precompute coefficients for rotation formula
1444 // (sine and cosine of the angle)
1445 const double cos_angle = cos(angle);
1446 const double sin_angle = sin(angle);
1447
1448 // Create new Image to store the result
1449 // First, find rectangle that covers the rotated image; to do that,
1450 // rotate the four corners
1451
1452 const wxRealPoint p0(centre_of_rotation.x, centre_of_rotation.y);
1453
1454 wxRealPoint p1 = rotated_point (0, 0, cos_angle, sin_angle, p0);
1455 wxRealPoint p2 = rotated_point (0, GetHeight(), cos_angle, sin_angle, p0);
1456 wxRealPoint p3 = rotated_point (GetWidth(), 0, cos_angle, sin_angle, p0);
1457 wxRealPoint p4 = rotated_point (GetWidth(), GetHeight(), cos_angle, sin_angle, p0);
1458
1459 int x1 = (int) floor (wxMin (wxMin(p1.x, p2.x), wxMin(p3.x, p4.x)));
1460 int y1 = (int) floor (wxMin (wxMin(p1.y, p2.y), wxMin(p3.y, p4.y)));
1461 int x2 = (int) ceil (wxMax (wxMax(p1.x, p2.x), wxMax(p3.x, p4.x)));
1462 int y2 = (int) ceil (wxMax (wxMax(p1.y, p2.y), wxMax(p3.y, p4.y)));
1463
1464 wxImage rotated (x2 - x1 + 1, y2 - y1 + 1);
1465
1466 if (offset_after_rotation != NULL)
1467 {
1468 *offset_after_rotation = wxPoint (x1, y1);
1469 }
1470
1471 // GRG: The rotated (destination) image is always accessed
1472 // sequentially, so there is no need for a pointer-based
1473 // array here (and in fact it would be slower).
1474 //
1475 unsigned char * dst = rotated.GetData();
1476
1477 // GRG: if the original image has a mask, use its RGB values
1478 // as the blank pixel, else, fall back to default (black).
1479 //
1480 unsigned char blank_r = 0;
1481 unsigned char blank_g = 0;
1482 unsigned char blank_b = 0;
1483
1484 if (HasMask())
1485 {
1486 blank_r = GetMaskRed();
1487 blank_g = GetMaskGreen();
1488 blank_b = GetMaskBlue();
1489 rotated.SetMaskColour( blank_r, blank_g, blank_b );
1490 }
1491
1492 // Now, for each point of the rotated image, find where it came from, by
1493 // performing an inverse rotation (a rotation of -angle) and getting the
1494 // pixel at those coordinates
1495
1496 // GRG: I've taken the (interpolating) test out of the loops, so that
1497 // it is done only once, instead of repeating it for each pixel.
1498
1499 int x;
1500 if (interpolating)
1501 {
1502 for (int y = 0; y < rotated.GetHeight(); y++)
1503 {
1504 for (x = 0; x < rotated.GetWidth(); x++)
1505 {
1506 wxRealPoint src = rotated_point (x + x1, y + y1, cos_angle, -sin_angle, p0);
1507
1508 if (-0.25 < src.x && src.x < GetWidth() - 0.75 &&
1509 -0.25 < src.y && src.y < GetHeight() - 0.75)
1510 {
1511 // interpolate using the 4 enclosing grid-points. Those
1512 // points can be obtained using floor and ceiling of the
1513 // exact coordinates of the point
1514 // C.M. 2000-02-17: when the point is near the border, special care is required.
1515
1516 int x1, y1, x2, y2;
1517
1518 if (0 < src.x && src.x < GetWidth() - 1)
1519 {
1520 x1 = wxCint(floor(src.x));
1521 x2 = wxCint(ceil(src.x));
1522 }
1523 else // else means that x is near one of the borders (0 or width-1)
1524 {
1525 x1 = x2 = wxCint (src.x);
1526 }
1527
1528 if (0 < src.y && src.y < GetHeight() - 1)
1529 {
1530 y1 = wxCint(floor(src.y));
1531 y2 = wxCint(ceil(src.y));
1532 }
1533 else
1534 {
1535 y1 = y2 = wxCint (src.y);
1536 }
1537
1538 // get four points and the distances (square of the distance,
1539 // for efficiency reasons) for the interpolation formula
1540
1541 // GRG: Do not calculate the points until they are
1542 // really needed -- this way we can calculate
1543 // just one, instead of four, if d1, d2, d3
1544 // or d4 are < gs_Epsilon
1545
1546 const double d1 = (src.x - x1) * (src.x - x1) + (src.y - y1) * (src.y - y1);
1547 const double d2 = (src.x - x2) * (src.x - x2) + (src.y - y1) * (src.y - y1);
1548 const double d3 = (src.x - x2) * (src.x - x2) + (src.y - y2) * (src.y - y2);
1549 const double d4 = (src.x - x1) * (src.x - x1) + (src.y - y2) * (src.y - y2);
1550
1551 // Now interpolate as a weighted average of the four surrounding
1552 // points, where the weights are the distances to each of those points
1553
1554 // If the point is exactly at one point of the grid of the source
1555 // image, then don't interpolate -- just assign the pixel
1556
1557 if (d1 < gs_Epsilon) // d1,d2,d3,d4 are positive -- no need for abs()
1558 {
1559 unsigned char *p = data[y1] + (3 * x1);
1560 *(dst++) = *(p++);
1561 *(dst++) = *(p++);
1562 *(dst++) = *(p++);
1563 }
1564 else if (d2 < gs_Epsilon)
1565 {
1566 unsigned char *p = data[y1] + (3 * x2);
1567 *(dst++) = *(p++);
1568 *(dst++) = *(p++);
1569 *(dst++) = *(p++);
1570 }
1571 else if (d3 < gs_Epsilon)
1572 {
1573 unsigned char *p = data[y2] + (3 * x2);
1574 *(dst++) = *(p++);
1575 *(dst++) = *(p++);
1576 *(dst++) = *(p++);
1577 }
1578 else if (d4 < gs_Epsilon)
1579 {
1580 unsigned char *p = data[y2] + (3 * x1);
1581 *(dst++) = *(p++);
1582 *(dst++) = *(p++);
1583 *(dst++) = *(p++);
1584 }
1585 else
1586 {
1587 // weights for the weighted average are proportional to the inverse of the distance
1588 unsigned char *v1 = data[y1] + (3 * x1);
1589 unsigned char *v2 = data[y1] + (3 * x2);
1590 unsigned char *v3 = data[y2] + (3 * x2);
1591 unsigned char *v4 = data[y2] + (3 * x1);
1592
1593 const double w1 = 1/d1, w2 = 1/d2, w3 = 1/d3, w4 = 1/d4;
1594
1595 // GRG: Unrolled.
1596
1597 *(dst++) = (unsigned char)
1598 ( (w1 * *(v1++) + w2 * *(v2++) +
1599 w3 * *(v3++) + w4 * *(v4++)) /
1600 (w1 + w2 + w3 + w4) );
1601 *(dst++) = (unsigned char)
1602 ( (w1 * *(v1++) + w2 * *(v2++) +
1603 w3 * *(v3++) + w4 * *(v4++)) /
1604 (w1 + w2 + w3 + w4) );
1605 *(dst++) = (unsigned char)
1606 ( (w1 * *(v1++) + w2 * *(v2++) +
1607 w3 * *(v3++) + w4 * *(v4++)) /
1608 (w1 + w2 + w3 + w4) );
1609 }
1610 }
1611 else
1612 {
1613 *(dst++) = blank_r;
1614 *(dst++) = blank_g;
1615 *(dst++) = blank_b;
1616 }
1617 }
1618 }
1619 }
1620 else // not interpolating
1621 {
1622 for (int y = 0; y < rotated.GetHeight(); y++)
1623 {
1624 for (x = 0; x < rotated.GetWidth(); x++)
1625 {
1626 wxRealPoint src = rotated_point (x + x1, y + y1, cos_angle, -sin_angle, p0);
1627
1628 const int xs = wxCint (src.x); // wxCint rounds to the
1629 const int ys = wxCint (src.y); // closest integer
1630
1631 if (0 <= xs && xs < GetWidth() &&
1632 0 <= ys && ys < GetHeight())
1633 {
1634 unsigned char *p = data[ys] + (3 * xs);
1635 *(dst++) = *(p++);
1636 *(dst++) = *(p++);
1637 *(dst++) = *(p++);
1638 }
1639 else
1640 {
1641 *(dst++) = blank_r;
1642 *(dst++) = blank_g;
1643 *(dst++) = blank_b;
1644 }
1645 }
1646 }
1647 }
1648
1649 delete [] data;
1650
1651 return rotated;
1652 }
1653
1654
1655
1656
1657
1658 // A module to allow wxImage initialization/cleanup
1659 // without calling these functions from app.cpp or from
1660 // the user's application.
1661
1662 class wxImageModule: public wxModule
1663 {
1664 DECLARE_DYNAMIC_CLASS(wxImageModule)
1665 public:
1666 wxImageModule() {}
1667 bool OnInit() { wxImage::InitStandardHandlers(); return TRUE; };
1668 void OnExit() { wxImage::CleanUpHandlers(); };
1669 };
1670
1671 IMPLEMENT_DYNAMIC_CLASS(wxImageModule, wxModule)
1672
1673
1674 #endif // wxUSE_IMAGE