summaryrefslogtreecommitdiffstats
path: root/plug-ins/file-fits/fits.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--plug-ins/file-fits/fits.c1222
1 files changed, 1222 insertions, 0 deletions
diff --git a/plug-ins/file-fits/fits.c b/plug-ins/file-fits/fits.c
new file mode 100644
index 0000000..b843a68
--- /dev/null
+++ b/plug-ins/file-fits/fits.c
@@ -0,0 +1,1222 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ * FITS file plugin
+ * reading and writing code Copyright (C) 1997 Peter Kirchgessner
+ * e-mail: peter@kirchgessner.net, WWW: http://www.kirchgessner.net
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+/* Event history:
+ * V 1.00, PK, 05-May-97: Creation
+ * V 1.01, PK, 19-May-97: Problem with compilation on Irix fixed
+ * V 1.02, PK, 08-Jun-97: Bug with saving gray images fixed
+ * V 1.03, PK, 05-Oct-97: Parse rc-file
+ * V 1.04, PK, 12-Oct-97: No progress bars for non-interactive mode
+ * V 1.05, nn, 20-Dec-97: Initialize image_ID in run()
+ * V 1.06, PK, 21-Nov-99: Internationalization
+ * Fix bug with gimp_export_image()
+ * (moved it from load to save)
+ * V 1.07, PK, 16-Aug-06: Fix problems with internationalization
+ * (writing 255,0 instead of 255.0)
+ * Fix problem with not filling up properly last record
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <errno.h>
+
+#include <glib/gstdio.h>
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "fits-io.h"
+
+#include "libgimp/stdplugins-intl.h"
+
+
+#define LOAD_PROC "file-fits-load"
+#define SAVE_PROC "file-fits-save"
+#define PLUG_IN_BINARY "file-fits"
+#define PLUG_IN_ROLE "gimp-file-fits"
+
+
+/* Load info */
+typedef struct
+{
+ gint replace; /* replacement for blank/NaN-values */
+ gint use_datamin; /* Use DATAMIN/MAX-scaling if possible */
+ gint compose; /* compose images with naxis==3 */
+} FITSLoadVals;
+
+
+/* Declare some local functions.
+ */
+static void query (void);
+static void run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals);
+
+static gint32 load_image (const gchar *filename,
+ GError **error);
+static gint save_image (const gchar *filename,
+ gint32 image_ID,
+ gint32 drawable_ID,
+ GError **error);
+
+static FitsHduList * create_fits_header (FitsFile *ofp,
+ guint width,
+ guint height,
+ guint channels,
+ guint bitpix);
+
+static gint save_fits (FitsFile *ofp,
+ gint32 image_ID,
+ gint32 drawable_ID);
+
+static gint32 create_new_image (const gchar *filename,
+ guint pagenum,
+ guint width,
+ guint height,
+ GimpImageBaseType itype,
+ GimpImageType dtype,
+ GimpPrecision iprecision,
+ gint32 *layer_ID,
+ GeglBuffer **buffer);
+
+static void check_load_vals (void);
+
+static gint32 load_fits (const gchar *filename,
+ FitsFile *ifp,
+ guint picnum,
+ guint ncompose);
+
+static gboolean load_dialog (void);
+static void show_fits_errors (void);
+
+
+static FITSLoadVals plvals =
+{
+ 0, /* Replace with black */
+ 0, /* Do autoscale on pixel-values */
+ 0 /* Don't compose images */
+};
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+ NULL, /* init_proc */
+ NULL, /* quit_proc */
+ query, /* query_proc */
+ run, /* run_proc */
+};
+
+/* The run mode */
+static GimpRunMode l_run_mode;
+
+
+MAIN ()
+
+static void
+query (void)
+
+{
+ static const GimpParamDef load_args[] =
+ {
+ { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
+ { GIMP_PDB_STRING, "filename", "The name of the file to load" },
+ { GIMP_PDB_STRING, "raw-filename", "The name of the file to load" },
+ };
+ static const GimpParamDef load_return_vals[] =
+ {
+ { GIMP_PDB_IMAGE, "image", "Output image" },
+ };
+
+ static const GimpParamDef save_args[] =
+ {
+ { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
+ { GIMP_PDB_IMAGE, "image", "Input image" },
+ { GIMP_PDB_DRAWABLE, "drawable", "Drawable to export" },
+ { GIMP_PDB_STRING, "filename", "The name of the file to export the image in" },
+ { GIMP_PDB_STRING, "raw-filename", "The name of the file to export the image in" },
+ };
+
+ gimp_install_procedure (LOAD_PROC,
+ "load file of the FITS file format",
+ "load file of the FITS file format "
+ "(Flexible Image Transport System)",
+ "Peter Kirchgessner",
+ "Peter Kirchgessner (peter@kirchgessner.net)",
+ "1997",
+ N_("Flexible Image Transport System"),
+ NULL,
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (load_args),
+ G_N_ELEMENTS (load_return_vals),
+ load_args, load_return_vals);
+
+ gimp_register_file_handler_mime (LOAD_PROC, "image/x-fits");
+ gimp_register_magic_load_handler (LOAD_PROC,
+ "fit,fits",
+ "",
+ "0,string,SIMPLE");
+
+ gimp_install_procedure (SAVE_PROC,
+ "export file in the FITS file format",
+ "FITS exporting handles all image types except "
+ "those with alpha channels.",
+ "Peter Kirchgessner",
+ "Peter Kirchgessner (peter@kirchgessner.net)",
+ "1997",
+ N_("Flexible Image Transport System"),
+ "RGB, GRAY, INDEXED",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (save_args), 0,
+ save_args, NULL);
+
+ gimp_register_file_handler_mime (SAVE_PROC, "image/x-fits");
+ gimp_register_save_handler (SAVE_PROC, "fit,fits", "");
+}
+
+
+static void
+run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals)
+{
+ static GimpParam values[2];
+ GimpRunMode run_mode;
+ GimpPDBStatusType status = GIMP_PDB_SUCCESS;
+ gint32 image_ID;
+ gint32 drawable_ID;
+ GimpExportReturn export = GIMP_EXPORT_CANCEL;
+ GError *error = NULL;
+
+ INIT_I18N ();
+ gegl_init (NULL, NULL);
+
+ l_run_mode = run_mode = (GimpRunMode)param[0].data.d_int32;
+
+ *nreturn_vals = 1;
+ *return_vals = values;
+
+ values[0].type = GIMP_PDB_STATUS;
+ values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
+
+ if (strcmp (name, LOAD_PROC) == 0)
+ {
+ switch (run_mode)
+ {
+ case GIMP_RUN_INTERACTIVE:
+ /* Possibly retrieve data */
+ gimp_get_data (LOAD_PROC, &plvals);
+
+ if (!load_dialog ())
+ status = GIMP_PDB_CANCEL;
+ break;
+
+ case GIMP_RUN_NONINTERACTIVE:
+ if (nparams != 3)
+ status = GIMP_PDB_CALLING_ERROR;
+ break;
+
+ case GIMP_RUN_WITH_LAST_VALS:
+ /* Possibly retrieve data */
+ gimp_get_data (LOAD_PROC, &plvals);
+ break;
+
+ default:
+ break;
+ }
+
+ if (status == GIMP_PDB_SUCCESS)
+ {
+ check_load_vals ();
+ image_ID = load_image (param[1].data.d_string, &error);
+
+ /* Write out error messages of FITS-Library */
+ show_fits_errors ();
+
+ if (image_ID != -1)
+ {
+ *nreturn_vals = 2;
+ values[1].type = GIMP_PDB_IMAGE;
+ values[1].data.d_image = image_ID;
+ }
+ else
+ {
+ status = GIMP_PDB_EXECUTION_ERROR;
+ }
+
+ /* Store plvals data */
+ if (status == GIMP_PDB_SUCCESS)
+ gimp_set_data (LOAD_PROC, &plvals, sizeof (FITSLoadVals));
+ }
+ }
+ else if (strcmp (name, SAVE_PROC) == 0)
+ {
+ image_ID = param[1].data.d_int32;
+ drawable_ID = param[2].data.d_int32;
+
+ /* eventually export the image */
+ switch (run_mode)
+ {
+ case GIMP_RUN_INTERACTIVE:
+ case GIMP_RUN_WITH_LAST_VALS:
+ gimp_ui_init (PLUG_IN_BINARY, FALSE);
+
+ export = gimp_export_image (&image_ID, &drawable_ID, "FITS",
+ GIMP_EXPORT_CAN_HANDLE_RGB |
+ GIMP_EXPORT_CAN_HANDLE_GRAY |
+ GIMP_EXPORT_CAN_HANDLE_INDEXED);
+
+ if (export == GIMP_EXPORT_CANCEL)
+ {
+ values[0].data.d_status = GIMP_PDB_CANCEL;
+ return;
+ }
+ break;
+ default:
+ break;
+ }
+
+ switch (run_mode)
+ {
+ case GIMP_RUN_INTERACTIVE:
+ break;
+
+ case GIMP_RUN_NONINTERACTIVE:
+ /* Make sure all the arguments are there! */
+ if (nparams != 5)
+ status = GIMP_PDB_CALLING_ERROR;
+ break;
+
+ case GIMP_RUN_WITH_LAST_VALS:
+ break;
+
+ default:
+ break;
+ }
+
+ if (status == GIMP_PDB_SUCCESS)
+ {
+ if (! save_image (param[3].data.d_string, image_ID, drawable_ID,
+ &error))
+ status = GIMP_PDB_EXECUTION_ERROR;
+ }
+
+ if (export == GIMP_EXPORT_EXPORT)
+ gimp_image_delete (image_ID);
+ }
+ else
+ {
+ status = GIMP_PDB_CALLING_ERROR;
+ }
+
+ if (status != GIMP_PDB_SUCCESS && error)
+ {
+ *nreturn_vals = 2;
+ values[1].type = GIMP_PDB_STRING;
+ values[1].data.d_string = error->message;
+ }
+
+ values[0].data.d_status = status;
+}
+
+
+static gint32
+load_image (const gchar *filename,
+ GError **error)
+{
+ gint32 image_ID, *image_list, *nl;
+ guint picnum;
+ gint k, n_images, max_images, hdu_picnum;
+ gint compose;
+ FILE *fp;
+ FitsFile *ifp;
+ FitsHduList *hdu;
+
+ fp = g_fopen (filename, "rb");
+ if (!fp)
+ {
+ g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
+ _("Could not open '%s' for reading: %s"),
+ gimp_filename_to_utf8 (filename), g_strerror (errno));
+ return -1;
+ }
+ fclose (fp);
+
+ ifp = fits_open (filename, "r");
+ if (ifp == NULL)
+ {
+ g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+ "%s", _("Error during open of FITS file"));
+ return -1;
+ }
+ if (ifp->n_pic <= 0)
+ {
+ g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+ "%s", _("FITS file keeps no displayable images"));
+ fits_close (ifp);
+ return -1;
+ }
+
+ image_list = g_new (gint32, 10);
+ n_images = 0;
+ max_images = 10;
+
+ for (picnum = 1; picnum <= ifp->n_pic; )
+ {
+ /* Get image info to see if we can compose them */
+ hdu = fits_image_info (ifp, picnum, &hdu_picnum);
+ if (hdu == NULL) break;
+
+ /* Get number of FITS-images to compose */
+ compose = ( plvals.compose && (hdu_picnum == 1) && (hdu->naxis == 3)
+ && (hdu->naxisn[2] > 1) && (hdu->naxisn[2] <= 4));
+ if (compose)
+ compose = hdu->naxisn[2];
+ else
+ compose = 1; /* Load as GRAY */
+
+ image_ID = load_fits (filename, ifp, picnum, compose);
+
+ /* Write out error messages of FITS-Library */
+ show_fits_errors ();
+
+ if (image_ID == -1) break;
+ if (n_images == max_images)
+ {
+ nl = (gint32 *)g_realloc (image_list, (max_images+10)*sizeof (gint32));
+ if (nl == NULL) break;
+ image_list = nl;
+ max_images += 10;
+ }
+ image_list[n_images++] = image_ID;
+
+ picnum += compose;
+ }
+
+ /* Write out error messages of FITS-Library */
+ show_fits_errors ();
+
+ fits_close (ifp);
+
+ /* Display images in reverse order. The last will be displayed by GIMP itself*/
+ if (l_run_mode != GIMP_RUN_NONINTERACTIVE)
+ {
+ for (k = n_images-1; k >= 1; k--)
+ {
+ gimp_image_undo_enable (image_list[k]);
+ gimp_image_clean_all (image_list[k]);
+ gimp_display_new (image_list[k]);
+ }
+ }
+
+ image_ID = (n_images > 0) ? image_list[0] : -1;
+ g_free (image_list);
+
+ return (image_ID);
+}
+
+
+static gint
+save_image (const gchar *filename,
+ gint32 image_ID,
+ gint32 drawable_ID,
+ GError **error)
+{
+ FitsFile *ofp;
+ GimpImageType drawable_type;
+ gint retval;
+
+ drawable_type = gimp_drawable_type (drawable_ID);
+
+ /* Make sure we're not exporting an image with an alpha channel */
+ if (gimp_drawable_has_alpha (drawable_ID))
+ {
+ g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+ "%s",
+ _("FITS export cannot handle images with alpha channels"));
+ return FALSE;
+ }
+
+ switch (drawable_type)
+ {
+ case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE:
+ case GIMP_GRAY_IMAGE: case GIMP_GRAYA_IMAGE:
+ case GIMP_RGB_IMAGE: case GIMP_RGBA_IMAGE:
+ break;
+ default:
+ g_message (_("Cannot operate on unknown image types."));
+ return (FALSE);
+ break;
+ }
+
+ gimp_progress_init_printf (_("Exporting '%s'"),
+ gimp_filename_to_utf8 (filename));
+
+ /* Open the output file. */
+ ofp = fits_open (filename, "w");
+ if (!ofp)
+ {
+ g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
+ _("Could not open '%s' for writing: %s"),
+ gimp_filename_to_utf8 (filename), g_strerror (errno));
+ return (FALSE);
+ }
+
+ retval = save_fits (ofp,image_ID, drawable_ID);
+
+ fits_close (ofp);
+
+ return (retval);
+}
+
+
+/* Check (and correct) the load values plvals */
+static void
+check_load_vals (void)
+{
+ if (plvals.replace > 255) plvals.replace = 255;
+}
+
+
+/* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */
+static gint32
+create_new_image (const gchar *filename,
+ guint pagenum,
+ guint width,
+ guint height,
+ GimpImageBaseType itype,
+ GimpImageType dtype,
+ GimpPrecision iprecision,
+ gint32 *layer_ID,
+ GeglBuffer **buffer)
+{
+ gint32 image_ID;
+ char *tmp;
+
+ image_ID = gimp_image_new_with_precision (width, height, itype, iprecision);
+
+ if ((tmp = g_malloc (strlen (filename) + 64)) != NULL)
+ {
+ sprintf (tmp, "%s-img%ld", filename, (long)pagenum);
+ gimp_image_set_filename (image_ID, tmp);
+ g_free (tmp);
+ }
+ else
+ gimp_image_set_filename (image_ID, filename);
+
+ gimp_image_undo_disable (image_ID);
+ *layer_ID = gimp_layer_new (image_ID, _("Background"), width, height,
+ dtype, 100,
+ gimp_image_get_default_new_layer_mode (image_ID));
+ gimp_image_insert_layer (image_ID, *layer_ID, -1, 0);
+
+ *buffer = gimp_drawable_get_buffer (*layer_ID);
+
+ return image_ID;
+}
+
+
+/* Load FITS image. ncompose gives the number of FITS-images which have
+ * to be composed together. This will result in different GIMP image types:
+ * 1: GRAY, 2: GRAYA, 3: RGB, 4: RGBA
+ */
+static gint32
+load_fits (const gchar *filename,
+ FitsFile *ifp,
+ guint picnum,
+ guint ncompose)
+{
+ register guchar *dest, *src;
+ guchar *data, *data_end, *linebuf;
+ int width, height, tile_height, scan_lines;
+ int i, j, max_scan;
+ double a, b;
+ gint32 layer_ID, image_ID;
+ GeglBuffer *buffer;
+ GimpImageBaseType itype;
+ GimpImageType dtype;
+ GimpPrecision iprecision;
+ gint err = 0;
+ FitsHduList *hdulist;
+ FitsPixTransform trans;
+ double datamax, replacetransform;
+ const Babl *type, *format;
+
+ hdulist = fits_seek_image (ifp, (int)picnum);
+ if (hdulist == NULL)
+ return -1;
+
+ width = hdulist->naxisn[0]; /* Set the size of the FITS image */
+ height = hdulist->naxisn[1];
+
+ switch (hdulist->bitpix)
+ {
+ case 8:
+ iprecision = GIMP_PRECISION_U8_GAMMA;
+ type = babl_type ("u8");
+ datamax = 255.0;
+ replacetransform = 1.0;
+ break;
+ case 16:
+ iprecision = GIMP_PRECISION_U16_GAMMA; /* FIXME precision */
+ type = babl_type ("u16");
+ datamax = 65535.0;
+ replacetransform = 257;
+ break;
+ case 32:
+ iprecision = GIMP_PRECISION_U32_LINEAR;
+ type = babl_type ("u32");
+ datamax = 4294967295.0;
+ replacetransform = 16843009;
+ break;
+ case -32:
+ iprecision = GIMP_PRECISION_FLOAT_LINEAR;
+ type = babl_type ("float");
+ datamax = 1.0;
+ replacetransform = 1.0 / 255.0;
+ break;
+ case -64:
+ iprecision = GIMP_PRECISION_DOUBLE_LINEAR;
+ type = babl_type ("double");
+ datamax = 1.0;
+ replacetransform = 1.0 / 255.0;
+ break;
+ default:
+ return -1;
+ }
+
+ if (ncompose == 2)
+ {
+ itype = GIMP_GRAY;
+ dtype = GIMP_GRAYA_IMAGE;
+ format = babl_format_new (babl_model ("Y'A"),
+ type,
+ babl_component ("Y'"),
+ babl_component ("A"),
+ NULL);
+ }
+ else if (ncompose == 3)
+ {
+ itype = GIMP_RGB;
+ dtype = GIMP_RGB_IMAGE;
+ format = babl_format_new (babl_model ("R'G'B'"),
+ type,
+ babl_component ("R'"),
+ babl_component ("G'"),
+ babl_component ("B'"),
+ NULL);
+ }
+ else if (ncompose == 4)
+ {
+ itype = GIMP_RGB;
+ dtype = GIMP_RGBA_IMAGE;
+ format = babl_format_new (babl_model ("R'G'B'A"),
+ type,
+ babl_component ("R'"),
+ babl_component ("G'"),
+ babl_component ("B'"),
+ babl_component ("A"),
+ NULL);
+ }
+ else
+ {
+ ncompose = 1;
+ itype = GIMP_GRAY;
+ dtype = GIMP_GRAY_IMAGE;
+ format = babl_format_new (babl_model ("Y'"),
+ type,
+ babl_component ("Y'"),
+ NULL);
+ }
+
+ image_ID = create_new_image (filename, picnum, width, height,
+ itype, dtype, iprecision,
+ &layer_ID, &buffer);
+
+ tile_height = gimp_tile_height ();
+
+ data = g_malloc (tile_height * width * ncompose * hdulist->bpp);
+ if (data == NULL)
+ return -1;
+
+ data_end = data + tile_height * width * ncompose * hdulist->bpp;
+
+ /* If the transformation from pixel value to data value has been
+ * specified, use it
+ */
+ if (plvals.use_datamin &&
+ hdulist->used.datamin && hdulist->used.datamax &&
+ hdulist->used.bzero && hdulist->used.bscale)
+ {
+ a = (hdulist->datamin - hdulist->bzero) / hdulist->bscale;
+ b = (hdulist->datamax - hdulist->bzero) / hdulist->bscale;
+
+ if (a < b)
+ trans.pixmin = a, trans.pixmax = b;
+ else
+ trans.pixmin = b, trans.pixmax = a;
+ }
+ else
+ {
+ trans.pixmin = hdulist->pixmin;
+ trans.pixmax = hdulist->pixmax;
+ }
+
+ trans.datamin = 0.0;
+ trans.datamax = datamax;
+ trans.replacement = plvals.replace * replacetransform;
+ trans.dsttyp = 'k';
+
+ /* FITS stores images with bottom row first. Therefore we have to
+ * fill the image from bottom to top.
+ */
+
+ if (ncompose == 1)
+ {
+ dest = data + tile_height * width * hdulist->bpp;
+ scan_lines = 0;
+
+ for (i = 0; i < height; i++)
+ {
+ /* Read FITS line */
+ dest -= width * hdulist->bpp;
+ if (fits_read_pixel (ifp, hdulist, width, &trans, dest) != width)
+ {
+ err = 1;
+ break;
+ }
+
+ scan_lines++;
+
+ if ((i % 20) == 0)
+ gimp_progress_update ((gdouble) (i + 1) / (gdouble) height);
+
+ if ((scan_lines == tile_height) || ((i + 1) == height))
+ {
+ gegl_buffer_set (buffer,
+ GEGL_RECTANGLE (0, height - i - 1,
+ width, scan_lines), 0,
+ format, dest, GEGL_AUTO_ROWSTRIDE);
+
+ scan_lines = 0;
+ dest = data + tile_height * width * hdulist->bpp;
+ }
+
+ if (err)
+ break;
+ }
+ }
+ else /* multiple images to compose */
+ {
+ gint channel;
+
+ linebuf = g_malloc (width * hdulist->bpp);
+ if (linebuf == NULL)
+ return -1;
+
+ for (channel = 0; channel < ncompose; channel++)
+ {
+ dest = data + tile_height * width * hdulist->bpp * ncompose + channel * hdulist->bpp;
+ scan_lines = 0;
+
+ for (i = 0; i < height; i++)
+ {
+ if ((channel > 0) && ((i % tile_height) == 0))
+ {
+ /* Reload a region for follow up channels */
+ max_scan = tile_height;
+
+ if (i + tile_height > height)
+ max_scan = height - i;
+
+ gegl_buffer_get (buffer,
+ GEGL_RECTANGLE (0, height - i - max_scan,
+ width, max_scan), 1.0,
+ format, data_end - max_scan * width * hdulist->bpp * ncompose,
+ GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+ }
+
+ /* Read FITS scanline */
+ dest -= width * ncompose * hdulist->bpp;
+ if (fits_read_pixel (ifp, hdulist, width, &trans, linebuf) != width)
+ {
+ err = 1;
+ break;
+ }
+ j = width;
+ src = linebuf;
+ while (j--)
+ {
+ memcpy (dest, src, hdulist->bpp);
+ src += hdulist->bpp;
+ dest += ncompose * hdulist->bpp;
+ }
+ dest -= width * ncompose * hdulist->bpp;
+ scan_lines++;
+
+ if ((i % 20) == 0)
+ gimp_progress_update ((gdouble) (channel * height + i + 1) /
+ (gdouble) (height * ncompose));
+
+ if ((scan_lines == tile_height) || ((i + 1) == height))
+ {
+ gegl_buffer_set (buffer,
+ GEGL_RECTANGLE (0, height - i - 1,
+ width, scan_lines), 0,
+ format, dest - channel * hdulist->bpp, GEGL_AUTO_ROWSTRIDE);
+
+ scan_lines = 0;
+ dest = data + tile_height * width * ncompose * hdulist->bpp + channel * hdulist->bpp;
+ }
+
+ if (err)
+ break;
+ }
+ }
+
+ g_free (linebuf);
+ }
+
+ g_free (data);
+
+ if (err)
+ g_message (_("EOF encountered on reading"));
+
+ g_object_unref (buffer);
+
+ gimp_progress_update (1.0);
+
+ return err ? -1 : image_ID;
+}
+
+
+static FitsHduList *
+create_fits_header (FitsFile *ofp,
+ guint width,
+ guint height,
+ guint channels,
+ guint bitpix)
+{
+ FitsHduList *hdulist;
+ gint print_ctype3 = 0; /* The CTYPE3-card may not be FITS-conforming */
+
+ static const char *ctype3_card[] =
+ {
+ NULL, NULL, NULL, /* bpp = 0: no additional card */
+ "COMMENT Image type within GIMP: GIMP_GRAY_IMAGE",
+ NULL,
+ NULL,
+ "COMMENT Image type within GIMP: GIMP_GRAYA_IMAGE (gray with alpha channel)",
+ "COMMENT Sequence for NAXIS3 : GRAY, ALPHA",
+ "CTYPE3 = 'GRAYA ' / GRAY IMAGE WITH ALPHA CHANNEL",
+ "COMMENT Image type within GIMP: GIMP_RGB_IMAGE",
+ "COMMENT Sequence for NAXIS3 : RED, GREEN, BLUE",
+ "CTYPE3 = 'RGB ' / RGB IMAGE",
+ "COMMENT Image type within GIMP: GIMP_RGBA_IMAGE (rgb with alpha channel)",
+ "COMMENT Sequence for NAXIS3 : RED, GREEN, BLUE, ALPHA",
+ "CTYPE3 = 'RGBA ' / RGB IMAGE WITH ALPHA CHANNEL"
+ };
+
+ hdulist = fits_add_hdu (ofp);
+ if (hdulist == NULL)
+ return NULL;
+
+ hdulist->used.simple = 1;
+ hdulist->bitpix = bitpix;
+ hdulist->naxis = (channels == 1) ? 2 : 3;
+ hdulist->naxisn[0] = width;
+ hdulist->naxisn[1] = height;
+ hdulist->naxisn[2] = channels;
+ hdulist->used.datamin = 1;
+ hdulist->datamin = 0.0;
+ hdulist->used.datamax = 1;
+ hdulist->used.bzero = 1;
+ hdulist->bzero = 0.0;
+ hdulist->used.bscale = 1;
+ hdulist->bscale = 1.0;
+
+ switch (bitpix)
+ {
+ case 8:
+ hdulist->datamax = 255;
+ break;
+ case 16:
+ hdulist->datamax = 65535;
+ break;
+ case 32:
+ hdulist->datamax = 4294967295.0; /* .0 to silence gcc */
+ break;
+ case -32:
+ hdulist->datamax = 1.0;
+ break;
+ case -64:
+ hdulist->datamax = 1.0;
+ break;
+ default:
+ return NULL;
+ }
+
+ fits_add_card (hdulist, "");
+ fits_add_card (hdulist,
+ "HISTORY THIS FITS FILE WAS GENERATED BY GIMP USING FITSRW");
+ fits_add_card (hdulist, "");
+ fits_add_card (hdulist,
+ "COMMENT FitsRW is (C) Peter Kirchgessner (peter@kirchgessner.net), but available");
+ fits_add_card (hdulist,
+ "COMMENT under the GNU general public licence.");
+ fits_add_card (hdulist,
+ "COMMENT For sources see http://www.kirchgessner.net");
+ fits_add_card (hdulist, "");
+ fits_add_card (hdulist, ctype3_card[channels * 3]);
+
+ if (ctype3_card[channels * 3 + 1] != NULL)
+ fits_add_card (hdulist, ctype3_card[channels * 3 + 1]);
+
+ if (print_ctype3 && (ctype3_card[channels * 3 + 2] != NULL))
+ fits_add_card (hdulist, ctype3_card[channels * 3 + 2]);
+
+ fits_add_card (hdulist, "");
+
+ return hdulist;
+}
+
+
+/* Save direct colors (GRAY, GRAYA, RGB, RGBA) */
+static gint
+save_fits (FitsFile *ofp,
+ gint32 image_ID,
+ gint32 drawable_ID)
+{
+ gint height, width, i, j, channel, channelnum;
+ gint tile_height, bpp, bpsl, bitpix, bpc;
+ long nbytes;
+ guchar *data, *src;
+ GeglBuffer *buffer;
+ const Babl *format, *type;
+ FitsHduList *hdu;
+
+ buffer = gimp_drawable_get_buffer (drawable_ID);
+
+ width = gegl_buffer_get_width (buffer);
+ height = gegl_buffer_get_height (buffer);
+
+ format = gegl_buffer_get_format (buffer);
+ type = babl_format_get_type (format, 0);
+
+ if (type == babl_type ("u8"))
+ {
+ bitpix = 8;
+ }
+ else if (type == babl_type ("u16"))
+ {
+ bitpix = 16;
+ }
+ else if (type == babl_type ("u32"))
+ {
+ bitpix = 32;
+ }
+ else if (type == babl_type ("half"))
+ {
+ bitpix = -32;
+ type = babl_type ("float");
+ }
+ else if (type == babl_type ("float"))
+ {
+ bitpix = -32;
+ }
+ else if (type == babl_type ("double"))
+ {
+ bitpix = -64;
+ }
+ else
+ {
+ return FALSE;
+ }
+
+ switch (gimp_drawable_type (drawable_ID))
+ {
+ case GIMP_GRAY_IMAGE:
+ format = babl_format_new (babl_model ("Y'"),
+ type,
+ babl_component ("Y'"),
+ NULL);
+ break;
+
+ case GIMP_GRAYA_IMAGE:
+ format = babl_format_new (babl_model ("Y'A"),
+ type,
+ babl_component ("Y'"),
+ babl_component ("A"),
+ NULL);
+ break;
+
+ case GIMP_RGB_IMAGE:
+ case GIMP_INDEXED_IMAGE:
+ format = babl_format_new (babl_model ("R'G'B'"),
+ type,
+ babl_component ("R'"),
+ babl_component ("G'"),
+ babl_component ("B'"),
+ NULL);
+ break;
+
+ case GIMP_RGBA_IMAGE:
+ case GIMP_INDEXEDA_IMAGE:
+ format = babl_format_new (babl_model ("R'G'B'A"),
+ type,
+ babl_component ("R'"),
+ babl_component ("G'"),
+ babl_component ("B'"),
+ babl_component ("A"),
+ NULL);
+ break;
+ }
+
+ channelnum = babl_format_get_n_components (format);
+ bpp = babl_format_get_bytes_per_pixel (format);
+
+ bpc = bpp / channelnum; /* Bytes per channel */
+ bpsl = width * bpp; /* Bytes per scanline */
+
+ tile_height = gimp_tile_height ();
+
+ /* allocate a buffer for retrieving information from the pixel region */
+ src = data = (guchar *) g_malloc (width * height * bpp);
+
+ hdu = create_fits_header (ofp, width, height, channelnum, bitpix);
+ if (hdu == NULL)
+ return FALSE;
+
+ if (fits_write_header (ofp, hdu) < 0)
+ return FALSE;
+
+ nbytes = 0;
+ for (channel = 0; channel < channelnum; channel++)
+ {
+ for (i = 0; i < height; i++)
+ {
+ if ((i % tile_height) == 0)
+ {
+ gint scan_lines;
+
+ scan_lines = (i + tile_height-1 < height) ?
+ tile_height : (height - i);
+
+ gegl_buffer_get (buffer,
+ GEGL_RECTANGLE (0, height - i - scan_lines,
+ width, scan_lines), 1.0,
+ format, data,
+ GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+
+ src = data + bpsl * (scan_lines - 1) + channel * bpc;
+ }
+
+ if (channelnum == 1 && bitpix == 8) /* One channel and 8 bit? Write the scanline */
+ {
+ fwrite (src, bpc, width, ofp->fp);
+ src += bpsl;
+ }
+ else /* Multiple channels or high bit depth */
+ {
+ /* Write out bytes for current channel */
+ /* FIXME: Don't assume a little endian arch */
+ switch (bitpix)
+ {
+ case 8:
+ for (j = 0; j < width; j++)
+ {
+ putc (*src, ofp->fp);
+ src += bpp;
+ }
+ break;
+ case 16:
+ for (j = 0; j < width; j++)
+ {
+ *((guint16*)src) += 32768;
+ putc (*(src + 1), ofp->fp);
+ putc (*(src + 0), ofp->fp);
+ src += bpp;
+ }
+ break;
+ case 32:
+ for (j = 0; j < width; j++)
+ {
+ *((guint32*)src) += 2147483648.0; /* .0 to silence gcc */
+ putc (*(src + 3), ofp->fp);
+ putc (*(src + 2), ofp->fp);
+ putc (*(src + 1), ofp->fp);
+ putc (*(src + 0), ofp->fp);
+ src += bpp;
+ }
+ break;
+ case -32:
+ for (j = 0; j < width; j++)
+ {
+ putc (*(src + 3), ofp->fp);
+ putc (*(src + 2), ofp->fp);
+ putc (*(src + 1), ofp->fp);
+ putc (*(src + 0), ofp->fp);
+ src += bpp;
+ }
+ break;
+ case -64:
+ for (j = 0; j < width; j++)
+ {
+ putc (*(src + 7), ofp->fp);
+ putc (*(src + 6), ofp->fp);
+ putc (*(src + 5), ofp->fp);
+ putc (*(src + 4), ofp->fp);
+ putc (*(src + 3), ofp->fp);
+ putc (*(src + 2), ofp->fp);
+ putc (*(src + 1), ofp->fp);
+ putc (*(src + 0), ofp->fp);
+ src += bpp;
+ }
+ break;
+ default:
+ return FALSE;
+ }
+ }
+
+ nbytes += width * bpc;
+ src -= 2 * bpsl;
+
+ if ((i % 20) == 0)
+ gimp_progress_update ((gdouble) (i + channel * height) /
+ (gdouble) (height * channelnum));
+ }
+ }
+
+ nbytes = nbytes % FITS_RECORD_SIZE;
+ if (nbytes)
+ {
+ while (nbytes++ < FITS_RECORD_SIZE)
+ putc (0, ofp->fp);
+ }
+
+ g_free (data);
+
+ g_object_unref (buffer);
+
+ gimp_progress_update (1.0);
+
+ if (ferror (ofp->fp))
+ {
+ g_message (_("Write error occurred"));
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+/* Load interface functions */
+
+static gboolean
+load_dialog (void)
+{
+ GtkWidget *dialog;
+ GtkWidget *vbox;
+ GtkWidget *frame;
+ gboolean run;
+
+ gimp_ui_init (PLUG_IN_BINARY, FALSE);
+
+ dialog = gimp_dialog_new (_("Load FITS File"), PLUG_IN_ROLE,
+ NULL, 0,
+ gimp_standard_help_func, LOAD_PROC,
+
+ _("_Cancel"), GTK_RESPONSE_CANCEL,
+ _("_Open"), GTK_RESPONSE_OK,
+
+ NULL);
+
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+ GTK_RESPONSE_OK,
+ GTK_RESPONSE_CANCEL,
+ -1);
+
+ gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
+
+ gimp_window_set_transient (GTK_WINDOW (dialog));
+
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
+ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+ vbox, TRUE, TRUE, 0);
+ gtk_widget_show (vbox);
+
+ frame = gimp_int_radio_group_new (TRUE, _("Replacement for undefined pixels"),
+ G_CALLBACK (gimp_radio_button_update),
+ &plvals.replace, plvals.replace,
+
+ _("_Black"), 0, NULL,
+ _("_White"), 255, NULL,
+
+ NULL);
+ gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+ gtk_widget_show (frame);
+
+ frame =
+ gimp_int_radio_group_new (TRUE, _("Pixel value scaling"),
+ G_CALLBACK (gimp_radio_button_update),
+ &plvals.use_datamin, plvals.use_datamin,
+
+ _("_Automatic"), FALSE, NULL,
+ _("By _DATAMIN/DATAMAX"), TRUE, NULL,
+
+ NULL);
+ gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+ gtk_widget_show (frame);
+
+ frame =
+ gimp_int_radio_group_new (TRUE, _("Image Composing"),
+ G_CALLBACK (gimp_radio_button_update),
+ &plvals.compose, plvals.compose,
+
+ C_("composing", "_None"), FALSE, NULL,
+ "NA_XIS=3, NAXIS3=2,...,4", TRUE, NULL,
+
+ NULL);
+ gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
+ gtk_widget_show (frame);
+
+ gtk_widget_show (dialog);
+
+ run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
+
+ gtk_widget_destroy (dialog);
+
+ return run;
+}
+
+static void
+show_fits_errors (void)
+{
+ const gchar *msg;
+
+ /* Write out error messages of FITS-Library */
+ while ((msg = fits_get_error ()) != NULL)
+ g_message ("%s", msg);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-06 09:34:54 +0000