matrix/0000755000076500007650000000000010562415756013613 5ustar ptolemyptolemy00000000000000matrix/._.DS_Store0000400000076500000000000000012210561266477015070 0ustar ptolemywheel00000000000000Mac OS X  2 R@matrix/.DS_Store0000644000076500007650000001400410561266477015300 0ustar ptolemyptolemy00000000000000Bud1 tiff_i#libtiff_io.c#Ilocblob#libtiff_io.h#Ilocblob #tiffany.m#Ilocblob5 libtiff_io.cIlocblob5 libtiff_io.c~IlocblobZ libtiff_io.hIlocblob libtiff_io.h~IlocblobZ5 libtiff_io.oIlocblobMakefileIlocblobZ! matrices.mIlocblob!matrix.mIlocblob!Mercury.optionsIlocblobZ} test_matrix.mIlocblob}tiffIlocblob}tifffwi0blobicnvtifffwswlong tiffany.mIlocblobZ tiffany.m~Ilocblob  @ @ @ @ E DSDB ` @ @ @matrix/checker_write_tiff.m0000644000076500007650000000274710561262543017622 0ustar ptolemyptolemy00000000000000:- module checker_write_tiff. % Overlays a red checker pattern on an input TIFF image, also adds some % blue vertical bars. Saves result as "checked.tif" % author: Douglas M. Auclair (DMA) % created: February 2, 2007 % http://www.logicaltypes.com :- interface. :- import_module io. :- pred main(io::di, io::uo) is det. :- implementation. :- import_module array2d, tiffany, int. main --> { M0 = read_to_matrix("tiff/output.tif"), checker_me_baby(M0, Matrix), write_as_tiff(Matrix, "checked.tif") }, print("Did it, yo!\n"). :- pred checker_me_baby(array2d(int), array2d(int)). :- mode checker_me_baby(array2d_di, out(array2d)) is det. checker_me_baby(!Matrix) :- bounds(!.Matrix, Height, Width), checker_rows(0, Height, Width, !Matrix). :- pred checker_rows(int, int, int, array2d(int), array2d(int)). :- mode checker_rows(in, in, in, array2d_di, out(array2d)) is det. checker_rows(Start, Height, Width) --> { Start = Height } -> [] ; checker_each_row(0, Width, Start), checker_rows(Start + 1, Height, Width). :- pred checker_each_row(int, int, int, array2d(int), array2d(int)). :- mode checker_each_row(in, in, in, array2d_di, out(array2d)) is det. checker_each_row(Col, Width, Row, !Matrix) :- Col = Width -> true ; ((Col mod 25 = 0 ; Row > 0, Row mod 25 = 0) -> set(Row, Col, 0xff, !Matrix) ; Col mod 33 = 0 -> set(Row, Col, 0xffff00, !Matrix) ; set(Row, Col, !.Matrix ^ elem(Row, Col), !Matrix)), checker_each_row(Col + 1, Width, Row, !Matrix). matrix/copy_write_tiff.m0000644000076500007650000000062410561262561017160 0ustar ptolemyptolemy00000000000000:- module copy_write_tiff. % Copies the read-in image to "my.tif" % author: Douglas M. Auclair (DMA) % created: February 2, 2007 % http://www.logicaltypes.com :- interface. :- import_module io. :- pred main(io::di, io::uo) is det. :- implementation. :- import_module tiffany. main --> { Matrix = read_to_matrix("tiff/output.tif"), write_as_tiff(Matrix, "my.tif") }, print("Did it, yo!\n"). matrix/grey_write_tiff.m0000644000076500007650000000307410561262577017165 0ustar ptolemyptolemy00000000000000:- module grey_write_tiff. % Takes an input image and converts the RGBA to a greyscale equivalent, % saving the result to "greyed.tif" -- run checker_write_tiff first! % author: Douglas M. Auclair (DMA) % created: February 2, 2007 % http://www.logicaltypes.com :- interface. :- import_module io. :- pred main(io::di, io::uo) is det. :- implementation. :- import_module array2d, tiffany, int, float. main --> { M0 = read_to_matrix("checked.tif"), grey_me_baby(M0, Matrix), write_as_tiff(Matrix, "greyed.tif") }, print("Did it, yo!\n"). :- pred grey_me_baby(array2d(int), array2d(int)). :- mode grey_me_baby(array2d_di, out(array2d)) is det. grey_me_baby(!Matrix) :- bounds(!.Matrix, Height, Width), grey_rows(0, Height, Width, !Matrix). :- pred grey_rows(int, int, int, array2d(int), array2d(int)). :- mode grey_rows(in, in, in, array2d_di, out(array2d)) is det. grey_rows(Start, Height, Width) --> { Start = Height } -> [] ; grey_each_row(0, Width, Start), grey_rows(Start + 1, Height, Width). :- pred grey_each_row(int, int, int, array2d(int), array2d(int)). :- mode grey_each_row(in, in, in, array2d_di, out(array2d)) is det. grey_each_row(Col, Width, Row, !Matrix) :- Col = Width -> true ; Pixel = !.Matrix ^ elem(Row, Col), GreyRed = round_to_int(float(Pixel /\ 0xff) * 0.299), GreyGreen = round_to_int(float(Pixel >> 8 /\ 0xff) * 0.587), GreyBlue = round_to_int(float(Pixel >> 16 /\ 0xff) * 0.114), Grix = GreyRed + GreyGreen + GreyBlue, set(Row, Col, Grix + Grix << 8 + Grix << 16, !Matrix), grey_each_row(Col + 1, Width, Row, !Matrix). matrix/libtiff_io.c0000644000076500007650000000771510562233611016063 0ustar ptolemyptolemy00000000000000/* file: libtiff_io.c * created: February 2, 2007 * author: Douglas M. Auclair (DMA) * synopsis: Provides read/write access to RGBA TIFF images */ #include #include #include #include #include "libtiff_io.h" struct image { int width; int height; int* raster; TIFF* file; }; int rgba_image_read(struct image* image, int row, int col) { int pixel = image->raster[(image->height - row - 1) * image->width + col]; /* The libtiff colour channel macros: int red = TIFFGetR(pixel); int green = TIFFGetG(pixel); int blue = TIFFGetB(pixel); int alpha = TIFFGetA(pixel); */ /* N.B. pixels are stored in RGBA TIFF images as ABGR (red is the low end of the int bitstream. And A (alpha channel) is usually 255, so you get some really big nulls ... mask out the alpha with pixel & 0xffffff */ return pixel & 0xffffff; /* N.B.: we mask the alpha for now ... */ } struct image* rgba_image_write(int row, int col, int pixel, struct image* img) { img->raster[row * img->width + col] = pixel; return img; } /* open-ended: must deallocate memory and close TIFF file with procedure * close_tiff_file_and_deallocate_rgba_image */ struct image* open_and_read_rgba_tiff_file(const char* filename) { int imagesize = 0; static struct image* image = 0; image = (struct image*)malloc(sizeof(struct image)); image->file = TIFFOpen(filename, "r"); TIFFGetField(image->file, TIFFTAG_IMAGEWIDTH, &(image->width)); TIFFGetField(image->file, TIFFTAG_IMAGELENGTH, &(image->height)); imagesize = image->width * image->height + 1; image->raster = (int*)malloc(sizeof(int) * imagesize); TIFFReadRGBAStrip(image->file, 0, (uint32*)image->raster); return image; } void close_tiff_file_and_dealloc_rgba_image(struct image* img) { TIFFClose(img->file); free(img->raster); free(img); } /* This is also an "open-ended" procedure -- we must finish out * the work started here with its dual: save_to_rgba_tiff_file_and_close */ struct image* open_to_write_rgba_tiff_file(const char* filename, int width, int height) { static struct image* image; int imagesize = sizeof(int) * width * height; image = (struct image*)malloc(sizeof(struct image)); image->file = TIFFOpen(filename, "w"); image->raster = (int*) malloc(imagesize + 1); memset(image->raster, imagesize, 0); image->width = width; image->height = height; /* Write the tiff tags to the file */ TIFFSetField(image->file, TIFFTAG_IMAGEWIDTH, width); TIFFSetField(image->file, TIFFTAG_IMAGELENGTH, height); TIFFSetField(image->file, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE); TIFFSetField(image->file, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG); TIFFSetField(image->file, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB); TIFFSetField(image->file, TIFFTAG_BITSPERSAMPLE, 8); /* our image is stored in a uint32* matrix, but the samples say it's * a char* matrix (it is properly a uchar* matrix), so we will convert * at the save point */ TIFFSetField(image->file, TIFFTAG_SAMPLESPERPIXEL, 3); return image; } void save_to_rgba_tiff_file_and_close(struct image* img) { int x = 0; int y = 0; char* matrix = (char*)malloc(sizeof(char) * img->width * img->height * 3); memset(matrix, sizeof(char) * img->width * img->height * 3 - 1, 0); for(; x < img->width; x++) { for(y = 0; y < img->height; y++) { int pt = y * img->width + x; uint32 pixel = img->raster[pt]; matrix[pt * 3] = TIFFGetR(pixel); matrix[pt * 3 + 1] = TIFFGetG(pixel); matrix[pt * 3 + 2] = TIFFGetB(pixel); } } TIFFWriteEncodedStrip(img->file, 0, matrix, img->width * img->height * 3); close_tiff_file_and_dealloc_rgba_image(img); free(matrix); } /* As Mercury does not peek into the image structure passed to it, we * provide these getter functions to provide that data to Mercury users */ int get_image_width(struct image* img) { return img->width; } int get_image_height(struct image* img) { return img->height; } matrix/libtiff_io.h0000644000076500007650000000152410562230070016054 0ustar ptolemyptolemy00000000000000#ifndef LIBTIFF_IO_H #define LIBTIFF_IO_H /* file: libtiff_io.h * created: February 2, 2007 * author: Douglas M. Auclair (DMA) * synopsis: Interface to libtiff for RGBA image reads/writes */ struct image; /* peeks at the pixel in image at row,col */ int rgba_image_read(struct image*, int row, int col); /* pokes pixel into r0 at row, col, giving raster */ struct image* rgba_image_write(int row, int col, int pt, struct image*); /* opens file in read-only mode, giving width/height and image */ struct image* open_and_read_rgba_tiff_file(const char* file); void close_tiff_file_and_dealloc_rgba_image(struct image*); struct image* open_to_write_rgba_tiff_file(const char*, int width, int height); void save_to_rgba_tiff_file_and_close(struct image*); int get_image_width(struct image*); int get_image_height(struct image*); #endif matrix/Makefile0000644000076500007650000000235310562152344015245 0ustar ptolemyptolemy00000000000000.SUFFIXES: .m PROJECT_DIR=. INSTALL_DIR=$(PROJECT_DIR) C_API_DIR=$(PROJECT_DIR) LIB_C_OBJS=$(C_API_DIR)/libtiff_io.o LIB_SRCS=tiffany.m COMPILE_FLAGS=--c-include-directory $(C_API_DIR) LINK_FLAGS=-lm -ltiff MMC=$(MERCURY_HOME)/bin/mmc CC=/usr/bin/gcc .c.o: $(CC) -I$(C_API_DIR) -c $*.c -o $*.o BASE_DEPENDS = libtiff_io.o tiffany.m LINKER = $(MMC) --make $(LINK_FLAGS) $(COMPILE_FLAGS) EXECUTABLES = read_tiff copy_write_tiff checker_write_tiff grey_write_tiff IMAGES = my.tif checked.tif greyed.tif run_all: $(EXECUTABLES) clean_images echo "Running all tiff io tests"; \ ./read_tiff | head -3; \ ./copy_write_tiff; \ ./checker_write_tiff; \ ./grey_write_tiff; \ echo "Done; look at $(IMAGES)" read_tiff: $(BASE_DEPENDS) $(MATRIX_DEPENDS) read_tiff.m $(LINKER) $@ copy_write_tiff: $(BASE_DEPENDS) copy_write_tiff.m $(LINKER) $@ checker_write_tiff: $(BASE_DEPENDS) checker_write_tiff.m $(LINKER) $@ grey_write_tiff: $(BASE_DEPENDS) grey_write_tiff.m $(LINKER) $@ clean: clean_images rm -f *~ *.err *.mh *.d *.o $(EXECUTABLES) tiff-matrix-*.tgz clean_images: rm -f $(IMAGES) realclean: clean clean_images rm -rf Mercury tar: realclean cd ..; \ tar cvzf tiff-matrix-`date +%Y-%m-%d`.tgz matrix; \ mv tiff-matrix-*.tgz matrix matrix/matrices.m0000644000076500007650000000156610561263233015576 0ustar ptolemyptolemy00000000000000:- module matrices. % Some common matrix instance types. % author: Douglas M. Auclair (DMA) % created: January 31, 2007 % http://www.logicaltypes.com :- interface. :- import_module int, float, rational, matrix. :- instance number(int). :- instance number(float). :- instance number(rational). :- implementation. :- instance number(int) where [ func(matrix.(+)/2) is int.(+), func(matrix.(-)/2) is int.(-), func(matrix.(*)/2) is int.(*), pred(matrix.(<)/2) is int.(<) ]. :- instance number(float) where [ func(matrix.(+)/2) is float.(+), func(matrix.(-)/2) is float.(-), func(matrix.(*)/2) is float.(*), pred(matrix.(<)/2) is float.(<) ]. :- instance number(rational) where [ func(matrix.(+)/2) is rational.(+), func(matrix.(-)/2) is rational.(-), func(matrix.(*)/2) is rational.(*), pred(matrix.(<)/2) is rational.(<) ]. matrix/matrix.m0000644000076500007650000000740010561263304015263 0ustar ptolemyptolemy00000000000000:- module matrix. % A module that implements fast and comprehensive operations for large % matrices. % author: Douglas M. Auclair (DMA) % created: January 31, 2007 % http://www.logicaltypes.com :- interface. :- import_module int, io, array2d. :- typeclass number(T) where [ func T * T = T, func T + T = T, func T - T = T, pred (T::in) < (T::in) is semidet ]. :- type matrix(T). :- func as_array2d(matrix(T)) = array2d(T). :- func from_array2d(array2d(T)) = matrix(T) <= number(T). :- func fill(T, int, int) = matrix(T) <= number(T). :- func id(T, int) = matrix(T) <= number(T). % dot product (matrix x scalar; scalar x matrix) % :- func o(matrix(T), T) = matrix(T). :- func o(T, matrix(T)) = matrix(T) <= number(T). % :- mode o(in, array2d_di) = out(array2d) is det. :- func maxin(matrix(T)) = T <= number(T). :- pred print_matrix(matrix(T)::in, io::di, io::uo) is det. :- implementation. :- import_module array2d. :- type matrix(T) == array2d(T). as_array2d(M) = M. from_array2d(M) = M. fill(Val, Y, X) = new(X, Y, Val). id(Id, Side) = Matrix :- M0 = new(Side, Side, Id - Id), diag_set(0, Side, Id, M0, Matrix). o(T, M0) = Matrix :- bounds(M0, Y, X), destructive_copy_of(M0, M1), scale_rows(0, Y, X, T, M1, Matrix). maxin(M) = Ans :- bounds(M, Y, X), maxin_rows(M, 0, Y, X, M ^ elem(0, 0), Ans). print_matrix(Matrix) --> { bounds(Matrix, Y, X) }, print_rows(Matrix, 0, Y, X). :- pred maxin_rows(matrix(T), int, int, int, T, T) <= number(T). :- mode maxin_rows(in, in, in, in, in, out) is det. maxin_rows(M, Start, Rows, Cols, Guess, Ans) :- Start = Rows -> Guess = Ans ; maxin_row(M, Start, 0, Cols, Guess, NewGuess), maxin_rows(M, Start + 1, Rows, Cols, NewGuess, Ans). :- pred maxin_row(matrix(T), int, int, int, T, T) <= number(T). :- mode maxin_row(in, in, in, in, in, out) is det. maxin_row(M, Row, Start, Cols, Guess, Ans) :- Start = Cols -> Guess = Ans ; NewGuess = M ^ elem(Row, Start), (NewGuess < Guess -> New = Guess ; New = NewGuess), maxin_row(M, Row, Start + 1, Cols, New, Ans). :- pred destructive_copy_of(matrix(T), matrix(T)) <= number(T). :- mode destructive_copy_of(in, out(array2d)) is det. destructive_copy_of(M, M). :- pred print_rows(matrix(T), int, int, int, io, io). :- mode print_rows(in, in, in, in, di, uo) is det. print_rows(Matrix, Start, Finish, Length) --> { Start = Finish } -> [] ; print("| "), print_each_row(Matrix, Start, 0, Length), print("|\n"), print_rows(Matrix, Start + 1, Finish, Length). :- pred print_each_row(matrix(T), int, int, int, io, io). :- mode print_each_row(in, in, in, in, di, uo) is det. print_each_row(Matrix, Row, Start, Finish) --> { Start = Finish } -> [] ; print(Matrix ^ elem(Row, Start)), print(" "), print_each_row(Matrix, Row, Start + 1, Finish). :- pred diag_set(int, int, T, matrix(T), matrix(T)). :- mode diag_set(in, in, in, array2d_di, out(array2d)) is det. diag_set(Start, Finish, Id, M0, Matrix) :- Start = Finish -> M0 = Matrix ; M1 = M0 ^ elem(Start, Start) := Id, diag_set(Start + 1, Finish, Id, M1, Matrix). :- pred scale_rows(int, int, int, T, matrix(T), matrix(T)) <= number(T). :- mode scale_rows(in, in, in, in, array2d_di, out(array2d)) is det. scale_rows(Start, Finish, Length, Value) --> { Start = Finish } -> [] ; scale_row_elems(Start, 0, Length, Value), scale_rows(Start + 1, Finish, Length, Value). :- pred scale_row_elems(int, int, int, T, matrix(T), matrix(T)) <= number(T). :- mode scale_row_elems(in, in, in, in, array2d_di, out(array2d)) is det. scale_row_elems(Row, Start, Finish, Value, M0, Matrix) :- Start = Finish -> M0 = Matrix ; Elem = M0 ^ elem(Row, Start), M1 = M0 ^ elem(Row, Start) := Elem * Value, scale_row_elems(Row, Start + 1, Finish, Value, M1, Matrix). matrix/._Mercury.options0000400000076500000000000000012210561257115016435 0ustar ptolemywheel00000000000000Mac OS X  2 Rmatrix/Mercury.options0000644000076500007650000000002410561257115016642 0ustar ptolemyptolemy00000000000000MLOBJS=libtiff_io.o matrix/read_tiff.m0000644000076500007650000000102210561263066015701 0ustar ptolemyptolemy00000000000000:- module read_tiff. % reads in a TIFF and then prints out the resulting matrix. Best run as % $ ./read_tiff | head -3 % so as to avoid the neverending stream of zeros. % author: Douglas M. Auclair % created: February 2, 2007 % http://www.logicaltypes.com :- interface. :- import_module io. :- pred main(io::di, io::uo) is det. :- implementation. :- import_module matrix, tiffany, matrices. main --> { Matrix = read_to_matrix("tiff/output.tif") }, print("Matrix of TIFF is:\n\n"), print_matrix(from_array2d(Matrix)). matrix/README0000644000076500007650000000246510562152541014470 0ustar ptolemyptolemy00000000000000This is a very small foreign interface to libtiff that allows reading and writing of RGBA (Red/Blue/Green/Alpha) TIFF images using the matrix protocol (included). libtiff must be installed for this to work. The (small) libtiff protocol is provided by the tiffany module. Some sample programs are included to show how this all works on a provided image (tiff/output.tif): * read_tiff - reads the image into a matrix (you probably wish to `head -3`) * copy_write_tiff - copied the read tiff exactly to my.tif * checker_write_tiff - overlays a red checker pattern on the read tiff, saving it as checked.tif * grey_write_tiff - converts checker.tif to greyscale (greyed.tif). The Makefile provides run_all to build and run each in turn. Or, to the point: $ make run_all does the whole shooting match. The module tiffany provides two interfaces to libtiff: % read_to_matrix/1 opens a TIFF file, reads the TIFF as % RGBA pixels (ints). :- func read_to_matrix(string) = array2d(int). :- mode read_to_matrix(in) = out(array2d) is det. % write_as_tiff/2 takes a matrix(int) and stores it % as an RGBA TIFF in whatever format that doesn't make % me pull my hair out in frustration. :- pred write_as_tiff(array2d(int)::in, string::in) is det. Douglas M. Auclair http://www.logicaltypes.com matrix/test_matrix.m0000644000076500007650000000123510561263352016325 0ustar ptolemyptolemy00000000000000:- module test_matrix. % Puts the matrix module through its paces. % author: Douglas M. Auclair (DMA) % created: January 31, 2007 % http://www.logicaltypes.com :- interface. :- import_module io. :- pred main(io::di, io::uo) is det. :- implementation. :- import_module matrix, matrices, array2d, list. main --> { M = id(1.0, 5), N = fill(7.3, 3, 6), O = o(0.5, M), P = o(3.0, N), Q = from_array2d(array2d([[3,1,4], [1,5,9], [2,6,5]])), Maxy = maxin(Q) }, % We know this an int; does the compiler? print_matrix(O), nl, nl, nl, print_matrix(P), print("The max element in:\n"), print_matrix(Q), print("\nis "), print(Maxy), nl. matrix/tiff/0000755000076500007650000000000010561260135014527 5ustar ptolemyptolemy00000000000000matrix/tiff/._.DS_Store0000400000076500000000000000012210561260141015776 0ustar ptolemywheel00000000000000Mac OS X  2 R@matrix/tiff/.DS_Store0000644000076500007650000001400410561260141016206 0ustar ptolemyptolemy00000000000000Bud1%  @ @ @ @ E%DSDB` @ @ @matrix/tiff/output.tif0000644000076500007650000000072410560712533016601 0ustar ptolemyptolemy00000000000000II*\xA 0yDeR\>jԩYv?/a ` Tmatrix/tiffany.m0000644000076500007650000001310510562415673015427 0ustar ptolemyptolemy00000000000000:- module tiffany. % The foreign interface to libtiff that reads a TIFF into a matrix % and writes a matrix to a .tif file. % author: Douglas M. Auclair (DMA) % created: February 2, 2007 % http://www.logicaltypes.com % modified: February 6, 2007 % changed: Shifted to the up-to-date and supported foreign protocol. :- interface. :- import_module string, array2d, int. % read_to_matrix/1 opens a TIFF file, reads the TIFF as % RGBA pixels (ints). :- func read_to_matrix(string) = array2d(int). :- mode read_to_matrix(in) = out(array2d) is det. % write_as_tiff/2 takes a matrix(int) and stores it % as an RGBA TIFF in whatever format that doesn't make % me pull my hair out in frustration. :- pred write_as_tiff(array2d(int)::in, string::in) is det. :- implementation. read_to_matrix(File) = Array2d :- Image = open_and_read_tiff_file(File), Width = get_width(Image), Height = get_height(Image), Arr2d0 = new(Height, Width, 0), read_rows(Image, 0, Width, Height, Arr2d0, Array2d), impure close_and_deallocate_tiff_file(Image). :- pragma promise_pure(read_to_matrix/1). write_as_tiff(Arr2d, File) :- bounds(Arr2d, Height, Width), R0 = open_to_write_tiff_file(File, Width, Height), write_rows(0, Width, Height, Arr2d, R0, Raster), impure save_to_tiff_file_and_close(Raster). :- pragma promise_pure(write_as_tiff/2). %-------------------------------------------------------% % The foreign image type :- pragma foreign_decl("C", "#include "). :- type image. :- pragma foreign_type("C", image, "struct image*"). %-------------------------------------------------------% % reading/writing iteration :- pred read_rows(image, int, int, int, array2d(int), array2d(int)). :- mode read_rows(ui, in, in, in, array2d_di, out(array2d)) is det. read_rows(Raster, Start, Width, Height) --> { Start = Width } -> [] ; read_each_row(Raster, 0, Height, Start), read_rows(Raster, Start + 1, Width, Height). :- pred read_each_row(image, int, int, int, array2d(int), array2d(int)). :- mode read_each_row(ui, in, in, in, array2d_di, out(array2d)) is det. read_each_row(Raster, Start, Height, Row) --> { Start = Height } -> [] ; set(Start, Row, rgba_read(Raster, Start, Row)), read_each_row(Raster, Start + 1, Height, Row). :- pred write_rows(int, int, int, array2d(int), image, image). :- mode write_rows(in, in, in, in, di, uo) is det. write_rows(Start, Width, Height, Arr2d) --> { Start = Width } -> [] ; write_each_row(0, Height, Start, Arr2d), write_rows(Start + 1, Width, Height, Arr2d). :- pred write_each_row(int, int, int, array2d(int), image, image). :- mode write_each_row(in, in, in, in, di, uo) is det. write_each_row(Start, Height, Row, Arr2d) --> { Start = Height } -> [] ; rgba_write(Start, Row, Arr2d ^ elem(Start, Row)), write_each_row(Start + 1, Height, Row, Arr2d). %-------------------------------------------------------% % foreign declarations :- func rgba_read(image, int, int) = int. :- mode rgba_read(ui, in, in) = out is det. :- pragma foreign_proc("C", rgba_read(Image::ui, X::in, Y::in) = (Pixel::out), [will_not_call_mercury, will_not_modify_trail, not_thread_safe, promise_pure], "Pixel = rgba_image_read(Image, X, Y);"). :- pred rgba_write(int, int, int, image, image). :- mode rgba_write(in, in, in, di, uo) is det. rgba_write(Start, Row, Pixel, !Image) :- !:Image = my_rgba_write(Start, Row, Pixel, !.Image). :- func my_rgba_write(int, int, int, image) = image. :- mode my_rgba_write(in, in, in, di) = uo is det. :- pragma foreign_proc("C", my_rgba_write(X::in, Y::in, Pixel::in, I0::di) = (Img::uo), [will_not_call_mercury, will_not_modify_trail, not_thread_safe, promise_pure], "Img = rgba_image_write(X, Y, Pixel, I0);"). :- func open_and_read_tiff_file(string) = image. :- mode open_and_read_tiff_file(in) = uo is det. :- pragma foreign_proc("C", open_and_read_tiff_file(FileName::in) = (Image::uo), [will_not_call_mercury, will_not_modify_trail, not_thread_safe, promise_pure], "Image = open_and_read_rgba_tiff_file(FileName);"). :- impure pred close_and_deallocate_tiff_file(image::di) is det. :- pragma foreign_proc("C", close_and_deallocate_tiff_file(Image::di), [will_not_call_mercury, will_not_modify_trail, not_thread_safe], "close_tiff_file_and_dealloc_rgba_image(Image);"). :- func open_to_write_tiff_file(string, int, int) = image. :- mode open_to_write_tiff_file(in, in, in) = uo is det. :- pragma foreign_proc("C", open_to_write_tiff_file(File::in, Xmax::in, Ymax::in) = (Img::uo), [will_not_call_mercury, will_not_modify_trail, not_thread_safe, promise_pure], "Img = open_to_write_rgba_tiff_file(File, Xmax, Ymax);"). :- impure pred save_to_tiff_file_and_close(image::di) is det. :- pragma foreign_proc("C", save_to_tiff_file_and_close(Image::di), [will_not_call_mercury, will_not_modify_trail, not_thread_safe], "save_to_rgba_tiff_file_and_close(Image);"). :- func get_width(image) = int. :- mode get_width(ui) = out is det. :- pragma foreign_proc("C", get_width(Image::ui) = (Width::out), [will_not_call_mercury, will_not_modify_trail, not_thread_safe, promise_pure], "Width = get_image_width(Image);"). :- func get_height(image) = int. :- mode get_height(ui) = out is det. :- pragma foreign_proc("C", get_height(Image::ui) = (Length::out), [will_not_call_mercury, will_not_modify_trail, not_thread_safe, promise_pure], "Length = get_image_height(Image);").