source: trunk/FACT++/gui/RawEventsViewer/RawEventsViewer.cc @ 17036

Last change on this file since 17036 was 17036, checked in by lyard, 6 years ago
remove the hard-coding of the pixels map
File size: 76.5 KB
Line 
1/*
2 * QtGl.cpp
3 *
4 *  Created on: Jul 19, 2011
5 *      Author: lyard
6 *
7 ******
8 */
9#include <math.h>
10#include <fstream>
11
12#include <boost/date_time/local_time/local_time.hpp>
13
14#include "RawEventsViewer.h"
15#include "viewer.h"
16
17#include <QFileDialog>
18#include <QMouseEvent>
19
20#include <qwt_symbol.h>
21#include <qwt_plot_grid.h>
22#include <qwt_plot_zoomer.h>
23
24#include "src/Configuration.h"
25#include "externals/factfits.h"
26
27
28using namespace std;
29
30#undef ACTUAL_NUM_PIXELS
31#define ACTUAL_NUM_PIXELS 1440
32
33//bounding box for diplaying the impulse curve
34float bboxMin[2] = {-0.8,-0.9};
35float bboxMax[2] = {0.8,-0.3};
36/************************************************************
37 * CALC BLUR COLOR if in blur display mode, calculate the interpolated
38 * colour for a given vertex
39 ************************************************************/
40void RawDataViewer::calcBlurColor(int pixel,  int vertex)
41{
42    GLfloat color[3];
43    int first, second;
44    first = vertex-1;
45    second = vertex;
46    if (first < 0)
47        first = 5;
48
49    first = neighbors[pixel][first];
50    second = neighbors[pixel][second];
51//    cout << pixel << " " << vertex << " " << "first: " << first << " second: " << second << endl;
52    for (int i=0;i<3;i++)
53        color[i] = pixelsColor[pixel][i];
54    float divide = 1;
55    if (first != -1)
56    {
57        divide++;
58        for (int i=0;i<3;i++)
59            color[i] += pixelsColor[first][i];
60    }
61    if (second != -1)
62    {
63        divide++;
64        for (int i=0;i<3;i++)
65            color[i] += pixelsColor[second][i];
66    }
67    for (int i=0;i<3;i++)
68        color[i] /= divide;
69
70//    cout << color[0] << " " << color[1] << " " << color[2] << endl;
71
72    glColor3fv(color);
73}
74void RawDataViewer::calcMidBlurColor(int pixel, int vertex)
75{
76    GLfloat color[3];
77    int first;
78    first = vertex-1;
79    if (first < 0)
80        first = 5;
81    first = neighbors[pixel][first];
82    for (int i=0;i<3;i++)
83        color[i] = pixelsColor[pixel][i];
84    float divide = 1;
85    if (first != -1)
86    {
87        divide++;
88        for (int i=0;i<3;i++)
89            color[i] += pixelsColor[first][i];
90    }
91    for (int i=0;i<3;i++)
92        color[i] /= divide;
93    glColor3fv(color);
94}
95/************************************************************
96 * DRAW BLURRY HEXAGON. draws a solid hexagon, with interpolated colours
97 ************************************************************/
98void RawDataViewer::drawBlurryHexagon(int index)
99{
100
101//per-pixel mesh
102    GLfloat color[3];
103    for (int i=0;i<3;i++)
104        color[i] = pixelsColor[index][i];
105    glBegin(GL_TRIANGLES);
106    calcBlurColor(index, 0);
107    glVertex2fv(verticesList[verticesIndices[index][0]]);
108    glColor3fv(color);
109    glVertex2fv(pixelsCoords[index]);
110
111    calcBlurColor(index, 1);
112    glVertex2fv(verticesList[verticesIndices[index][1]]);
113
114    glVertex2fv(verticesList[verticesIndices[index][1]]);
115    glColor3fv(color);
116    glVertex2fv(pixelsCoords[index]);
117
118    calcBlurColor(index, 2);
119    glVertex2fv(verticesList[verticesIndices[index][2]]);
120
121    glVertex2fv(verticesList[verticesIndices[index][2]]);
122    glColor3fv(color);
123    glVertex2fv(pixelsCoords[index]);
124
125    calcBlurColor(index, 3);
126    glVertex2fv(verticesList[verticesIndices[index][3]]);
127
128    glVertex2fv(verticesList[verticesIndices[index][3]]);
129    glColor3fv(color);
130    glVertex2fv(pixelsCoords[index]);
131
132    calcBlurColor(index, 4);
133    glVertex2fv(verticesList[verticesIndices[index][4]]);
134
135    glVertex2fv(verticesList[verticesIndices[index][4]]);
136    glColor3fv(color);
137    glVertex2fv(pixelsCoords[index]);
138
139    calcBlurColor(index, 5);
140    glVertex2fv(verticesList[verticesIndices[index][5]]);
141
142    glVertex2fv(verticesList[verticesIndices[index][5]]);
143    glColor3fv(color);
144    glVertex2fv(pixelsCoords[index]);
145
146    calcBlurColor(index, 0);
147    glVertex2fv(verticesList[verticesIndices[index][0]]);
148    glEnd();
149
150    return;
151}
152
153/************************************************************
154 * DRAW CAMERA draws all the camera pixels
155 ************************************************************/
156void RawDataViewer::drawCamera(bool alsoWire)
157{
158    glLoadIdentity();
159    if (!drawImpulse)
160    {
161        glTranslatef(0,-0.44,0);
162        glRotatef(cameraRotation, 0,0,-1);
163        if (cameraRotation == 90)
164        {
165            glTranslatef(-0.45,-0.45,0);
166        }
167        if (cameraRotation == -90)
168        {
169            glTranslatef(0.45,-0.45,0);
170        }
171        glScalef(1.5,1.5,1);
172    }
173    else
174    {
175        glRotatef(cameraRotation, 0,0,-1);
176          if (cameraRotation == 90)
177        {
178            glTranslatef(-0.45/1.5,-0.45/1.5,0);
179        }
180        if (cameraRotation == -90)
181        {
182            glTranslatef(0.45/1.5,-0.45/1.5,0);
183        }
184  }
185    glColor3f(0.5,0.5,0.5);
186    glLineWidth(1.0);
187    float color;
188
189    for (int i=0;i<ACTUAL_NUM_PIXELS;i++)
190    {
191        if (!nRoi)
192          color = (float)(i)/(float)(ACTUAL_NUM_PIXELS);
193        else
194
195//        if (_softwareOrdering)
196//            color = float(eventData[nRoi*i + whichSlice] + (VALUES_SPAN/2))/(float)(VALUES_SPAN-1);
197//        else
198            color = float(eventData[nRoi*hardwareMapping[i] + whichSlice]+(VALUES_SPAN/2))/(float)(VALUES_SPAN-1);
199        if (logScale)
200        {
201            color *= 9;
202            color += 1;
203            color = log10(color);
204        }
205
206        if (color < ss[0])
207        {
208            pixelsColor[i][0] = tooLowValueCoulour[0];
209            pixelsColor[i][1] = tooLowValueCoulour[1];
210            pixelsColor[i][2] = tooLowValueCoulour[2];
211            continue;
212        }
213        if (color > ss[4])
214        {
215            pixelsColor[i][0] = tooHighValueCoulour[0];
216            pixelsColor[i][1] = tooHighValueCoulour[1];
217            pixelsColor[i][2] = tooHighValueCoulour[2];
218            continue;
219        }
220        int index = 0;
221        while (ss[index] < color && index < 4)
222            index++;
223        index--;
224        if (index < 0) index = 0;
225        float weight0 = (color-ss[index]) / (ss[index+1]-ss[index]);
226        if (weight0 > 1.0f) weight0 = 1.0f;
227        if (weight0 < 0.0f) weight0 = 0.0f;
228        float weight1 = 1.0f-weight0;
229        pixelsColor[i][0] = weight1*rr[index] + weight0*rr[index+1];
230        pixelsColor[i][1] = weight1*gg[index] + weight0*gg[index+1];
231        pixelsColor[i][2] = weight1*bb[index] + weight0*bb[index+1];
232    }
233
234    for (int i=0;i<ACTUAL_NUM_PIXELS;i++)
235    {
236
237        glColor3fv(pixelsColor[i]);
238        glLoadName(i);
239if (drawBlur)
240    drawBlurryHexagon(i);
241else
242    drawHexagon(i,true);
243
244    }
245    if (!alsoWire)
246        return;
247    glTranslatef(0,0,0.1f);
248    glColor3f(0.0f,0.0f,0.0f);
249    for (int i=0;i<ACTUAL_NUM_PIXELS;i++)
250    {
251
252        drawHexagon(i, false);
253    }
254
255}
256
257/************************************************************
258 * DRAW PIXEL CURVE. draws the raw impulse curve of the currently selected pixel
259 ************************************************************/
260void RawDataViewer::drawPixelCurve()
261{
262    float xRange = bboxMax[0] - bboxMin[0];
263    float yRange = bboxMax[1] - bboxMin[1];
264
265    glBegin(GL_LINES);
266    glLineWidth(1.0f);
267    glColor3f(0.0,0.0,0.0);
268    glVertex2f(bboxMin[0], bboxMin[1]);
269    glVertex2f(bboxMax[0], bboxMin[1]);
270    glVertex2f(bboxMin[0], bboxMin[1]);
271    glVertex2f(bboxMin[0], bboxMax[1]);
272    glVertex2f(bboxMin[0], (bboxMin[1]+bboxMax[1])/2.0f);
273    glVertex2f(bboxMax[0], (bboxMin[1]+bboxMax[1])/2.0f);
274    glVertex2f(bboxMin[0] + xRange*nRoi/(float)(nRoi+nRoiTM),
275               bboxMin[1]);
276    glVertex2f(bboxMin[0] + xRange*nRoi/(float)(nRoi+nRoiTM),
277               bboxMax[1]);
278   glEnd();
279    glTranslatef(0,0,0.1f);
280    if (!nRoi)
281          return;
282     glBegin(GL_LINES);
283    glColor3f(1.0f,1.0f,0.0f);
284    float divideMe = (float)(VALUES_SPAN-1);
285    float plusMe = (float)(VALUES_SPAN)/2;
286    if (divideMe <= 0)
287        divideMe = 1;
288
289    /*
290    if (drawCalibrationLoaded)
291        plusMe += 0;//VALUES_SPAN/2;
292    if (drawCalibrationLoaded && calibrationLoaded)
293    {
294        divideMe /=2;
295        plusMe = 0 ;///=2;
296        }*/
297
298//    int mapping = _softwareOrdering ? selectedPixel : hardwareMapping[selectedPixel];
299    int mapping = hardwareMapping[selectedPixel];
300    const int hw = mapping;
301    const PixelMapEntry& mapEntry = fPixelMap.index(selectedPixel);
302    const int pixelIdInPatch = mapEntry.pixel();
303    const int patchId = mapEntry.patch();
304    const int boardId = mapEntry.board();
305    const int crateId = mapEntry.crate();
306
307    if (selectedPixel != -1)
308    {
309    for (int i=0;i<nRoi-1;i++)
310    {
311        float d1 = eventData[nRoi*hw + i]+plusMe;
312        float d2 = eventData[nRoi*hw + i+1]+plusMe;
313        if (!finite(d1)) d1 = 20000;
314        if (!finite(d2)) d2 = 20000;
315        glVertex2f(bboxMin[0] + xRange*i/(float)(nRoi+nRoiTM),
316                   bboxMin[1] + yRange*(d1) /divideMe);
317        glVertex2f(bboxMin[0] + xRange*(i+1)/(float)(nRoi+nRoiTM),
318                   bboxMin[1] + yRange*(d2) /divideMe);
319    }
320    glEnd();
321
322    glColor3f(0.0f, 1.0f, 1.0f);
323    glBegin(GL_LINES);
324    if (pixelIdInPatch == 8)//this channel has a time marker
325    {
326
327        for (int i=0;i<nRoiTM-1;i++)
328        {
329            float d1 = eventData[nRoi*1440 + nRoiTM*(40*crateId + 4*boardId + patchId) + i] + plusMe;
330            float d2 = eventData[nRoi*1440 + nRoiTM*(40*crateId + 4*boardId + patchId) + i+1] + plusMe;
331            if (!finite(d1)) d1 = 20000;
332            if (!finite(d2)) d2 = 20000;
333            glVertex2f(bboxMin[0] + xRange*(i+nRoi)/(float)(nRoi+nRoiTM),
334                       bboxMin[1] + yRange*(d1)/divideMe);
335            glVertex2f(bboxMin[0] + xRange*(i+1+nRoi)/(float)(nRoi+nRoiTM),
336                       bboxMin[1] + yRange*(d2) / divideMe);
337        }
338    }
339
340    }
341    glEnd();
342    glTranslatef(0,0,0.1f);
343    glBegin(GL_LINES);
344    glColor3f(1.0,0.0,0.0);
345    glVertex2f(bboxMin[0] + xRange*whichSlice/(float)(nRoi+nRoiTM),
346               bboxMin[1]);
347    glVertex2f(bboxMin[0] + xRange*whichSlice/(float)(nRoi+nRoiTM),
348               bboxMax[1]);
349
350    glEnd();
351
352}
353/************************************************************
354 * CONSTRUCTOR.
355 ************************************************************/
356RawDataViewer::RawDataViewer(QWidget *cParent) : BasicGlCamera(cParent), RMSvalues(1440), Meanvalues(1440), Maxvalues(1440), PosOfMaxvalues(1440), VALUES_SPAN(4096)
357
358{
359
360    whichSlice = 0;
361
362    nRoi = 0;
363    nRoiTM = 0;
364    offSetRoi = 0;
365    eventNum = 0;
366    rowNum = -1;
367    eventStep = 1;
368    selectedPixel = 393;
369    inputFile = NULL;
370    eventData = NULL;
371    drawPatch = false;
372    drawImpulse = true;
373    drawBlur = false;
374    loopCurrentEvent = false;
375    fIsDrsCalibration = false;
376    SetAutoRefresh(true);
377    runType = "unkown";
378
379
380}
381
382void RawDataViewer::assignPixelMapFile(const string& map)
383{
384    PixelMap mypMap;
385    if (map=="")
386    {
387        if (!mypMap.Read("/swdev_nfs/FACT++/FACTmap111030.txt"))
388        {
389            if (!mypMap.Read("./FACTmap111030.txt"))
390            {
391                cerr << "ERROR - Problems reading FACTmap111030.txt" << endl;
392                exit(-1);
393            }
394        }
395    }
396    else
397    {
398        if (!mypMap.Read(map))
399        {
400            cerr << "ERROR - Problems reading " << map << endl;
401            exit(-1);
402        }
403    }
404
405    assignPixelMap(mypMap);
406
407    for (int i=0;i<160;i++)
408    {
409        const float color[3] = { 0.5, 0.5, 0.3 };
410
411        for (int j=0;j<3;j++)
412            patchesColor[i][j] = color[j];
413    }
414    fZeroArray = NULL;
415
416    _softwareOrdering = false;
417}
418/************************************************************
419 *  DESTRUCTOR
420 ************************************************************/
421RawDataViewer::~RawDataViewer()
422{
423    if (inputFile != NULL)
424    {
425        inputFile->close();
426        delete inputFile;
427    }
428    if (eventData != NULL) {
429        delete[] eventData;
430        delete[] rawEventData;
431        delete[] waveLetArray;
432    }
433    if (fZeroArray != NULL)
434        delete[] fZeroArray;
435}
436void RawDataViewer::allocateZeroArray()
437{
438    if (fZeroArray == NULL)
439    {
440        fZeroArray = new char[8192];
441    }
442}
443/************************************************************
444 * PAINT GL. main drawing function.
445 ************************************************************/
446void RawDataViewer::paintGL()
447{
448    //Should not be required, but apparently it helps when piping it through X forwarding
449    glFinish();
450    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
451    glLoadIdentity();
452
453    glTranslatef(0,0,-0.5);
454
455    if (drawBlur)
456    {
457        glShadeModel(GL_SMOOTH);
458        drawCamera(false);
459    }
460    else
461    {
462        glShadeModel(GL_FLAT);
463        drawCamera(true);
464    }
465    glTranslatef(0,0,0.1f);
466    if (drawPatch)
467        drawPatches();
468    glTranslatef(0,0,0.1f);
469   if (!drawBlur && (selectedPixel != -1))
470   {
471        glLineWidth(1.0f);
472        glColor3f(1.0,1.0,1.0);
473        drawHexagon(selectedPixel, false);
474   }
475   glTranslatef(0,0,0.1f);
476   if (drawImpulse)
477   {
478    //   glRotatef(cameraRotation, 0,0,1);
479       glLoadIdentity();
480       glLineWidth(2.0);
481       drawPixelCurve();
482   }
483   glTranslatef(0,0,0.1f);
484   DrawScale();
485}
486
487/************************************************************
488 * MOUSE PRESS EVENT. mouse click handler.
489 ************************************************************/
490void RawDataViewer::mousePressEvent(QMouseEvent *cEvent)
491{
492    if (cEvent->pos().x() > width()-(width()/50.f))
493    {
494        toggleInterfaceDisplay();
495        return;
496    }
497    lastPos = cEvent->pos();
498    if (setCorrectSlice(cEvent))
499        return;
500    int face = PixelAtPosition(cEvent->pos());
501
502        selectedPixel = face;
503        emit signalCurrentPixel(face);
504
505    updateGL();
506}
507
508/************************************************************
509 * SET CORRECT SLICE. if displayed, figures out if the graph was
510 * clicked, and if so, which slice should be displayed
511 ************************************************************/
512bool RawDataViewer::setCorrectSlice(QMouseEvent* cEvent)
513{
514    if (!drawImpulse)
515        return false;
516    float cx = (float)cEvent->x() * pixelSize - shownSizex/2;
517    float cy = ((float)height()-(float)cEvent->y())*pixelSize - shownSizey/2;
518    if (cx < bboxMin[0] ||
519        cx > bboxMax[0] ||
520        cy < bboxMin[1] ||
521        cy > bboxMax[1])
522        return false;
523    whichSlice = (cx - bboxMin[0])*(nRoi+nRoiTM)/(bboxMax[0] - bboxMin[0]);
524    if (whichSlice >= nRoi)
525        whichSlice = nRoi-1;
526    emit signalCurrentSlice(whichSlice);
527    return true;
528}
529
530/************************************************************
531 * MOUSE MOVE EVENT. used to track the dragging of slices display
532 ************************************************************/
533void RawDataViewer::mouseMoveEvent(QMouseEvent *cEvent)
534{
535    if (cEvent->buttons() & Qt::LeftButton) {
536        setCorrectSlice(cEvent);
537        updateGL();
538    } else if (cEvent->buttons() & Qt::RightButton) {
539        updateGL();
540    }
541    lastPos = cEvent->pos();
542}
543
544/************************************************************
545 * MOUSE DOUBLE CLICK EVENT. used to select pixels
546 ************************************************************/
547void RawDataViewer::mouseDoubleClickEvent(QMouseEvent *cEvent)
548{
549    int face = PixelAtPosition(cEvent->pos());
550    if (face != -1) {
551        selectedPixel = face;
552        emit signalCurrentPixel(face);
553        updateGL();
554        }
555}
556
557/************************************************************
558 * OPEN FILE. opens a new fits file
559 ************************************************************/
560void RawDataViewer::openFile(string& file)
561{
562    if (inputFile)
563    {
564        inputFile->close();
565        delete inputFile;
566    }
567    try {
568    inputFile = new factfits(file, "Events");
569    }
570    catch (std::runtime_error e)
571    {
572        cout << "Something went wrong while loading fits. Aborting: " << e.what() << endl;
573        return;
574    }
575    if (!*inputFile)
576    {
577        delete inputFile;
578        inputFile = NULL;
579        return;
580    }
581    vector<string> entriesToCheck;
582    if (inputFile->IsCompressedFITS())
583        entriesToCheck.push_back("ZNAXIS2");
584    else
585        entriesToCheck.push_back("NAXIS2");
586    entriesToCheck.push_back("NROI");
587    entriesToCheck.push_back("REVISION");
588    entriesToCheck.push_back("RUNID");
589    entriesToCheck.push_back("NBOARD");
590    entriesToCheck.push_back("NPIX");
591    entriesToCheck.push_back("NROITM");
592    entriesToCheck.push_back("TIMESYS");
593    entriesToCheck.push_back("DATE");
594    entriesToCheck.push_back("NIGHT");
595    entriesToCheck.push_back("CAMERA");
596    entriesToCheck.push_back("DAQ");
597    entriesToCheck.push_back("TSTART");
598    entriesToCheck.push_back("TSTOP");
599
600
601    for (vector<string>::const_iterator it=entriesToCheck.begin(); it != entriesToCheck.end(); it++)
602    {
603        try {
604        if (!inputFile->HasKey(*it)){
605            cout << "Warning: header keyword " << *it << " missing." << endl;
606            }
607        }
608        catch (std::runtime_error e)
609        {
610            cout << e.what() << endl;
611            return;
612        }
613    }
614
615    nRows = 0;
616    if (inputFile->IsCompressedFITS())
617        nRows = inputFile->HasKey("ZNAXIS2") ? inputFile->GetInt("ZNAXIS2") : 0;
618    else
619        nRows = inputFile->HasKey("NAXIS2") ? inputFile->GetInt("NAXIS2") : 0;
620    nRoi =           inputFile->HasKey("NROI") ?  inputFile->GetInt("NROI") : 0;
621    runNumber =      inputFile->HasKey("RUNID") ?  inputFile->GetInt("RUNID") : -1;
622    nTM =            inputFile->HasKey("NTMARK") ? inputFile->GetInt("NTMARK") : 0;
623
624    runType = "unkown";
625    if (inputFile->HasKey("RUNTYPE"))
626    {
627        runType = inputFile->GetStr("RUNTYPE");
628        if (runType == "")
629            runType = "unkown";
630    }
631    firstDataTime =  inputFile->HasKey("TSTART") ? inputFile->GetInt("TSTART") : -1;
632    lastDataTime =   inputFile->HasKey("TSTOP") ? inputFile->GetInt("TSTOP"): -1;
633    nRoiTM =         inputFile->HasKey("NROITM") ? inputFile->GetInt("NROITM") : 0;
634    revision =       inputFile->HasKey("REVISION") ? inputFile->GetInt("REVISION") : -1;
635    builderVersion = inputFile->HasKey("BLDVER") ? inputFile->GetInt("BLDVER") : -1;
636    nBoards =        inputFile->HasKey("NBOARD") ? inputFile->GetInt("NBOARD") : 0;
637    nPixels =        inputFile->HasKey("NPIX") ?  inputFile->GetInt("NPIX") : 0;
638    timeSystem =     inputFile->HasKey("TIMESYS") ? inputFile->GetStr("TIMESYS") : "";
639    creationDate =   inputFile->HasKey("DATE") ? inputFile->GetStr("DATE") : "";
640    nightInt =       inputFile->HasKey("NIGHT") ? inputFile->GetInt("NIGHT") : 0;
641    camera =         inputFile->HasKey("CAMERA") ? inputFile->GetStr("CAMERA") : "";
642    daq =            inputFile->HasKey("DAQ") ? inputFile->GetStr("DAQ") : "";
643    adcCount =       inputFile->HasKey("ADCRANGE") ? inputFile->GetFloat("ADCRANGE") : 2000;
644    if (nPixels == 0)
645    {
646        cout << "could not read num pixels from fits header. Assuming 1440 (FACT)." << endl;
647        nPixels = 1440;
648    }
649    if (nRoi == 0 && !inputFile->HasKey("NROI"))
650    {//let's try to figure out the roi from the column's format
651        const fits::Table::Columns& cols = inputFile->GetColumns();
652        if (cols.find("Data") == cols.end())
653        {
654            cout << "ERROR: Column \"Data\" could not be found. abortin load." << endl;
655            return;
656        }
657        const fits::Table::Columns::const_iterator col = cols.find("Data");
658        if (col->second.type != 'I')
659        {
660            cout << "ERROR: Data Column has type " << col->second.type << " while viewer expects I" << endl;
661            return;
662        }
663        if (col->second.num % nPixels != 0)
664        {
665            cout << "ERROR: Num pixels (" << nPixels << ") does not match Data length (" << col->second.num << "). Aborting" << endl;
666            return;
667        }
668        nRoi = col->second.num/nPixels;
669        cout << "Estimate num samples per pixels to be " << nRoi;
670        _softwareOrdering = true;
671    }
672    else
673        _softwareOrdering = false;
674
675    if (inputFile->HasKey("OFFSET"))
676        offSetRoi = inputFile->GetInt("OFFSET");
677
678    nbOk = 0;//inputFile->GetInt("NBEVTOK");
679    nbRej = 0;//inputFile->GetInt("NBEVTREJ");
680    nbBad = 0;//inputFile->GetInt("NBEVTBAD");
681
682    eventNum = 1;
683
684    if (eventData != NULL) {
685        delete[] eventData;
686        delete[] rawEventData;
687        delete[] waveLetArray;
688    }
689    eventData = new float[1440*nRoi + 160*nRoiTM];//(1440+160)*nRoi];
690
691    rawEventData = new int16_t[1440*nRoi + 160*nRoiTM];//(1440+160)*nRoi];
692    waveLetArray = new int16_t[1024*1440];
693    try
694    {
695        inputFile->SetPtrAddress("Data", rawEventData);
696        if (inputFile->HasColumn("EventNum"))
697            inputFile->SetPtrAddress("EventNum", &eventNum);
698        else
699            cout << "Warning: could not find column \"EventNum\"" << endl;
700        if (inputFile->HasColumn("TriggerType"))
701            inputFile->SetPtrAddress("TriggerType", &triggerType);
702        else
703            cout << "Warning: could not find column \"TriggerType\"" << endl;
704        if (inputFile->HasColumn("SoftTrig"))
705            inputFile->SetPtrAddress("SoftTrig", &softTrig);
706        else
707            cout << "Warning: could not find column \"SoftTrig\"" << endl;
708        if (inputFile->HasColumn("BoardTime"))
709            inputFile->SetPtrAddress("BoardTime", boardTime);
710        else
711            cout << "Warning: could not find column \"BoardTime\"" << endl;
712        if (inputFile->HasColumn("StartCellData"))
713            inputFile->SetPtrAddress("StartCellData", startPix);
714        else
715            cout << "Warning: could not find column \"StartCellData\"" << endl;
716        if (inputFile->HasColumn("StartCellTimeMarker"))
717            inputFile->SetPtrAddress("StartCellTimeMarker", startTM);
718        else
719            cout << "Warning: could not find column \"StartCellTimeMarker\"" << endl;
720        if (inputFile->HasColumn("TimeMarker"))
721            inputFile->SetPtrAddress("TimeMarker", &rawEventData[1440*nRoi]);
722        else
723            cout << "Warning: could not find column \"TimeMarker\"" << endl;
724    }
725    catch (const runtime_error &e)
726    {
727        cout << e.what() << endl;
728        cout << "Loading aborted." << endl;
729
730        nRoi = nRows = 0;
731
732        return;
733    }
734
735    try
736    {
737        pcTime[0] = pcTime[1] = 0;
738        if (inputFile->HasColumn("UnixTimeUTC"))
739            inputFile->SetPtrAddress("UnixTimeUTC", pcTime);
740    }
741    catch (const runtime_error&)
742    {
743            try
744        {
745            if (inputFile->HasColumn("PCTime"))
746                inputFile->SetPtrAddress("PCTime", pcTime);
747            else
748                cout << "Warning: could not find column \"UnixTimeUTC\" nor \"PCTime\"" << endl;
749
750        }
751        catch (const runtime_error&)
752        {
753
754        }
755    }
756
757
758    int backupStep = eventStep;
759    rowNum = -1;
760    eventStep = 1;
761
762    plusEvent();
763    eventStep = backupStep;
764    emit newFileLoaded();
765    emit signalCurrentPixel(selectedPixel);
766}
767
768void RawDataViewer::openCalibFile(string& file)
769{
770    //calibrationLoaded = false;
771    string msg;
772    try
773    {
774        msg = fDrsCalib.ReadFitsImp(file);
775        if (msg.empty())
776        {
777            emit newFileLoaded();
778            updateGL();
779            return;
780        }
781    }
782    catch (const runtime_error &e)
783    {
784        msg = string("Something went wrong while loading Drs Calib: ") + e.what() + string(".. Aborting file loading");
785    }
786    cerr << msg << endl;
787    fDrsCalib.Clear();
788}
789
790template <typename T>
791void RawDataViewer::getCalibrationDataForDisplay(const CalibDataTypes/* calibTypes*/,
792                                                 const vector<T>& inputData,
793                                                 const int roi,
794                                                 const int roiTM)
795{
796
797    eventData = new float[1440*roi + 160*roiTM];//(1440+160)*nRoi];
798    nRoi=roi;
799    nRoiTM=roiTM;
800
801    long long min, max, mean;
802    min = max = inputData[0];
803    mean=0;
804    for (int i=0;i<1440*roi + 160*roiTM;i++) {
805        eventData[i] = (float)inputData[i];
806        mean += inputData[i];
807        if (inputData[i] > max)
808            max = inputData[i];
809        if (inputData[i] < min)
810            min = inputData[i];
811    }
812    mean /= 1440*roi + 160*roiTM;
813    for (int i=0;i<1440*roi + 160*roiTM;i++)
814        eventData[i] -= (float)mean;
815    VALUES_SPAN = max - min;
816//    cout << VALUES_SPAN << " " << min << " " << max << " " << mean << endl;
817//    cout << 1440*roi + 160*roiTM << " " << roi << " " << roiTM << " " << inputData.size() << endl;
818}
819/************************************************************
820 * PLUS EVENT
821 ************************************************************/
822void RawDataViewer::plusEvent()
823{
824    eventStepping(true);
825}
826/************************************************************
827 * MINUS EVENT
828 ************************************************************/
829void RawDataViewer::minusEvent()
830{
831    eventStepping(false);
832}
833/************************************************************
834 * SET EVENT STEP
835 ************************************************************/
836void RawDataViewer::setEventStep(int step)
837{
838    eventStep = step;
839}
840/************************************************************
841 * EVENT STEPPING
842 ************************************************************/
843
844void RawDataViewer::ApplyCalibration()
845{
846    for (int i=0;i<1440*nRoi + 160*nRoiTM;i++)//(1440+160)*nRoi;i++)
847        eventData[i] = (float)rawEventData[i];
848
849    if (fIsDrsCalibration)
850    {
851        fDrsCalib.Apply(eventData, rawEventData, startPix, nRoi);
852        DrsCalibrate::RemoveSpikes(eventData, nRoi);
853        //TODO apply calibration to the Time markers
854    }
855
856    //hide the time markers
857    int nSlicesToRemove = 60;
858    float* backupData = 0;
859    if (nRoiTM == 0) //they are written into the regular channel
860    {
861        backupData = new float[nSlicesToRemove*160];
862        for (int i=0;i<1440;i++)
863        {
864            const PixelMapEntry& mapEntry = fPixelMap.index(i);
865            const int pixelIdInPatch = mapEntry.pixel();
866            const int patchId = mapEntry.patch();
867            const int boardId = mapEntry.board();
868            const int crateId = mapEntry.crate();
869
870            const int hw = mapEntry.hw();
871            if (pixelIdInPatch == 8)
872            {
873                for (int j=0;j<nSlicesToRemove;j++)
874                {
875                    backupData[(40*crateId + 4*boardId + patchId)*nSlicesToRemove+j] = eventData[(hw*nRoi) + (nRoi-nSlicesToRemove) + j];
876                    eventData[(hw*nRoi) + (nRoi-nSlicesToRemove) + j] = eventData[hw*nRoi + (nRoi-nSlicesToRemove) - 1];
877                }
878            }
879        }
880    }
881
882    vector<float> pixelStatsData(1440*4);
883    DrsCalibrate::GetPixelStats(pixelStatsData.data(), eventData, nRoi);
884
885    for (vector<PixelMapEntry>::const_iterator it=fPixelMap.begin(); it!=fPixelMap.end(); it++)
886    {
887        Meanvalues[it->index]     = pixelStatsData[0*1440+it->hw()];
888        RMSvalues[it->index]      = pixelStatsData[1*1440+it->hw()];
889        Maxvalues[it->index]      = pixelStatsData[2*1440+it->hw()];
890        PosOfMaxvalues[it->index] = pixelStatsData[3*1440+it->hw()];
891    }
892    if (nRoiTM == 0)//move back the data back in place
893    {
894        for (int i=0;i<1440;i++)
895        {
896            const PixelMapEntry& mapEntry = fPixelMap.index(i);
897            const int pixelIdInPatch = mapEntry.pixel();
898            const int patchId = mapEntry.patch();
899            const int boardId = mapEntry.board();
900            const int crateId = mapEntry.crate();
901            if (patchId > 160)
902                cout << "Voila mon probleme: " << patchId << endl;
903            const int hw = mapEntry.hw();
904            if (pixelIdInPatch == 8)
905            {
906 //               cout << "|" << crateId << " " << boardId << " " << patchId << " " << hw << "| ";
907                for (int j=0;j<nSlicesToRemove;j++)
908                {
909                    eventData[(hw*nRoi) + (nRoi - nSlicesToRemove) + j] = backupData[(40*crateId + 4*boardId + patchId)*nSlicesToRemove+j];
910                }
911            }
912        }
913        delete[] backupData;
914    }
915    if (isVisible())
916        updateGL();
917}
918
919void RawDataViewer::eventStepping(bool plus)
920{
921    if (plus)
922        rowNum += eventStep;
923    else
924        rowNum -= eventStep;
925    if (rowNum >= nRows)
926        rowNum -= nRows;
927    if (rowNum < 0)
928        rowNum += nRows;
929
930    if (inputFile == NULL)
931        return;
932    inputFile->GetRow(rowNum);
933    if (_softwareOrdering)
934    {//remap pixels data according to hardware id
935        if (nRoiTM != 0)
936            cout << "Warning: did not expect Time Markers data from Monte-Carlo simulations. These will not be mapped properly." << endl;
937        //first copy the data
938        int16_t* tempData = new int16_t[1440*nRoi];
939        for (int i=0;i<1440*nRoi;i++)
940            tempData[i] = rawEventData[i];
941        //copy back the data and re-map it on the fly
942        for (int i=0;i<1440;i++)
943            for (int j=0;j<nRoi;j++)
944                rawEventData[i*nRoi + j] = tempData[softwareMapping[i]*nRoi + j];
945
946        delete[] tempData;
947    }
948//    cout << "Getting row " << rowNum << endl;
949
950
951    ApplyCalibration();
952
953    emit signalCurrentEvent(eventNum);
954    emit signalCurrentPixel(selectedPixel);
955}
956
957/************************************************************
958 * NEXT SLICE. deprec ?
959 ************************************************************/
960void RawDataViewer::nextSlice()
961{
962    whichSlice++;
963    if (whichSlice >= nRoi)
964    {
965        whichSlice = 0;
966        if (!loopCurrentEvent)
967        {
968            int backupStep = eventStep;
969            eventStep = 1;
970            eventStepping(true);
971            eventStep = backupStep;
972        }
973    }
974    emit signalCurrentSlice(whichSlice);
975    updateGL();
976}
977void RawDataViewer::previousSlice()
978{
979    whichSlice--;
980    if (whichSlice < 0)
981    {
982        whichSlice = nRoi-1;
983        if (!loopCurrentEvent)
984        {
985            int backupStep = eventStep;
986            eventStep = 1;
987            eventStepping(false);
988            eventStep = backupStep;
989        }
990    }
991    emit signalCurrentSlice(whichSlice);
992    updateGL();
993}
994void RawDataViewer::setCurrentPixel(int pix)
995{
996 //   if (pix == -1)
997 //       return;
998    selectedPixel = pix;
999    if (isVisible())
1000    updateGL();
1001     emit signalCurrentPixel(pix);
1002}
1003void RawDataViewer::computePulsesStatistics()
1004{
1005    if (!inputFile)
1006    {
1007        cout << "A FITS file must be open in order to complete this operation" << endl;
1008        return;
1009    }
1010
1011
1012//    for (int i=0;i<nRows;i++)//for all events
1013//    {
1014//        inputFile->GetRow(rowNum);
1015//        for (int i=0;i<(1440+160)*nRoi;i++)
1016//            eventData[i] = (float)rawEventData[i];
1017
1018//        for (int j=0;j<ACTUAL_NUM_PIXELS;j++)
1019///        {
1020    int j = selectedPixel;
1021    if (j == -1)
1022        return;
1023            for (int i=0;i<nRoi;i++)
1024            {
1025                aMeas[i] = eventData[j*nRoi+i];// * adcCount;
1026
1027            }
1028            for (int i=0;i<nRoi;i++)
1029            {
1030                if (i==0)
1031                    n1mean[i] = aMeas[i+1];
1032                else
1033                {
1034                    if (i==1023)
1035                        n1mean[i] = aMeas[i-1];
1036                    else
1037                        n1mean[i] = (aMeas[i-1]+aMeas[i+1])/2.f;
1038                }
1039            }
1040            //find spike
1041            for (int i=0;i<nRoi-3;i++)
1042            {
1043                const float fract = 0.8f;
1044                float xx, xp, xpp;
1045                vCorr[i] = 0;//aMeas[i];
1046                xx = aMeas[i] - n1mean[i];
1047                if (xx < -8.f)
1048                {
1049                    xp = aMeas[i+1] - n1mean[i+1];
1050                    xpp = aMeas[i+2] - n1mean[i+2];
1051                    if ((aMeas[i+2] - (aMeas[i] + aMeas[i+3])/2.f) > 10.f)
1052                    {
1053                        vCorr[i+1] = (aMeas[i] + aMeas[i+3])/2.f;
1054                        vCorr[i+2] = (aMeas[i] + aMeas[i+3])/2.f;
1055                        i = i+2;
1056                    }
1057                    else
1058                    {
1059                        if ((xp > -2.*xx*fract) && (xpp < -10.f))
1060                        {
1061                            vCorr[i+1] = n1mean[i+1];
1062                            n1mean[i+2] = aMeas[i+1] - aMeas[i+3]/2.f;
1063                            i++;
1064                        }
1065                    }
1066                }
1067            }
1068            for (int i=0;i<nRoi;i++)
1069                n1mean[i] = aMeas[i]-n1mean[i];
1070 //       }
1071 //   }
1072}
1073/************************************************************
1074 * UICONNECTOR CONSTRUCTOR
1075 ************************************************************/
1076UIConnector::UIConnector(QWidget *p)
1077{
1078    setupUi(this);
1079    initHistograms();
1080
1081    currentFile = "none";
1082    currentCalibFile = "none";
1083
1084    updateSpinnerDisplay = true;
1085    updating = false;
1086
1087    timer.setInterval(10.0);
1088    QObject::connect(&timer, SIGNAL(timeout()),
1089                     this, SLOT(nextSlicePlease()));
1090
1091    QButtonGroup &scaleGroup = *new QButtonGroup(p);// = new QButtonGroup(canvas);
1092    QButtonGroup &animateGroup = *new QButtonGroup(p);// = new QButtonGroup(canvas);
1093
1094    scaleGroup.addButton(currentPixelScale);
1095    scaleGroup.addButton(entireCameraScale);
1096
1097    animateGroup.addButton(playEventsRadio);
1098    animateGroup.addButton(playSlicesRadio);
1099    animateGroup.addButton(playPixelsRadio);
1100
1101    entireCameraScale->setChecked(true);
1102
1103    RMS_window->enableText(false);
1104    Mean_window->enableText(false);
1105    PosOfMax_window->enableText(false);
1106    Max_window->enableText(false);
1107
1108 //   RMS_window->ShowPatchCursor(true);
1109
1110    QObject::connect(GLWindow, SIGNAL(colorPaletteHasChanged()),
1111                     this, SLOT(on_autoScaleColor_clicked()));
1112    QObject::connect(GLWindow, SIGNAL(signalCurrentSlice(int)),
1113                     this, SLOT(currentSliceHasChanged(int)));
1114    QObject::connect(GLWindow, SIGNAL(signalCurrentEvent(int)),
1115                     this, SLOT(currentEventHasChanged(int)));
1116    QObject::connect(GLWindow, SIGNAL(signalCurrentPixel(int)),
1117                     this, SLOT(pixelChanged(int)));
1118    QObject::connect(GLWindow, SIGNAL(newFileLoaded()),
1119                     this, SLOT(newFileLoaded()));
1120
1121    QObject::connect(RMS_window, SIGNAL(signalCurrentPixel(int)),
1122                     GLWindow, SLOT(setCurrentPixel(int)));
1123    QObject::connect(Max_window, SIGNAL(signalCurrentPixel(int)),
1124                     GLWindow, SLOT(setCurrentPixel(int)));
1125    QObject::connect(PosOfMax_window, SIGNAL(signalCurrentPixel(int)),
1126                     GLWindow, SLOT(setCurrentPixel(int)));
1127    QObject::connect(Mean_window, SIGNAL(signalCurrentPixel(int)),
1128                     GLWindow, SLOT(setCurrentPixel(int)));
1129
1130
1131
1132    show();
1133}
1134UIConnector::~UIConnector()
1135{
1136    grid1->detach();
1137    grid2->detach();
1138    grid3->detach();
1139    grid4->detach();
1140    grid5->detach();
1141    grid6->detach();
1142    boardsTimeHistoItem.detach();
1143    startCellHistoItem.detach();
1144    startTimeMarkHistoItem.detach();
1145    pixelValueCurveItem.detach();
1146    pixelAverageCurveItem.detach();
1147    aMeanCurveItem.detach();
1148    vCorrCurveItem.detach();
1149    meanCurveItem.detach();
1150}
1151void UIConnector::slicesPlusPlus()
1152{
1153    GLWindow->nextSlice();
1154}
1155void UIConnector::slicesMinusMinus()
1156{
1157    GLWindow->previousSlice();
1158}
1159void UIConnector::on_calibratedCheckBox_stateChanged(int state)
1160{
1161    GLWindow->fIsDrsCalibration = state;
1162    GLWindow->ApplyCalibration();
1163    threeD_Window->setData(GLWindow->eventData);
1164
1165    on_autoScaleColor_clicked();
1166    pixelChanged(GLWindow->selectedPixel);
1167
1168}
1169/************************************************************
1170 * DRAW PATCHES CHECK CHANGE. checkbox handler
1171 ************************************************************/
1172void UIConnector::on_drawPatchCheckBox_stateChanged(int state)
1173{
1174    GLWindow->drawPatch = state;
1175    GLWindow->updateGL();
1176    RMS_window->fDrawPatch = state;
1177    RMS_window->updateGL();
1178    Mean_window->fDrawPatch = state;
1179    Mean_window->updateGL();
1180    Max_window->fDrawPatch = state;
1181    Max_window->updateGL();
1182    PosOfMax_window->fDrawPatch = state;
1183    PosOfMax_window->updateGL();
1184}
1185/************************************************************
1186 * DRAW IMPULSE CHECK CHANGE. checkbox handler
1187 ************************************************************/
1188void UIConnector::on_drawImpulseCheckBox_stateChanged(int state)
1189{
1190    GLWindow->drawImpulse = state;
1191    TriggerOffset_window->drawImpulse = state;
1192    Gain_window->drawImpulse = state;
1193    Baseline_window->drawImpulse = state;
1194    GLWindow->updateGL();
1195    TriggerOffset_window->updateGL();
1196    Gain_window->updateGL();
1197    Baseline_window->updateGL();
1198}
1199/************************************************************
1200 * DRAW BLUR CHECK CHANGE. checkbox handler
1201 ************************************************************/
1202void UIConnector::on_drawBlurCheckBox_stateChanged(int state)
1203{
1204    GLWindow->drawBlur = state;
1205    GLWindow->updateGL();
1206}
1207void UIConnector::on_loopOverCurrentEventBox_stateChanged(int state)
1208{
1209    GLWindow->loopCurrentEvent = state;
1210}
1211
1212/************************************************************
1213 * NEXT SLICE PLEASE
1214 ************************************************************/
1215void UIConnector::nextSlicePlease()
1216{
1217    if (playEventsRadio->isChecked ())
1218        GLWindow->eventStepping(true);
1219    else
1220        if (playPixelsRadio->isChecked())
1221            GLWindow->setCurrentPixel((GLWindow->getCurrentPixel()+1)%1440);
1222        else
1223            GLWindow->nextSlice();
1224}
1225
1226/************************************************************
1227 * SET VIEWER.
1228 ************************************************************/
1229//void UIConnector::setViewer(RawDataViewer* v)
1230//{
1231//    viewer = v;
1232//}
1233/************************************************************
1234 * SLICES PER SECOND CHANGED. timing ui handler
1235 ************************************************************/
1236void UIConnector::slicesPerSecondChanged(double value)
1237{
1238    timer.setInterval(1000.0/value);
1239}
1240
1241void UIConnector::on_colorRange0_valueChanged(double value) { GLWindow->ss[0] = (float)value; GLWindow->updateGL(); }
1242void UIConnector::on_colorRange1_valueChanged(double value) { GLWindow->ss[1] = (float)value; GLWindow->updateGL(); }
1243void UIConnector::on_colorRange2_valueChanged(double value) { GLWindow->ss[2] = (float)value; GLWindow->updateGL(); }
1244void UIConnector::on_colorRange3_valueChanged(double value) { GLWindow->ss[3] = (float)value; GLWindow->updateGL(); }
1245void UIConnector::on_colorRange4_valueChanged(double value) { GLWindow->ss[4] = (float)value; GLWindow->updateGL(); }
1246
1247void UIConnector::on_redValue0_valueChanged(double value) { GLWindow->rr[0] = (float)value; GLWindow->updateGL(); }
1248void UIConnector::on_redValue1_valueChanged(double value) { GLWindow->rr[1] = (float)value; GLWindow->updateGL(); }
1249void UIConnector::on_redValue2_valueChanged(double value) { GLWindow->rr[2] = (float)value; GLWindow->updateGL(); }
1250void UIConnector::on_redValue3_valueChanged(double value) { GLWindow->rr[3] = (float)value; GLWindow->updateGL(); }
1251void UIConnector::on_redValue4_valueChanged(double value) { GLWindow->rr[4] = (float)value; GLWindow->updateGL(); }
1252
1253void UIConnector::on_greenValue0_valueChanged(double value) { GLWindow->gg[0] = (float)value; GLWindow->updateGL(); }
1254void UIConnector::on_greenValue1_valueChanged(double value) { GLWindow->gg[1] = (float)value; GLWindow->updateGL(); }
1255void UIConnector::on_greenValue2_valueChanged(double value) { GLWindow->gg[2] = (float)value; GLWindow->updateGL(); }
1256void UIConnector::on_greenValue3_valueChanged(double value) { GLWindow->gg[3] = (float)value; GLWindow->updateGL(); }
1257void UIConnector::on_greenValue4_valueChanged(double value) { GLWindow->gg[4] = (float)value; GLWindow->updateGL(); }
1258
1259void UIConnector::on_blueValue0_valueChanged(double value) { GLWindow->bb[0] = (float)value; GLWindow->updateGL(); }
1260void UIConnector::on_blueValue1_valueChanged(double value) { GLWindow->bb[1] = (float)value; GLWindow->updateGL(); }
1261void UIConnector::on_blueValue2_valueChanged(double value) { GLWindow->bb[2] = (float)value; GLWindow->updateGL(); }
1262void UIConnector::on_blueValue3_valueChanged(double value) { GLWindow->bb[3] = (float)value; GLWindow->updateGL(); }
1263void UIConnector::on_blueValue4_valueChanged(double value) { GLWindow->bb[4] = (float)value; GLWindow->updateGL(); }
1264
1265/************************************************************
1266 * LOAD NEW FILE CLICKED. button handler
1267 ************************************************************/
1268void UIConnector::on_loadNewFileButton_clicked()
1269{
1270    QFileDialog dialog;
1271    dialog.setFileMode(QFileDialog::ExistingFile);
1272    dialog.open(this, SLOT(fileSelected(QString)));
1273    dialog.setVisible(true);
1274    dialog.exec();
1275}
1276void UIConnector::on_loadDRSCalibButton_clicked()
1277{
1278    QFileDialog dialog;
1279    dialog.setFileMode(QFileDialog::ExistingFile);
1280    dialog.open(this, SLOT(calibFileSelected(QString)));
1281    dialog.setVisible(true);
1282    dialog.exec();
1283}
1284/************************************************************
1285 * FILE SELECTED. return of the file open dialog handler
1286 ************************************************************/
1287void UIConnector::fileSelected(QString file)
1288{
1289    currentFile = file.toStdString();
1290    if (currentFile != "")
1291        GLWindow->openFile(currentFile);
1292}
1293void UIConnector::calibFileSelected(QString file)
1294{
1295    currentCalibFile = file.toStdString();
1296    if (currentCalibFile != "")
1297        GLWindow->openCalibFile(currentCalibFile);
1298    if (GLWindow->fDrsCalib.fRoi != 0)
1299    {//spread the calibration data to the displayers
1300        Baseline_window->getCalibrationDataForDisplay(RawDataViewer::CALIB_BASELINE,
1301                                                      GLWindow->fDrsCalib.fOffset,
1302                                                      GLWindow->fDrsCalib.fRoi,
1303                                                      GLWindow->fDrsCalib.fNumTm);
1304
1305        Gain_window->getCalibrationDataForDisplay(RawDataViewer::CALIB_GAIN,
1306                                                  GLWindow->fDrsCalib.fGain,
1307                                                  GLWindow->fDrsCalib.fRoi,
1308                                                  GLWindow->fDrsCalib.fNumTm);
1309
1310        TriggerOffset_window->getCalibrationDataForDisplay(RawDataViewer::CALIB_TRIG_OFFSET,
1311                                                           GLWindow->fDrsCalib.fTrgOff,
1312                                                           GLWindow->fDrsCalib.fRoi,
1313                                                           GLWindow->fDrsCalib.fNumTm);
1314
1315    }
1316}
1317/************************************************************
1318 * NEW FILE LOADED. update of the UI after a new file has been loaded
1319 ************************************************************/
1320void UIConnector::newFileLoaded()
1321{
1322    ostringstream str;
1323
1324    //extract the file name only (no path) from the full name
1325    str << "File: ";
1326    if (currentFile.size() > 2)
1327        str << currentFile.substr(currentFile.find_last_of("//")+1, currentFile.size()) << "\n";
1328    else
1329        str << "--\n";
1330    str << "Calibration: ";
1331    if (currentCalibFile.size() > 2)
1332        str << currentCalibFile.substr(currentCalibFile.find_last_of("//")+1, currentCalibFile.size()) << "\n";
1333    else
1334        str << "--\n";
1335//    fileLoadedLabel->setText(QString(str.str().c_str()));
1336//    str.str("");
1337    str << "Run number: " << GLWindow->runNumber << "\n";
1338//    runNumberLabel->setText(QString(str.str().c_str()));
1339//    str.str("");
1340    str << "Number of Events: " << GLWindow->nRows << "\n";
1341
1342    displayingEventBox->setMaximum(GLWindow->nRows-1);
1343
1344    str << "Number of Slices: " << GLWindow->nRoi << "\n";// << "/1024";
1345//    numberOfSlicesLabel->setText(QString(str.str().c_str()));
1346//    str.str("");
1347    str << "Number of Time Marks: " << GLWindow->nTM << "\n";
1348//    numberOfTimeMarksLabel->setText(QString(str.str().c_str()));
1349
1350//    str.str("");
1351    str << "Run Type: " << GLWindow->runType << "\n";
1352//    runTypeLabel->setText(QString(str.str().c_str()));
1353//    str.str("");
1354    str << "Time of 1st data: " << GLWindow->firstDataTime << "\n";
1355//    firstTimeLabel->setText(QString(str.str().c_str()));
1356//    str.str("");
1357    str << "Time of last data: " << GLWindow->lastDataTime << "\n";
1358//    lastTimeLabel->setText(QString(str.str().c_str()));
1359//    str.str("");
1360    str << "SVN revision: " << GLWindow->revision << '\n';
1361    str << "Number of boards: " << GLWindow->nBoards << '\n';
1362    str << "Number of pixels: " << GLWindow->nPixels << '\n';
1363    str << "Number of Slices TM: " << GLWindow->nRoiTM << '\n';
1364    str << "Time system: " << GLWindow->timeSystem << '\n';
1365    str << "Date: " << GLWindow->creationDate << '\n';
1366    str << "Night: " << GLWindow->nightInt << '\n';
1367    str << "Camera: " << GLWindow->camera << '\n';
1368    str << "DAQ: " << GLWindow->daq << '\n';
1369    str << "ADC Count: " << GLWindow->adcCount << '\n';
1370    str << "NB Evts OK:" << GLWindow->nbOk << '\n';
1371    str << "NB Evts Rejected: " << GLWindow->nbRej << '\n';
1372    str << "NB Evts Bad: " << GLWindow->nbBad << '\n';
1373    extraInfoLabel->setText(QString(str.str().c_str()));
1374
1375    /*
1376    if (GLWindow->calibrationLoaded)
1377    {
1378        drawCalibrationCheckBox->setEnabled(true);
1379    }*/
1380
1381
1382}
1383/************************************************************
1384 * PLAY PAUSE CLICKED. ui handler
1385 ************************************************************/
1386void UIConnector::on_playPauseButton_clicked()
1387{
1388    if (timer.isActive())
1389        timer.stop();
1390    else
1391        timer.start();
1392}
1393
1394void UIConnector::displaySliceValue()
1395{
1396    if (!GLWindow->nRoi)
1397        return;
1398    if (GLWindow->selectedPixel == -1)
1399    {
1400        ostringstream str;
1401        str << " Current Pixel val.: --";
1402        currentPixelValue->setText(QString(str.str().c_str()));
1403        return;
1404    }
1405//    int mapping = GLWindow->_softwareOrdering ? GLWindow->selectedPixel : GLWindow->hardwareMapping[GLWindow->selectedPixel];
1406    int mapping = GLWindow->hardwareMapping[GLWindow->selectedPixel];
1407    const int idx = GLWindow->nRoi*mapping + GLWindow->whichSlice;
1408
1409    ostringstream str;
1410    str << "Current Pixel val.: " << GLWindow->eventData[idx];
1411    currentPixelValue->setText(QString(str.str().c_str()));
1412}
1413
1414/************************************************************
1415 * CURRENT SLICE HAS CHANGE. ui handler
1416 ************************************************************/
1417void UIConnector::currentSliceHasChanged(int slice)
1418{
1419    if (!GLWindow->nRoi)
1420        return;
1421
1422    if (updateSpinnerDisplay)
1423        displayingSliceBox->setValue(slice);
1424
1425    displaySliceValue();
1426}
1427
1428/*****
1429 *******************************************************
1430 * CURRENT EVENT HAS CHANGED. ui handler
1431 ************************************************************/
1432
1433double xval[50000];
1434double yval[50000];
1435void UIConnector::on_displayingEventBox_valueChanged(int cEvent)
1436{
1437//    cout << "Here " << updateSpinnerDisplay << endl;
1438    if (!updateSpinnerDisplay)
1439        return;
1440    updateSpinnerDisplay = false;
1441//    currentEventHasChanged(cEvent);
1442    GLWindow->rowNum = cEvent - GLWindow->eventStep;
1443    GLWindow->eventStepping(true);
1444    updateSpinnerDisplay = true;
1445
1446//    GLWindow->updateGL();
1447}
1448void UIConnector::on_slicesPerSecValue_valueChanged(double value)
1449{
1450    timer.setInterval(1000.0/value);
1451}
1452void UIConnector::on_displayingSliceBox_valueChanged(int cSlice)
1453{
1454    updateSpinnerDisplay = false;
1455    currentSliceHasChanged(cSlice);
1456    updateSpinnerDisplay = true;
1457    GLWindow->whichSlice = cSlice;
1458    GLWindow->updateGL();
1459}
1460void UIConnector::currentEventHasChanged(int )
1461{
1462
1463    RMS_window->SetData(GLWindow->RMSvalues);
1464    Mean_window->SetData(GLWindow->Meanvalues);
1465    PosOfMax_window->SetData(GLWindow->PosOfMaxvalues);
1466    Max_window->SetData(GLWindow->Maxvalues);
1467    threeD_Window->setData(GLWindow->eventData);//rawEventData);
1468
1469    if (RMS_window->isVisible())
1470        RMS_window->updateGL();
1471    if (Mean_window->isVisible())
1472        Mean_window->updateGL();
1473    if (PosOfMax_window->isVisible())
1474        PosOfMax_window->updateGL();
1475    if (Max_window->isVisible())
1476        Max_window->updateGL();
1477    ostringstream str;
1478//    str << "Displaying Event " << cEvent;
1479//    QString qstr(str.str().c_str());
1480//    emit updateCurrentEventDisplay(qstr);
1481    if (updateSpinnerDisplay)
1482    {
1483        updateSpinnerDisplay = false;
1484        displayingEventBox->setValue(GLWindow->rowNum);
1485        updateSpinnerDisplay = true;
1486    }
1487
1488 //   GLWindow->doWaveLetOnCurrentEventPlease();
1489
1490        //retrieve the data that we want to display
1491    boost::posix_time::ptime hrTime( boost::gregorian::date(1970, boost::gregorian::Jan, 1),
1492            boost::posix_time::seconds(GLWindow->pcTime[0]) +  boost::posix_time::microsec(GLWindow->pcTime[1]));
1493
1494    str.str("");
1495    str << "PC Time: " << boost::posix_time::to_iso_extended_string(hrTime);
1496    PCTimeLabel->setText(QString(str.str().c_str()));
1497
1498    str.str("");
1499    str << "Software Trigger: " << GLWindow->softTrig;
1500    softwareTriggerLabel->setText(QString(str.str().c_str()));
1501
1502    str.str("");
1503    str << "Trigger Type: " << GLWindow->triggerType;
1504    triggerTypeLabel->setText(QString(str.str().c_str()));
1505
1506    displaySliceValue();
1507
1508    if (autoScaleColor->isChecked())
1509        emit GLWindow->colorPaletteHasChanged();//autoScalePressed();
1510
1511    boardsTimeList->clear();
1512    startPixelsList->clear();
1513    startTimeMarksList->clear();
1514    triggerDelayList->clear();
1515    std::map<int, int> boardsHistoMap;
1516    for (int i=0;i <NBOARDS; i++)
1517    {
1518        str.str("");
1519        str << i;
1520        if (i<10) str << " ";
1521        if (i<100) str << " ";
1522        if (i<1000) str << " ";
1523        str << ": " << GLWindow->boardTime[i];
1524        boardsTimeList->addItem(QString(str.str().c_str()));
1525        if (boardsHistoMap.find(GLWindow->boardTime[i]) != boardsHistoMap.end())
1526            boardsHistoMap[GLWindow->boardTime[i]]++;
1527        else
1528            boardsHistoMap[GLWindow->boardTime[i]] = 1;
1529    }
1530    std::map<int, int> pixelHistoMap;
1531    for (int i=0;i <NPIX; i++)
1532    {
1533        str.str("");
1534        str << i;
1535        if (i<10) str << " ";
1536        if (i<100) str << " ";
1537        if (i<1000) str << " ";
1538        str << ": " << GLWindow->startPix[i];
1539        startPixelsList->addItem(QString(str.str().c_str()));
1540        if (pixelHistoMap.find(GLWindow->startPix[i]) != pixelHistoMap.end())
1541            pixelHistoMap[GLWindow->startPix[i]]++;
1542        else
1543            pixelHistoMap[GLWindow->startPix[i]] = 1;
1544    }
1545
1546    std::map<int, int> timeMarksMap;
1547    for (int i=0;i <NTMARK; i++)
1548    {
1549        str.str("");
1550        str << i;
1551        if (i<10) str << " ";
1552        if (i<100) str << " ";
1553        if (i<1000) str << " ";
1554        str << ": " << GLWindow->startTM[i];
1555        startTimeMarksList->addItem(QString(str.str().c_str()));
1556        if (timeMarksMap.find(GLWindow->startTM[i]) != timeMarksMap.end())
1557            timeMarksMap[GLWindow->startTM[i]]++;
1558        else
1559            timeMarksMap[GLWindow->startTM[i]] = 1;
1560    }
1561    std::map<int,int> delayMap;
1562    triggerDelayList->addItem(QString("Patch | Slice:Delay Slice:Delay..."));
1563    for (int i=0;i<NTMARK; i++)
1564    {
1565        str.str("");
1566        str << i << " | ";
1567        for (int j=0;j<GLWindow->nRoi;j++)
1568        {
1569            int value = GLWindow->eventData[1440*GLWindow->nRoi + i*GLWindow->nRoi + j];
1570            if (delayMap.find(value) != delayMap.end())
1571                 delayMap[value]++;
1572             else
1573                 delayMap[value] = 1;
1574            str << j << ":" << value << " ";
1575         }
1576        triggerDelayList->addItem(QString(str.str().c_str()));
1577    }
1578
1579    std::map<int,int>::iterator it = boardsHistoMap.begin();
1580    int nsamples = 0;
1581    int previousValue = it->first-10;
1582    for (unsigned int i=0;i<boardsHistoMap.size();i++)
1583    {
1584        if (previousValue != it->first-1)
1585        {
1586            xval[nsamples] = previousValue+1;
1587            yval[nsamples] = 0;
1588            nsamples++;
1589            xval[nsamples] = it->first-1;
1590            yval[nsamples] = 0;
1591            nsamples++;
1592        }
1593        xval[nsamples] = it->first;
1594        yval[nsamples] = it->second;
1595        previousValue = it->first;
1596        it++;
1597        nsamples++;
1598        xval[nsamples] = previousValue;
1599        yval[nsamples] = 0;
1600        nsamples++;
1601        if (nsamples > 4090)
1602        {
1603            cout << "Error: Maximum number of samples reached for histograms. skipping what's remaining" << endl;
1604            break;
1605        }
1606    }
1607    xval[nsamples] = it==boardsHistoMap.begin() ? 0 : (--it)->first+1;
1608    yval[nsamples] = 0;
1609    nsamples++;
1610 //   if (nsamples > 5)
1611#if QWT_VERSION < 0x060000
1612       boardsTimeHistoItem.setData(xval, yval, nsamples);
1613#else
1614       boardsTimeHistoItem.setSamples(xval, yval, nsamples);
1615#endif
1616
1617    it = pixelHistoMap.begin();
1618    nsamples = 0;
1619    previousValue = it->first-10;
1620    for (unsigned int i=0;i<pixelHistoMap.size();i++)
1621    {
1622        if (previousValue != it->first-1)
1623        {
1624            xval[nsamples] = previousValue+1;
1625            yval[nsamples] = 0;
1626            nsamples++;
1627            xval[nsamples] = it->first-1;
1628            yval[nsamples] = 0;
1629            nsamples++;
1630        }
1631        xval[nsamples] = it->first;
1632        yval[nsamples] = it->second;
1633        previousValue = it->first;
1634        it++;
1635        nsamples++;
1636        xval[nsamples] = previousValue;
1637        yval[nsamples] = 0;
1638        nsamples++;
1639        if (nsamples > 4090)
1640        {
1641            cout << "Error: Maximum number of samples reached for histograms. skipping what's remaining" << endl;
1642            break;
1643        }
1644   }
1645    xval[nsamples] = it==pixelHistoMap.begin() ? 0 : (--it)->first+1;
1646    yval[nsamples] = 0;
1647    nsamples++;
1648//    if (nsamples > 5)
1649#if QWT_VERSION < 0x060000
1650       startCellHistoItem.setData(xval, yval, nsamples);
1651#else
1652       startCellHistoItem.setSamples(xval, yval, nsamples);
1653#endif
1654
1655    it = timeMarksMap.begin();
1656    nsamples = 0;
1657    previousValue = it->first-10;
1658    for (unsigned int i=0;i<timeMarksMap.size();i++)
1659    {
1660        if (previousValue != it->first-1)
1661        {
1662            xval[nsamples] = previousValue+1;
1663            yval[nsamples] = 0;
1664            nsamples++;
1665            xval[nsamples] = it->first-1;
1666            yval[nsamples] = 0;
1667            nsamples++;
1668        }
1669        xval[nsamples] = it->first;
1670        yval[nsamples] = it->second;
1671        previousValue = it->first;
1672        it++;
1673        nsamples++;
1674        xval[nsamples] = previousValue;
1675        yval[nsamples] = 0;
1676        nsamples++;
1677        if (nsamples > 4090)
1678        {
1679            cout << "Error: Maximum number of samples reached for histograms. skipping what's remaining" << endl;
1680            break;
1681        }
1682    }
1683    xval[nsamples] = it==timeMarksMap.begin() ? 0 : (--it)->first+1;
1684    yval[nsamples] = 0;
1685    nsamples++;
1686 //   if (nsamples > 5)
1687#if QWT_VERSION < 0x060000
1688       startTimeMarkHistoItem.setData(xval, yval, nsamples);
1689#else
1690       startTimeMarkHistoItem.setSamples(xval, yval, nsamples);
1691#endif
1692
1693    it = delayMap.begin();
1694    nsamples = 0;
1695    previousValue = it->first-10;
1696    for (unsigned int i=0;i<delayMap.size();i++)
1697    {
1698        if (previousValue != it->first-1)
1699        {
1700            xval[nsamples] = previousValue+1;
1701            yval[nsamples] = 0;
1702            nsamples++;
1703            xval[nsamples] = it->first-1;
1704            yval[nsamples] = 0;
1705            nsamples++;
1706        }
1707        xval[nsamples] = it->first;
1708        yval[nsamples] = it->second;
1709        previousValue = it->first;
1710        it++;
1711        nsamples++;
1712        xval[nsamples] = previousValue;
1713        yval[nsamples] = 0;
1714        nsamples++;
1715        if (nsamples > 4090)
1716        {
1717            cout << "Error: Maximum number of samples reached for histograms. skipping what's remaining" << endl;
1718            break;
1719        }
1720    }
1721    xval[nsamples] = it==delayMap.begin() ? 0 : (--it)->first+1;
1722    yval[nsamples] = 0;
1723    nsamples++;
1724  //  if (nsamples > 5)
1725#if QWT_VERSION < 0x060000
1726       triggerDelayHistoItem.setData(xval, yval, nsamples);
1727#else
1728       triggerDelayHistoItem.setSamples(xval, yval, nsamples);
1729#endif
1730       //WAVELETS HACK
1731/*       std::map<int, int> valuesHistoMap;
1732       std::map<int, int> waveletHistoMap;
1733       for (int i=0;i<1024*1440;i++)
1734       {
1735           if (valuesHistoMap.find(GLWindow->rawEventData[i]) != valuesHistoMap.end())
1736               valuesHistoMap[GLWindow->rawEventData[i]]++;
1737           else
1738               valuesHistoMap[GLWindow->rawEventData[i]] = 1;
1739           if (waveletHistoMap.find(GLWindow->waveLetArray[i]) != waveletHistoMap.end())
1740               waveletHistoMap[GLWindow->waveLetArray[i]]++;
1741           else
1742               waveletHistoMap[GLWindow->waveLetArray[i]] = 1;
1743       }
1744
1745       it = valuesHistoMap.begin();
1746       nsamples = 0;
1747       previousValue = it->first-10;
1748       cout << "Num values Original: " << valuesHistoMap.size() << endl;
1749       for (unsigned int i=0;i<valuesHistoMap.size();i++)
1750       {
1751           if (previousValue != it->first-1)
1752           {
1753               xval[nsamples] = previousValue+1;
1754               yval[nsamples] = 0;
1755               nsamples++;
1756               xval[nsamples] = it->first-1;
1757               yval[nsamples] = 0;
1758               nsamples++;
1759           }
1760           xval[nsamples] = it->first;
1761           yval[nsamples] = it->second;
1762           previousValue = it->first;
1763           it++;
1764           nsamples++;
1765           xval[nsamples] = previousValue;
1766           yval[nsamples] = 0;
1767           nsamples++;
1768           if (nsamples > 50000)
1769           {
1770               cout << "Error: Maximum number of samples reached for histograms. skipping what's remaining" << endl;
1771               break;
1772           }
1773       }
1774       xval[nsamples] = it==valuesHistoMap.begin() ? 0 : (--it)->first+1;
1775       yval[nsamples] = 0;
1776       nsamples++;
1777     //  if (nsamples > 5)
1778   #if QWT_VERSION < 0x060000
1779          triggerDelayHistoItem.setData(xval, yval, nsamples);
1780   #else
1781          triggerDelayHistoItem.setSamples(xval, yval, nsamples);
1782   #endif
1783
1784          it = waveletHistoMap.begin();
1785          nsamples = 0;
1786          previousValue = it->first-10;
1787          cout << "Num values WaveLets: " << waveletHistoMap.size() << endl;
1788          for (unsigned int i=0;i<waveletHistoMap.size();i++)
1789          {
1790              if (previousValue != it->first-1)
1791              {
1792                  xval[nsamples] = previousValue+1;
1793                  yval[nsamples] = 0;
1794                  nsamples++;
1795                  xval[nsamples] = it->first-1;
1796                  yval[nsamples] = 0;
1797                  nsamples++;
1798              }
1799              xval[nsamples] = it->first;
1800              yval[nsamples] = it->second;
1801              previousValue = it->first;
1802              it++;
1803              nsamples++;
1804              xval[nsamples] = previousValue;
1805              yval[nsamples] = 0;
1806              nsamples++;
1807              if (nsamples > 50000)
1808              {
1809                  cout << "Error: Maximum number of samples reached for histograms. skipping what's remaining" << endl;
1810                  break;
1811              }
1812          }
1813          xval[nsamples] = it==waveletHistoMap.begin() ? 0 : (--it)->first+1;
1814          yval[nsamples] = 0;
1815          nsamples++;
1816        //  if (nsamples > 5)
1817      #if QWT_VERSION < 0x060000
1818          startTimeMarkHistoItem.setData(xval, yval, nsamples);
1819      #else
1820          startTimeMarkHistoItem.setSamples(xval, yval, nsamples);
1821      #endif
1822*/
1823//END OF WAVELETS HACK
1824       //    startCellHistoZoom->setZoomBase(startCellHistoItem.boundingRect());
1825    QStack< QRectF > stack;
1826//    QRectF cRectangle = boardsTimeHistoItem.boundingRect();
1827    stack.push(scaleBoundingRectangle(boardsTimeHistoItem.boundingRect(), 1.05f));//cRectangle);//boardsTimeHistoItem.boundingRect());
1828    boardsTimeHistoZoom->setZoomStack(stack);
1829    stack.pop();
1830    stack.push(scaleBoundingRectangle(startCellHistoItem.boundingRect(), 1.05f));
1831    startCellHistoZoom->setZoomStack(stack);
1832    stack.pop();
1833    stack.push(scaleBoundingRectangle(startTimeMarkHistoItem.boundingRect(), 1.05f));
1834    startTimeMarkHistoZoom->setZoomStack(stack);
1835    stack.pop();
1836    stack.push(scaleBoundingRectangle(triggerDelayHistoItem.boundingRect(), 1.05f));
1837    triggerDelayHistoZoom->setZoomStack(stack);
1838    stack.pop();
1839
1840    pixelChanged(GLWindow->selectedPixel);
1841}
1842//can't use a ref to rectangle, as the type must be converted first
1843QRectF UIConnector::scaleBoundingRectangle(QRectF rectangle, float scale)
1844{
1845    QPointF bottomRight = rectangle.bottomRight();
1846    QPointF topLeft = rectangle.topLeft();
1847    QPointF center = rectangle.center();
1848    return QRectF(topLeft + (topLeft-center)*(scale-1.0f), //top left
1849                  bottomRight + (bottomRight-center)*(scale-1.0f)); //bottom right
1850}
1851void UIConnector::initHistograms()
1852{
1853//    QwtPlot*     boardsTimeHisto;
1854//    QwtPlotHistogram boardsTimeHistoItem;
1855    grid1 = new QwtPlotGrid;
1856    grid1->enableX(false);
1857    grid1->enableY(true);
1858    grid1->enableXMin(false);
1859    grid1->enableYMin(false);
1860    grid1->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
1861    grid1->attach(boardsTimeHisto);
1862
1863    grid2 = new QwtPlotGrid;
1864    grid2->enableX(false);
1865    grid2->enableY(true);
1866    grid2->enableXMin(false);
1867    grid2->enableYMin(false);
1868    grid2->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
1869    grid2->attach(startCellsHisto);
1870
1871    grid3 = new QwtPlotGrid;
1872    grid3->enableX(false);
1873    grid3->enableY(true);
1874    grid3->enableXMin(false);
1875    grid3->enableYMin(false);
1876    grid3->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
1877    grid3->attach(startTimeMarkHisto);
1878
1879    grid4 = new QwtPlotGrid;
1880    grid4->enableX(false);
1881    grid4->enableY(true);
1882    grid4->enableXMin(false);
1883    grid4->enableYMin(false);
1884    grid4->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
1885    grid4->attach(pixelValueCurve);
1886
1887    grid6 = new QwtPlotGrid;
1888    grid6->enableX(false);
1889    grid6->enableY(true);
1890    grid6->enableXMin(false);
1891    grid6->enableYMin(false);
1892    grid6->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
1893    grid6->attach(pixelAverageCurve);
1894
1895    grid5 = new QwtPlotGrid;
1896    grid5->enableX(false);
1897    grid5->enableY(true);
1898    grid5->enableXMin(false);
1899    grid5->enableYMin(false);
1900    grid5->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
1901    grid5->attach(triggerDelayHisto);
1902
1903    boardsTimeHisto->setAutoReplot(true);
1904    startCellsHisto->setAutoReplot(true);
1905    startTimeMarkHisto->setAutoReplot(true);
1906    pixelValueCurve->setAutoReplot(true);
1907    pixelAverageCurve->setAutoReplot(true);
1908    triggerDelayHisto->setAutoReplot(true);
1909    boardsTimeHisto->setTitle("Boards time values");
1910    startCellsHisto->setTitle("Start Cell values");
1911    startTimeMarkHisto->setTitle("Start Time Marks values");
1912    pixelValueCurve->setTitle("Current pixel values");
1913    pixelAverageCurve->setTitle("Average pixels values");
1914    triggerDelayHisto->setTitle("Trigger Delays");
1915
1916 //   boardsTimeHistoItem.setBrush(QBrush(Qt::red));
1917//    startCellHistoItem.setBrush(QBrush(Qt::red));
1918//    startTimeMarkHistoItem.setBrush(QBrush(Qt::red));
1919//    triggerDelayHistoItem.setBrush(QBrush(Qt::red));
1920//    pixelValueCurveItem.setBrush(QBrush(Qt::red));
1921
1922    boardsTimeHistoItem.setPen(QColor(Qt::darkGreen));
1923    boardsTimeHistoItem.setStyle(QwtPlotCurve::Steps);
1924    startCellHistoItem.setPen(QColor(Qt::darkGreen));
1925    startCellHistoItem.setStyle(QwtPlotCurve::Steps);
1926    startTimeMarkHistoItem.setPen(QColor(Qt::darkGreen));
1927    startTimeMarkHistoItem.setStyle(QwtPlotCurve::Steps);
1928    triggerDelayHistoItem.setPen(QColor(Qt::darkGreen));
1929    triggerDelayHistoItem.setStyle(QwtPlotCurve::Steps);
1930
1931    boardsTimeHistoItem.attach(boardsTimeHisto);
1932    startCellHistoItem.attach(startCellsHisto);
1933    startTimeMarkHistoItem.attach(startTimeMarkHisto);
1934    triggerDelayHistoItem.attach(triggerDelayHisto);
1935
1936    //curve
1937//    pixelValueCurveItem.setSymbol(new QwtSymbol(QwtSymbol::Cross, Qt::NoBrush, QPen(Qt::black), QSize(5,5)));
1938    pixelValueCurveItem.setPen(QColor(Qt::black));
1939    pixelAverageCurveItem.setPen(QColor(Qt::black));
1940    aMeanCurveItem.setPen(QColor(Qt::darkGreen));
1941    vCorrCurveItem.setPen(QColor(Qt::red));
1942    meanCurveItem.setPen(QColor(Qt::blue));
1943    pixelValueCurveItem.setStyle(QwtPlotCurve::Lines);
1944    pixelAverageCurveItem.setStyle(QwtPlotCurve::Lines);
1945    aMeanCurveItem.setStyle(QwtPlotCurve::Lines);
1946    vCorrCurveItem.setStyle(QwtPlotCurve::Lines);
1947    meanCurveItem.setStyle(QwtPlotCurve::Lines);
1948
1949//    pixelValueCurveItem.setCurveAttribute(QwtPlotCurve::Fitted);
1950    pixelValueCurveItem.attach(pixelValueCurve);
1951    pixelAverageCurveItem.attach(pixelAverageCurve);
1952//    aMeanCurveItem.attach(pixelValueCurve);
1953 //   vCorrCurveItem.attach(pixelValueCurve);
1954//    meanCurveItem.attach(pixelValueCurve);
1955
1956    //FIXME delete these pointers with the destructor
1957    curveZoom = new QwtPlotZoomer(pixelValueCurve->canvas());
1958    curveZoom->setRubberBandPen(QPen(Qt::gray, 2, Qt::DotLine));
1959    curveZoom->setTrackerPen(QPen(Qt::gray));
1960    averageCurveZoom = new QwtPlotZoomer(pixelAverageCurve->canvas());
1961    averageCurveZoom->setRubberBandPen(QPen(Qt::gray, 2, Qt::DotLine));
1962    averageCurveZoom->setTrackerPen(QPen(Qt::gray));
1963
1964    boardsTimeHistoZoom = new QwtPlotZoomer(boardsTimeHisto->canvas());
1965    boardsTimeHistoZoom->setRubberBandPen(QPen(Qt::gray, 2, Qt::DotLine));
1966    boardsTimeHistoZoom->setTrackerPen(QPen(Qt::gray));
1967
1968    startCellHistoZoom = new QwtPlotZoomer(startCellsHisto->canvas());
1969    startCellHistoZoom->setRubberBandPen(QPen(Qt::gray, 2, Qt::DotLine));
1970    startCellHistoZoom->setTrackerPen(QPen(Qt::gray));
1971
1972    startTimeMarkHistoZoom = new QwtPlotZoomer(startTimeMarkHisto->canvas());
1973    startTimeMarkHistoZoom->setRubberBandPen(QPen(Qt::gray, 2, Qt::DotLine));
1974    startTimeMarkHistoZoom->setTrackerPen(QPen(Qt::gray));
1975
1976    triggerDelayHistoZoom = new QwtPlotZoomer(triggerDelayHisto->canvas());
1977    triggerDelayHistoZoom->setRubberBandPen(QPen(Qt::gray, 2, Qt::DotLine));
1978    triggerDelayHistoZoom->setTrackerPen(QPen(Qt::gray));
1979
1980
1981}
1982
1983void UIConnector::pixelChanged(int pixel)
1984{
1985    RMS_window->fWhite = pixel;
1986    Mean_window->fWhite = pixel;
1987    Max_window->fWhite = pixel;
1988    PosOfMax_window->fWhite = pixel;
1989    if (pixel != -1)
1990    {
1991        RMS_window->fWhitePatch = RMS_window->pixelsPatch[pixel];
1992        Mean_window->fWhitePatch = Mean_window->pixelsPatch[pixel];
1993        Max_window->fWhitePatch = Max_window->pixelsPatch[pixel];
1994        PosOfMax_window->fWhitePatch = PosOfMax_window->pixelsPatch[pixel];
1995    }
1996    else
1997    {
1998        RMS_window->fWhitePatch = -1;
1999        Mean_window->fWhitePatch = -1;
2000        Max_window->fWhitePatch = -1;
2001        PosOfMax_window->fWhitePatch = -1;
2002    }
2003    if (pixel == -1)
2004        return;
2005    int softwarePix = pixel;
2006//    if (!GLWindow->_softwareOrdering)
2007        pixel = GLWindow->hardwareMapping[pixel];
2008
2009    HwIDBox->setValue(pixel);
2010
2011    if (!GLWindow->nRoi)
2012        return;
2013
2014int currentPixel = pixel;
2015
2016    for (int i=0;i<GLWindow->nRoi;i++)
2017    {
2018        xval[i] = i;
2019        yval[i] = GLWindow->eventData[GLWindow->nRoi*currentPixel + i];
2020    }
2021
2022
2023int realNumSamples = GLWindow->nRoi;
2024    if (GLWindow->nRoiTM != 0)
2025    {
2026        const PixelMapEntry& mapEntry = GLWindow->fPixelMap.index(softwarePix);
2027        const int pixelIdInPatch = mapEntry.pixel();
2028        const int patchId = mapEntry.patch();
2029        const int boardId = mapEntry.board();
2030        const int crateId = mapEntry.crate();
2031        if (pixelIdInPatch == 8)
2032        {
2033            int TMIndex = 0;
2034            int xIndex = GLWindow->nRoi;
2035            int arrayIndex = GLWindow->nRoi;
2036            if (GLWindow->offSetRoi < 0)
2037                TMIndex -= GLWindow->offSetRoi;
2038            if (GLWindow->offSetRoi > 0)
2039                xIndex += GLWindow->offSetRoi;
2040            for (int i=TMIndex;i<GLWindow->nRoiTM;i++, xIndex++, arrayIndex++)
2041            {
2042                xval[arrayIndex] = xIndex;
2043                yval[arrayIndex] = GLWindow->eventData[GLWindow->nRoi*1440 + GLWindow->nRoiTM*(40*crateId + 4*boardId + patchId) + i];
2044            }
2045            realNumSamples += GLWindow->nRoiTM - TMIndex;
2046        }
2047      //  cout << pixelIdInPatch << " " ;
2048    }
2049
2050#if QWT_VERSION < 0x060000
2051    pixelValueCurveItem.setData(xval, yval, realNumSamples);
2052#else
2053       pixelValueCurveItem.setSamples(xval, yval, realNumSamples);
2054#endif
2055
2056//now compute the average value of all pixels
2057       currentPixel = 0;
2058       for (int i=0;i<GLWindow->nRoi;i++)
2059           yval[i] = 0;
2060       for (int j=0;j<1440;j++) {
2061           currentPixel = j;
2062           for (int i=0;i<GLWindow->nRoi;i++)
2063           {
2064               xval[i] = i;
2065               yval[i] += GLWindow->eventData[GLWindow->nRoi*currentPixel + i];
2066           }
2067       }
2068       for (int i=0;i<GLWindow->nRoi;i++)
2069           yval[i] /= 1440;
2070#if QWT_VERSION < 0x060000
2071       pixelAverageCurveItem.setData(xval, yval, GLWindow->nRoi);
2072#else
2073    pixelAverageCurveItem.setSamples(xval, yval, realNumSamples);
2074#endif
2075
2076    QStack< QRectF > stack;
2077    stack.push(scaleBoundingRectangle(pixelValueCurveItem.boundingRect(), 1.5f));
2078    curveZoom->setZoomBase(scaleBoundingRectangle(pixelValueCurveItem.boundingRect(), 1.5f));
2079    curveZoom->setZoomStack(stack);
2080    stack.pop();
2081    stack.push(scaleBoundingRectangle(pixelAverageCurveItem.boundingRect(), 1.5f));
2082    averageCurveZoom->setZoomBase(scaleBoundingRectangle(pixelAverageCurveItem.boundingRect(), 1.5f));
2083    averageCurveZoom->setZoomStack(stack);
2084    stack.pop();
2085
2086    displaySliceValue();
2087    on_autoScaleColor_clicked();
2088}
2089
2090void UIConnector::on_HwIDBox_valueChanged(int)
2091{
2092    updating = true;
2093
2094    const int hwID = HwIDBox->value();
2095
2096    const int crateID =  hwID/360;
2097    const int boardID = (hwID%360)/36;
2098    const int patchID = (hwID%36 )/9;
2099    const int pixelID =  hwID%9;
2100
2101    SwIDBox->setValue(GLWindow->softwareMapping[hwID]);
2102
2103    crateIDBox->setValue(crateID);
2104    boardIDBox->setValue(boardID);
2105    patchIDBox->setValue(patchID);
2106    pixelIDBox->setValue(pixelID);
2107
2108    updating = false;
2109
2110    GLWindow->selectedPixel = GLWindow->softwareMapping[hwID];
2111    GLWindow->updateGL();
2112
2113    pixelChanged(GLWindow->selectedPixel);
2114}
2115
2116void UIConnector::cbpxChanged()
2117{
2118    if (updating)
2119        return;
2120
2121    const int hwid = crateIDBox->value()*360 + boardIDBox->value()*36 + patchIDBox->value()*9 + pixelIDBox->value();
2122    HwIDBox->setValue(hwid);
2123}
2124
2125void UIConnector::on_SwIDBox_valueChanged(int swid)
2126{
2127    if (updating)
2128        return;
2129
2130//    if (GLWindow->_softwareOrdering)
2131//        HwIDBox->setValue(swid);
2132//    else
2133        HwIDBox->setValue(GLWindow->hardwareMapping[swid]);
2134}
2135
2136void UIConnector::on_autoScaleColor_clicked()
2137{
2138    if (!autoScaleColor->isChecked())
2139    {
2140        GLWindow->ss[0] = 0.496;
2141        GLWindow->ss[1] = 0.507;
2142        GLWindow->ss[2] = 0.518;
2143        GLWindow->ss[3] = 0.529;
2144        GLWindow->ss[4] = 0.540;;
2145        colorRange0->setValue(GLWindow->ss[0]);
2146        colorRange1->setValue(GLWindow->ss[1]);
2147        colorRange2->setValue(GLWindow->ss[2]);
2148        colorRange3->setValue(GLWindow->ss[3]);
2149        colorRange4->setValue(GLWindow->ss[4]);
2150        return;
2151    }
2152    if (!GLWindow->nRoi)
2153        return;
2154
2155    int start = 0;
2156    int end   = 1440;
2157
2158    if (!entireCameraScale->isChecked())
2159    {
2160        start = GLWindow->selectedPixel;
2161        end   = GLWindow->selectedPixel+1;
2162        if (end == 0)
2163        {
2164            start = 0;
2165            end = 1440;
2166        }
2167    }
2168
2169    int min =  100000; //real min = -2048, int_16 = -32768 to 32767
2170    int max = -100000; //real max = 2047
2171
2172    long average = 0;
2173    long numSamples = 0;
2174    int errorDetected = -1;
2175
2176    for (int i=start;i<end;i++)
2177    {
2178        if (i==863)//keep crazy pixel out of the autoscale
2179            continue;
2180        for (int j=10;j<GLWindow->nRoi-50;j++)
2181        {
2182            int cValue = GLWindow->eventData[i*GLWindow->nRoi+j];
2183            if (cValue > max && cValue < 32767)
2184                max = cValue;
2185            if (cValue < min && cValue > -32768)
2186               min = cValue;
2187            if (cValue < 32767 && cValue > -32768)
2188            {
2189                average+=cValue;
2190                numSamples++;
2191            }
2192            else
2193            {
2194                errorDetected = i;
2195            }
2196//            numSamples++;
2197        }
2198    }
2199    average /= numSamples;
2200    if (errorDetected != -1)
2201    {
2202        cout << "Overflow detected at pixel " << errorDetected << " (at least)" << endl;
2203    }
2204//    cout << "min: " << min << " max: " << max << " average: " << average << endl;
2205    float minRange = (float)(min+(GLWindow->VALUES_SPAN/2))/(float)(GLWindow->VALUES_SPAN-1);
2206    float maxRange = (float)(max+(GLWindow->VALUES_SPAN/2))/(float)(GLWindow->VALUES_SPAN-1);
2207    float midRange = (float)(average+(GLWindow->VALUES_SPAN/2))/(float)(GLWindow->VALUES_SPAN-1);
2208    if (GLWindow->logScale)
2209    {
2210        minRange *= 9;
2211        maxRange *= 9;
2212//        midRange *= 9;
2213        minRange += 1;
2214        maxRange += 1;
2215//        midRange += 1;
2216        minRange = log10(minRange);
2217        maxRange = log10(maxRange);
2218//        midRange = (minRange + maxRange)/2.f;
2219        midRange = log10(midRange);
2220    }
2221
2222    GLWindow->ss[0] = minRange;
2223    colorRange0->setValue(GLWindow->ss[0]);
2224    GLWindow->ss[4] = maxRange;
2225    colorRange4->setValue(GLWindow->ss[4]);
2226//    GLWindow->ss[2] = midRange;
2227//    range2->setValue(GLWindow->ss[2]);
2228//    GLWindow->ss[1] = (minRange+midRange)/2;
2229//    range1->setValue(GLWindow->ss[1]);
2230//    GLWindow->ss[3] = (maxRange+midRange)/2;
2231//    range3->setValue(GLWindow->ss[3]);
2232
2233    GLWindow->ss[2] = (maxRange+minRange)/2;
2234    colorRange2->setValue(GLWindow->ss[2]);
2235
2236    GLWindow->ss[1] = minRange+(maxRange-minRange)/4;
2237    colorRange1->setValue(GLWindow->ss[1]);
2238
2239    GLWindow->ss[3] = minRange+3*(maxRange-minRange)/4;
2240    colorRange3->setValue(GLWindow->ss[3]);
2241}
2242
2243void PrintUsage()
2244{
2245    cout << "\n"
2246        "The FACT++ raw data viewer.\n"
2247        "\n"
2248        "Usage: viewer [OPTIONS] [datafile.fits[.gz|.fz] [calibration.drs.fits[.gz]]]\n"
2249        "  or:  viewer [OPTIONS]\n";
2250    cout << endl;
2251
2252}
2253
2254void PrintHelp()
2255{
2256    cout <<
2257            "\n"
2258         << endl;
2259}
2260
2261int UIConnector::SetupConfiguration(Configuration &conf)
2262{
2263    RawDataViewer *canvas = GLWindow;
2264
2265    if (conf.Has("mappingFile"))
2266    {
2267        canvas->assignPixelMapFile(conf.Get<string>("mappingFile"));
2268    }
2269    else
2270        canvas->assignPixelMapFile("");
2271
2272    if (conf.Has("color.range"))
2273    {
2274        vector<double> value = conf.Vec<double>("color.range");
2275        if (value.size() != 5)
2276        {
2277            cout << "Error, colorRange option should have exactly 5 double values" << endl;
2278            return -1;
2279        }
2280        for (int i=0;i<5;i++)
2281            canvas->ss[i] = value[i];
2282    }
2283
2284    if (conf.Has("color.red"))
2285    {
2286        vector<double> value = conf.Vec<double>("color.red");
2287        if (value.size() != 5)
2288        {
2289            cout << "Error, colorRed option should have exactly 5 double values" << endl;
2290            return -1;
2291        }
2292        for (int i=0;i<5;i++)
2293            canvas->rr[i] = value[i];
2294    }
2295
2296    if (conf.Has("color.green"))
2297    {
2298        vector<double> value = conf.Vec<double>("color.green");
2299        if (value.size() != 5)
2300        {
2301            cout << "Error, colorGreen option should have exactly 5 double values" << endl;
2302            return -1;
2303        }
2304        for (int i=0;i<5;i++)
2305            canvas->gg[i] = value[i];
2306    }
2307
2308    if (conf.Has("color.blue"))
2309    {
2310        vector<double> value = conf.Vec<double>("color.blue");
2311        if (value.size() != 5)
2312        {
2313            cout << "Error, colorBlue option should have exactly 5 double values" << endl;
2314            return -1;
2315        }
2316        for (int i=0;i<5;i++)
2317            canvas->bb[i] = value[i];
2318    }
2319
2320    colorRange0->setValue(canvas->ss[0]);
2321    colorRange1->setValue(canvas->ss[1]);
2322    colorRange2->setValue(canvas->ss[2]);
2323    colorRange3->setValue(canvas->ss[3]);
2324    colorRange4->setValue(canvas->ss[4]);
2325    redValue0->setValue(canvas->rr[0]);
2326    redValue1->setValue(canvas->rr[1]);
2327    redValue2->setValue(canvas->rr[2]);
2328    redValue3->setValue(canvas->rr[3]);
2329    redValue4->setValue(canvas->rr[4]);
2330    greenValue0->setValue(canvas->gg[0]);
2331    greenValue1->setValue(canvas->gg[1]);
2332    greenValue2->setValue(canvas->gg[2]);
2333    greenValue3->setValue(canvas->gg[3]);
2334    greenValue4->setValue(canvas->gg[4]);
2335    blueValue0->setValue(canvas->bb[0]);
2336    blueValue1->setValue(canvas->bb[1]);
2337    blueValue2->setValue(canvas->bb[2]);
2338    blueValue3->setValue(canvas->bb[3]);
2339    blueValue4->setValue(canvas->bb[4]);
2340
2341    if (conf.Has("drs"))
2342    {
2343        const QString qstr(conf.Get<string>("drs").c_str());
2344        calibFileSelected(qstr);
2345    }
2346
2347    if (conf.Has("file"))
2348    {
2349        const QString qstr(conf.Get<string>("file").c_str());
2350        fileSelected(qstr);
2351    }
2352
2353
2354    return 0;
2355}
2356
2357void SetupConfiguration(Configuration& conf)
2358{
2359    po::options_description configs("Raw Events Viewer Options");
2360    configs.add_options()
2361        ("color.range", vars<double>(), "Range of the display colours")
2362        ("color.red",   vars<double>(), "Range of red values")
2363        ("color.green", vars<double>(), "Range of green values")
2364        ("color.blue",  vars<double>(), "Range of blue values")
2365        ("file,f",      var<string>(),  "File to be loaded")
2366        ("drs,d",       var<string>(),  "DRS calibration file to be loaded")
2367        ("mappingFile", var<string>(),  "Which pixels mapping file to use")
2368        ;
2369    conf.AddOptions(configs);
2370
2371    po::positional_options_description p;
2372    p.add("file", 1); // The first positional options
2373    p.add("drs",  2); // The first positional options
2374    conf.SetArgumentPositions(p);
2375
2376}
2377
2378/************************************************************
2379 * MAIN PROGRAM FUNCTION.
2380 ************************************************************/
2381int main(int argc, const char *argv[])
2382{
2383    QApplication app(argc, const_cast<char**>(argv));
2384
2385    if (!QGLFormat::hasOpenGL()) {
2386        std::cerr << "This system has no OpenGL support" << std::endl;
2387        return 1;
2388    }
2389
2390    Configuration conf(argv[0]);
2391    conf.SetPrintUsage(PrintUsage);
2392    SetupConfiguration(conf);
2393    if (!conf.DoParse(argc, argv, PrintHelp))
2394        return 2;
2395
2396    UIConnector myUi;
2397    if (myUi.SetupConfiguration(conf)<0)
2398        return 3;
2399
2400    return app.exec();
2401}
2402
Note: See TracBrowser for help on using the repository browser.