[Numpy-discussion] saving and loading as PNG

Martin Teichmann lkb.teichmann@gmail....
Thu Nov 8 09:25:57 CST 2007


Hi all,

i am working with numpy and mostly 16 bit matrices, and so I was looking
for a standard way of saving them. I found that PNG actually supports
that, but I could not find a way to use this feature from within
python. I thought that it actually is a cool way of storing matrices
and thus I wrote a little pyrex program that does the job. I figured
this might be interesting to a broader audience, so I posted it here,
maybe for inclusion in numpy?

Some more thoughts:
* Other implementations: There is other people who have done such a thing.
the PIL knows how to read and write PNG, but only 8 bit. The same holds
for matplotlib.

* Problems: until now, numpy does not link agains libpng. This should not
be a problem on linux-like systems, as those normally all have libpng 
installed. Windows however, I don't know. Same thing with pyrex. 
Numpy doesn't use pyrex until now.

* other places to put: numpy could be considered to basic to have such
a functionality, one could put it in scipy. Well, but png is not really
a _scientific_ application (even though I personally use it to do science).
Matplotlib would be another nice place to put this feature, big advantage
is that matplotlib already links against libpng.

So, now I shared my thoughts with you, comments?

Greetings,

Martin

And here the code (188 lines are hopefully ok for a mailinglist?)

cimport c_numpy
import numpy

cdef extern from "stdlib.h":
    cdef void *malloc(int)
    cdef void free(void *)

cdef extern from "stdio.h":
    cdef struct file:
        pass
    ctypedef file FILE
    cdef FILE *fopen(char *, char *)
    cdef int fclose(FILE *)

cdef extern from "errno.h":
    cdef int errno

cdef extern from "png.h":
    cdef struct jmp_buf:
        pass
    cdef int setjmp(jmp_buf)
    cdef struct png_struct:
        jmp_buf jmpbuf
    ctypedef png_struct *png_structp

    cdef struct png_info:
        int width
        int height
        int bit_depth
        int color_type
        int channels
    ctypedef png_info *png_infop

    cdef struct png_text:
        int compression
        char *key
        char *text
        int text_length
    ctypedef png_text *png_textp

    cdef png_structp png_create_read_struct(char *, void *, void *, void*)
    cdef void png_init_io(png_structp, FILE *)
    cdef void png_set_sig_bytes(png_structp, int)
    cdef png_infop png_create_info_struct(png_structp)
    cdef void png_read_info(png_structp, png_infop)
    cdef int png_set_interlace_handling(png_structp)
    cdef void png_read_update_info(png_structp, png_infop)
    cdef void png_read_image(png_structp, unsigned char **)
    cdef void png_read_png(png_structp, png_infop, int, void *)
    cdef void png_read_end(png_structp, png_infop)
    cdef void png_destroy_read_struct(png_structp *, png_infop *, void *)
    cdef png_structp png_create_write_struct(char *, void *, void *, void*)
    cdef void png_set_IHDR(png_structp, png_infop, unsigned int,
        unsigned int, int, int, int, int, int)
    cdef void png_write_info(png_structp, png_infop)
    cdef void png_write_image(png_structp, unsigned char **)
    cdef void png_write_end(png_structp, png_infop)
    cdef void png_destroy_write_struct(png_structp *,png_infop *)
    cdef void png_set_swap(png_structp)
    cdef void png_set_rows(png_structp, png_infop, unsigned char **)
    cdef void png_write_png(png_structp, png_infop, int, void *)
    cdef void png_set_text(png_structp, png_infop, png_textp, int)
    cdef int PNG_COLOR_TYPE_GRAY
    cdef int PNG_COLOR_TYPE_PALETTE
    cdef int PNG_COLOR_TYPE_RGB
    cdef int PNG_COLOR_TYPE_RGB_ALPHA
    cdef int PNG_COLOR_TYPE_GRAY_ALPHA
    cdef int PNG_INTERLACE_NONE
    cdef int PNG_COMPRESSION_TYPE_BASE
    cdef int PNG_FILTER_TYPE_BASE
    cdef int PNG_TRANSFORM_IDENTITY
    cdef int PNG_TRANSFORM_SWAP_ENDIAN
    cdef char *PNG_LIBPNG_VER_STRING

def load(fn):
    """ load a PNG file into a NumPy array.

    This function can read all kinds of PNG images in a senseful way:
    Depending on the number of bits per pixel, we chose numpy.bool,
    numpy.unit8 or numpy.uint16 as base type. For gray scale images or
    pallettes, this returns a 2-D array, for everything else a 3-D array,
    where the third dimension has a size of 2 for gray+alpha images, 3 for
    RGB and 4 for RGBA images.  """

    cdef FILE *f
    f = fopen(fn, "rb")
    if f == NULL:
        raise IOError(errno)
    cdef png_structp p
    p = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL)
    if setjmp(p.jmpbuf):
        fclose(f)
        raise RuntimeError("libpng reported error")
    cdef png_infop i
    i = png_create_info_struct(p)
    png_init_io(p, f)
    png_read_info(p, i)

    if i.color_type == PNG_COLOR_TYPE_GRAY:
        shape = (i.height, i.width)
    elif i.color_type == PNG_COLOR_TYPE_GRAY_ALPHA:
        shape = (i.height, i.width, 2)
    elif i.color_type == PNG_COLOR_TYPE_PALETTE:
        shape = (i.height, i.width)
    elif i.color_type ==  PNG_COLOR_TYPE_RGB:
        shape = (i.height, i.width, 3)
    elif i.color_type == PNG_COLOR_TYPE_RGB_ALPHA:
        shape = (i.height, i.width, 4)

    if i.bit_depth == 1: dtype = numpy.bool
    elif i.bit_depth == 8: dtype = numpy.uint8
    elif i.bit_depth == 16: dtype = numpy.uint16

    png_set_interlace_handling(p)
    png_read_update_info(p, i)

    r = numpy.zeros(shape, dtype)
    cdef c_numpy.ndarray s
    s = r
    cdef unsigned char **rp
    rp = <unsigned char **> malloc(sizeof(char *) * i.height)
    cdef int j
    for j from 0 <= j < i.height:
        rp[j] = <unsigned char *> &s.data[(j *
            i.channels * i.width * i.bit_depth) / 8]
    png_set_swap(p)
    png_read_image(p, rp)
    free(rp)
    png_destroy_read_struct(&p, &i, NULL)
    fclose(f)
    return r

def save(fn, data):
    """ Save a NumPy array to PNG

    This function saves the NumPy array in data to the file fn. It saves
    the data the best way it can: 2-D arrays are saved as gray scale
    images, 3-D arrays are saved as gray+alpha, rgb or rgba depending on
    the size of the 3rd dimension.  """

    cdef c_numpy.ndarray d
    d = numpy.ascontiguousarray(data)
    cdef int j
    cdef int width
    if data.itemsize > 2:
        raise ValueError("PNG cannot handle BPP > 16")
    if data.ndim == 2:
        width = data.shape[1] * data.itemsize
    elif data.ndim == 3:
        width = data.shape[2] * data.shape[1] * data.itemsize
    else:
        raise ValueError("Can only save 2-D or 3-D arrays to PNG")
    cdef FILE *f
    f = fopen(fn, "wb")
    cdef png_structp p
    p = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL)

    cdef unsigned char **rp
    rp = NULL
    if setjmp(p.jmpbuf):
        free(rp)
        fclose(f)
        raise RuntimeError("libpng reported error")
    cdef png_infop i
    i = png_create_info_struct(p)
    png_init_io(p, f)
    if data.ndim == 2:
        color = PNG_COLOR_TYPE_GRAY
    elif data.shape[2] == 2:
        color = PNG_COLOR_TYPE_GRAY_ALPHA
    elif data.shape[2] == 3:
        color = PNG_COLOR_TYPE_RGB
    elif data.shape[2] == 4:
        color = PNG_COLOR_TYPE_RGB_ALPHA
    else:
        raise ValueError("Third dimension must be <= 4 for saving to PNG")
    png_set_IHDR(p, i, data.shape[1], data.shape[0], data.itemsize*8,
        color, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE,
        PNG_FILTER_TYPE_BASE)

    rp = <unsigned char **> malloc(sizeof(char *) * data.shape[0])
    for j from 0 <= j < data.shape[0]:
        rp[j] = <unsigned char *> &d.data[j * width]
    png_set_rows(p, i, rp)
    png_write_png(p, i, PNG_TRANSFORM_SWAP_ENDIAN, NULL)
    free(rp)
    png_destroy_write_struct(&p, &i)
    fclose(f)




More information about the Numpy-discussion mailing list