changed JF structures and tiff writer for rectangular detectors

slsDetectorCalibration/dataStructures/jungfrauLGADStrixelsData.h

@@ -207,7 +207,7 @@ class jungfrauLGADStrixelsData : public slsDetectorData<uint16_t> {
 
     int getFrameNumber(char *buff) {
         return ((header *)buff)->detHeader.frameNumber;
-    }
+    };
 
     /**
 
@@ -220,74 +220,10 @@ class jungfrauLGADStrixelsData : public slsDetectorData<uint16_t> {
     */
     int getPacketNumber(char *buff) {
         return ((header *)buff)->detHeader.packetNumber;
-    }
+    };
-
-    /* int getFrameNumber(char *buff) { */
-      
-    /*   //  return ((jf_header *)buff)->bunchNumber; */
-    /* };  */
-
-    /* /\** */
-
-    /*    Returns the packet number for the given dataset. purely virtual func */
-    /*    \param buff pointer to the dataset */
-    /*    \returns packet number number */
 
    
 
-    /* *\/ */
-    /* int getPacketNumber(char *buff) { */
-    /*     return 0; */
-    /* } ; */
-
-    /*    /\** */
-
-    /*      Loops over a memory slot until a complete frame is found (i.e. all
-     * packets 0 to nPackets, same frame number). purely virtual func */
-    /*      \param data pointer to the memory to be analyzed */
-    /*      \param ndata reference to the amount of data found for the frame, in
-     * case the frame is incomplete at the end of the memory slot */
-    /*      \param dsize size of the memory slot to be analyzed */
-    /*      \returns pointer to the beginning of the last good frame (might be
-     * incomplete if ndata smaller than dataSize), or NULL if no frame is found
-     */
-
-    /*   *\/ */
-    /*     virtual  char *findNextFrame(char *data, int &ndata, int
-     * dsize){ndata=dsize; setDataSize(dsize);  return data;}; */
-
-    /*    /\** */
-
-    /*      Loops over a file stream until a complete frame is found (i.e. all
-     * packets 0 to nPackets, same frame number). Can be overloaded for
-     * different kind of detectors!  */
-    /*      \param filebin input file stream (binary) */
-    /*      \returns pointer to the begin of the last good frame, NULL if no
-     * frame is found or last frame is incomplete */
-
-    /* */
-       /* char *readNextFrame(ifstream &filebin){ */
-       /*    //	int afifo_length=0; */
-       /*    uint16_t *afifo_cont; */
-       /*    int ib=0; */
-       /*    if (filebin.is_open()) { */
-       /* 	afifo_cont=new uint16_t[dataSize/2]; */
-       /* 	while (filebin.read(((char*)afifo_cont)+ib,2)) { */
-       /* 	  ib+=2; */
-       /* 	  if (ib==dataSize) break; */
-       /* 	} */
-       /* 	if (ib>0) { */
-       /* 	  iframe++; */
-       /* 	  // cout << ib << "-" << endl; */
-       /* 	  return (char*)afifo_cont; */
-       /* 	} else { */
-       /* 	  delete [] afifo_cont; */
-       /* 	  return NULL; */
-       /* 	} */
-       /*    } */
-       /*    return NULL; */
-       /*  }; */
-
     char *readNextFrame(ifstream &filebin) {
         int ff = -1, np = -1;
         return readNextFrame(filebin, ff, np);

slsDetectorCalibration/dataStructures/jungfrauModuleData.h

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+#ifndef JUNGFRAUMODULEDATA_H
+#define JUNGFRAUMODULEDATA_H
+#include "slsDetectorData.h"
+
+//#define VERSION_V2
+/**
+    @short  structure for a Detector Packet or Image Header
+    @li frameNumber is the frame number
+    @li expLength is the subframe number (32 bit eiger) or real time exposure
+   time in 100ns (others)
+    @li packetNumber is the packet number
+    @li bunchId is the bunch id from beamline
+    @li timestamp is the time stamp with 10 MHz clock
+    @li modId is the unique module id (unique even for left, right, top, bottom)
+    @li xCoord is the x coordinate in the complete detector system
+    @li yCoord is the y coordinate in the complete detector system
+    @li zCoord is the z coordinate in the complete detector system
+    @li debug is for debugging purposes
+    @li roundRNumber is the round robin set number
+    @li detType is the detector type see :: detectorType
+    @li version is the version number of this structure format
+*/
+typedef struct {
+    uint64_t bunchNumber; /**< is the frame number */
+    uint64_t pre;         /**< something */
+
+} jf_header;
+
+using namespace std;  
+class jungfrauModuleData : public slsDetectorData<uint16_t> {
+
+  private:
+    int iframe;
+
+  public:
+    /**
+       Implements the slsReceiverData structure for the moench02 prototype read
+       out by a module i.e. using the slsReceiver (160x160 pixels, 40 packets
+       1286 large etc.) \param c crosstalk parameter for the output buffer
+
+    */
+    jungfrauModuleData()
+        : slsDetectorData<uint16_t>(1024, 512,
+                                    1024* 512 * 2 + sizeof(jf_header)) {
+
+        for (int ix = 0; ix < 1024; ix++) {
+            for (int iy = 0; iy < 512; iy++) {
+                dataMap[iy][ix] = sizeof(jf_header) + (1024 * iy + ix) * 2;
+#ifdef HIGHZ
+                dataMask[iy][ix] = 0x3fff;
+#endif
+            }
+        }
+
+        iframe = 0;
+        //  cout << "data struct created" << endl;
+    };
+
+    /**
+       Returns the value of the selected channel for the given dataset as
+       double. \param data pointer to the dataset (including headers etc) \param
+       ix pixel number in the x direction \param iy pixel number in the y
+       direction \returns data for the selected channel, with inversion if
+       required as double
+
+    */
+    virtual double getValue(char *data, int ix, int iy = 0) {
+
+        uint16_t val = getChannel(data, ix, iy) & 0x3fff;
+	/* if (ix==0 && iy==0) */
+	/*   cout << val << endl; */
+        return val;
+    };
+
+   
+
+    /**
+
+    Returns the frame number for the given dataset. Purely virtual func.
+    \param buff pointer to the dataset
+    \returns frame number
+
+ */
+
+    /* class jfrau_packet_header_t { */
+    /*  public: */
+    /* 	unsigned char reserved[4]; */
+    /* 	unsigned char packetNumber[1]; */
+    /* 	unsigned char frameNumber[3]; */
+    /* 	unsigned char bunchid[8]; */
+    /* }; */
+
+    int getFrameNumber(char *buff) {
+        return ((jf_header *)buff)->bunchNumber;
+    };
+  
+    /**
+
+       Returns the packet number for the given dataset. purely virtual func
+       \param buff pointer to the dataset
+       \returns packet number number
+
+
+
+    */
+    int getPacketNumber(char *buff) {
+        return 0;
+    };
+
+   
+    char *readNextFrame(ifstream &filebin) {
+        int ff = -1, np = -1;
+        return readNextFrame(filebin, ff, np);
+    };
+
+    char *readNextFrame(ifstream &filebin, int &ff) {
+        int np = -1;
+        return readNextFrame(filebin, ff, np);
+    };
+
+    char *readNextFrame(ifstream &filebin, int &ff, int &np) {
+        char *data = new char[dataSize];
+        char *d = readNextFrame(filebin, ff, np, data);
+        if (d == NULL) {
+            delete[] data;
+            data = NULL;
+        }
+        return data;
+    };
+
+    char *readNextFrame(ifstream &filebin, int &ff, int &np,char *data) {
+        char *retval = 0;
+        int nd;
+        int fnum = -1;
+        np = 0;
+        int pn;
+
+        //  cout << dataSize << endl;
+        if (ff >= 0)
+            fnum = ff;
+
+        if (filebin.is_open()) {
+            if (filebin.read(data, dataSize)) {
+                ff = getFrameNumber(data);
+                np = getPacketNumber(data);
+                return data;
+            }
+        }
+        return NULL;
+    };
+
+    /**
+
+       Loops over a memory slot until a complete frame is found (i.e. all
+       packets 0 to nPackets, same frame number). purely virtual func \param
+       data pointer to the memory to be analyzed \param ndata reference to the
+       amount of data found for the frame, in case the frame is incomplete at
+       the end of the memory slot \param dsize size of the memory slot to be
+       analyzed \returns pointer to the beginning of the last good frame (might
+       be incomplete if ndata smaller than dataSize), or NULL if no frame is
+       found
+
+    */
+    virtual char *findNextFrame(char *data, int &ndata, int dsize) {
+        if (dsize < dataSize)
+            ndata = dsize;
+        else
+            ndata = dataSize;
+        return data;
+    };
+
+    // int getPacketNumber(int x, int y) {return dataMap[y][x]/packetSize;};
+};
+
+#endif

slsDetectorCalibration/tiffio/include/sls/tiffIO.h

@@ -5,12 +5,12 @@
 
 //Write 32bit float data to tiff file
 //Always returns nullptr, prints message on failure
-void *WriteToTiff(float *imgData, const char *imgname, int nrow, int ncol);
+void *WriteToTiff(float *imgData, const char *imgname, int ncol, int nrow);
 
 //Read 32bit float data from tiff file, returns pointer to data and sets
 //image dimensions in the out parameters nrow, ncol. 
 //Returns nullptr on failure
 //The caller is responsible to deallocate the memory that the returned
 //pointer points to. 
-float *ReadFromTiff(const char *imgname, uint32_t &nrow, uint32_t &ncol);
+float *ReadFromTiff(const char *imgname, uint32_t &ncol, uint32_t &nrow);
 

slsDetectorCalibration/tiffio/src/tiffIO.cpp

@@ -5,7 +5,7 @@
 #include <iostream>
 #include <tiffio.h>
 
-void *WriteToTiff(float *imgData, const char *imgname, int nrow, int ncol) {
+void *WriteToTiff(float *imgData, const char *imgname, int ncol, int nrow) {
     constexpr uint32_t sampleperpixel = 1;
     TIFF *tif = TIFFOpen(imgname, "w");
     if (tif) {
@@ -30,7 +30,7 @@ void *WriteToTiff(float *imgData, const char *imgname, int nrow, int ncol) {
     return nullptr;
 }
 
-float *ReadFromTiff(const char *imgname, uint32_t &nrow, uint32_t &ncol) {
+float *ReadFromTiff(const char *imgname, uint32_t &ncol, uint32_t &nrow) {
     TIFF *tif = TIFFOpen(imgname, "r");
     if (tif) {
         TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &ncol);