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

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