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