fabio 0.1.1__zip

Library/Python/2.7/site-packages/fabio/mar345image.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python
+#coding: utf8 
+from __future__ import with_statement
+__doc__ = """
+
+Authors: Henning O. Sorensen & Erik Knudsen
+         Center for Fundamental Research: Metal Structures in Four Dimensions
+         Risoe National Laboratory
+         Frederiksborgvej 399
+         DK-4000 Roskilde
+         email:erik.knudsen@risoe.dk
+          +
+         Jon Wright, Jerome Kieffer, Gael Goret ESRF, France
+"""
+
+from fabioimage import fabioimage
+import numpy, struct, time, sys
+import logging
+logger = logging.getLogger("mar345image")
+from compression import compPCK, decPCK
+
+class mar345image(fabioimage):
+    _need_a_real_file = True
+    def __init__(self, *args, **kwargs):
+        fabioimage.__init__(self, *args, **kwargs)
+        self.numhigh = None
+        self.numpixels = None
+
+    def read(self, fname, frame=None):
+        """ Read a mar345 image"""
+        self.filename = fname
+        f = self._open(self.filename, "rb")
+        self._readheader(f)
+        if 'compressed' in self.header['Format']:
+            try:
+                self.data = decPCK(f, self.dim1, self.dim2, self.numhigh)
+            except Exception, error:
+                logger.error('%s. importing the mar345_io backend: generate an empty 1x1 picture' % error)
+                f.close()
+                self.dim1 = 1
+                self.dim2 = 1
+                self.bytecode = numpy.int #
+                self.data = numpy.resize(numpy.array([0], numpy.int), [1, 1])
+                return self
+
+        else:
+            logger.error("cannot handle these formats yet " + \
+                "due to lack of documentation")
+            return None
+        self.bytecode = numpy.uint
+        f.close()
+        return self
+
+    def _readheader(self, infile=None):
+        """ Read a mar345 image header """
+        # clip was not used anywhere - commented out
+        # clip = '\x00'
+        #using a couple of local variables inside this function
+        f = infile
+        h = {}
+
+        #header is 4096 bytes long
+        l = f.read(64)
+        #the contents of the mar345 header is taken to be as
+        # described in
+        # http://www.mar-usa.com/support/downloads/mar345_formats.pdf
+        #the first 64 bytes are 4-byte integers (but in the CBFlib
+        # example image it seems to 128 bytes?)
+        #first 4-byte integer is a marker to check endianness
+        if struct.unpack("<i", l[0:4])[0] == 1234:
+            fs = '<i'
+        else:
+            fs = '>i'
+
+        #image dimensions
+        self.dim1 = self.dim2 = int(struct.unpack(fs, l[4:8])[0])
+        #number of high intensity pixels
+        self.numhigh = struct.unpack(fs, l[2 * 4 : (2 + 1) * 4])[0]
+        h['NumHigh'] = self.numhigh
+        #Image format
+        i = struct.unpack(fs, l[3 * 4 : (3 + 1) * 4])[0]
+        if i == 1:
+            h['Format'] = 'compressed'
+        elif i == 2:
+            h['Format'] = 'spiral'
+        else:
+            h['Format'] = 'compressed'
+            logger.warning("image format could not be detetermined" + \
+                "- assuming compressed mar345")
+        #collection mode
+        h['Mode'] = {0:'Dose', 1: 'Time'}[struct.unpack(fs, l[4 * 4:(4 + 1) * 4])[0]]
+        #total number of pixels
+        self.numpixels = struct.unpack(fs, l[5 * 4:(5 + 1) * 4])[0]
+        h['NumPixels'] = str(self.numpixels)
+        #pixel dimensions (length,height) in mm
+        h['PixelLength'] = struct.unpack(fs, l[6 * 4:(6 + 1) * 4])[0] / 1000.0
+        h['PixelHeight'] = struct.unpack(fs, l[7 * 4:(7 + 1) * 4])[0] / 1000.0
+        #x-ray wavelength in AA
+        h['Wavelength'] = struct.unpack(fs, l[8 * 4:(8 + 1) * 4])[0] / 1000000.0
+        #used distance
+        h['Distance'] = struct.unpack(fs, l[9 * 4:(9 + 1) * 4])[0] / 1000.0
+        #starting and ending phi
+        h['StartPhi'] = struct.unpack(fs, l[10 * 4:11 * 4])[0] / 1000.0
+        h['EndPhi'] = struct.unpack(fs, l[11 * 4:12 * 4])[0] / 1000.0
+        #starting and ending omega
+        h['StartOmega'] = struct.unpack(fs, l[12 * 4:13 * 4])[0] / 1000.0
+        h['EndOmega'] = struct.unpack(fs, l[13 * 4:14 * 4])[0] / 1000.0
+        #Chi and Twotheta angles
+        h['Chi'] = struct.unpack(fs, l[14 * 4:15 * 4])[0] / 1000.0
+        h['TwoTheta'] = struct.unpack(fs, l[15 * 4:16 * 4])[0] / 1000.0
+
+        #the rest of the header is ascii
+        # TODO: validate these values against the binaries already read
+        l = f.read(128)
+        if not 'mar research' in l:
+            logger.warning("the string \"mar research\" should be in " + \
+                "bytes 65-76 of the header but was not")
+            start = 128
+        else:
+            start = l.index('mar research')
+            f.seek(64 + start)
+        l = f.read(4096 - start - 64).strip()
+        for m in l.splitlines():
+            if m == 'END OF HEADER':
+                break
+            n = m.split(' ', 1)
+            if n[0] == '':
+                continue
+            if n[0] in ('PROGRAM', 'DATE', 'SCANNER', 'HIGH', 'MULTIPLIER',
+                        'GAIN', 'WAVELENGTH', 'DISTANCE', 'RESOLUTION',
+                        'CHI', 'TWOTHETA', 'MODE', 'TIME', 'GENERATOR',
+                        'MONOCHROMATOR', 'REMARK'):
+                logger.debug("reading: %s %s", n[0], n[1])
+                h[n[0]] = n[1].strip()
+                continue
+            if n[0] in ('FORMAT'):
+                (h['DIM'], h['FORMAT_TYPE'], h['NO_PIXELS']) = n[1].split()
+                continue
+            if n[0] in ('PIXEL', 'OFFSET', 'PHI', 'OMEGA', 'COUNTS',
+                        'CENTER', 'INTENSITY', 'HISTOGRAM', 'COLLIMATOR'):
+                n = m.split()
+                h.update([(n[0] + '_' + n[j], n[j + 1]) for j in range(1, len(n), 2)])
+                continue
+        self.header = h
+        return h
+
+    def write(self, fname):
+        """Try to write mar345 file. This is still in beta version.
+        It uses CCP4 (LGPL) PCK1 algo from JPA"""
+        headers = self._writeheader()
+        hotpixels = self._high_intensity_pixel_records()
+        compressed_stream = compPCK(self.data)
+        try:
+            outfile = self._open(fname, mode="wb")
+            outfile.write(headers)
+            outfile.write(hotpixels)
+            outfile.write(compressed_stream)
+            outfile.close()
+        except Exception, error:
+            logger.error("Error in writing file %s: %s" % (fname, error))
+
+    def _writeheader(self, linesep="\n", size=4096):#the standard padding does not inclued
+        """
+        @param linesep: end of line separator
+        @return string/bytes containing the mar345 header
+        """
+        try:
+            version = sys.modules["fabio"].version
+        except (KeyError, AttributeError):
+            version = "0.1.1"
+        lnsep = len(linesep)
+
+        self.header["HIGH"] = str(self.nb_overflow_pixels())
+        binheader = numpy.zeros(16, "int32")
+        binheader[:4] = numpy.array([1234, self.dim1, int(self.header["HIGH"]), 1])
+        binheader[4] = (self.header.get("MODE", "TIME") == "TIME")
+        binheader[5] = self.dim1 * self.dim2
+        binheader[6] = int(self.header.get("PIXEL_LENGTH", 1))
+        binheader[7] = int(self.header.get("PIXEL_HEIGHT", 1))
+        binheader[8] = int(float(self.header.get("WAVELENGTH", 1)) * 1e6)
+        binheader[9] = int(float(self.header.get("DISTANCE", 1)) * 1e3)
+        binheader[10] = int(float(self.header.get("PHI_START", 1)) * 1e3)
+        binheader[11] = int(float(self.header.get("PHI_END", 1)) * 1e3)
+        binheader[12] = int(float(self.header.get("OMEGA_START", 1)) * 1e3)
+        binheader[13] = int(float(self.header.get("OMEGA_END", 1)) * 1e3)
+        binheader[14] = int(float(self.header.get("CHI", 1)) * 1e3)
+        binheader[15] = int(float(self.header.get("TWOTHETA", 1)) * 1e3)
+        lstout = [binheader.tostring() + 'mar research'.ljust(64 - lnsep)]
+        lstout.append("PROGRAM".ljust(15) + (str(self.header.get("PROGRAM", "FabIO Version %s" % (version))).ljust(49 - lnsep)))
+        lstout.append("DATE".ljust(15) + (str(self.header.get("DATE", time.ctime()))).ljust(49 - lnsep))
+        key = "SCANNER"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key = "FORMAT_TYPE"
+        if key in self.header:
+            lstout.append("FORMAT".ljust(15) + ("%s  %s %s" % (self.dim1, self.header[key], self.dim1 * self.dim2)).ljust(49 - lnsep))
+        key = "HIGH"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key1 = "PIXEL_LENGTH"
+        key2 = "PIXEL_HEIGHT"
+        if (key1 in self.header) and (key2 in self.header):
+            lstout.append("PIXEL".ljust(15) + ("LENGTH %s  HEIGHT %s" % (self.header[key1], self.header[key2])).ljust(49 - lnsep))
+        key1 = "OFFSET_ROFF"
+        key2 = "OFFSET_TOFF"
+        if key1 in self.header and key2 in self.header:
+            lstout.append("OFFSET".ljust(15) + ("ROFF %s  TOFF %s" % (self.header[key1], self.header[key2])).ljust(49 - lnsep))
+        key = "MULTIPLIER"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key = "GAIN"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key = "WAVELENGTH"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key = "DISTANCE"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key = "RESOLUTION"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key1 = "PHI_START"
+        key2 = "PHI_END"
+        key3 = "PHI_OSC"
+        if (key1 in self.header) and (key2 in self.header) and (key3 in self.header):
+            lstout.append("PHI".ljust(15) + ("START %s  END %s  OSC %s" % (self.header[key1], self.header[key2], self.header[key3])).ljust(49 - lnsep))
+        key1 = "OMEGA_START"
+        key2 = "OMEGA_END"
+        key3 = "OMEGA_OSC"
+        if (key1 in self.header) and (key2 in self.header) and (key3 in self.header):
+            lstout.append("OMEGA".ljust(15) + ("START %s  END %s  OSC %s" % (self.header[key1], self.header[key2], self.header[key3])).ljust(49 - lnsep))
+        key = "CHI"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key = "TWOTHETA"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key1 = "CENTER_X"
+        key2 = "CENTER_Y"
+        if (key1 in self.header) and (key2 in self.header):
+            lstout.append("CENTER".ljust(15) + ("X %s  Y %s" % (self.header[key1], self.header[key2])).ljust(49 - lnsep))
+        key = "MODE"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key = "TIME"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key1 = "COUNTS_START"
+        key2 = "COUNTS_END"
+        key3 = "COUNTS_NMEAS"
+        if key1 in self.header and key2 in self.header and key3 in self.header:
+            lstout.append("COUNTS".ljust(15) + ("START %s  END %s  NMEAS %s" % (self.header[key1], self.header[key2], self.header[key3])).ljust(49 - lnsep))
+        key1 = "COUNTS_MIN"
+        key2 = "COUNTS_MAX"
+        if key1 in self.header and key2 in self.header:
+            lstout.append("COUNTS".ljust(15) + ("MIN %s  MAX %s" % (self.header[key1], self.header[key2])).ljust(49 - lnsep))
+        key1 = "COUNTS_AVE"
+        key2 = "COUNTS_SIG"
+        if key1 in self.header and key2 in self.header:
+            lstout.append("COUNTS".ljust(15) + ("AVE %s  SIG %s" % (self.header[key1], self.header[key2])).ljust(49 - lnsep))
+        key1 = "INTENSITY_MIN"
+        key2 = "INTENSITY_MAX"
+        key3 = "INTENSITY_AVE"
+        key4 = "INTENSITY_SIG"
+        if key1 in self.header and key2 in self.header and key3 in self.header and key4 in self.header:
+            lstout.append("INTENSITY".ljust(15) + ("MIN %s  MAX %s  AVE %s  SIG %s" % (self.header[key1], self.header[key2], self.header[key3], self.header[key4])).ljust(49 - lnsep))
+        key1 = "HISTOGRAM_START"
+        key2 = "HISTOGRAM_END"
+        key3 = "HISTOGRAM_MAX"
+        if key1 in self.header and key2 in self.header and key3 in self.header:
+            lstout.append("HISTOGRAM".ljust(15) + ("START %s  END %s  MAX %s" % (self.header[key1], self.header[key2], self.header[key3])).ljust(49 - lnsep))
+        key = "GENERATOR"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key = "MONOCHROMATOR"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        key1 = "COLLIMATOR_WIDTH"
+        key2 = "COLLIMATOR_HEIGHT"
+        if key1 in self.header and key2 in self.header:
+            lstout.append("COLLIMATOR".ljust(15) + ("WIDTH %s  HEIGHT %s" % (self.header[key1], self.header[key2])).ljust(49 - lnsep))
+        key = "REMARK"
+        if key in self.header:
+            lstout.append(key.ljust(15) + str(self.header[key]).ljust(49 - lnsep))
+        else:
+            lstout.append(key.ljust(64 - lnsep))
+        key = "END OF HEADER"
+        lstout.append(key)
+        return linesep.join(lstout).ljust(size)
+
+
+    def _high_intensity_pixel_records(self):
+        flt_data = self.data.flatten()
+        pix_location = numpy.where(flt_data > 65535)[0]
+        nb_pix = pix_location.size
+        if nb_pix % 8 == 0:
+            tmp = numpy.zeros((nb_pix, 2), dtype="int32")
+        else:
+            tmp = numpy.zeros(((nb_pix // 8 + 1) * 8, 2), dtype="int32")
+        tmp[:nb_pix, 0] = pix_location + 1
+        tmp[:nb_pix, 1] = flt_data[pix_location]
+        return tmp.tostring()
+
+    def nb_overflow_pixels(self):
+        return (self.data > 65535).sum()
+
+    @staticmethod
+    def checkData(data=None):
+        if data is None:
+            return None
+        else:
+#            enforce square image 
+            shape = data.shape
+            assert len(shape) == 2, "image has 2 dimensions"
+            mshape = max(shape)
+            z = numpy.zeros((mshape, mshape), dtype=int)
+            z[:shape[0], :shape[1]] = data
+            return z
+

Library/Python/2.7/site-packages/fabio/marccdimage.py

@@ -0,0 +1,309 @@
+#!/usr/bin/env python
+"""
+
+Authors: Henning O. Sorensen & Erik Knudsen
+         Center for Fundamental Research: Metal Structures in Four Dimensions
+         Risoe National Laboratory
+         Frederiksborgvej 399
+         DK-4000 Roskilde
+         email:henning.sorensen@risoe.dk
+
+         + (mods for fabio) Jon Wright, ESRF
+marccdimage can read MarCCD and MarMosaic images including header info.
+
+JPW : Use a parser in case of typos (sorry?)
+
+"""
+
+
+# Base this on the tifimage (as marccd seems to be tiff with a 
+# special header 
+
+from tifimage import tifimage
+import logging
+logger = logging.getLogger("marccdimage")
+
+# Now for the c definition (found on mar webpage)
+# The following string is therefore copyrighted by Mar I guess
+
+CDEFINITION = """
+typedef struct frame_header_type {
+         /* File/header format parameters (256 bytes) */
+         UINT32        header_type;  /* flag for header type  
+                                           (can be  used as magic number) */
+         char header_name[16];           /* header name (MMX) */
+         UINT32        header_major_version;   /* header_major_version  (n.) */
+         UINT32        header_minor_version;   /* header_minor_version  (.n) */
+         UINT32        header_byte_order;/* BIG_ENDIAN (Motorola,MIPS);  
+                                            LITTLE_ENDIAN (DEC, Intel) */
+         UINT32        data_byte_order;  /* BIG_ENDIAN (Motorola,MIPS);  
+                                            LITTLE_ENDIAN (DEC, Intel) */
+         UINT32        header_size;      /* in bytes                     */
+         UINT32        frame_type;       /* flag for frame type */
+         UINT32        magic_number;     /* to be used as a flag - 
+                                            usually  to indicate new file */
+         UINT32        compression_type; /* type of image compression    */
+         UINT32        compression1;     /* compression parameter 1 */
+         UINT32        compression2;     /* compression parameter 2 */
+         UINT32        compression3;     /* compression parameter 3 */
+         UINT32        compression4;     /* compression parameter 4 */
+         UINT32        compression5;     /* compression parameter 4 */
+         UINT32        compression6;     /* compression parameter 4 */
+         UINT32        nheaders;         /* total number of headers      */
+         UINT32        nfast;            /* number of pixels in one line */
+         UINT32        nslow;            /* number of lines in image     */
+         UINT32        depth;            /* number of bytes per pixel    */
+         UINT32        record_length;    /* number of pixels between 
+                                            succesive rows */
+         UINT32        signif_bits;      /* true depth of data, in bits  */
+         UINT32        data_type;        /* (signed,unsigned,float...) */
+         UINT32        saturated_value;  /* value marks pixel as saturated */
+         UINT32        sequence;         /* TRUE or FALSE */
+         UINT32        nimages;          /* total number of images - size of 
+                                            each is nfast*(nslow/nimages) */
+         UINT32        origin;           /* corner of origin             */
+         UINT32        orientation;      /* direction of fast axis       */
+         UINT32        view_direction;   /* direction to view frame      */
+         UINT32        overflow_location;/* FOLLOWING_HEADER,  FOLLOWING_DATA */
+         UINT32        over_8_bits;      /* # of pixels with counts  255 */
+         UINT32        over_16_bits;     /* # of pixels with count  65535 */
+         UINT32        multiplexed;      /* multiplex flag */
+         UINT32        nfastimages;      /* # of images in fast direction */
+         UINT32        nslowimages;      /* # of images in slow direction */
+         UINT32        background_applied;/* flags correction has been applied 
+                                              hold magic number ? */
+         UINT32        bias_applied;     /* flags correction has been applied
+                                             hold magic number ? */
+         UINT32        flatfield_applied;/* flags correction has been applied -
+                                              hold magic number ? */
+         UINT32        distortion_applied;/*flags correction has been applied - 
+                                              hold magic number ? */
+         UINT32        original_header_type;    /* Header/frame type from  file 
+                                                    that frame is read from */
+         UINT32        file_saved;         /* Flag that file has been  saved, 
+                                              should be zeroed if modified */
+         char reserve1[(64-40)*sizeof(INT32)-16];
+
+         /* Data statistics (128) */
+         UINT32        total_counts[2];  /* 64 bit integer range = 1.85E19*/
+         UINT32        special_counts1[2];
+         UINT32        special_counts2[2];
+         UINT32        min;
+         UINT32        max;
+         UINT32        mean;
+         UINT32        rms;
+         UINT32        p10;
+         UINT32        p90;
+         UINT32        stats_uptodate;
+         UINT32        pixel_noise[MAXIMAGES]; /*1000*base noise value (ADUs) */
+         char reserve2[(32-13-MAXIMAGES)*sizeof(INT32)];
+
+         /* More statistics (256) */
+         UINT16 percentile[128];
+
+
+         /* Goniostat parameters (128 bytes) */
+         INT32 xtal_to_detector;  /* 1000*distance in millimeters */
+         INT32 beam_x;            /* 1000*x beam position (pixels) */
+         INT32 beam_y;            /* 1000*y beam position (pixels) */
+         INT32 integration_time;  /* integration time in  milliseconds */
+         INT32 exposure_time;     /* exposure time in milliseconds */
+         INT32 readout_time;      /* readout time in milliseconds */
+         INT32 nreads;            /* number of readouts to get this  image */
+         INT32 start_twotheta;    /* 1000*two_theta angle */
+         INT32 start_omega;       /* 1000*omega angle */
+         INT32 start_chi;         /* 1000*chi angle */
+         INT32 start_kappa;       /* 1000*kappa angle */
+         INT32 start_phi;         /* 1000*phi angle */
+         INT32 start_delta;       /* 1000*delta angle */
+         INT32 start_gamma;       /* 1000*gamma angle */
+         INT32 start_xtal_to_detector; /* 1000*distance in mm (dist in um)*/
+         INT32 end_twotheta;           /* 1000*two_theta angle */
+         INT32 end_omega;              /* 1000*omega angle */
+         INT32 end_chi;                /* 1000*chi angle */
+         INT32 end_kappa;              /* 1000*kappa angle */
+         INT32 end_phi;                /* 1000*phi angle */
+         INT32 end_delta;              /* 1000*delta angle */
+         INT32 end_gamma;              /* 1000*gamma angle */
+         INT32 end_xtal_to_detector;   /* 1000*distance in mm (dist in um)*/
+         INT32 rotation_axis;          /* active rotation axis */
+         INT32 rotation_range;         /* 1000*rotation angle */
+         INT32 detector_rotx;          /* 1000*rotation of detector  around X */
+         INT32 detector_roty;          /* 1000*rotation of detector  around Y */
+         INT32 detector_rotz;          /* 1000*rotation of detector  around Z */
+         char reserve3[(32-28)*sizeof(INT32)];
+
+         /* Detector parameters (128 bytes) */
+         INT32 detector_type;            /* detector type */
+         INT32 pixelsize_x;              /* pixel size (nanometers) */
+         INT32 pixelsize_y;              /* pixel size (nanometers) */
+         INT32 mean_bias;                        /* 1000*mean bias value */
+         INT32 photons_per_100adu;       /* photons / 100 ADUs */
+         INT32 measured_bias[MAXIMAGES];/* 1000*mean bias value for each image*/
+         INT32 measured_temperature[MAXIMAGES];  /* Temperature of each  
+                                                    detector in milliKelvins */
+         INT32 measured_pressure[MAXIMAGES]; /* Pressure of each  chamber 
+                                               in microTorr */
+         /* Retired reserve4 when MAXIMAGES set to 9 from 16 and 
+            two fields removed, and temp and pressure added
+          char reserve4[(32-(5+3*MAXIMAGES))*sizeof(INT32)]
+         */
+
+         /* X-ray source and optics parameters (128 bytes) */
+         /* X-ray source parameters (8*4 bytes) */
+         INT32 source_type;              /* (code) - target, synch. etc */
+         INT32 source_dx;                /* Optics param. - (size  microns) */
+         INT32 source_dy;                /* Optics param. - (size  microns) */
+         INT32 source_wavelength;        /* wavelength  (femtoMeters) */
+         INT32 source_power;             /* (Watts) */
+         INT32 source_voltage;           /* (Volts) */
+         INT32 source_current;           /* (microAmps) */
+         INT32 source_bias;              /* (Volts) */
+         INT32 source_polarization_x;    /* () */
+         INT32 source_polarization_y;    /* () */
+         char reserve_source[4*sizeof(INT32)];
+
+         /* X-ray optics_parameters (8*4 bytes) */
+         INT32 optics_type;              /* Optics type (code)*/
+         INT32 optics_dx;                /* Optics param. - (size  microns) */
+         INT32 optics_dy;                /* Optics param. - (size  microns) */
+         INT32 optics_wavelength;        /* Optics param. - (size  microns) */
+         INT32 optics_dispersion;        /* Optics param. - (*10E6) */
+         INT32 optics_crossfire_x;       /* Optics param. - (microRadians) */
+         INT32 optics_crossfire_y;       /* Optics param. - (microRadians) */
+         INT32 optics_angle;             /* Optics param. - (monoch.  
+                                                    2theta - microradians) */
+         INT32 optics_polarization_x;    /* () */
+         INT32 optics_polarization_y;    /* () */
+         char reserve_optics[4*sizeof(INT32)];
+
+         char reserve5[((32-28)*sizeof(INT32))];
+
+         /* File parameters (1024 bytes) */
+         char filetitle[128];            /*  Title                  */
+         char filepath[128];             /* path name for data  file  */
+         char filename[64];              /* name of data  file  */
+         char acquire_timestamp[32];     /* date and time of  acquisition */
+         char header_timestamp[32];      /* date and time of header  update  */
+         char save_timestamp[32];        /* date and time file  saved */
+         char file_comments[512];        /* comments, use as desired   */
+         char reserve6[1024-(128+128+64+(3*32)+512)];
+
+         /* Dataset parameters (512 bytes) */
+         char dataset_comments[512];     /* comments, used as desired   */
+         /* pad out to  3072 bytes */
+         char pad[3072-(256+128+256+(3*128)+1024+512)];     
+
+         } frame_header;
+"""
+
+import struct
+
+# Convert mar c header file types to python struct module types
+C_TO_STRUCT = {
+    "INT32"  : "i",
+    "UINT32" : "I",
+    "char"   : "c",
+    "UINT16" : "H"
+    }
+
+# Sizes (bytes) of mar c header objects
+C_SIZES = {
+    "INT32"  : 4,
+    "UINT32" : 4,
+    "char"   : 1,
+    "UINT16" : 2
+    }
+
+# This was worked out by trial and error from a trial image I think
+MAXIMAGES = 9
+
+
+def make_format(c_def_string):
+    """
+    Reads the header definition in c and makes the format 
+    string to pass to struct.unpack
+    """
+    lines = c_def_string.split("\n")
+    fmt = ""
+    names = []
+    expected = 0
+    for line in lines:
+        if line.find(";") == -1:
+            continue
+        decl = line.split(";")[0].lstrip().rstrip()
+        try:
+            [typ, name] = decl.split()
+        except ValueError:
+            logger.debug("skipping: %s" , line)
+            continue
+
+        if name.find("[") > -1:
+            # repeated ... times
+            try:
+                num = name.split("[")[1].split("]")[0]
+                num = num.replace("MAXIMAGES", str(MAXIMAGES))
+                num = num.replace("sizeof(INT32)", "4")
+                times = eval(num)
+            except Exception, error:
+                logger.error("%s Please decode %s", error, decl)
+                raise error
+        else:
+            times = 1
+        try:
+            fmt += C_TO_STRUCT[typ] * times
+            names += [name] * times
+            expected += C_SIZES[typ] * times
+        except KeyError:
+            continue
+    return names, fmt
+
+# Make these be compiled on loading module
+HEADER_NAMES, HEADER_FORMAT = make_format(CDEFINITION)
+
+def interpret_header(header, fmt, names):
+    """
+    given a format and header interpret it
+    """
+    values = struct.unpack(fmt, header)
+    hdr = {}
+    i = 0
+    for name in names:
+        if hdr.has_key(name):
+            if type(values[i]) == type("string"):
+                hdr[name] = hdr[name] + values[i]
+            else:
+                try:
+                    hdr[name].append(values[i])
+                except AttributeError:
+                    hdr[name] = [hdr[name], values[i]]
+        else:
+            hdr[name] = values[i]
+        i = i + 1
+
+    return hdr
+
+
+class marccdimage(tifimage):
+    """ Read in data in mar ccd format, also 
+        MarMosaic images, including header info """
+
+
+    def _readheader(self, infile):
+        """
+        Parser based approach
+        Gets all entries
+        """
+        infile.seek(1024)
+        hstr = infile.read(3072)
+        self.header = interpret_header(hstr, HEADER_FORMAT, HEADER_NAMES)
+
+
+
+    def _read(self, fname):
+        """
+        inherited from tifimage
+        ... a marccd image *is a* tif image
+        just with a header
+        """
+        return tifimage.read(self, fname)