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