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

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