File containing common libtiff wrapper functions. More...

#include "tiff_util.h"
#include <math.h>

Include dependency graph for tiff_util.c:

Functions
vector *	tiff_to_vec (char *filename)
	Converts tiff to vector this function will take a TIFF filename and return a vector* with every element corresponding to pixel. More...

TIFF *	vec_to_tiff (char filename, vector vec, size_t width, size_t height)
	Converts vector to tiff this function will take a vector and return a TIFF* with every element corresponding to pixel. More...

FILE *	get_all_tiff (char path, int num_files)
	Recursively earches the path for all files of .tiff type the search relies on being able to run the commands find and ls. More...

vector *	tiff_stream_to_vec (FILE *stream)
	Converts FILE* tiff stream into a vector the images are appended row-wise. More...

Detailed Description

File containing common libtiff wrapper functions.

Minhyuk Park

Date: 9 Nov 2017

Function Documentation

FILE* get_all_tiff	(	char *	path,
		int *	num_files
	)

Recursively earches the path for all files of .tiff type the search relies on being able to run the commands find and ls.

Returns: FILE* the stream containing all the files separated by new line characters

Parameters

path	char* the path containing the files
num_files	int* outputs the number of files read

                                                {
     char* command = malloc(strlen(path) + 100);
     sprintf(command, "%s%s%s", "find ", path, "*.tiff -type f -exec ls {} \\;");
      
     
     printf("%s\n", command);
     FILE* retval = popen(command, "r");
 
     sprintf(command, "%s%s%s", "find ", path, "*.tiff -type f -exec ls {} \\; | wc -l");
     
     printf("%s\n", command);
     FILE* num_files_fp = popen(command, "r");
     if(fgets(command, sizeof(command), num_files_fp) != NULL) {
         *num_files = atoi(command);
     }
     pclose(num_files_fp);
     free(command);
     return retval;
 }

vector* tiff_stream_to_vec ( FILE * stream )

Converts FILE* tiff stream into a vector the images are appended row-wise.

Returns: vector* newly malloced vector* containing all the images from the stream

Parameters

stream FILE* returned from get_all_tiff()

References tiff_to_vec(), and vec_append().

                                          {
     char* image_filename;
     char buffer[4096];
 
     vector* cumulative_image = NULL;
     while(fgets(buffer, sizeof(buffer), stream) != NULL) {
         image_filename = malloc(100);
         strcpy(image_filename, buffer);
         image_filename[strlen(image_filename) - 1] = '\0';
         if(cumulative_image == NULL) {
             cumulative_image = tiff_to_vec(image_filename);
         } else {
             vec_append(&cumulative_image, tiff_to_vec(image_filename));
         }
         free(image_filename);
     }
     return cumulative_image;
 }

vector* tiff_to_vec ( char * filename )

Converts tiff to vector this function will take a TIFF filename and return a vector* with every element corresponding to pixel.

Returns: vector* newly malloced representing the image

Parameters

filename char* the input filename

References _vector::padding, VEC, and vector_create().

Referenced by tiff_stream_to_vec().

                                     {
     TIFF* image = TIFFOpen(filename, "r");
     uint32 width;
     uint32 height;
     TIFFGetField(image, TIFFTAG_IMAGEWIDTH, &width);
     TIFFGetField(image, TIFFTAG_IMAGELENGTH, &height);
 
     uint32 num_pixels = width * height;
     uint32 * raster=(uint32*) _TIFFmalloc(num_pixels * sizeof(uint32));
     vector* retvec = vector_create(num_pixels);
 
     TIFFReadRGBAImage(image, width, height, raster, 0);
 
     for(size_t i = 0; i < num_pixels; i ++) {
         VEC(retvec, i) = *(raster + i);
     }
     _TIFFfree(raster);
 
     retvec->padding = width;
     TIFFClose(image);
     return retvec;
 }

TIFF* vec_to_tiff	(	char *	filename,
		vector *	vec,
		size_t	width,
		size_t	height
	)

Converts vector to tiff this function will take a vector and return a TIFF* with every element corresponding to pixel.

Returns: TIFF* opened tiff file stream with necessary data written to from the vector

Parameters

filename	char* the output filename
vec	vector* vector representing the image
width	size_t width of the image
height	size_t height of the image

References _vector::size, and VEC.

                                                                             {
     TIFF* rettiff = TIFFOpen(filename, "w");
 
     char* image_char = malloc(vec->size * 4); // 4 since RGBA
 
     for(size_t i = 0; i < vec->size; i ++) {
         image_char[4 * i] = (char)TIFFGetR((uint32)VEC(vec, i));
         image_char[4 * i + 1] = (char)TIFFGetG((uint32)VEC(vec, i));
         image_char[4 * i + 2] = (char)TIFFGetB((uint32)VEC(vec, i));
         image_char[4 * i + 3] = (char)TIFFGetA((uint32)VEC(vec, i));
     }
     TIFFSetField (rettiff, TIFFTAG_IMAGEWIDTH, width);
     TIFFSetField(rettiff, TIFFTAG_IMAGELENGTH, height);
     TIFFSetField(rettiff, TIFFTAG_SAMPLESPERPIXEL, 4);
     TIFFSetField(rettiff, TIFFTAG_BITSPERSAMPLE, 8);
     TIFFSetField(rettiff, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
     TIFFSetField(rettiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
     TIFFSetField(rettiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
 
     tsize_t linebytes = 4 * width;
     unsigned char* buf = NULL;
 
     if (TIFFScanlineSize(rettiff) == linebytes) {
         buf =(unsigned char*)_TIFFmalloc(linebytes);
     } else {
         buf = (unsigned char*)_TIFFmalloc(TIFFScanlineSize(rettiff));
     }
 
     TIFFSetField(rettiff, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(rettiff, width * 4));
 
     for (uint32 i = 0; i < height; i++) {
         memcpy(buf, &image_char[(height - i - 1) * linebytes], linebytes);
         if (TIFFWriteScanline(rettiff, buf, i, 0) < 0) {
             break;
         }
     }
     _TIFFfree(buf);
     free(image_char);
     return rettiff;
 }

Functions

Detailed Description

Function Documentation