granicus.if.org Git - imagemagick/blob - coders/fits.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                        FFFFF  IIIII  TTTTT  SSSSS                           %
   7 %                        F        I      T    SS                              %
   8 %                        FFF      I      T     SSS                            %
   9 %                        F        I      T       SS                           %
  10 %                        F      IIIII    T    SSSSS                           %
  11 %                                                                             %
  12 %                                                                             %
  13 %            Read/Write Flexible Image Transport System Images.               %
  14 %                                                                             %
  15 %                              Software Design                                %
  16 %                                   Cristy                                    %
  17 %                                 July 1992                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2015 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40   Include declarations.
  41 */
  42 #include "MagickCore/studio.h"
  43 #include "MagickCore/attribute.h"
  44 #include "MagickCore/blob.h"
  45 #include "MagickCore/blob-private.h"
  46 #include "MagickCore/cache.h"
  47 #include "MagickCore/color-private.h"
  48 #include "MagickCore/colorspace.h"
  49 #include "MagickCore/colorspace-private.h"
  50 #include "MagickCore/constitute.h"
  51 #include "MagickCore/exception.h"
  52 #include "MagickCore/exception-private.h"
  53 #include "MagickCore/image.h"
  54 #include "MagickCore/image-private.h"
  55 #include "MagickCore/list.h"
  56 #include "MagickCore/magick.h"
  57 #include "MagickCore/memory_.h"
  58 #include "MagickCore/module.h"
  59 #include "MagickCore/monitor.h"
  60 #include "MagickCore/monitor-private.h"
  61 #include "MagickCore/pixel-accessor.h"
  62 #include "MagickCore/property.h"
  63 #include "MagickCore/quantum-private.h"
  64 #include "MagickCore/static.h"
  65 #include "MagickCore/statistic.h"
  66 #include "MagickCore/string_.h"
  67 #include "MagickCore/string-private.h"
  68 #include "MagickCore/module.h"
  69 \f
  70 /*
  71   Forward declarations.
  72 */
  73 #define FITSBlocksize  2880UL
  74 \f
  75 /*
  76   Forward declarations.
  77 */
  78 static MagickBooleanType
  79   WriteFITSImage(const ImageInfo *,Image *,ExceptionInfo *);
  80 \f
  81 /*
  82 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  83 %                                                                             %
  84 %                                                                             %
  85 %                                                                             %
  86 %   I s F I T S                                                               %
  87 %                                                                             %
  88 %                                                                             %
  89 %                                                                             %
  90 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  91 %
  92 %  IsFITS() returns MagickTrue if the image format type, identified by the
  93 %  magick string, is FITS.
  94 %
  95 %  The format of the IsFITS method is:
  96 %
  97 %      MagickBooleanType IsFITS(const unsigned char *magick,const size_t length)
  98 %
  99 %  A description of each parameter follows:
 100 %
 101 %    o magick: compare image format pattern against these bytes.
 102 %
 103 %    o length: Specifies the length of the magick string.
 104 %
 105 */
 106 static MagickBooleanType IsFITS(const unsigned char *magick,const size_t length)
 107 {
 108   if (length < 6)
 109     return(MagickFalse);
 110   if (LocaleNCompare((const char *) magick,"IT0",3) == 0)
 111     return(MagickTrue);
 112   if (LocaleNCompare((const char *) magick,"SIMPLE",6) == 0)
 113     return(MagickTrue);
 114   return(MagickFalse);
 115 }
 116 \f
 117 /*
 118 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 119 %                                                                             %
 120 %                                                                             %
 121 %                                                                             %
 122 %   R e a d F I T S I m a g e                                                 %
 123 %                                                                             %
 124 %                                                                             %
 125 %                                                                             %
 126 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 127 %
 128 %  ReadFITSImage() reads a FITS image file and returns it.  It allocates the
 129 %  memory necessary for the new Image structure and returns a pointer to the
 130 %  new image.
 131 %
 132 %  The format of the ReadFITSImage method is:
 133 %
 134 %      Image *ReadFITSImage(const ImageInfo *image_info,
 135 %        ExceptionInfo *exception)
 136 %
 137 %  A description of each parameter follows:
 138 %
 139 %    o image_info: the image info.
 140 %
 141 %    o exception: return any errors or warnings in this structure.
 142 %
 143 */
 144
 145 static inline double GetFITSPixel(Image *image,int bits_per_pixel)
 146 {
 147   switch (image->depth >> 3)
 148   {
 149     case 1:
 150       return((double) ReadBlobByte(image));
 151     case 2:
 152       return((double) ((short) ReadBlobShort(image)));
 153     case 4:
 154     {
 155       if (bits_per_pixel > 0)
 156         return((double) ((int) ReadBlobLong(image)));
 157       return((double) ReadBlobFloat(image));
 158     }
 159     case 8:
 160     {
 161       if (bits_per_pixel > 0)
 162         return((double) ((MagickOffsetType) ReadBlobLongLong(image)));
 163     }
 164     default:
 165       break;
 166   }
 167   return(ReadBlobDouble(image));
 168 }
 169
 170 static MagickOffsetType GetFITSPixelExtrema(Image *image,
 171   const int bits_per_pixel,double *minima,double *maxima)
 172 {
 173   double
 174     pixel;
 175
 176   MagickOffsetType
 177     offset;
 178
 179   MagickSizeType
 180     number_pixels;
 181
 182   register MagickOffsetType
 183     i;
 184
 185   offset=TellBlob(image);
 186   if (offset == -1)
 187     return(-1);
 188   number_pixels=(MagickSizeType) image->columns*image->rows;
 189   *minima=GetFITSPixel(image,bits_per_pixel);
 190   *maxima=(*minima);
 191   for (i=1; i < (MagickOffsetType) number_pixels; i++)
 192   {
 193     pixel=GetFITSPixel(image,bits_per_pixel);
 194     if (pixel < *minima)
 195       *minima=pixel;
 196     if (pixel > *maxima)
 197       *maxima=pixel;
 198   }
 199   return(SeekBlob(image,offset,SEEK_SET));
 200 }
 201
 202 static inline double GetFITSPixelRange(const size_t depth)
 203 {
 204   return((double) ((MagickOffsetType) GetQuantumRange(depth)));
 205 }
 206
 207 static void SetFITSUnsignedPixels(const size_t length,
 208   const size_t bits_per_pixel,const EndianType endian,unsigned char *pixels)
 209 {
 210   register ssize_t
 211     i;
 212
 213   if (endian != MSBEndian)
 214     pixels+=(bits_per_pixel >> 3)-1;
 215   for (i=0; i < (ssize_t) length; i++)
 216   {
 217     *pixels^=0x80;
 218     pixels+=bits_per_pixel >> 3;
 219   }
 220 }
 221
 222 static Image *ReadFITSImage(const ImageInfo *image_info,
 223   ExceptionInfo *exception)
 224 {
 225   typedef struct _FITSInfo
 226   {
 227     MagickBooleanType
 228       extend,
 229       simple;
 230
 231     int
 232       bits_per_pixel,
 233       columns,
 234       rows,
 235       number_axes,
 236       number_planes;
 237
 238     double
 239       min_data,
 240       max_data,
 241       zero,
 242       scale;
 243
 244     EndianType
 245       endian;
 246   } FITSInfo;
 247
 248   char
 249     *comment,
 250     keyword[9],
 251     property[MagickPathExtent],
 252     value[73];
 253
 254   double
 255     pixel,
 256     scale;
 257
 258   FITSInfo
 259     fits_info;
 260
 261   Image
 262     *image;
 263
 264   int
 265     c;
 266
 267   MagickBooleanType
 268     status;
 269
 270   MagickSizeType
 271     number_pixels;
 272
 273   register ssize_t
 274     i,
 275     x;
 276
 277   register Quantum
 278     *q;
 279
 280   ssize_t
 281     count,
 282     scene,
 283     y;
 284
 285   /*
 286     Open image file.
 287   */
 288   assert(image_info != (const ImageInfo *) NULL);
 289   assert(image_info->signature == MagickSignature);
 290   if (image_info->debug != MagickFalse)
 291     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
 292       image_info->filename);
 293   assert(exception != (ExceptionInfo *) NULL);
 294   assert(exception->signature == MagickSignature);
 295   image=AcquireImage(image_info,exception);
 296   status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
 297   if (status == MagickFalse)
 298     {
 299       image=DestroyImageList(image);
 300       return((Image *) NULL);
 301     }
 302   /*
 303     Initialize image header.
 304   */
 305   (void) ResetMagickMemory(&fits_info,0,sizeof(fits_info));
 306   fits_info.extend=MagickFalse;
 307   fits_info.simple=MagickFalse;
 308   fits_info.bits_per_pixel=8;
 309   fits_info.columns=1;
 310   fits_info.rows=1;
 311   fits_info.rows=1;
 312   fits_info.number_planes=1;
 313   fits_info.min_data=0.0;
 314   fits_info.max_data=0.0;
 315   fits_info.zero=0.0;
 316   fits_info.scale=1.0;
 317   fits_info.endian=MSBEndian;
 318   /*
 319     Decode image header.
 320   */
 321   for (comment=(char *) NULL; EOFBlob(image) == MagickFalse; )
 322   {
 323     for ( ; EOFBlob(image) == MagickFalse; )
 324     {
 325       register char
 326         *p;
 327
 328       count=ReadBlob(image,8,(unsigned char *) keyword);
 329       if (count != 8)
 330         break;
 331       for (i=0; i < 8; i++)
 332       {
 333         if (isspace((int) ((unsigned char) keyword[i])) != 0)
 334           break;
 335         keyword[i]=tolower((int) ((unsigned char) keyword[i]));
 336       }
 337       keyword[i]='\0';
 338       count=ReadBlob(image,72,(unsigned char *) value);
 339       value[72]='\0';
 340       if (count != 72)
 341         break;
 342       p=value;
 343       if (*p == '=')
 344         {
 345           p+=2;
 346           while (isspace((int) ((unsigned char) *p)) != 0)
 347             p++;
 348         }
 349       if (LocaleCompare(keyword,"end") == 0)
 350         break;
 351       if (LocaleCompare(keyword,"extend") == 0)
 352         fits_info.extend=(*p == 'T') || (*p == 't') ? MagickTrue : MagickFalse;
 353       if (LocaleCompare(keyword,"simple") == 0)
 354         fits_info.simple=(*p == 'T') || (*p == 't') ? MagickTrue : MagickFalse;
 355       if (LocaleCompare(keyword,"bitpix") == 0)
 356         fits_info.bits_per_pixel=StringToLong(p);
 357       if (LocaleCompare(keyword,"naxis") == 0)
 358         fits_info.number_axes=StringToLong(p);
 359       if (LocaleCompare(keyword,"naxis1") == 0)
 360         fits_info.columns=StringToLong(p);
 361       if (LocaleCompare(keyword,"naxis2") == 0)
 362         fits_info.rows=StringToLong(p);
 363       if (LocaleCompare(keyword,"naxis3") == 0)
 364         fits_info.number_planes=StringToLong(p);
 365       if (LocaleCompare(keyword,"datamax") == 0)
 366         fits_info.max_data=StringToDouble(p,(char **) NULL);
 367       if (LocaleCompare(keyword,"datamin") == 0)
 368         fits_info.min_data=StringToDouble(p,(char **) NULL);
 369       if (LocaleCompare(keyword,"bzero") == 0)
 370         fits_info.zero=StringToDouble(p,(char **) NULL);
 371       if (LocaleCompare(keyword,"bscale") == 0)
 372         fits_info.scale=StringToDouble(p,(char **) NULL);
 373       if (LocaleCompare(keyword,"comment") == 0)
 374         {
 375           if (comment == (char *) NULL)
 376             comment=ConstantString(p);
 377           else
 378             (void) ConcatenateString(&comment,p);
 379         }
 380       if (LocaleCompare(keyword,"xendian") == 0)
 381         {
 382           if (LocaleNCompare(p,"big",3) == 0)
 383             fits_info.endian=MSBEndian;
 384           else
 385             fits_info.endian=LSBEndian;
 386         }
 387       (void) FormatLocaleString(property,MagickPathExtent,"fits:%s",keyword);
 388       (void) SetImageProperty(image,property,p,exception);
 389     }
 390     c=0;
 391     while (((TellBlob(image) % FITSBlocksize) != 0) && (c != EOF))
 392       c=ReadBlobByte(image);
 393     if (fits_info.extend == MagickFalse)
 394       break;
 395     if ((fits_info.bits_per_pixel != 8) && (fits_info.bits_per_pixel != 16) &&
 396         (fits_info.bits_per_pixel != 32) && (fits_info.bits_per_pixel != 64) &&
 397         (fits_info.bits_per_pixel != -32) && (fits_info.bits_per_pixel != -64))
 398       ThrowReaderException(CorruptImageError,"ImproperImageHeader");
 399     number_pixels=(MagickSizeType) fits_info.columns*fits_info.rows;
 400     if ((fits_info.simple != MagickFalse) && (fits_info.number_axes >= 1) &&
 401         (fits_info.number_axes <= 4) && (number_pixels != 0))
 402       break;
 403   }
 404   /*
 405     Verify that required image information is defined.
 406   */
 407   if (comment != (char *) NULL)
 408     {
 409       (void) SetImageProperty(image,"comment",comment,exception);
 410       comment=DestroyString(comment);
 411     }
 412   if (EOFBlob(image) != MagickFalse)
 413     ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
 414       image->filename);
 415   number_pixels=(MagickSizeType) fits_info.columns*fits_info.rows;
 416   if ((fits_info.simple == MagickFalse) || (fits_info.number_axes < 1) ||
 417       (fits_info.number_axes > 4) || (number_pixels == 0))
 418     ThrowReaderException(CorruptImageError,"ImageTypeNotSupported");
 419   for (scene=0; scene < (ssize_t) fits_info.number_planes; scene++)
 420   {
 421     image->columns=(size_t) fits_info.columns;
 422     image->rows=(size_t) fits_info.rows;
 423     image->depth=(size_t) (fits_info.bits_per_pixel < 0 ? -1 : 1)*
 424       fits_info.bits_per_pixel;
 425     image->endian=fits_info.endian;
 426     image->scene=(size_t) scene;
 427     if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))
 428       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
 429         break;
 430     status=SetImageExtent(image,image->columns,image->rows,exception);
 431     if (status == MagickFalse)
 432       return(DestroyImageList(image));
 433     /*
 434       Initialize image structure.
 435     */
 436     (void) SetImageColorspace(image,GRAYColorspace,exception);
 437     if ((fits_info.min_data == 0.0) && (fits_info.max_data == 0.0))
 438       {
 439         if (fits_info.zero == 0.0)
 440           (void) GetFITSPixelExtrema(image,fits_info.bits_per_pixel,
 441             &fits_info.min_data,&fits_info.max_data);
 442         else
 443           fits_info.max_data=GetFITSPixelRange((size_t)
 444             fits_info.bits_per_pixel);
 445       }
 446     else
 447       fits_info.max_data=GetFITSPixelRange((size_t) fits_info.bits_per_pixel);
 448     /*
 449       Convert FITS pixels to pixel packets.
 450     */
 451     scale=QuantumRange/(fits_info.max_data-fits_info.min_data);
 452     for (y=(ssize_t) image->rows-1; y >= 0; y--)
 453     {
 454       q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
 455       if (q == (Quantum *) NULL)
 456         break;
 457       for (x=0; x < (ssize_t) image->columns; x++)
 458       {
 459         pixel=GetFITSPixel(image,fits_info.bits_per_pixel);
 460         if ((image->depth == 16) || (image->depth == 32) ||
 461             (image->depth == 64))
 462           SetFITSUnsignedPixels(1,image->depth,image->endian,
 463             (unsigned char *) &pixel);
 464         SetPixelGray(image,ClampToQuantum(scale*(fits_info.scale*(pixel-
 465           fits_info.min_data)+fits_info.zero)),q);
 466         q+=GetPixelChannels(image);
 467       }
 468       if (SyncAuthenticPixels(image,exception) == MagickFalse)
 469         break;
 470       if (image->previous == (Image *) NULL)
 471         {
 472           status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
 473             image->rows);
 474           if (status == MagickFalse)
 475             break;
 476         }
 477     }
 478     if (EOFBlob(image) != MagickFalse)
 479       {
 480         ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
 481           image->filename);
 482         break;
 483       }
 484     /*
 485       Proceed to next image.
 486     */
 487     if (image_info->number_scenes != 0)
 488       if (image->scene >= (image_info->scene+image_info->number_scenes-1))
 489         break;
 490     if (scene < (ssize_t) (fits_info.number_planes-1))
 491       {
 492         /*
 493           Allocate next image structure.
 494         */
 495         AcquireNextImage(image_info,image,exception);
 496         if (GetNextImageInList(image) == (Image *) NULL)
 497           {
 498             image=DestroyImageList(image);
 499             return((Image *) NULL);
 500           }
 501         image=SyncNextImageInList(image);
 502         status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
 503           GetBlobSize(image));
 504         if (status == MagickFalse)
 505           break;
 506       }
 507   }
 508   (void) CloseBlob(image);
 509   return(GetFirstImageInList(image));
 510 }
 511 \f
 512 /*
 513 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 514 %                                                                             %
 515 %                                                                             %
 516 %                                                                             %
 517 %   R e g i s t e r F I T S I m a g e                                         %
 518 %                                                                             %
 519 %                                                                             %
 520 %                                                                             %
 521 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 522 %
 523 %  RegisterFITSImage() adds attributes for the FITS image format to
 524 %  the list of supported formats.  The attributes include the image format
 525 %  tag, a method to read and/or write the format, whether the format
 526 %  supports the saving of more than one frame to the same file or blob,
 527 %  whether the format supports native in-memory I/O, and a brief
 528 %  description of the format.
 529 %
 530 %  The format of the RegisterFITSImage method is:
 531 %
 532 %      size_t RegisterFITSImage(void)
 533 %
 534 */
 535 ModuleExport size_t RegisterFITSImage(void)
 536 {
 537   MagickInfo
 538     *entry;
 539
 540   entry=AcquireMagickInfo("FITS","FITS","Flexible Image Transport System");
 541   entry->decoder=(DecodeImageHandler *) ReadFITSImage;
 542   entry->encoder=(EncodeImageHandler *) WriteFITSImage;
 543   entry->magick=(IsImageFormatHandler *) IsFITS;
 544   entry->flags^=CoderAdjoinFlag;
 545   entry->flags|=CoderSeekableStreamFlag;
 546   (void) RegisterMagickInfo(entry);
 547   entry=AcquireMagickInfo("FITS","FTS","Flexible Image Transport System");
 548   entry->decoder=(DecodeImageHandler *) ReadFITSImage;
 549   entry->encoder=(EncodeImageHandler *) WriteFITSImage;
 550   entry->magick=(IsImageFormatHandler *) IsFITS;
 551   entry->flags^=CoderAdjoinFlag;
 552   entry->flags|=CoderSeekableStreamFlag;
 553   (void) RegisterMagickInfo(entry);
 554   return(MagickImageCoderSignature);
 555 }
 556 \f
 557 /*
 558 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 559 %                                                                             %
 560 %                                                                             %
 561 %                                                                             %
 562 %   U n r e g i s t e r F I T S I m a g e                                     %
 563 %                                                                             %
 564 %                                                                             %
 565 %                                                                             %
 566 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 567 %
 568 %  UnregisterFITSImage() removes format registrations made by the
 569 %  FITS module from the list of supported formats.
 570 %
 571 %  The format of the UnregisterFITSImage method is:
 572 %
 573 %      UnregisterFITSImage(void)
 574 %
 575 */
 576 ModuleExport void UnregisterFITSImage(void)
 577 {
 578   (void) UnregisterMagickInfo("FITS");
 579   (void) UnregisterMagickInfo("FTS");
 580 }
 581 \f
 582 /*
 583 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 584 %                                                                             %
 585 %                                                                             %
 586 %                                                                             %
 587 %   W r i t e F I T S I m a g e                                               %
 588 %                                                                             %
 589 %                                                                             %
 590 %                                                                             %
 591 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 592 %
 593 %  WriteFITSImage() writes a Flexible Image Transport System image to a
 594 %  file as gray scale intensities [0..255].
 595 %
 596 %  The format of the WriteFITSImage method is:
 597 %
 598 %      MagickBooleanType WriteFITSImage(const ImageInfo *image_info,
 599 %        Image *image,ExceptionInfo *exception)
 600 %
 601 %  A description of each parameter follows.
 602 %
 603 %    o image_info: the image info.
 604 %
 605 %    o image:  The image.
 606 %
 607 %    o exception: return any errors or warnings in this structure.
 608 %
 609 */
 610 static MagickBooleanType WriteFITSImage(const ImageInfo *image_info,
 611   Image *image,ExceptionInfo *exception)
 612 {
 613   char
 614     header[FITSBlocksize],
 615     *fits_info;
 616
 617   MagickBooleanType
 618     status;
 619
 620   QuantumInfo
 621     *quantum_info;
 622
 623   register const Quantum
 624     *p;
 625
 626   size_t
 627     length;
 628
 629   ssize_t
 630     count,
 631     offset,
 632     y;
 633
 634   unsigned char
 635     *pixels;
 636
 637   /*
 638     Open output image file.
 639   */
 640   assert(image_info != (const ImageInfo *) NULL);
 641   assert(image_info->signature == MagickSignature);
 642   assert(image != (Image *) NULL);
 643   assert(image->signature == MagickSignature);
 644   if (image->debug != MagickFalse)
 645     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 646   assert(exception != (ExceptionInfo *) NULL);
 647   assert(exception->signature == MagickSignature);
 648   status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
 649   if (status == MagickFalse)
 650     return(status);
 651   (void) TransformImageColorspace(image,sRGBColorspace,exception);
 652   /*
 653     Allocate image memory.
 654   */
 655   fits_info=(char *) AcquireQuantumMemory(FITSBlocksize,sizeof(*fits_info));
 656   if (fits_info == (char *) NULL)
 657     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
 658   (void) ResetMagickMemory(fits_info,' ',FITSBlocksize*sizeof(*fits_info));
 659   /*
 660     Initialize image header.
 661   */
 662   image->depth=GetImageQuantumDepth(image,MagickFalse);
 663   image->endian=MSBEndian;
 664   quantum_info=AcquireQuantumInfo(image_info,image);
 665   if (quantum_info == (QuantumInfo *) NULL)
 666     ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
 667   offset=0;
 668   (void) FormatLocaleString(header,FITSBlocksize,
 669     "SIMPLE  =                    T");
 670   (void) strncpy(fits_info+offset,header,strlen(header));
 671   offset+=80;
 672   (void) FormatLocaleString(header,FITSBlocksize,"BITPIX  =           %10ld",
 673     (long) ((quantum_info->format == FloatingPointQuantumFormat ? -1 : 1)*
 674     image->depth));
 675   (void) strncpy(fits_info+offset,header,strlen(header));
 676   offset+=80;
 677   (void) FormatLocaleString(header,FITSBlocksize,"NAXIS   =           %10lu",
 678     SetImageGray(image,exception) != MagickFalse ? 2UL : 3UL);
 679   (void) strncpy(fits_info+offset,header,strlen(header));
 680   offset+=80;
 681   (void) FormatLocaleString(header,FITSBlocksize,"NAXIS1  =           %10lu",
 682     (unsigned long) image->columns);
 683   (void) strncpy(fits_info+offset,header,strlen(header));
 684   offset+=80;
 685   (void) FormatLocaleString(header,FITSBlocksize,"NAXIS2  =           %10lu",
 686     (unsigned long) image->rows);
 687   (void) strncpy(fits_info+offset,header,strlen(header));
 688   offset+=80;
 689   if (SetImageGray(image,exception) == MagickFalse)
 690     {
 691       (void) FormatLocaleString(header,FITSBlocksize,
 692         "NAXIS3  =           %10lu",3UL);
 693       (void) strncpy(fits_info+offset,header,strlen(header));
 694       offset+=80;
 695     }
 696   (void) FormatLocaleString(header,FITSBlocksize,"BSCALE  =         %E",1.0);
 697   (void) strncpy(fits_info+offset,header,strlen(header));
 698   offset+=80;
 699   (void) FormatLocaleString(header,FITSBlocksize,"BZERO   =         %E",
 700     image->depth > 8 ? GetFITSPixelRange(image->depth)/2.0 : 0.0);
 701   (void) strncpy(fits_info+offset,header,strlen(header));
 702   offset+=80;
 703   (void) FormatLocaleString(header,FITSBlocksize,"DATAMAX =         %E",
 704     1.0*((MagickOffsetType) GetQuantumRange(image->depth)));
 705   (void) strncpy(fits_info+offset,header,strlen(header));
 706   offset+=80;
 707   (void) FormatLocaleString(header,FITSBlocksize,"DATAMIN =         %E",0.0);
 708   (void) strncpy(fits_info+offset,header,strlen(header));
 709   offset+=80;
 710   if (image->endian == LSBEndian)
 711     {
 712       (void) FormatLocaleString(header,FITSBlocksize,"XENDIAN = 'SMALL'");
 713       (void) strncpy(fits_info+offset,header,strlen(header));
 714       offset+=80;
 715     }
 716   (void) FormatLocaleString(header,FITSBlocksize,"HISTORY %.72s",
 717     GetMagickVersion((size_t *) NULL));
 718   (void) strncpy(fits_info+offset,header,strlen(header));
 719   offset+=80;
 720   (void) strncpy(header,"END",FITSBlocksize);
 721   (void) strncpy(fits_info+offset,header,strlen(header));
 722   offset+=80;
 723   (void) WriteBlob(image,FITSBlocksize,(unsigned char *) fits_info);
 724   /*
 725     Convert image to fits scale PseudoColor class.
 726   */
 727   pixels=(unsigned char *) GetQuantumPixels(quantum_info);
 728   if (SetImageGray(image,exception) != MagickFalse)
 729     {
 730       length=GetQuantumExtent(image,quantum_info,GrayQuantum);
 731       for (y=(ssize_t) image->rows-1; y >= 0; y--)
 732       {
 733         p=GetVirtualPixels(image,0,y,image->columns,1,exception);
 734         if (p == (const Quantum *) NULL)
 735           break;
 736         length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
 737           GrayQuantum,pixels,exception);
 738         if (image->depth == 16)
 739           SetFITSUnsignedPixels(image->columns,image->depth,image->endian,
 740             pixels);
 741         if (((image->depth == 32) || (image->depth == 64)) &&
 742             (quantum_info->format != FloatingPointQuantumFormat))
 743           SetFITSUnsignedPixels(image->columns,image->depth,image->endian,
 744             pixels);
 745         count=WriteBlob(image,length,pixels);
 746         if (count != (ssize_t) length)
 747           break;
 748         status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
 749           image->rows);
 750         if (status == MagickFalse)
 751           break;
 752       }
 753     }
 754   else
 755     {
 756       length=GetQuantumExtent(image,quantum_info,RedQuantum);
 757       for (y=(ssize_t) image->rows-1; y >= 0; y--)
 758       {
 759         p=GetVirtualPixels(image,0,y,image->columns,1,exception);
 760         if (p == (const Quantum *) NULL)
 761           break;
 762         length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
 763           RedQuantum,pixels,exception);
 764         if (image->depth == 16)
 765           SetFITSUnsignedPixels(image->columns,image->depth,image->endian,
 766             pixels);
 767         if (((image->depth == 32) || (image->depth == 64)) &&
 768             (quantum_info->format != FloatingPointQuantumFormat))
 769           SetFITSUnsignedPixels(image->columns,image->depth,image->endian,
 770             pixels);
 771         count=WriteBlob(image,length,pixels);
 772         if (count != (ssize_t) length)
 773           break;
 774         status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
 775           image->rows);
 776         if (status == MagickFalse)
 777           break;
 778       }
 779       length=GetQuantumExtent(image,quantum_info,GreenQuantum);
 780       for (y=(ssize_t) image->rows-1; y >= 0; y--)
 781       {
 782         p=GetVirtualPixels(image,0,y,image->columns,1,exception);
 783         if (p == (const Quantum *) NULL)
 784           break;
 785         length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
 786           GreenQuantum,pixels,exception);
 787         if (image->depth == 16)
 788           SetFITSUnsignedPixels(image->columns,image->depth,image->endian,
 789             pixels);
 790         if (((image->depth == 32) || (image->depth == 64)) &&
 791             (quantum_info->format != FloatingPointQuantumFormat))
 792           SetFITSUnsignedPixels(image->columns,image->depth,image->endian,
 793             pixels);
 794         count=WriteBlob(image,length,pixels);
 795         if (count != (ssize_t) length)
 796           break;
 797         status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
 798           image->rows);
 799         if (status == MagickFalse)
 800           break;
 801       }
 802       length=GetQuantumExtent(image,quantum_info,BlueQuantum);
 803       for (y=(ssize_t) image->rows-1; y >= 0; y--)
 804       {
 805         p=GetVirtualPixels(image,0,y,image->columns,1,exception);
 806         if (p == (const Quantum *) NULL)
 807           break;
 808         length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
 809           BlueQuantum,pixels,exception);
 810         if (image->depth == 16)
 811           SetFITSUnsignedPixels(image->columns,image->depth,image->endian,
 812             pixels);
 813         if (((image->depth == 32) || (image->depth == 64)) &&
 814             (quantum_info->format != FloatingPointQuantumFormat))
 815           SetFITSUnsignedPixels(image->columns,image->depth,image->endian,
 816             pixels);
 817         count=WriteBlob(image,length,pixels);
 818         if (count != (ssize_t) length)
 819           break;
 820         status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
 821           image->rows);
 822         if (status == MagickFalse)
 823           break;
 824       }
 825     }
 826   quantum_info=DestroyQuantumInfo(quantum_info);
 827   length=(size_t) (FITSBlocksize-TellBlob(image) % FITSBlocksize);
 828   if (length != 0)
 829     {
 830       (void) ResetMagickMemory(fits_info,0,length*sizeof(*fits_info));
 831       (void) WriteBlob(image,length,(unsigned char *) fits_info);
 832     }
 833   fits_info=DestroyString(fits_info);
 834   (void) CloseBlob(image);
 835   return(MagickTrue);
 836 }