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

Last change on this file since 19374 was 19374, checked in by tbretz, 16 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.