Context Navigation

source: ImageMagick/trunk/coders/fits.c @ 8316

Revision 8316, 28.2 KB checked in by cristy, 12 months ago (diff)

Line
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	% John Cristy %
17	% July 1992 %
18	% %
19	% %
20	% Copyright 1999-2012 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
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
70	/*
71	Forward declarations.
72	*/
73	#define FITSBlocksize 2880UL
74
75	/*
76	Forward declarations.
77	*/
78	static MagickBooleanType
79	WriteFITSImage(const ImageInfo ,Image ,ExceptionInfo *);
80
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
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 void GetFITSPixelExtrema(Image *image,const int bits_per_pixel,
171	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	number_pixels=(MagickSizeType) image->columns*image->rows;
187	*minima=GetFITSPixel(image,bits_per_pixel);
188	maxima=(minima);
189	for (i=1; i < (MagickOffsetType) number_pixels; i++)
190	{
191	pixel=GetFITSPixel(image,bits_per_pixel);
192	if (pixel < *minima)
193	*minima=pixel;
194	if (pixel > *maxima)
195	*maxima=pixel;
196	}
197	(void) SeekBlob(image,offset,SEEK_SET);
198	}
199
200	static inline double GetFITSPixelRange(const size_t depth)
201	{
202	return((double) ((MagickOffsetType) GetQuantumRange(depth)));
203	}
204
205	static void SetFITSUnsignedPixels(const size_t length,
206	const size_t bits_per_pixel,unsigned char *pixels)
207	{
208	register ssize_t
209	i;
210
211	for (i=0; i < (ssize_t) length; i++)
212	{
213	*pixels^=0x80;
214	pixels+=bits_per_pixel >> 3;
215	}
216	}
217
218	static Image ReadFITSImage(const ImageInfo image_info,
219	ExceptionInfo *exception)
220	{
221	typedef struct _FITSInfo
222	{
223	MagickBooleanType
224	extend,
225	simple;
226
227	int
228	bits_per_pixel,
229	columns,
230	rows,
231	number_axes,
232	number_planes;
233
234	double
235	min_data,
236	max_data,
237	zero,
238	scale;
239
240	EndianType
241	endian;
242	} FITSInfo;
243
244	char
245	*comment,
246	keyword[9],
247	property[MaxTextExtent],
248	value[73];
249
250	double
251	pixel,
252	scale;
253
254	FITSInfo
255	fits_info;
256
257	Image
258	*image;
259
260	int
261	c;
262
263	MagickBooleanType
264	status;
265
266	MagickSizeType
267	number_pixels;
268
269	register ssize_t
270	i,
271	x;
272
273	register Quantum
274	*q;
275
276	ssize_t
277	count,
278	scene,
279	y;
280
281	/*
282	Open image file.
283	*/
284	assert(image_info != (const ImageInfo *) NULL);
285	assert(image_info->signature == MagickSignature);
286	if (image_info->debug != MagickFalse)
287	(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
288	image_info->filename);
289	assert(exception != (ExceptionInfo *) NULL);
290	assert(exception->signature == MagickSignature);
291	image=AcquireImage(image_info,exception);
292	status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
293	if (status == MagickFalse)
294	{
295	image=DestroyImageList(image);
296	return((Image *) NULL);
297	}
298	/*
299	Initialize image header.
300	*/
301	(void) ResetMagickMemory(&fits_info,0,sizeof(fits_info));
302	fits_info.extend=MagickFalse;
303	fits_info.simple=MagickFalse;
304	fits_info.bits_per_pixel=8;
305	fits_info.columns=1;
306	fits_info.rows=1;
307	fits_info.rows=1;
308	fits_info.number_planes=1;
309	fits_info.min_data=0.0;
310	fits_info.max_data=0.0;
311	fits_info.zero=0.0;
312	fits_info.scale=1.0;
313	fits_info.endian=MSBEndian;
314	/*
315	Decode image header.
316	*/
317	for (comment=(char *) NULL; EOFBlob(image) == MagickFalse; )
318	{
319	for ( ; EOFBlob(image) == MagickFalse; )
320	{
321	register char
322	*p;
323
324	count=ReadBlob(image,8,(unsigned char *) keyword);
325	if (count != 8)
326	break;
327	for (i=0; i < 8; i++)
328	{
329	if (isspace((int) ((unsigned char) keyword[i])) != 0)
330	break;
331	keyword[i]=tolower((int) ((unsigned char) keyword[i]));
332	}
333	keyword[i]='\0';
334	count=ReadBlob(image,72,(unsigned char *) value);
335	if (count != 72)
336	break;
337	value[72]='\0';
338	p=value;
339	if (*p == '=')
340	{
341	p+=2;
342	while (isspace((int) ((unsigned char) *p)) != 0)
343	p++;
344	}
345	if (LocaleCompare(keyword,"end") == 0)
346	break;
347	if (LocaleCompare(keyword,"extend") == 0)
348	fits_info.extend=(p == 'T') \|\| (p == 't') ? MagickTrue : MagickFalse;
349	if (LocaleCompare(keyword,"simple") == 0)
350	fits_info.simple=(p == 'T') \|\| (p == 't') ? MagickTrue : MagickFalse;
351	if (LocaleCompare(keyword,"bitpix") == 0)
352	fits_info.bits_per_pixel=StringToLong(p);
353	if (LocaleCompare(keyword,"naxis") == 0)
354	fits_info.number_axes=StringToLong(p);
355	if (LocaleCompare(keyword,"naxis1") == 0)
356	fits_info.columns=StringToLong(p);
357	if (LocaleCompare(keyword,"naxis2") == 0)
358	fits_info.rows=StringToLong(p);
359	if (LocaleCompare(keyword,"naxis3") == 0)
360	fits_info.number_planes=StringToLong(p);
361	if (LocaleCompare(keyword,"datamax") == 0)
362	fits_info.max_data=StringToDouble(p,(char **) NULL);
363	if (LocaleCompare(keyword,"datamin") == 0)
364	fits_info.min_data=StringToDouble(p,(char **) NULL);
365	if (LocaleCompare(keyword,"bzero") == 0)
366	fits_info.zero=StringToDouble(p,(char **) NULL);
367	if (LocaleCompare(keyword,"bscale") == 0)
368	fits_info.scale=StringToDouble(p,(char **) NULL);
369	if (LocaleCompare(keyword,"comment") == 0)
370	{
371	if (comment == (char *) NULL)
372	comment=ConstantString(p);
373	else
374	(void) ConcatenateString(&comment,p);
375	}
376	if (LocaleCompare(keyword,"xendian") == 0)
377	{
378	if (LocaleNCompare(p,"big",3) == 0)
379	fits_info.endian=MSBEndian;
380	else
381	fits_info.endian=LSBEndian;
382	}
383	(void) FormatLocaleString(property,MaxTextExtent,"fits:%s",keyword);
384	(void) SetImageProperty(image,property,p,exception);
385	}
386	c=0;
387	while (((TellBlob(image) % FITSBlocksize) != 0) && (c != EOF))
388	c=ReadBlobByte(image);
389	if (fits_info.extend == MagickFalse)
390	break;
391	number_pixels=(MagickSizeType) fits_info.columns*fits_info.rows;
392	if ((fits_info.simple != MagickFalse) && (fits_info.number_axes >= 1) &&
393	(fits_info.number_axes <= 4) && (number_pixels != 0))
394	break;
395	}
396	/*
397	Verify that required image information is defined.
398	*/
399	if (comment != (char *) NULL)
400	{
401	(void) SetImageProperty(image,"comment",comment,exception);
402	comment=DestroyString(comment);
403	}
404	if (EOFBlob(image) != MagickFalse)
405	ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
406	image->filename);
407	number_pixels=(MagickSizeType) fits_info.columns*fits_info.rows;
408	if ((fits_info.simple == MagickFalse) \|\| (fits_info.number_axes < 1) \|\|
409	(fits_info.number_axes > 4) \|\| (number_pixels == 0))
410	ThrowReaderException(CorruptImageError,"ImageTypeNotSupported");
411	for (scene=0; scene < (ssize_t) fits_info.number_planes; scene++)
412	{
413	image->columns=(size_t) fits_info.columns;
414	image->rows=(size_t) fits_info.rows;
415	image->depth=(size_t) (fits_info.bits_per_pixel < 0 ? -1 : 1)*
416	fits_info.bits_per_pixel;
417	image->endian=fits_info.endian;
418	image->scene=(size_t) scene;
419	if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0))
420	if (image->scene >= (image_info->scene+image_info->number_scenes-1))
421	break;
422	/*
423	Initialize image structure.
424	*/
425	SetImageColorspace(image,GRAYColorspace,exception);
426	if ((fits_info.min_data != 0.0) \|\| (fits_info.max_data != 0.0))
427	{
428	if ((fits_info.bits_per_pixel != 0) && (fits_info.max_data == 0.0))
429	fits_info.max_data=GetFITSPixelRange((size_t)
430	fits_info.bits_per_pixel);
431	}
432	else
433	GetFITSPixelExtrema(image,fits_info.bits_per_pixel,&fits_info.min_data,
434	&fits_info.max_data);
435	/*
436	Convert FITS pixels to pixel packets.
437	*/
438	scale=(double) QuantumRange/(fits_info.scale*(fits_info.max_data-
439	fits_info.min_data)+fits_info.zero);
440	for (y=(ssize_t) image->rows-1; y >= 0; y--)
441	{
442	q=QueueAuthenticPixels(image,0,y,image->columns,1,exception);
443	if (q == (Quantum *) NULL)
444	break;
445	for (x=0; x < (ssize_t) image->columns; x++)
446	{
447	pixel=GetFITSPixel(image,fits_info.bits_per_pixel);
448	SetPixelGray(image,ClampToQuantum(scale(fits_info.scale(pixel-
449	fits_info.min_data)+fits_info.zero)),q);
450	q+=GetPixelChannels(image);
451	}
452	if (SyncAuthenticPixels(image,exception) == MagickFalse)
453	break;
454	if (image->previous == (Image *) NULL)
455	{
456	status=SetImageProgress(image,LoadImageTag,(MagickOffsetType) y,
457	image->rows);
458	if (status == MagickFalse)
459	break;
460	}
461	}
462	if (EOFBlob(image) != MagickFalse)
463	{
464	ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile",
465	image->filename);
466	break;
467	}
468	/*
469	Proceed to next image.
470	*/
471	if (image_info->number_scenes != 0)
472	if (image->scene >= (image_info->scene+image_info->number_scenes-1))
473	break;
474	if (scene < (ssize_t) (fits_info.number_planes-1))
475	{
476	/*
477	Allocate next image structure.
478	*/
479	AcquireNextImage(image_info,image,exception);
480	if (GetNextImageInList(image) == (Image *) NULL)
481	{
482	image=DestroyImageList(image);
483	return((Image *) NULL);
484	}
485	image=SyncNextImageInList(image);
486	status=SetImageProgress(image,LoadImagesTag,TellBlob(image),
487	GetBlobSize(image));
488	if (status == MagickFalse)
489	break;
490	}
491	}
492	(void) CloseBlob(image);
493	return(GetFirstImageInList(image));
494	}
495
496	/*
497	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
498	% %
499	% %
500	% %
501	% R e g i s t e r F I T S I m a g e %
502	% %
503	% %
504	% %
505	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
506	%
507	% RegisterFITSImage() adds attributes for the FITS image format to
508	% the list of supported formats. The attributes include the image format
509	% tag, a method to read and/or write the format, whether the format
510	% supports the saving of more than one frame to the same file or blob,
511	% whether the format supports native in-memory I/O, and a brief
512	% description of the format.
513	%
514	% The format of the RegisterFITSImage method is:
515	%
516	% size_t RegisterFITSImage(void)
517	%
518	*/
519	ModuleExport size_t RegisterFITSImage(void)
520	{
521	MagickInfo
522	*entry;
523
524	entry=SetMagickInfo("FITS");
525	entry->decoder=(DecodeImageHandler *) ReadFITSImage;
526	entry->encoder=(EncodeImageHandler *) WriteFITSImage;
527	entry->magick=(IsImageFormatHandler *) IsFITS;
528	entry->adjoin=MagickFalse;
529	entry->seekable_stream=MagickTrue;
530	entry->description=ConstantString("Flexible Image Transport System");
531	entry->module=ConstantString("FITS");
532	(void) RegisterMagickInfo(entry);
533	entry=SetMagickInfo("FTS");
534	entry->decoder=(DecodeImageHandler *) ReadFITSImage;
535	entry->encoder=(EncodeImageHandler *) WriteFITSImage;
536	entry->magick=(IsImageFormatHandler *) IsFITS;
537	entry->adjoin=MagickFalse;
538	entry->seekable_stream=MagickTrue;
539	entry->description=ConstantString("Flexible Image Transport System");
540	entry->module=ConstantString("FTS");
541	(void) RegisterMagickInfo(entry);
542	return(MagickImageCoderSignature);
543	}
544
545	/*
546	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
547	% %
548	% %
549	% %
550	% U n r e g i s t e r F I T S I m a g e %
551	% %
552	% %
553	% %
554	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
555	%
556	% UnregisterFITSImage() removes format registrations made by the
557	% FITS module from the list of supported formats.
558	%
559	% The format of the UnregisterFITSImage method is:
560	%
561	% UnregisterFITSImage(void)
562	%
563	*/
564	ModuleExport void UnregisterFITSImage(void)
565	{
566	(void) UnregisterMagickInfo("FITS");
567	(void) UnregisterMagickInfo("FTS");
568	}
569
570	/*
571	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
572	% %
573	% %
574	% %
575	% W r i t e F I T S I m a g e %
576	% %
577	% %
578	% %
579	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
580	%
581	% WriteFITSImage() writes a Flexible Image Transport System image to a
582	% file as gray scale intensities [0..255].
583	%
584	% The format of the WriteFITSImage method is:
585	%
586	% MagickBooleanType WriteFITSImage(const ImageInfo *image_info,
587	% Image image,ExceptionInfo exception)
588	%
589	% A description of each parameter follows.
590	%
591	% o image_info: the image info.
592	%
593	% o image: The image.
594	%
595	% o exception: return any errors or warnings in this structure.
596	%
597	*/
598	static MagickBooleanType WriteFITSImage(const ImageInfo *image_info,
599	Image image,ExceptionInfo exception)
600	{
601	char
602	header[FITSBlocksize],
603	*fits_info;
604
605	MagickBooleanType
606	status;
607
608	QuantumInfo
609	*quantum_info;
610
611	register const Quantum
612	*p;
613
614	size_t
615	length;
616
617	ssize_t
618	count,
619	offset,
620	y;
621
622	unsigned char
623	*pixels;
624
625	/*
626	Open output image file.
627	*/
628	assert(image_info != (const ImageInfo *) NULL);
629	assert(image_info->signature == MagickSignature);
630	assert(image != (Image *) NULL);
631	assert(image->signature == MagickSignature);
632	if (image->debug != MagickFalse)
633	(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
634	assert(exception != (ExceptionInfo *) NULL);
635	assert(exception->signature == MagickSignature);
636	status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
637	if (status == MagickFalse)
638	return(status);
639	if ((IssRGBColorspace(image->colorspace) == MagickFalse) &&
640	(IsImageGray(image,exception) == MagickFalse))
641	(void) TransformImageColorspace(image,sRGBColorspace,exception);
642	/*
643	Allocate image memory.
644	*/
645	fits_info=(char ) AcquireQuantumMemory(FITSBlocksize,sizeof(fits_info));
646	if (fits_info == (char *) NULL)
647	ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
648	(void) ResetMagickMemory(fits_info,' ',FITSBlocksizesizeof(fits_info));
649	/*
650	Initialize image header.
651	*/
652	image->depth=GetImageQuantumDepth(image,MagickFalse);
653	quantum_info=AcquireQuantumInfo((const ImageInfo *) NULL,image);
654	if (quantum_info == (QuantumInfo *) NULL)
655	ThrowWriterException(ResourceLimitError,"MemoryAllocationFailed");
656	offset=0;
657	(void) FormatLocaleString(header,FITSBlocksize,
658	"SIMPLE = T");
659	(void) strncpy(fits_info+offset,header,strlen(header));
660	offset+=80;
661	(void) FormatLocaleString(header,FITSBlocksize,"BITPIX = %10ld",
662	(long) (quantum_info->format == FloatingPointQuantumFormat ? -1 : 1)*
663	image->depth);
664	(void) strncpy(fits_info+offset,header,strlen(header));
665	offset+=80;
666	(void) FormatLocaleString(header,FITSBlocksize,"NAXIS = %10lu",
667	IsImageGray(image,exception) != MagickFalse ? 2UL : 3UL);
668	(void) strncpy(fits_info+offset,header,strlen(header));
669	offset+=80;
670	(void) FormatLocaleString(header,FITSBlocksize,"NAXIS1 = %10lu",
671	(unsigned long) image->columns);
672	(void) strncpy(fits_info+offset,header,strlen(header));
673	offset+=80;
674	(void) FormatLocaleString(header,FITSBlocksize,"NAXIS2 = %10lu",
675	(unsigned long) image->rows);
676	(void) strncpy(fits_info+offset,header,strlen(header));
677	offset+=80;
678	if (IsImageGray(image,exception) == MagickFalse)
679	{
680	(void) FormatLocaleString(header,FITSBlocksize,
681	"NAXIS3 = %10lu",3UL);
682	(void) strncpy(fits_info+offset,header,strlen(header));
683	offset+=80;
684	}
685	(void) FormatLocaleString(header,FITSBlocksize,"BSCALE = %E",1.0);
686	(void) strncpy(fits_info+offset,header,strlen(header));
687	offset+=80;
688	(void) FormatLocaleString(header,FITSBlocksize,"BZERO = %E",
689	image->depth > 8 ? GetFITSPixelRange(image->depth) : 0.0);
690	(void) strncpy(fits_info+offset,header,strlen(header));
691	offset+=80;
692	(void) FormatLocaleString(header,FITSBlocksize,"DATAMAX = %E",
693	1.0*((MagickOffsetType) GetQuantumRange(image->depth)));
694	(void) strncpy(fits_info+offset,header,strlen(header));
695	offset+=80;
696	(void) FormatLocaleString(header,FITSBlocksize,"DATAMIN = %E",0.0);
697	(void) strncpy(fits_info+offset,header,strlen(header));
698	offset+=80;
699	if (image->endian == LSBEndian)
700	{
701	(void) FormatLocaleString(header,FITSBlocksize,"XENDIAN = 'SMALL'");
702	(void) strncpy(fits_info+offset,header,strlen(header));
703	offset+=80;
704	}
705	(void) FormatLocaleString(header,FITSBlocksize,"HISTORY %.72s",
706	GetMagickVersion((size_t *) NULL));
707	(void) strncpy(fits_info+offset,header,strlen(header));
708	offset+=80;
709	(void) strncpy(header,"END",FITSBlocksize);
710	(void) strncpy(fits_info+offset,header,strlen(header));
711	offset+=80;
712	(void) WriteBlob(image,FITSBlocksize,(unsigned char *) fits_info);
713	/*
714	Convert image to fits scale PseudoColor class.
715	*/
716	pixels=GetQuantumPixels(quantum_info);
717	if (IsImageGray(image,exception) != MagickFalse)
718	{
719	length=GetQuantumExtent(image,quantum_info,GrayQuantum);
720	for (y=(ssize_t) image->rows-1; y >= 0; y--)
721	{
722	p=GetVirtualPixels(image,0,y,image->columns,1,exception);
723	if (p == (const Quantum *) NULL)
724	break;
725	length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
726	GrayQuantum,pixels,exception);
727	if (image->depth == 16)
728	SetFITSUnsignedPixels(image->columns,image->depth,pixels);
729	if (((image->depth == 32) \|\| (image->depth == 64)) &&
730	(quantum_info->format != FloatingPointQuantumFormat))
731	SetFITSUnsignedPixels(image->columns,image->depth,pixels);
732	count=WriteBlob(image,length,pixels);
733	if (count != (ssize_t) length)
734	break;
735	status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
736	image->rows);
737	if (status == MagickFalse)
738	break;
739	}
740	}
741	else
742	{
743	length=GetQuantumExtent(image,quantum_info,RedQuantum);
744	for (y=(ssize_t) image->rows-1; y >= 0; y--)
745	{
746	p=GetVirtualPixels(image,0,y,image->columns,1,exception);
747	if (p == (const Quantum *) NULL)
748	break;
749	length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
750	RedQuantum,pixels,exception);
751	if (image->depth == 16)
752	SetFITSUnsignedPixels(image->columns,image->depth,pixels);
753	if (((image->depth == 32) \|\| (image->depth == 64)) &&
754	(quantum_info->format != FloatingPointQuantumFormat))
755	SetFITSUnsignedPixels(image->columns,image->depth,pixels);
756	count=WriteBlob(image,length,pixels);
757	if (count != (ssize_t) length)
758	break;
759	status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
760	image->rows);
761	if (status == MagickFalse)
762	break;
763	}
764	length=GetQuantumExtent(image,quantum_info,GreenQuantum);
765	for (y=(ssize_t) image->rows-1; y >= 0; y--)
766	{
767	p=GetVirtualPixels(image,0,y,image->columns,1,exception);
768	if (p == (const Quantum *) NULL)
769	break;
770	length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
771	GreenQuantum,pixels,exception);
772	if (image->depth == 16)
773	SetFITSUnsignedPixels(image->columns,image->depth,pixels);
774	if (((image->depth == 32) \|\| (image->depth == 64)) &&
775	(quantum_info->format != FloatingPointQuantumFormat))
776	SetFITSUnsignedPixels(image->columns,image->depth,pixels);
777	count=WriteBlob(image,length,pixels);
778	if (count != (ssize_t) length)
779	break;
780	status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
781	image->rows);
782	if (status == MagickFalse)
783	break;
784	}
785	length=GetQuantumExtent(image,quantum_info,BlueQuantum);
786	for (y=(ssize_t) image->rows-1; y >= 0; y--)
787	{
788	p=GetVirtualPixels(image,0,y,image->columns,1,exception);
789	if (p == (const Quantum *) NULL)
790	break;
791	length=ExportQuantumPixels(image,(CacheView *) NULL,quantum_info,
792	BlueQuantum,pixels,exception);
793	if (image->depth == 16)
794	SetFITSUnsignedPixels(image->columns,image->depth,pixels);
795	if (((image->depth == 32) \|\| (image->depth == 64)) &&
796	(quantum_info->format != FloatingPointQuantumFormat))
797	SetFITSUnsignedPixels(image->columns,image->depth,pixels);
798	count=WriteBlob(image,length,pixels);
799	if (count != (ssize_t) length)
800	break;
801	status=SetImageProgress(image,SaveImageTag,(MagickOffsetType) y,
802	image->rows);
803	if (status == MagickFalse)
804	break;
805	}
806	}
807	quantum_info=DestroyQuantumInfo(quantum_info);
808	length=(size_t) (FITSBlocksize-TellBlob(image) % FITSBlocksize);
809	if (length != 0)
810	{
811	(void) ResetMagickMemory(fits_info,0,lengthsizeof(fits_info));
812	(void) WriteBlob(image,length,(unsigned char *) fits_info);
813	}
814	fits_info=DestroyString(fits_info);
815	(void) CloseBlob(image);
816	return(MagickTrue);
817	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: