0022922: Clean up warnings on uninitialized / unused variables
[occt.git] / src / AlienImage / AlienImage_X11XWDAlienData.cxx
CommitLineData
7fd59977 1#define PRO9517 //GG_010997
2// 1) Le swap ne fonctionne pas correctement sur DEC
3// car X11XColor.pixel est int et non long (::Read(),::Write()).
4// 2) Initialiser la table des couleurs avant d'ecrire
5// le fichier temporaire (::Write())
6
7#define K4 //GG_110398
8// Ne pas initialiser una AsciiString avec '\0' dans le
9// constructeur de AlienImage_X11XWDAlienData sinon RAISE !
10
11#define TEST //GG_140699
12// Check file extension, must be ".xwd".
13
14#ifndef WNT
15# include <X11/Xlib.h>
16#endif // WNT
17#include <Aspect_GenericColorMap.hxx>
18#include <Image_PseudoColorImage.hxx>
19#include <AlienImage_MemoryOperations.hxx>
20#include <AlienImage_X11XColor.hxx>
21#include <AlienImage_X11XWDAlienData.ixx>
22#include <Aspect_ColorMapEntry.hxx>
23#include <Standard.hxx>
24
25#ifdef TRACE
26static int Verbose = 0 ;
27#endif
28
29
30
31AlienImage_X11XWDAlienData::AlienImage_X11XWDAlienData()
32
33{ myData = NULL ;
34 myColors = NULL ;
35}
36
37void AlienImage_X11XWDAlienData::SetName( const TCollection_AsciiString& aName)
38
39{ myName = aName + TCollection_AsciiString( "\0" ) ;
40 myHeader.header_size = sizeof( myHeader ) + myName.Length() ;
41}
42
43const TCollection_AsciiString& AlienImage_X11XWDAlienData::Name() const
44
45{ return ( myName ) ; }
46
47void AlienImage_X11XWDAlienData::Clear()
48
49{ Standard_Integer size ;
50
51 myHeader.header_size = sizeof( myHeader ) ;
52 /* Size of the entire file header (bytes).*/
53 myHeader.file_version = 0 ; /* XWD_FILE_VERSION */
54 myHeader.pixmap_format= 0; /* Pixmap format */
55 myHeader.pixmap_depth = 0 ; /* Pixmap depth */
56 myHeader.pixmap_width = 0 ; /* Pixmap width */
57 myHeader.pixmap_height= 0 ; /* Pixmap height */
58 myHeader.xoffset = 0 ; /* Bitmap x offset */
59 myHeader.byte_order = 0; /* MSBFirst, LSBFirst */
60 myHeader.bitmap_unit = 0 ; /* Bitmap unit */
61 myHeader.bitmap_bit_order = 0; /* MSBFirst, LSBFirst */
62 myHeader.bitmap_pad = 0 ; /* Bitmap scanline pad */
63 myHeader.bits_per_pixel = 0 ; /* Bits per pixel */
64 myHeader.bytes_per_line =0 ; /* Bytes per scanline */
65 myHeader.visual_class = 0 ; /* Class of colormap */
66 myHeader.red_mask = 0 ; /* Z red mask */
67 myHeader.green_mask = 0 ; /* Z green mask */
68 myHeader.blue_mask = 0 ; /* Z blue mask */
69 myHeader.bits_per_rgb = 0 ; /* Log2 of distinct color values */
70 myHeader.colormap_entries = 0 ; /* Number of entries in colormap */
71 myHeader.ncolors = 0 ; /* Number of Color structures */
72 myHeader.window_width = 0 ; /* Window width */
73 myHeader.window_height= 0 ; /* Window height */
74 myHeader.window_x = 0 ; /* Window upper left X coordinate */
75 myHeader.window_y = 0 ; /* Window upper left Y coordinate */
76 myHeader.window_bdrwidth =0 ; /* Window border width */
77
78 myName.Clear() ;
79
80 if ( myData ) {
81 //Free all allocated memory
82 Standard::Free(myData) ;
83 myData = NULL ;
84 }
85
86 if ( myColors ) {
87 size = ( Standard_Integer )
88 myHeader.ncolors * sizeof( AlienImage_X11XColor ) ;
89 //Free all allocated memory
90 Standard::Free(myColors);
91 myColors = NULL ;
92 }
93
94}
95
96Standard_Boolean AlienImage_X11XWDAlienData::Write( OSD_File& file ) const
97
98{ Standard_Integer size, i ;
99 unsigned long swaptest = 1;
100 AlienImage_X11XWDFileHeader TheHeader = myHeader ;
101
102 if ( myData == NULL ) return( Standard_False ) ;
103 if ( TheHeader.ncolors &&
104 myColors == NULL ) return( Standard_False ) ;
105
106
107 // Write out TheHeader information
108
109 size = ( Standard_Integer ) TheHeader.header_size - sizeof( TheHeader ) ;
110
111 if ( size ) {
112 // Add '\0' at the end of name
113 TheHeader.header_size++ ;
114 }
115
116 if (*(char *) &swaptest) {
117 AlienImage_X11XWDFileHeader SwapHeader = TheHeader ;
118
119 AlienImage_MemoryOperations::SwapLong( ( Standard_Address ) &SwapHeader,
120 sizeof(SwapHeader));
121 file.Write( &SwapHeader , sizeof( SwapHeader ) ) ;
122 }
123 else {
124 const Standard_Address pHeader = ( Standard_Address ) &TheHeader ;
125
126 file.Write( pHeader, sizeof( TheHeader ) ) ;
127 }
128
129 if ( file.Failed() ) {
130 // ERROR
131 file.Seek( 0, OSD_FromBeginning ) ;
132 return( Standard_False ) ;
133 }
134
135 size = ( Standard_Integer ) TheHeader.header_size - sizeof( TheHeader ) ;
136
137 if ( size ) {
138 char end = '\0' ;
139 Standard_Address pend = Standard_Address( &end ) ;
140
141 file.Write( myName, myName.Length() ) ;
142
143 file.Write( pend, 1 ) ;
144 }
145
146 if ( file.Failed() ) {
147 // ERROR
148 file.Seek( 0, OSD_FromBeginning ) ;
149 return( Standard_False ) ;
150 }
151
152 // write out the color map buffer
153
154 if ( TheHeader.ncolors ) {
155 size = ( Standard_Integer ) TheHeader.ncolors
156 * sizeof( AlienImage_X11XColor ) ;
157
158 if (*(char *) &swaptest) {
159 Standard_Address palloc =
160 Standard::Allocate( size ) ;
161#ifdef PRO9517
162 const AlienImage_X11XColor *p = ( AlienImage_X11XColor * ) myColors ;
163 AlienImage_X11XColor *pp = ( AlienImage_X11XColor * ) palloc ;
164
165 for (i = 0 ; (unsigned int ) i < TheHeader.ncolors; i++,p++,pp++) {
166 pp->pixel = p->pixel;
167 pp->red = p->red;
168 pp->green = p->green;
169 pp->blue = p->blue;
170 pp->flags = p->flags;
171 AlienImage_MemoryOperations::SwapLong (
172 (Standard_Address) &(pp->pixel), sizeof(int));
173 AlienImage_MemoryOperations::SwapShort(
174 (Standard_Address) &(pp->red) , 3 * sizeof(short));
175 }
176#else
177 const AlienImage_X11XColor *p = ( AlienImage_X11XColor * ) palloc ;
178
179 for (i = 0 ; i < TheHeader.ncolors; i++,p++) {
180 AlienImage_MemoryOperations::SwapLong (
181 (Standard_Address) &(p->pixel), sizeof(long));
182 AlienImage_MemoryOperations::SwapShort(
183 (Standard_Address) &(p->red) , 3 * sizeof(short));
184 }
185#endif
186
187 file.Write( palloc, size ) ;
188
189 //Free all allocated memory
190 Standard::Free(palloc) ;
191 }
192 else {
193 file.Write( myColors, size ) ;
194 }
195
196 if ( file.Failed() ) {
197 // ERROR
198 file.Seek( 0, OSD_FromBeginning ) ;
199 return( Standard_False ) ;
200 }
201
202 }
203
204 if ( DataSize() ) {
205 file.Write( myData, DataSize() ) ;
206
207 if ( file.Failed() ) {
208 // ERROR
209 file.Seek( 0, OSD_FromBeginning ) ;
210 return( Standard_False ) ;
211 }
212
213 }
214
215 return( Standard_True ) ;
216
217}
218
219
220Standard_Boolean AlienImage_X11XWDAlienData::Read( OSD_File& file )
221
222{ Standard_Integer bblcount, i, size ;
223 unsigned long swaptest = 1;
224 Standard_Address pheader = ( Standard_Address ) &myHeader ;
225
226#ifdef TEST
227 OSD_Path path; file.Path(path);
228 TCollection_AsciiString ext = path.Extension(); ext.LowerCase();
229 if( ext != ".xwd" ) {
230 TCollection_AsciiString sysname; path.SystemName(sysname);
231#ifdef TRACE
232 cout << " *** AlienImage_X11XWDAlienData::Read('" << sysname << "'). must have an '.xwd' extension" << endl;
233#endif
234 return Standard_False;
235 }
236#endif
237
238 // Read in myHeader information
239
240 file.Read( pheader, sizeof( myHeader ), bblcount ) ;
241
242 if ( file.Failed() || ( bblcount != sizeof( myHeader ) ) ) {
243 // ERROR
244 file.Seek( 0, OSD_FromBeginning ) ;
245 return( Standard_False ) ;
246 }
247
248 if (*(char *) &swaptest)
249 AlienImage_MemoryOperations::SwapLong( ( Standard_Address ) &myHeader,
250 sizeof(myHeader));
251
252 // check to see if the dump file is in the proper format */
253 if (myHeader.file_version != XWD_FILE_VERSION) {
254 // ERROR "XWD file format version mismatch."
255
256 if (*(char *) &swaptest)
257 AlienImage_MemoryOperations::SwapLong( ( Standard_Address ) &myHeader,
258 sizeof(myHeader));
259
260 if (myHeader.file_version != XWD_FILE_VERSION) {
261 // ERROR "XWD file format version mismatch."
262 file.Seek( 0, OSD_FromBeginning ) ;
263 return( Standard_False ) ;
264 }
265 else {
266 // Data come from a swaped computer ??
267 swaptest = 0 ;
268 }
269 }
270
271 if (myHeader.header_size < sizeof(myHeader)) {
272 // ERROR "XWD header size is too small."
273 file.Seek( 0, OSD_FromBeginning ) ;
274 return( Standard_False ) ;
275 }
276
277#ifdef TRACE
278 if ( Verbose ) cout << myHeader << endl << flush ;
279#endif
280
281 // read in window name
282
283 size = ( Standard_Integer ) myHeader.header_size - sizeof( myHeader ) ;
284
285 if ( size > 0 ) {
286#ifdef K4
287 TCollection_AsciiString name( bblcount ) ;
288#else
289 TCollection_AsciiString name( bblcount , '\0') ;
290#endif
291
292 file.Read( name, size ) ; bblcount = name.Length() ;
293#ifdef WNT
294 --size;
295#endif // WNT
296
297 if ( file.Failed() || ( bblcount != size ) ) {
298 // ERROR
299 file.Seek( 0, OSD_FromBeginning ) ;
300 return( Standard_False ) ;
301 }
302
303 myName = name ;
304
305#ifdef TRACE
306 if ( Verbose ) cout << myName << endl << flush ;
307#endif
308
309 }
310
311 // read in the color map buffer
312
313 if ( myHeader.ncolors ) {
314 size = ( Standard_Integer ) myHeader.ncolors
315 * sizeof( AlienImage_X11XColor ) ;
316
317 myColors = Standard::Allocate( size ) ;
318
319 file.Read( myColors, size, bblcount ) ;
320
321 if ( file.Failed() || ( bblcount != size ) ) {
322 // ERROR
323 file.Seek( 0, OSD_FromBeginning ) ;
324 return( Standard_False ) ;
325 }
326
327 if ( *(char *) &swaptest ) {
328 AlienImage_X11XColor *p
329 = ( AlienImage_X11XColor * )myColors ;
330 for (i = 0 ; (unsigned int ) i < myHeader.ncolors; i++,p++) {
331#ifdef PRO9517
332 AlienImage_MemoryOperations::SwapLong (
333 (Standard_Address) &(p->pixel), sizeof(int));
334#else
335 AlienImage_MemoryOperations::SwapLong (
336 (Standard_Address) &(p->pixel), sizeof(long));
337#endif
338 AlienImage_MemoryOperations::SwapShort(
339 (Standard_Address) &(p->red) , 3 * sizeof(short));
340 }
341 }
342
7fd59977 343#ifdef TRACE
344 if ( Verbose ) {
345 AlienImage_X11XColor *p = ( AlienImage_X11XColor * )myColors;
346
347 for (i = 0 ; i < myHeader.ncolors; i++,p++) {
348 cout << *p << endl << flush ;
349 }
350
351 }
352#endif
353 }
354
355 if ( DataSize() ) {
356 myData = Standard::Allocate( DataSize() ) ;
357
358 file.Read( myData, DataSize(), bblcount ) ;
359
360 if ( file.Failed() || ( bblcount != DataSize() ) ) {
361 // ERROR
362 file.Seek( 0, OSD_FromBeginning ) ;
363 return( Standard_False ) ;
364 }
365 }
366
367 return( Standard_True ) ;
368
369}
370
371Handle_Image_Image AlienImage_X11XWDAlienData::ToImage() const
372
373{ if ( myHeader.pixmap_depth <= 8 &&
374 myHeader.ncolors &&
375 myHeader.pixmap_format == ZPixmap) {
376 return( ToPseudoColorImage() ) ;
377 }
378 else if ( myHeader.visual_class == TrueColor &&
379 myHeader.pixmap_format == ZPixmap) {
380 return( ToColorImage() ) ;
381 }
382 else {
383 Standard_TypeMismatch_Raise_if( Standard_True,
384 "Attempt to convert a X11XWDAlienData to a unknown Image_Image type");
385
386 return( NULL ) ;
387 }
388}
389
390void AlienImage_X11XWDAlienData::FromImage( const Handle_Image_Image& anImage )
391
392{ if ( anImage->Type() == Image_TOI_PseudoColorImage ) {
393 Handle(Image_PseudoColorImage) aPImage =
394 Handle(Image_PseudoColorImage)::DownCast(anImage) ;
395
396 FromPseudoColorImage( aPImage ) ;
397 }
398 else if ( anImage->Type() == Image_TOI_ColorImage ) {
399 Handle(Image_ColorImage) aCImage =
400 Handle(Image_ColorImage)::DownCast(anImage) ;
401
402 FromColorImage( aCImage ) ;
403 }
404 else {
405 Standard_TypeMismatch_Raise_if( Standard_True,
406 "Attempt to convert a unknown Image_Image type to a X11XWDAlienData");
407 }
408}
409
410//------------------------------------------------------------------------------
411// Private Method
412//------------------------------------------------------------------------------
413
414
415void AlienImage_X11XWDAlienData::FromPseudoColorImage(
416 const Handle_Image_PseudoColorImage& anImage)
417
418{ Standard_Integer size, i ;
419
420 /* Size of the entire file header (bytes).*/
421 myHeader.header_size = sizeof(myHeader) + myName.Length() ;
422 myHeader.file_version = XWD_FILE_VERSION ; /* XWD_FILE_VERSION */
423 myHeader.pixmap_format = ZPixmap ; /* Pixmap format */
424 myHeader.pixmap_depth = 8 ; /* Pixmap depth */
425 myHeader.pixmap_width = anImage->Width() ;/* Pixmap width */
426 myHeader.pixmap_height = anImage->Height() ;/* Pixmap height */
427 myHeader.xoffset = 0 ; /* Bitmap x offset */
428 myHeader.byte_order = MSBFirst; /* MSBFirst, LSBFirst */
429 myHeader.bitmap_unit = 32 ; /* Bitmap unit */
430 myHeader.bitmap_bit_order = MSBFirst; /* MSBFirst, LSBFirst */
431 myHeader.bitmap_pad = 32 ; /* Bitmap scanline pad */
432 myHeader.bits_per_pixel = 8 ; /* Bits per pixel */
433 /* Bytes per scanline */
434 size = ( Standard_Integer ) ( anImage->Width() * myHeader.bits_per_pixel );
435
436 myHeader.bytes_per_line = size / myHeader.bitmap_unit ;
437 if ( size % myHeader.bitmap_pad ) myHeader.bytes_per_line += 1 ;
438
439 myHeader.bytes_per_line *= ( myHeader.bitmap_unit / 8 ) ;
440
441 myHeader.visual_class = PseudoColor ; /* Class of colormap */
442 myHeader.red_mask = 0 ; /* Z red mask */
443 myHeader.green_mask = 0 ; /* Z green mask */
444 myHeader.blue_mask = 0 ; /* Z blue mask */
445 myHeader.bits_per_rgb = 8 ; /* Log2 of distinct color values */
446 myHeader.colormap_entries = 256 ; /* Number of entries in colormap */
447 myHeader.ncolors = (anImage->ColorMap())->Size() ;
448 /* Number of Color structures */
449 myHeader.window_width = anImage->Width() ; /* Window width */
450 myHeader.window_height = anImage->Height() ; /* Window height */
451 myHeader.window_x = 0 ; /* Window upper left X coordinate */
452 myHeader.window_y = 0 ; /* Window upper left Y coordinate */
453 myHeader.window_bdrwidth = 0 ; /* Window border width */
454
455 size = ( Standard_Integer ) myHeader.ncolors
456 * sizeof( AlienImage_X11XColor ) ;
457
458 myColors = Standard::Allocate( size ) ;
459
460 AlienImage_X11XColor *p = ( AlienImage_X11XColor * )myColors ;
461 Aspect_ColorMapEntry aCentry ;
462
463 for ( i = 1 ; (unsigned int ) i <= myHeader.ncolors ; i++, p++ ) {
464 p->pixel = 0 ;
465 p->red = p->green = p->blue = 0 ;
466 p->flags = 0 ;
467
468 aCentry = (anImage->ColorMap())->Entry( i ) ;
469
470 if ( aCentry.IsAllocated() == Standard_True ) {
471 p->flags = DoRed | DoGreen | DoBlue ;
472 p->pixel = aCentry.Index() ;
473 p->red = ( unsigned short )
474 ( (aCentry.Color()).Red() * 0xffff + 0.5 ) ;
475 p->green = ( unsigned short )
476 ( (aCentry.Color()).Green() * 0xffff + 0.5 ) ;
477 p->blue = ( unsigned short )
478 ( (aCentry.Color()).Blue() * 0xffff + 0.5 ) ;
479 }
480 }
481
482 if ( anImage->Size() ) {
483 Standard_Integer x, y ;
484
485 myData = Standard::Allocate( DataSize() ) ;
486
487 for ( y = 0 ; (unsigned int ) y < myHeader.pixmap_height ; y++ ) {
488 for ( x = 0 ; (unsigned int ) x < myHeader.pixmap_width ; x++ ) {
489 SetPixel( x, y,
490 ( anImage->Pixel( anImage->LowerX()+x ,
491 anImage->LowerY()+y )).Value() ) ;
492 }
493 }
494
495 }
496}
497
498void AlienImage_X11XWDAlienData::FromColorImage(
499 const Handle_Image_ColorImage& anImage)
500
501{ long int size ;;
502
503 /* Size of the entire file header (bytes).*/
504 myHeader.header_size = sizeof(myHeader) + myName.Length() ;
505 myHeader.file_version = XWD_FILE_VERSION ; /* XWD_FILE_VERSION */
506 myHeader.pixmap_format = ZPixmap ; /* Pixmap format */
507 myHeader.pixmap_depth = 24 ; /* Pixmap depth */
508 myHeader.pixmap_width = anImage->Width() ;/* Pixmap width */
509 myHeader.pixmap_height = anImage->Height() ;/* Pixmap height */
510 myHeader.xoffset = 0 ; /* Bitmap x offset */
511 myHeader.byte_order = MSBFirst; /* MSBFirst, LSBFirst */
512 myHeader.bitmap_unit = 32 ; /* Bitmap unit */
513 myHeader.bitmap_bit_order = MSBFirst; /* MSBFirst, LSBFirst */
514 myHeader.bitmap_pad = 32 ; /* Bitmap scanline pad */
515 myHeader.bits_per_pixel = 32 ; /* Bits per pixel */
516 /* Bytes per scanline */
517 size = anImage->Width() * myHeader.bits_per_pixel ;
518
519 myHeader.bytes_per_line = size / myHeader.bitmap_unit ;
520 if ( size % myHeader.bitmap_pad ) myHeader.bytes_per_line += 1 ;
521
522 myHeader.bytes_per_line *= ( myHeader.bitmap_unit / 8 ) ;
523
524 myHeader.visual_class = TrueColor ; /* Class of colormap */
525 myHeader.red_mask = 0xff ; /* Z red mask */
526 myHeader.green_mask = 0xff00 ; /* Z green mask */
527 myHeader.blue_mask = 0xff0000 ; /* Z blue mask */
528 myHeader.bits_per_rgb = 8 ; /* Log2 of distinct color values */
529 myHeader.colormap_entries = 256 ; /* Number of entries in colormap */
530 myHeader.ncolors = 0 ; /* Number of Color structures */
531 myHeader.window_width = anImage->Width() ; /* Window width */
532 myHeader.window_height = anImage->Height() ; /* Window height */
533 myHeader.window_x = 0 ; /* Window upper left X coordinate */
534 myHeader.window_y = 0 ; /* Window upper left Y coordinate */
535 myHeader.window_bdrwidth = 0 ; /* Window border width */
536
537
538 myColors = NULL ;
539
540 if ( anImage->Size() ) {
541 Standard_Integer x, y, pix, c ;
542 const Standard_Integer rs = RedShift() ;
543 const Standard_Integer gs = GreenShift() ;
544 const Standard_Integer bs = BlueShift() ;
545 const Standard_Integer ColorRange =
546 Standard_Integer( ( 1 << myHeader.bits_per_rgb ) - 1 );
547 Quantity_Color col ;
548
549 myData = Standard::Allocate( DataSize() ) ;
550
551 for ( y = 0 ; (unsigned int ) y < myHeader.pixmap_height ; y++ ) {
552 for ( x = 0 ; (unsigned int ) x < myHeader.pixmap_width ; x++ ) {
553 col = anImage->Pixel( anImage->LowerX()+x ,
554 anImage->LowerY()+y ).Value() ;
555
556 pix = 0 ;
557
558 c = ( Standard_Integer ) ( col.Red() * ColorRange + 0.5 );
559 c = ( Standard_Integer ) (( c << rs ) & myHeader.red_mask) ;
560 pix |= c ;
561
562 c = ( Standard_Integer ) ( col.Green() * ColorRange + 0.5 );
563 c = ( Standard_Integer ) (( c << gs ) & myHeader.green_mask) ;
564 pix |= c ;
565
566 c = ( Standard_Integer ) ( col.Blue() * ColorRange + 0.5 );
567 c = ( Standard_Integer ) (( c << bs ) & myHeader.blue_mask) ;
568 pix |= c ;
569
570 SetPixel( x, y, pix ) ;
571 }
572 }
573
574 }
575}
576
577Handle_Image_ColorImage AlienImage_X11XWDAlienData::ToColorImage() const
578
579{ Aspect_ColorPixel CPixel ;
580 Quantity_Color acolor ;
581 Handle(Image_ColorImage) ret_image = NULL ;
582 Standard_Integer pix,x,y ;
583 Standard_Real r,g,b, maxcol ;
584
585 if ( myHeader.visual_class == TrueColor &&
586 myHeader.pixmap_format == ZPixmap) {
587 ret_image = new Image_ColorImage( 0,0,
588 (Standard_Integer)myHeader.pixmap_width,
589 (Standard_Integer)myHeader.pixmap_height ) ;
590
591 maxcol = ( 1 << myHeader.bits_per_rgb ) - 1 ;
592
593 for ( y = 0 ; (unsigned int ) y < myHeader.pixmap_height ; y++ ) {
594 for ( x = 0 ; (unsigned int ) x < myHeader.pixmap_width ; x++ ) {
595 pix = Pixel( x, y ) ;
596
597 r = ( ( pix & myHeader.red_mask ) >> RedShift() ) / maxcol ;
598 g = ( ( pix & myHeader.green_mask ) >> GreenShift() ) / maxcol ;
599 b = ( ( pix & myHeader.blue_mask ) >> BlueShift() ) / maxcol ;
600
601 acolor.SetValues( r,g,b, Quantity_TOC_RGB ) ;
602 CPixel.SetValue ( acolor ) ;
603
604 ret_image->SetPixel( ret_image->LowerX()+x ,
605 ret_image->LowerY()+y, CPixel ) ;
606 }
607 }
608
609 }
610
611 return( ret_image ) ;
612}
613
614Handle_Image_PseudoColorImage AlienImage_X11XWDAlienData::ToPseudoColorImage()
615 const
616
617{ Standard_Real r,g,b ;
618 Standard_Integer x, y ;
619 const Standard_Real XRange = Standard_Real( Standard_Integer(0xffff) );
620 const Standard_Integer newColorSize =
621 Standard_Integer(myHeader.colormap_entries*sizeof(AlienImage_X11XColor));
622 Handle(Image_PseudoColorImage) ret_image = NULL ;
623
624 if ( myHeader.pixmap_depth <= 8 &&
625 myHeader.ncolors &&
626 myHeader.pixmap_format == ZPixmap) {
627// unsigned long int i, j, ncol ;
628 unsigned long int i, ncol ;
629 Aspect_ColorMapEntry Centry ;
630 Quantity_Color color ;
631 AlienImage_X11XColor *p ;
632 AlienImage_X11XColor *newColor ;
633 Standard_Address palloc ;
634 Aspect_IndexPixel IPixel ;
635
636 palloc = Standard::Allocate( newColorSize ) ;
637
638 newColor = ( AlienImage_X11XColor * ) palloc ;
639
640 p = ( AlienImage_X11XColor * )myColors;
641
642 for ( i = 0 ; i < myHeader.ncolors ; i++, p++ ) newColor[p->pixel] = *p;
643 for ( i = 0 ; i < myHeader.colormap_entries ; i++ ) newColor[i].flags = 0 ;
644
645 for ( y = 0 ; (unsigned int ) y < myHeader.pixmap_height ; y++ ) {
646 for ( x = 0 ; (unsigned int ) x < myHeader.pixmap_width ; x++ ) {
647 newColor[ Pixel( x, y ) ].flags = DoRed | DoGreen | DoBlue ;
648 }
649 }
650
651 for ( i = ncol = 0 ; i < myHeader.colormap_entries ; i++ ) {
652 if ( newColor[i].flags ) ncol++ ;
653 }
654
655 Handle(Aspect_GenericColorMap) colormap =
656 new Aspect_GenericColorMap();
657
658 for ( i = 0 ; i < myHeader.colormap_entries ; i++ ) {
659 if ( newColor[i].flags ) {
660 r = ( Standard_Real ) newColor[i].red / XRange ;
661 g = ( Standard_Real ) newColor[i].green / XRange ;
662 b = ( Standard_Real ) newColor[i].blue / XRange ;
663 color.SetValues( r,g,b, Quantity_TOC_RGB );
664 Centry.SetValue( Standard_Integer(newColor[i].pixel), color ) ;
665 colormap->AddEntry( Centry ) ;
666 }
667 }
668
669 ret_image = new Image_PseudoColorImage( 0,0,
670 Standard_Integer(myHeader.pixmap_width),
671 Standard_Integer(myHeader.pixmap_height),
672 colormap ) ;
673
674 for ( y = 0 ; (unsigned int ) y < myHeader.pixmap_height ; y++ ) {
675 for ( x = 0 ; (unsigned int ) x < myHeader.pixmap_width ; x++ ) {
676 IPixel.SetValue( Pixel( x, y ) ) ;
677 ret_image->SetPixel( ret_image->LowerX()+x ,
678 ret_image->LowerY()+y, IPixel ) ;
679 }
680 }
681
682
683 //Free all allocated memory
684 Standard::Free(palloc);
685 }
686
687 return ret_image ;
688
689}
690
691Standard_Integer AlienImage_X11XWDAlienData::DataSize() const
692
693{
694 if ( myHeader.pixmap_format != ZPixmap)
695 return( myHeader.bytes_per_line * myHeader.pixmap_height
696 * myHeader.pixmap_depth );
697
698 return( myHeader.bytes_per_line * myHeader.pixmap_height);
699}
700
701void AlienImage_X11XWDAlienData::SetPixel(
702 const Standard_Integer x,
703 const Standard_Integer y,
704 const Standard_Integer value )
705
706{ unsigned char *p ;
707 unsigned long int pixel_size ;
708
709 Standard_OutOfRange_Raise_if(
710 ( x < 0 || (unsigned int ) x >= myHeader.pixmap_width ||
711 y < 0 || (unsigned int ) y >= myHeader.pixmap_height ),
712 "Index out of range in X11XWDAlienData::Pixel");
713
714 pixel_size = ( unsigned long int ) myHeader.bytes_per_line /
715 myHeader.pixmap_width;
716
717 p = ( unsigned char * ) myData ;
718 p += y * myHeader.bytes_per_line + x * pixel_size ;
719
720 if ( pixel_size == 1 ) {
721 *p = ( unsigned char ) value ;
722 }
723 else if ( pixel_size == 2 ) {
724 *( ( unsigned short int * ) p ) = ( unsigned short int ) value ;
725 }
726 else if ( pixel_size == 4 ) {
727 *( ( unsigned long int * ) p ) = ( unsigned long int ) value ;
728 }
729}
730
731Standard_Integer AlienImage_X11XWDAlienData::Pixel(
732 const Standard_Integer x, const Standard_Integer y ) const
733
734{ unsigned char *p ;
735 unsigned long int pixel_size ;
736 unsigned long int pix ;
737 Standard_Integer ret ;
738
739 Standard_OutOfRange_Raise_if(
740 ( x < 0 || (unsigned int ) x >= myHeader.pixmap_width ||
741 y < 0 || (unsigned int ) y >= myHeader.pixmap_height ),
742 "Index out of range in X11XWDAlienData::Pixel");
743
744 pixel_size = ( unsigned long int ) myHeader.bytes_per_line /
745 myHeader.pixmap_width;
746
747 p = ( unsigned char * ) myData ;
748 p += y * myHeader.bytes_per_line + x * pixel_size ;
749
750 if ( pixel_size == 1 ) {
751 pix = ( unsigned long int ) *p ;
752 }
753 else if ( pixel_size == 2 ) {
754 pix = *( ( unsigned short int * ) p ) ;
755 }
756 else {
757 pix = *( ( unsigned long int * ) p ) ;
758 }
759
760 ret = Standard_Integer ( pix );
761
762 return( ret ) ;
763
764}
765
766Standard_Integer AlienImage_X11XWDAlienData::RedShift() const
767
768{ Standard_Integer shift = 0 ;
769
770 Standard_TypeMismatch_Raise_if( myHeader.visual_class != TrueColor ,
771 "Attempt to get RedShift from a non TrueColor X11XWDImage" ) ;
772
773 if ( ( myHeader.red_mask >> myHeader.bits_per_rgb ) == 0 ) {
774 shift = 0 ;
775 }
776 else if ( ( myHeader.red_mask >> ( 2 * myHeader.bits_per_rgb ) ) == 0 ) {
777 shift = Standard_Integer( myHeader.bits_per_rgb ) ;
778 }
779 else {
780 shift = Standard_Integer( 2 * myHeader.bits_per_rgb );
781 }
782 return shift ;
783}
784
785Standard_Integer AlienImage_X11XWDAlienData::GreenShift() const
786
787{ Standard_Integer shift = 0 ;
788
789 Standard_TypeMismatch_Raise_if( myHeader.visual_class != TrueColor ,
790 "Attempt to get GreenShift from a non TrueColor X11XWDImage" ) ;
791
792 if ( ( myHeader.green_mask >> myHeader.bits_per_rgb ) == 0 ) {
793 shift = 0 ;
794 }
795 else if ( ( myHeader.green_mask >> ( 2 * myHeader.bits_per_rgb ) ) == 0 ) {
796 shift = Standard_Integer( myHeader.bits_per_rgb ) ;
797 }
798 else {
799 shift = Standard_Integer( 2 * myHeader.bits_per_rgb ) ;
800 }
801 return shift ;
802}
803
804Standard_Integer AlienImage_X11XWDAlienData::BlueShift() const
805
806{ Standard_Integer shift = 0 ;
807
808 Standard_TypeMismatch_Raise_if( myHeader.visual_class != TrueColor ,
809 "Attempt to get BlueShift from a non TrueColor X11XWDImage" ) ;
810
811 if ( ( myHeader.blue_mask >> myHeader.bits_per_rgb ) == 0 ) {
812 shift = 0 ;
813 }
814 else if ( ( myHeader.blue_mask >> ( 2 * myHeader.bits_per_rgb ) ) == 0 ) {
815 shift = Standard_Integer( myHeader.bits_per_rgb ) ;
816 }
817 else {
818 shift = Standard_Integer( 2 * myHeader.bits_per_rgb ) ;
819 }
820
821 return shift ;
822}
823