amss/io_tiff_all.c

Go to the documentation of this file.

/*
 * Copyright 2009, 2010 IPOL Image Processing On Line http://www.ipol.im/
 *
 * 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 <http://www.gnu.org/licenses/>.
 */

#include <stdlib.h>
#include <string.h>

#include "tiffio.h"

/*
 * READ FUNCTIONS
 */

static uint8 *read_tiff_rgba_raw(const char *fname,
                                 size_t * nx, size_t * ny, size_t * nc) 
{
    TIFF *tiffp = NULL;
    uint32 width = 0, height = 0, nbsamples = 0;
    uint32 *data_tiff = NULL;
    uint32 *ptr_in, *ptr_end;
    uint8 *data = NULL;
    uint8 *ptr_r, *ptr_g, *ptr_b;

    /* check the pointers */
    if ((NULL == nx) || (NULL == ny) || (NULL == nc))
        return NULL;

    /* no warning messages */
    (void) TIFFSetWarningHandler(NULL);

    /* open the TIFF file and structure */
    if (NULL == (tiffp = TIFFOpen(fname, "r")))
        return NULL;

    /* read width and height and allocate the storage raster */
    if (1 != TIFFGetField(tiffp, TIFFTAG_IMAGEWIDTH, &width)
            || 1 != TIFFGetField(tiffp, TIFFTAG_IMAGELENGTH, &height)
            || 1 != TIFFGetField(tiffp, TIFFTAG_SAMPLESPERPIXEL, &nbsamples)
            || NULL == (data_tiff = (uint32 *) malloc(width * height
                                    * sizeof(uint32)))) {
        TIFFClose(tiffp);
        return NULL;
    }

    /* read the image data */
    if (1 != TIFFReadRGBAImageOriented(tiffp, width, height, data_tiff,
                                       ORIENTATION_TOPLEFT, 1)) {
        free(data_tiff);
        TIFFClose(tiffp);
        return NULL;
    }
    /* close the TIFF file and structure */
    TIFFClose(tiffp);

    *nx = (size_t) width;
    *ny = (size_t) height;
    *nc = (size_t) nbsamples;    /* here I decide the correct number of 
                                 channels
                                 and here stops the equivalent function of
                                 tiff_float_rw2.c */


    /* allocate the RGB deinterlaced array */
    if (NULL == (data = (uint8 *) malloc(*nx * *ny * 3 * sizeof(uint8)))) {
        free(data_tiff);
        return NULL;
    }

    /*
     * deinterlace the TIFF raw array (ptr_in)
     * into four arrays (ptr_r, ptr_g, ptr_b, ptr_a)
     */
    ptr_in = data_tiff;
    ptr_end = ptr_in + *nx * *ny;
    ptr_r = data;
    ptr_g = ptr_r + *nx * *ny;
    ptr_b = ptr_g + *nx * *ny;
    while (ptr_in < ptr_end) {
        *ptr_r++ = (uint8) TIFFGetR(*ptr_in);
        *ptr_g++ = (uint8) TIFFGetG(*ptr_in);
        *ptr_b++ = (uint8) TIFFGetB(*ptr_in);
        ptr_in++;
    }
    free(data_tiff);

    /* select the correct number of channels to report */
    if ((3 == *nc)              /* RGB */
            || (3 < *nc))           /* RGB + alpha + ... */
        *nc = 3;
    else if ((1 == *nc)         /* grayscale */
             || (2 == *nc)) {   /* grayscale + alpha */
        *nc = 1;
        /* truncate the deinterlaced array */
        data = (uint8 *) realloc(data, *nx * *ny * *nc * sizeof(float));
    } else {                     /* 0 == *nc ?? */
        free(data);
        return NULL;
    }
    return data;
}

float *read_tiff_f32(const char *fname, size_t * nx, size_t * ny, size_t * nc) 
{
    uint8 *data_tiff = NULL;
    uint8 *ptr_in, *ptr_end;
    float *data = NULL;
    float *ptr_out;

    /* check the pointers */
    if ((NULL == nx) || (NULL == ny) || (NULL == nc))
        return NULL;

    /* get the raw TIFF data */
    if (NULL == (data_tiff = read_tiff_rgba_raw(fname, nx, ny, nc)))
        return NULL;
    if (NULL == (data = (float *) malloc(*nx * *ny * *nc * sizeof(float)))) {
        free(data_tiff);
        return NULL;
    }

    /* convert the image data */
    ptr_in = data_tiff;
    ptr_end = ptr_in + *nx * *ny * *nc;
    ptr_out = data;
    while (ptr_in < ptr_end)
        *ptr_out++ = (float) *ptr_in++;

    free(data_tiff);

    return data;
}

unsigned char *read_tiff_u8(const char *fname,
                            size_t * nx, size_t * ny, size_t * nc)  
/* The only difference
   between this function and the previous one is that here *data
   and *ptr_out are unsigned char, which permits us to save on memory */
{
    uint8 *data_tiff = NULL;
    uint8 *ptr_in, *ptr_end;
    unsigned char *data = NULL;
    unsigned char *ptr_out;

    /* check the pointers */
    if ((NULL == nx) || (NULL == ny) || (NULL == nc))
        return NULL;

    /* get the raw TIFF data */
    if (NULL == (data_tiff = read_tiff_rgba_raw(fname, nx, ny, nc)))
        return NULL;

    /* allocate the RGB array */
    if (NULL == (data = (unsigned char *)
                        malloc(*nx * *ny * *nc * sizeof(unsigned char)))) {
        free(data_tiff);
        return NULL;
    }

    /* convert the image data */
    ptr_in = data_tiff;
    ptr_end = ptr_in + *nx * *ny;
    ptr_out = data;
    while (ptr_in < ptr_end)
        *ptr_out++ = (unsigned char) *ptr_in++;

    free(data_tiff);

    return data;
}

/*
 * WRITE FUNCTIONS
 */

static int write_tiff_raw(const char *fname, const uint8 * data_raw,
                          size_t nx, size_t ny, size_t nc) 
{
    TIFF *tiffp = NULL;
    uint8 *data_tiff = NULL;
    uint16 ttag_photometric;

    /*
     * ensure the data is allocated
     * and the width and height are within the limits
     * (tiff uses uint32, 2^32 - 1 = 4294967295)
     * and open the TIFF file and structure
     */
    if (NULL == data_raw
            || 4294967295. < (double) nx || 4294967295. < (double) ny)
        return -1;

    if (1 == nc) {              /* grayscale */
        /* create the tiff array */
        if (NULL == (data_tiff = (uint8 *) malloc(nx * ny * nc
                                 * sizeof(uint8))))
            return -1;
        memcpy(data_tiff, data_raw, nx * ny * nc * sizeof(uint8));
        ttag_photometric = PHOTOMETRIC_MINISBLACK;
    } else if (3 == nc) {        /* RGB */
        uint8 *ptr_out, *ptr_end, *ptr_r, *ptr_g, *ptr_b;

        /* create the tiff array */
        if (NULL == (data_tiff = (uint8 *) malloc(nx * ny * nc
                                 * sizeof(uint8))))
            return -1;
        /* interlace three contiguous arrays (ptr_r, ptr_g, ptr_b) */
        ptr_out = data_tiff;
        ptr_end = ptr_out + nx * ny * nc;
        ptr_r = (uint8 *) data_raw;
        ptr_g = ptr_r + nx * ny;
        ptr_b = ptr_g + nx * ny;
        while (ptr_out < ptr_end) {
            *ptr_out++ = *ptr_r++;
            *ptr_out++ = *ptr_g++;
            *ptr_out++ = *ptr_b++;
        }
        ttag_photometric = PHOTOMETRIC_RGB;
    } else
        return -1;

    /* no warning messages */
    (void) TIFFSetWarningHandler(NULL);

    /* open the TIFF file and structure */
    if (NULL == (tiffp = TIFFOpen(fname, "w"))) {
        free(data_tiff);
        return -1;
    }

    /* insert tags into the TIFF structure */
    if (1 != TIFFSetField(tiffp, TIFFTAG_IMAGEWIDTH, nx)
            || 1 != TIFFSetField(tiffp, TIFFTAG_IMAGELENGTH, ny)
            || 1 != TIFFSetField(tiffp, TIFFTAG_ORIENTATION, 
                                 ORIENTATION_TOPLEFT)
            || 1 != TIFFSetField(tiffp, TIFFTAG_PLANARCONFIG, 
                                 PLANARCONFIG_CONTIG)
            || 1 != TIFFSetField(tiffp, TIFFTAG_BITSPERSAMPLE, 8)
            || 1 != TIFFSetField(tiffp, TIFFTAG_ROWSPERSTRIP, ny)
            || 1 != TIFFSetField(tiffp, TIFFTAG_COMPRESSION, COMPRESSION_LZW)
            /* nc-dependant tags */
            || 1 != TIFFSetField(tiffp, TIFFTAG_SAMPLESPERPIXEL, nc)
            || 1 != TIFFSetField(tiffp, TIFFTAG_PHOTOMETRIC, ttag_photometric)
            /* write the image as one single compressed strip */
            || (nx * ny * nc != (unsigned int)
                TIFFWriteEncodedStrip(tiffp, (tstrip_t) 0, (tdata_t) data_tiff,
                                      (tsize_t) (nx * ny * nc)))) {
        free(data_tiff);
        TIFFClose(tiffp);
        return -1;
    }

    /* free the TIFF structure and data, return success */
    free(data_tiff);
    TIFFClose(tiffp);
    return 0;
}

int write_tiff_f32(const char *fname, const float *data,
                   size_t nx, size_t ny, size_t nc) 
{
    uint8 *data_tiff = NULL;
    uint8 *ptr_out, *ptr_end;
    const float *ptr_in;
    int retval;

    /* check allocaton */
    if (NULL == data)
        return -1;

    /* create the tiff array */
    if (NULL == (data_tiff = (uint8 *) malloc(nx * ny * nc * sizeof(uint8))))
        return -1;

    /* round and convert to uint8 */
    ptr_out = data_tiff;
    ptr_end = ptr_out + nx * ny * nc;
    ptr_in = data;
    while (ptr_out < ptr_end)
        *ptr_out++ = (uint8) (*ptr_in++ + .5);

    /* write the file */
    retval = write_tiff_raw(fname, data_tiff, nx, ny, nc);

    free(data_tiff);

    return retval;
}

int write_tiff_u8(const char *fname, const unsigned char *data,
                  size_t nx, size_t ny, size_t nc) 
/* The only difference
   between this function and the previous one is that
   here *ptr_in is unsigned char, which permits us to save on memory 
*/
{
    uint8 *data_tiff = NULL;
    uint8 *ptr_out, *ptr_end;
    const unsigned char *ptr_in;
    int retval;

    /* check allocaton */
    if (NULL == data)
        return -1;

    /* create the tiff array */
    if (NULL == (data_tiff = (uint8 *) malloc(nx * ny * nc * sizeof(uint8))))
        return -1;

    /* round and convert to uint8 */
    ptr_out = data_tiff;
    ptr_end = ptr_out + nx * ny;
    ptr_in = data;
    while (ptr_out < ptr_end)
        *ptr_out++ = (uint8) (*ptr_in++ + .5);

    /* write the file */
    retval = write_tiff_raw(fname, data_tiff, nx, ny, nc);

    free(data_tiff);

    return retval;
}

---