00001
00002
00003
00004
00005
00006
00007 #include "xim.h"
00008 #include "xutil.h"
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 void MCW_kill_XImage( XImage *image )
00022 {
00023 ENTRY("MCW_kill_XImage") ;
00024 if( image != NULL ){
00025 if( image->data != NULL ){
00026 XtFree( image->data ) ; image->data = NULL ;
00027 }
00028 XDestroyImage( image ) ;
00029 }
00030 EXRETURN ;
00031 }
00032
00033
00034
00035
00036
00037
00038
00039 XImage * mri_to_XImage( MCW_DC *dc , MRI_IMAGE *im )
00040 {
00041 int w2, width, height ;
00042 unsigned char *Image;
00043 XImage *ximage;
00044 int border ;
00045
00046 register int i , hw , sk , k ;
00047 register short *sar ;
00048 register Pixel *ppix , *npix ;
00049 register unsigned char *ptr;
00050
00051 ENTRY("mri_to_XImage") ;
00052
00053 if( im->kind == MRI_rgb ) RETURN( rgb_to_XImage(dc,im) ) ;
00054
00055 if( im->kind != MRI_short ){
00056 fprintf(stderr,"\n*** ILLEGAL image input to mri_to_XImage\n") ;
00057 EXIT(1) ;
00058 }
00059 sar = MRI_SHORT_PTR(im) ;
00060 ppix = dc->pix_im ;
00061 npix = dc->ovc->pix_ov ;
00062
00063 width = im->nx ;
00064 height = im->ny ;
00065
00066 w2 = width * dc->byper ;
00067
00068 Image = (unsigned char *) XtMalloc( (size_t) (w2*height) );
00069
00070 ximage = XCreateImage( dc->display , dc->visual , dc->depth ,
00071 ZPixmap , 0 , Image , width,height , 8 , w2 ) ;
00072
00073 if( ximage == NULL ){
00074 fprintf(stderr,"\n*** CANNOT create new XImage for display\n") ;
00075 EXIT(1) ;
00076 }
00077
00078 border = ximage->byte_order ;
00079
00080 ptr = Image;
00081 k = 0;
00082 hw = height * width ;
00083
00084 switch( dc->byper ){
00085
00086 case 1:
00087 for( i=0 ; i < hw ; i++ ){
00088 sk = sar[k++] ;
00089 *ptr++ = (sk >= 0) ? (ppix[sk] & 0xff)
00090 : (npix[-sk] & 0xff) ;
00091 }
00092 break ;
00093
00094 case 2:
00095 if( border == MSBFirst ){
00096 for( i=0 ; i < hw ; i++ ){
00097 sk = sar[k++] ;
00098 if( sk >= 0 ){
00099 *ptr++ = (ppix[sk] >> 8) & 0xff ;
00100 *ptr++ = (ppix[sk]) & 0xff ;
00101 } else {
00102 *ptr++ = (npix[-sk] >> 8) & 0xff ;
00103 *ptr++ = (npix[-sk]) & 0xff ;
00104 }
00105 }
00106 } else {
00107 for( i=0 ; i < hw ; i++ ){
00108 sk = sar[k++] ;
00109 if( sk >= 0 ){
00110 *ptr++ = (ppix[sk]) & 0xff ;
00111 *ptr++ = (ppix[sk] >> 8) & 0xff ;
00112 } else {
00113 *ptr++ = (npix[-sk]) & 0xff ;
00114 *ptr++ = (npix[-sk] >> 8) & 0xff ;
00115 }
00116 }
00117 }
00118 break ;
00119
00120 case 3:
00121 if( border == MSBFirst ){
00122 for( i=0 ; i < hw ; i++ ){
00123 sk = sar[k++] ;
00124 if( sk >= 0 ){
00125 *ptr++ = (ppix[sk] >> 16) & 0xff ;
00126 *ptr++ = (ppix[sk] >> 8) & 0xff ;
00127 *ptr++ = (ppix[sk]) & 0xff ;
00128 } else {
00129 *ptr++ = (npix[-sk] >> 16) & 0xff ;
00130 *ptr++ = (npix[-sk] >> 8) & 0xff ;
00131 *ptr++ = (npix[-sk]) & 0xff ;
00132 }
00133 }
00134 } else {
00135 for( i=0 ; i < hw ; i++ ){
00136 sk = sar[k++] ;
00137 if( sk >= 0 ){
00138 *ptr++ = (ppix[sk]) & 0xff ;
00139 *ptr++ = (ppix[sk] >> 8) & 0xff ;
00140 *ptr++ = (ppix[sk] >> 16) & 0xff ;
00141 } else {
00142 *ptr++ = (npix[-sk]) & 0xff ;
00143 *ptr++ = (npix[-sk] >> 8) & 0xff ;
00144 *ptr++ = (npix[-sk] >> 16) & 0xff ;
00145 }
00146 }
00147 }
00148 break ;
00149
00150 case 4:
00151 if( border == MSBFirst ){
00152 for( i=0 ; i < hw ; i++ ){
00153 sk = sar[k++] ;
00154 if( sk >= 0 ){
00155 *ptr++ = (ppix[sk] >> 24) & 0xff ;
00156 *ptr++ = (ppix[sk] >> 16) & 0xff ;
00157 *ptr++ = (ppix[sk] >> 8) & 0xff ;
00158 *ptr++ = (ppix[sk]) & 0xff ;
00159 } else {
00160 *ptr++ = (npix[-sk] >> 24) & 0xff ;
00161 *ptr++ = (npix[-sk] >> 16) & 0xff ;
00162 *ptr++ = (npix[-sk] >> 8) & 0xff ;
00163 *ptr++ = (npix[-sk]) & 0xff ;
00164 }
00165 }
00166 } else {
00167 for( i=0 ; i < hw ; i++ ){
00168 sk = sar[k++] ;
00169 if( sk >= 0 ){
00170 *ptr++ = (ppix[sk]) & 0xff ;
00171 *ptr++ = (ppix[sk] >> 8) & 0xff ;
00172 *ptr++ = (ppix[sk] >> 16) & 0xff ;
00173 *ptr++ = (ppix[sk] >> 24) & 0xff ;
00174 } else {
00175 *ptr++ = (npix[-sk]) & 0xff ;
00176 *ptr++ = (npix[-sk] >> 8) & 0xff ;
00177 *ptr++ = (npix[-sk] >> 16) & 0xff ;
00178 *ptr++ = (npix[-sk] >> 24) & 0xff ;
00179 }
00180 }
00181 }
00182 break ;
00183
00184 default:
00185 fprintf(stderr,
00186 "\n*** ILLEGAL value of display bytes/pix=%d in mri_to_XImage\n",
00187 dc->byper);
00188 EXIT(1) ;
00189 }
00190
00191 RETURN( ximage ) ;
00192 }
00193
00194
00195
00196
00197
00198
00199
00200 XImage * resize_XImage( MCW_DC *dc , XImage *image ,
00201 int new_width , int new_height )
00202 {
00203 static int *lt = NULL ;
00204 static int old_width = -1 ;
00205
00206 register int iy, ex, ey, iW, iH, w2 ;
00207 char *ximag;
00208 char *Ep, *El, *Ip, *Il, *Id , *Ed ;
00209 int Erow , Irow ;
00210
00211 XImage *emage ;
00212
00213
00214
00215 ENTRY("resize_XImage") ;
00216
00217 if( new_width <= 0 || new_height <= 0 ){
00218 fprintf(stderr ,
00219 "\n***ILLEGAL new width %d or height %d in resize\n",
00220 new_width , new_height ) ;
00221 EXIT(1) ;
00222 }
00223
00224
00225
00226 iW = image->width ;
00227 iH = image->height ;
00228
00229 if( iW == new_width && iH == new_height ){
00230 RETURN( image ) ;
00231 }
00232
00233
00234
00235 w2 = new_width * dc->byper ;
00236 ximag = (char *) XtMalloc( (size_t) (w2 * new_height) );
00237
00238 if( ximag == NULL ){
00239 fprintf(stderr,"\n***CANNOT allocate memory for resizing XImage\n") ;
00240 EXIT(1) ;
00241 }
00242
00243 emage = XCreateImage( dc->display , dc->visual , dc->depth ,
00244 ZPixmap, 0, ximag, new_width,new_height, 8, w2 ) ;
00245
00246 if( emage == NULL ){
00247 fprintf(stderr,"\n*** CANNOT create new XImage for resizing\n") ;
00248 EXIT(1) ;
00249 }
00250
00251
00252
00253
00254
00255
00256 if( new_width > old_width ){
00257 lt = (int *) XtRealloc( (char *)lt,(size_t)(new_width * sizeof(int)) );
00258 old_width = new_width ;
00259 }
00260
00261 for( ex=0 ; ex < new_width ; ex++ )
00262 lt[ex] = MAP_XY(ex,new_width,iW) * dc->byper ;
00263
00264
00265
00266 Ed = (char *) emage->data ; Erow = emage->bytes_per_line ;
00267 Id = (char *) image->data ; Irow = image->bytes_per_line ;
00268
00269 switch( dc->byper ){
00270
00271 case 1:
00272 for( ey=0 ; ey < new_height ; ey++ ){
00273
00274 iy = MAP_XY(ey,new_height,iH) ;
00275 Il = Id + Irow * iy ;
00276 El = Ed + Erow * ey ;
00277 Ep = El ;
00278 for( ex=0 ; ex < new_width ; ex++ ){
00279 Ip = Il + lt[ex] ;
00280 *Ep++ = *Ip ;
00281 }
00282 }
00283 break ;
00284
00285 case 2:
00286 for( ey=0 ; ey < new_height ; ey++ ){
00287
00288 iy = MAP_XY(ey,new_height,iH) ;
00289 Il = Id + Irow * iy ;
00290 El = Ed + Erow * ey ;
00291 Ep = El ;
00292 for( ex=0 ; ex < new_width ; ex++ ){
00293 Ip = Il + lt[ex] ;
00294 *Ep++ = *Ip ;
00295 *Ep++ = *(Ip+1) ;
00296 }
00297 }
00298 break ;
00299
00300 case 3:
00301 for( ey=0 ; ey < new_height ; ey++ ){
00302
00303 iy = MAP_XY(ey,new_height,iH) ;
00304 Il = Id + Irow * iy ;
00305 El = Ed + Erow * ey ;
00306 Ep = El ;
00307 for( ex=0 ; ex < new_width ; ex++ ){
00308 Ip = Il + lt[ex] ;
00309 *Ep++ = *Ip ;
00310 *Ep++ = *(Ip+1) ;
00311 *Ep++ = *(Ip+2) ;
00312 }
00313 }
00314 break ;
00315
00316 case 4:
00317 for( ey=0 ; ey < new_height ; ey++ ){
00318
00319 iy = MAP_XY(ey,new_height,iH) ;
00320 Il = Id + Irow * iy ;
00321 El = Ed + Erow * ey ;
00322 Ep = El ;
00323 for( ex=0 ; ex < new_width ; ex++ ){
00324 Ip = Il + lt[ex] ;
00325 *Ep++ = *Ip ;
00326 *Ep++ = *(Ip+1) ;
00327 *Ep++ = *(Ip+2) ;
00328 *Ep++ = *(Ip+3) ;
00329 }
00330 }
00331 break ;
00332
00333 default:
00334 fprintf(stderr,"\n***ILLEGAL bytes/pix=%d for resizing\n",dc->byper) ;
00335 EXIT(1) ;
00336 }
00337
00338 RETURN( emage ) ;
00339 }
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354 MRI_IMAGE * XImage_to_mri( MCW_DC *dc , XImage *ximage , int code )
00355 {
00356 int nx , ny , npix , ii,jj , kk , allgray , lsize ;
00357 Pixel pp ;
00358 byte *rgb , *gray ;
00359 byte rr,gg,bb ;
00360 byte *ptr ;
00361 XColor *xc ;
00362 MRI_IMAGE *outim ;
00363 int border ;
00364
00365 int use_cmap = ((code & X2M_USE_CMAP ) != 0) ;
00366 int force_rgb = ((code & X2M_FORCE_RGB) != 0) ;
00367
00368 ENTRY("XImage_to_mri") ;
00369
00370 if( ximage == NULL || ximage->data == NULL ) RETURN( NULL ) ;
00371
00372 #if 0
00373 fprintf(stderr,
00374 "XImage bitmap_unit =%3d bitmap_pad=%3d depth =%3d\n"
00375 " bytes_per_line=%3d width =%3d height=%3d\n"
00376 " bits_per_pixel=%3d xoffset =%3d\n" ,
00377 ximage->bitmap_unit , ximage->bitmap_pad , ximage->depth ,
00378 ximage->bytes_per_line , ximage->width , ximage->height ,
00379 ximage->bits_per_pixel , ximage->xoffset ) ;
00380 #endif
00381
00382 nx = ximage->width ; ny = ximage->height ; npix = nx * ny ;
00383
00384 lsize = ximage->bytes_per_line ;
00385
00386 ptr = (byte *) ximage->data ;
00387
00388 rgb = (byte *) malloc( sizeof(byte) * 3*npix ) ;
00389 if( rgb == NULL ){
00390 fprintf(stderr,"\n*** malloc failure in XImage_to_mri\n") ;
00391 EXIT(1) ;
00392 }
00393
00394 border = ximage->byte_order ;
00395
00396 switch( dc->byper ){
00397
00398 case 1:
00399 kk = 0 ; allgray = !force_rgb ;
00400 for( jj=0 ; jj < ny ; jj++ ){
00401 for( ii=0 ; ii < nx ; ii++ ){
00402 pp = ptr[ii+jj*lsize] ;
00403 xc = DCpix_to_XColor( dc , pp , use_cmap ) ;
00404 rr = rgb[kk++] = INTEN_TO_BYTE( xc->red ) ;
00405 gg = rgb[kk++] = INTEN_TO_BYTE( xc->green ) ;
00406 bb = rgb[kk++] = INTEN_TO_BYTE( xc->blue ) ;
00407 allgray = allgray && (rr==gg) && (gg=bb) ;
00408 }
00409 }
00410 break ;
00411
00412 case 2:
00413 kk = 0 ; allgray = !force_rgb ;
00414 for( jj=0 ; jj < ny ; jj++ ){
00415 for( ii=0 ; ii < nx ; ii++ ){
00416 if( border == MSBFirst )
00417 pp = (ptr[2*ii+jj*lsize] << 8) | ptr[2*ii+jj*lsize+1] ;
00418 else
00419 pp = (ptr[2*ii+jj*lsize+1] << 8) | ptr[2*ii+jj*lsize] ;
00420
00421 xc = DCpix_to_XColor( dc , pp , use_cmap ) ;
00422 rr = rgb[kk++] = INTEN_TO_BYTE( xc->red ) ;
00423 gg = rgb[kk++] = INTEN_TO_BYTE( xc->green ) ;
00424 bb = rgb[kk++] = INTEN_TO_BYTE( xc->blue ) ;
00425 allgray = allgray && (rr==gg) && (gg=bb) ;
00426 }
00427 }
00428 break ;
00429
00430 case 3:
00431 kk = 0 ; allgray = !force_rgb ;
00432 for( jj=0 ; jj < ny ; jj++ ){
00433 for( ii=0 ; ii < nx ; ii++ ){
00434 if( border == MSBFirst )
00435 pp = (ptr[3*ii+jj*lsize] << 16) |
00436 (ptr[3*ii+jj*lsize+1] << 8) | ptr[3*ii+jj*lsize+2] ;
00437 else
00438 pp = (ptr[3*ii+jj*lsize+2] << 16) |
00439 (ptr[3*ii+jj*lsize+1] << 8) | ptr[3*ii+jj*lsize] ;
00440
00441 xc = DCpix_to_XColor( dc , pp , use_cmap ) ;
00442 rr = rgb[kk++] = INTEN_TO_BYTE( xc->red ) ;
00443 gg = rgb[kk++] = INTEN_TO_BYTE( xc->green ) ;
00444 bb = rgb[kk++] = INTEN_TO_BYTE( xc->blue ) ;
00445 allgray = allgray && (rr==gg) && (gg=bb) ;
00446 }
00447 }
00448 break ;
00449
00450 case 4:
00451 kk = 0 ; allgray = !force_rgb ;
00452 for( jj=0 ; jj < ny ; jj++ ){
00453 for( ii=0 ; ii < nx ; ii++ ){
00454 if( border == MSBFirst )
00455 pp = (ptr[4*ii+jj*lsize] << 24) | (ptr[4*ii+jj*lsize+1] << 16) |
00456 (ptr[4*ii+jj*lsize+2] << 8) | ptr[4*ii+jj*lsize+3] ;
00457 else
00458 pp = (ptr[4*ii+jj*lsize+3] << 24) | (ptr[4*ii+jj*lsize+2] << 16) |
00459 (ptr[4*ii+jj*lsize+1] << 8) | ptr[4*ii+jj*lsize] ;
00460
00461 xc = DCpix_to_XColor( dc , pp , use_cmap ) ;
00462 rr = rgb[kk++] = INTEN_TO_BYTE( xc->red ) ;
00463 gg = rgb[kk++] = INTEN_TO_BYTE( xc->green ) ;
00464 bb = rgb[kk++] = INTEN_TO_BYTE( xc->blue ) ;
00465 allgray = allgray && (rr==gg) && (gg=bb) ;
00466 }
00467 }
00468 break ;
00469
00470 default:
00471 fprintf(stderr,
00472 "\n*** ILLEGAL value of bytes/pix=%d in XImage_to_mri\n",
00473 dc->byper);
00474 EXIT(1) ;
00475 }
00476
00477
00478
00479 if( allgray ){
00480
00481 gray = (byte *) malloc( sizeof(byte) * npix ) ;
00482 if( gray == NULL ){
00483 fprintf(stderr,"\n*** malloc failure in XImage_to_mri\n") ;
00484 EXIT(1) ;
00485 }
00486 for( ii=0 , kk=0 ; ii < npix ; ii++ , kk+=3) gray[ii] = rgb[kk] ;
00487 free(rgb) ;
00488 outim = mri_new_vol_empty( nx , ny , 1 , MRI_byte ) ;
00489 mri_fix_data_pointer( gray , outim ) ;
00490
00491 } else {
00492
00493
00494
00495 outim = mri_new_vol_empty( nx , ny , 1 , MRI_rgb ) ;
00496 mri_fix_data_pointer( rgb , outim ) ;
00497 }
00498
00499 RETURN( outim ) ;
00500 }
00501
00502
00503
00504
00505
00506
00507 XImage * pixar_to_XImage( MCW_DC *dc, int nx, int ny, Pixel *par )
00508 {
00509 int w2, width, height , border ;
00510 unsigned char *Image ;
00511 XImage *ximage ;
00512 register int i , hw ;
00513 register unsigned char *ptr;
00514
00515
00516
00517 ENTRY("pixar_to_XImage") ;
00518
00519 if( dc == NULL || nx < 1 || ny < 1 || par == NULL ) RETURN( NULL ) ;
00520
00521 width = nx ; height = ny ;
00522
00523 w2 = width * dc->byper ;
00524
00525 Image = (unsigned char *) XtMalloc( (size_t) (w2*height) );
00526 if( Image == NULL ) RETURN( NULL ) ;
00527
00528 ximage = XCreateImage( dc->display , dc->visual , dc->depth ,
00529 ZPixmap , 0 , Image , width,height , 8 , w2 ) ;
00530 if( ximage == NULL ){ XtFree((char *)Image) ; RETURN( NULL ) ; }
00531
00532 border = ximage->byte_order ;
00533
00534 ptr = Image ;
00535 hw = height * width ;
00536
00537 switch( dc->byper ){
00538
00539 case 1:
00540 for( i=0 ; i < hw ; i++ ){
00541 *ptr++ = par[i] & 0xff ;
00542 }
00543 break ;
00544
00545 case 2:
00546 if( border == MSBFirst ){
00547 for( i=0 ; i < hw ; i++ ){
00548 *ptr++ = (par[i] >> 8) & 0xff ;
00549 *ptr++ = (par[i] ) & 0xff ;
00550 }
00551 } else {
00552 for( i=0 ; i < hw ; i++ ){
00553 *ptr++ = (par[i] ) & 0xff ;
00554 *ptr++ = (par[i] >> 8) & 0xff ;
00555 }
00556 }
00557 break ;
00558
00559 case 3:
00560 if( border == MSBFirst ){
00561 for( i=0 ; i < hw ; i++ ){
00562 *ptr++ = (par[i] >> 16) & 0xff ;
00563 *ptr++ = (par[i] >> 8) & 0xff ;
00564 *ptr++ = (par[i] ) & 0xff ;
00565 }
00566 } else {
00567 for( i=0 ; i < hw ; i++ ){
00568 *ptr++ = (par[i] ) & 0xff ;
00569 *ptr++ = (par[i] >> 8) & 0xff ;
00570 *ptr++ = (par[i] >> 16) & 0xff ;
00571 }
00572 }
00573 break ;
00574
00575 case 4:
00576 if( border == MSBFirst ){
00577 for( i=0 ; i < hw ; i++ ){
00578 *ptr++ = (par[i] >> 24) & 0xff ;
00579 *ptr++ = (par[i] >> 16) & 0xff ;
00580 *ptr++ = (par[i] >> 8) & 0xff ;
00581 *ptr++ = (par[i] ) & 0xff ;
00582 }
00583 } else {
00584 for( i=0 ; i < hw ; i++ ){
00585 *ptr++ = (par[i] ) & 0xff ;
00586 *ptr++ = (par[i] >> 8) & 0xff ;
00587 *ptr++ = (par[i] >> 16) & 0xff ;
00588 *ptr++ = (par[i] >> 24) & 0xff ;
00589 }
00590 }
00591 break ;
00592
00593 default:
00594 fprintf(stderr,
00595 "\n*** ILLEGAL value of display bytes/pix=%d in pixar_to_XImage\n",
00596 dc->byper);
00597 EXIT(1) ;
00598 }
00599
00600 RETURN( ximage ) ;
00601 }
00602
00603
00604 #undef INLINE
00605 #ifdef __GNUC__
00606 # define INLINE inline
00607 #else
00608 # define INLINE
00609 #endif
00610
00611
00612
00613
00614 static INLINE Pixel tc_rgb_to_pixel( MCW_DC *dc, byte rr, byte gg, byte bb )
00615 {
00616 static MCW_DC *dcold=NULL ;
00617 DC_colordef *cd = dc->cdef ;
00618 static unsigned long pold=0 ;
00619 static byte rold=0 , gold=0 , bold=0 ;
00620 unsigned long r , g , b ;
00621
00622 if( cd == NULL ){ reload_DC_colordef(dc) ; cd = dc->cdef ; }
00623
00624 if( rr == 0 && gg == 0 && bb == 0 ) return 0 ;
00625 if( rr == 255 && gg == 255 && bb == 255 ) return cd->whpix ;
00626
00627 if( dc == dcold && rr == rold && gg == gold && bb == bold )
00628 return (Pixel) pold ;
00629
00630 rold = rr ; gold = gg ; bold = bb ; dcold = dc ;
00631
00632 r = (cd->rrshift<0) ? (rr<<(-cd->rrshift))
00633 : (rr>>cd->rrshift) ; r = r & cd->rrmask ;
00634
00635 g = (cd->ggshift<0) ? (gg<<(-cd->ggshift))
00636 : (gg>>cd->ggshift) ; g = g & cd->ggmask ;
00637
00638 b = (cd->bbshift<0) ? (bb<<(-cd->bbshift))
00639 : (bb>>cd->bbshift) ; b = b & cd->bbmask ;
00640
00641 pold = r | g | b ;
00642 return (Pixel) pold ;
00643 }
00644
00645
00646
00647 static XImage * rgb_to_XImage_simple( MCW_DC *, MRI_IMAGE * ) ;
00648 static XImage * rgb_to_XImage_clever( MCW_DC *, MRI_IMAGE * ) ;
00649
00650
00651
00652
00653
00654 XImage * rgb_to_XImage( MCW_DC *dc , MRI_IMAGE *im )
00655 {
00656 switch( dc->visual_class ){
00657 case TrueColor: return rgb_to_XImage_simple(dc,im) ;
00658 case PseudoColor: return rgb_to_XImage_clever(dc,im) ;
00659 }
00660 return NULL ;
00661 }
00662
00663
00664
00665
00666
00667 static XImage * rgb_to_XImage_simple( MCW_DC *dc , MRI_IMAGE *im )
00668 {
00669 int nxy , ii ;
00670 byte *rgb ;
00671 Pixel *par ;
00672 XImage *xim ;
00673
00674 ENTRY("rgb_to_XImage_simple") ;
00675
00676
00677
00678 if( dc == NULL || im == NULL || im->kind != MRI_rgb ) RETURN( NULL ) ;
00679
00680 nxy = im->nx * im->ny ;
00681 rgb = MRI_RGB_PTR(im) ;
00682
00683 par = (Pixel *) malloc(sizeof(Pixel)*nxy); if( par == NULL ) RETURN(NULL) ;
00684
00685 for( ii=0 ; ii < nxy ; ii++ )
00686 par[ii] = tc_rgb_to_pixel( dc , rgb[3*ii], rgb[3*ii+1], rgb[3*ii+2] ) ;
00687
00688 xim = pixar_to_XImage( dc , im->nx , im->ny , par ) ;
00689
00690 free(par) ; RETURN( xim ) ;
00691 }
00692
00693
00694
00695
00696
00697 static XImage * rgb_to_XImage_clever( MCW_DC *dc , MRI_IMAGE *im )
00698 {
00699 int nxy , ii , c ;
00700 byte *rgb , r,g,b ;
00701 Pixel *par , p=0 ;
00702 XImage *xim ;
00703 int *col_ar , *ii_ar ;
00704
00705 ENTRY("rgb_to_XImage_clever") ;
00706
00707
00708
00709 if( dc == NULL || im == NULL || im->kind != MRI_rgb ) RETURN( NULL ) ;
00710
00711 nxy = im->nx * im->ny ;
00712 rgb = MRI_RGB_PTR(im) ;
00713
00714 col_ar = (int *) malloc( sizeof(int) * nxy ) ;
00715 ii_ar = (int *) malloc( sizeof(int) * nxy ) ;
00716 par = (Pixel *)malloc( sizeof(Pixel) * nxy ) ;
00717
00718 if( col_ar == NULL ) RETURN( NULL );
00719 if( ii_ar == NULL ){ free(col_ar); RETURN( NULL ); }
00720 if( par == NULL ){ free(col_ar); free(ii_ar); RETURN( NULL ); }
00721
00722 for( ii=0 ; ii < nxy ; ii++ ){
00723 ii_ar[ii] = ii ;
00724 col_ar[ii] = rgb[3*ii] << 16 | rgb[3*ii+1] << 8 | rgb[3*ii+2] ;
00725 }
00726
00727 qsort_intint( nxy , col_ar , ii_ar ) ;
00728
00729 c = -1 ;
00730
00731 for( ii=0 ; ii < nxy ; ii++ ){
00732 if( col_ar[ii] != c ){
00733 c = col_ar[ii] ;
00734 r = (c >> 16) & 0xff ; g = (c >> 8) & 0xff ; b = c & 0xff ;
00735 p = DC_rgb_to_pixel( dc , r,g,b ) ;
00736 }
00737 par[ii_ar[ii]] = p ;
00738 }
00739
00740 free(col_ar) ; free(ii_ar) ;
00741
00742 xim = pixar_to_XImage( dc , im->nx , im->ny , par ) ;
00743
00744 free(par) ; RETURN( xim ) ;
00745 }
00746
00747
00748
00749
00750 static int badsnap = 0 ;
00751 static MCW_DC *snap_dc = NULL ;
00752
00753
00754
00755 static int SNAP_errhandler( Display *d , XErrorEvent *x )
00756 {
00757 fprintf(stderr,"** X11 error trying to snapshot window!\n");
00758 badsnap = 1 ; return 0 ;
00759 }
00760
00761
00762
00763
00764
00765 MRI_IMAGE * SNAP_grab_image( Widget w , MCW_DC *dc )
00766 {
00767 XImage * xim ;
00768 MRI_IMAGE * tim ;
00769 Window win ;
00770 Widget wpar=w ;
00771 XWindowAttributes wa ;
00772 int (*old_handler)(Display *, XErrorEvent *) ;
00773
00774 ENTRY("SNAP_grab_image") ;
00775
00776 if( dc == NULL ) RETURN(NULL) ;
00777
00778 if( w == NULL ){
00779 win = RootWindow( dc->display , dc->screen_num ) ;
00780 } else {
00781 if( !XtIsWidget(w) ||
00782 !XtIsRealized(w) ||
00783 !XtIsManaged(w) ) RETURN(NULL) ;
00784 win = XtWindow(w) ;
00785 if( win == (Window)0 ) RETURN(NULL) ;
00786
00787 while( XtParent(wpar) != NULL ) wpar = XtParent(wpar) ;
00788
00789
00790
00791 #if 0
00792 XRaiseWindow( dc->display , XtWindow(wpar) ) ;
00793 #endif
00794 XFlush( dc->display ) ;
00795 XmUpdateDisplay( w ) ;
00796 if( !MCW_widget_visible(w) ) RETURN(NULL) ;
00797 }
00798
00799 RWC_sleep(20) ;
00800 XGetWindowAttributes( dc->display , win , &wa ) ;
00801 xim = NULL ; badsnap = 0 ;
00802 old_handler = XSetErrorHandler( SNAP_errhandler ) ;
00803 xim = XGetImage( dc->display , win ,
00804 0,0 , wa.width,wa.height,
00805 (unsigned long)(-1), ZPixmap ) ;
00806 (void) XSetErrorHandler( old_handler ) ;
00807 if( badsnap ){
00808 if( xim != NULL ) MCW_kill_XImage(xim) ;
00809 RETURN(NULL) ;
00810 }
00811 if( xim == NULL ) RETURN(NULL) ;
00812
00813 tim = XImage_to_mri( dc , xim , X2M_USE_CMAP | X2M_FORCE_RGB ) ;
00814 MCW_kill_XImage(xim) ;
00815 RETURN(tim) ;
00816 }
00817
00818
00819
00820
00821
00822
00823 void ISQ_snapfile( Widget w )
00824 {
00825 MRI_IMAGE *tim ;
00826 Window win ;
00827 char fname[64] , *eee , prefix[32] ;
00828 int ii ; static int last_ii=1 ;
00829
00830 ENTRY("ISQ_snapfile") ;
00831
00832 if( w == NULL || !XtIsWidget(w) ) EXRETURN ;
00833 if( !XtIsRealized(w) || !XtIsManaged(w) ) EXRETURN ;
00834 win = XtWindow(w); if( win == (Window)0 ) EXRETURN ;
00835
00836
00837
00838 if( snap_dc == NULL ){
00839 if( first_dc != NULL ) snap_dc = first_dc ;
00840 else snap_dc = MCW_new_DC( w, 4,0, NULL,NULL, 1.0,0 );
00841 }
00842
00843
00844
00845 tim = SNAP_grab_image( w , snap_dc ) ;
00846 if( tim == NULL ) EXRETURN ;
00847
00848 eee = getenv("AFNI_SNAPFILE_PREFIX") ;
00849 if( eee == NULL ){
00850 strcpy(prefix,"S_") ;
00851 } else {
00852 strncpy(prefix,eee,30) ; prefix[30] = '\0' ; strcat(prefix,"_") ;
00853 if( !THD_filename_ok(prefix) ) strcpy(prefix,"S_") ;
00854 }
00855 for( ii=last_ii ; ii <= 999999 ; ii++ ){
00856 sprintf(fname,"%s%06d.ppm",prefix,ii) ;
00857 if( ! THD_is_ondisk(fname) ) break ;
00858 }
00859 if( ii <= 999999 ) mri_write_pnm( fname , tim ) ;
00860 mri_free(tim) ; last_ii = ii ;
00861 EXRETURN ;
00862 }