source: trunk/FACT++/gui/BasicGlCamera.cc @ 19314

Last change on this file since 19314 was 18984, checked in by tbretz, 15 months ago
clang++ did not compile, it requires that the arguments here are floats and this requires either casts or a pre-defined constant.
File size: 38.8 KB
Line 
1#include "BasicGlCamera.h"
2
3#include <math.h>
4
5#include <fstream>
6#include <iostream>
7#include <string>
8#include <sstream>
9#include <algorithm>
10
11#include <QLabel>
12#include <QRadioButton>
13#include <QButtonGroup>
14
15#include <GL/glu.h>
16
17#include "src/Time.h"
18#include "src/tools.h"
19
20using namespace std;;
21
22//static variables
23PixelMap BasicGlCamera::fPixelMap;
24GLfloat BasicGlCamera::pixelsCoords[MAX_NUM_PIXELS][3];
25PixelsNeighbors BasicGlCamera::neighbors[MAX_NUM_PIXELS];
26int BasicGlCamera::hardwareMapping[NPIX];
27GLfloat BasicGlCamera::verticesList[NPIX*6][2];
28vector<edge> BasicGlCamera::patchesIndices[160];
29int BasicGlCamera::verticesIndices[NPIX][6];
30int BasicGlCamera::pixelsPatch[NPIX];
31int BasicGlCamera::softwareMapping[NPIX];
32
33static const float _coord = 1/sqrt(3.);
34
35//Coordinates of an hexagon of radius 1 and center 0
36GLfloat hexcoords[6][2] = {{-1*_coord,  1},
37                           { 1*_coord,  1},
38                           { 2*_coord,  0},
39                           { 1*_coord, -1},
40                           {-1*_coord, -1},
41                           {-2*_coord,  0}};
42
43
44
45    BasicGlCamera::BasicGlCamera(QWidget* cParent)
46    : QGLWidget(QGLFormat(QGL::DoubleBuffer |
47                          QGL::DepthBuffer),cParent)
48    {
49        QGL::setPreferredPaintEngine(QPaintEngine::OpenGL);
50        fWhite = -1;
51        fWhitePatch = -1;
52        fMin = -1;
53        fMax = -1;
54        fScaleLimit = -0.5;
55        fTextSize = 0;
56        autoRefresh = false;
57        logScale = false;
58        cameraRotation = +90;
59        fTextEnabled = true;
60        unitsText = "";
61        titleText = "";
62        dataText = "";
63        pixelContourColour[0] = 0.1f;
64        pixelContourColour[1] = 0.1f;
65        pixelContourColour[2] = 0.1f;
66        patchesCoulour[0] = 0.1f;
67        patchesCoulour[1] = 0.1f;
68        patchesCoulour[2] = 0.1f;
69        highlightedPatchesCoulour[0] = 0.6f;
70        highlightedPatchesCoulour[1] = 0.6f;
71        highlightedPatchesCoulour[2] = 0.6f;
72        highlightedPixelsCoulour[0] = 0.8f;
73        highlightedPixelsCoulour[1] = 0.8f;
74        highlightedPixelsCoulour[2] = 0.8f;
75
76        regularPalettePlease(true);
77
78
79        hexRadius = 0.015f;
80        hexTolerance = hexRadius/100.0f;
81        viewSize = 1.0f;
82        calculatePixelsCoords();
83
84        buildVerticesList();
85/*
86       ifstream fin1("Trigger-Patches.txt");
87       if (!fin1.is_open())
88       {
89           cout << "Error: file \"Trigger-Patches.txt\" missing. Aborting." << endl;
90           exit(-1);
91       }
92       l=0;
93        while (getline(fin1, buf, '\n'))
94        {
95            buf = Tools::Trim(buf);
96            if (buf[0]=='#')
97                continue;
98
99            stringstream str(buf);
100            for (int i=0; i<9; i++)
101            {
102                unsigned int n;
103                str >> n;
104
105                if (n>=1440)
106                    continue;
107
108                patches[l][i] = hardwareMapping[n];
109            }
110            l++;
111        }
112
113        //now construct the correspondance between pixels and patches
114        for (int i=0;i<NTMARK;i++)
115            for (int j=0;j<9;j++)
116                pixelsPatch[softwareMapping[patches[i][j]]] = i;
117
118        for (int i=0;i<1440;i++)
119            updateNeighbors(i);
120
121        buildPatchesIndices();
122*/////////////////////////////////
123        regularPalettePlease(true);
124//        ss[0] = 0;    ss[1] = 0.25f; ss[2] = 0.5f; ss[3] = 0.75f; ss[4] = 1.0f;
125//        rr[0] = 0.15; rr[1] = 0;     rr[2] = 0;    rr[3] = 1.0f;  rr[4] = 0.85f;
126//        gg[0] = 0.15; gg[1] = 0;     gg[2] = 1;    gg[3] = 0;     gg[4] = 0.85f;
127//        bb[0] = 0.15; bb[1] = 1;     bb[2] = 0;    bb[3] = 0;     bb[4] = 0.85f;
128
129        fPixelStride = 1;
130        fcSlice = 0;
131        fData.resize(1440);
132        for (int i=0;i<NPIX;i++)
133            fData[i] = (double)i;///1.44;//(double)(i)/(double)(ACTUAL_NUM_PIXELS);
134
135//        setFont(QFont("Arial", 8));
136        int buttonShift=0;
137        scaleLabel = new QLabel("Scale", this);
138//        buttonShift += scaleLabel->height();
139
140        linearButton = new QRadioButton("Linear", this);
141        linearButton->move(scaleLabel->width(), buttonShift);
142        buttonShift += linearButton->height();
143
144        logButton = new QRadioButton("Log", this);
145        logButton->move(scaleLabel->width(), buttonShift);
146        buttonShift += logButton->height()*1.1f;
147
148        colorPaletteLabel = new QLabel("Colour\nPalette", this);
149        colorPaletteLabel->move(0, buttonShift);
150 //       buttonShift += colorPaletteLabel->height();
151
152        regularPaletteButton = new QRadioButton("Regular", this);
153        regularPaletteButton->move(colorPaletteLabel->width(), buttonShift);
154        buttonShift += regularPaletteButton->height();
155
156        prettyPaletteButton = new QRadioButton("Pretty", this);
157        prettyPaletteButton->move(colorPaletteLabel->width(), buttonShift);
158        buttonShift += prettyPaletteButton->height();
159
160        greyScalePaletteButton = new QRadioButton("Grey Scale", this);
161        greyScalePaletteButton->move(colorPaletteLabel->width(), buttonShift);
162        buttonShift += greyScalePaletteButton->height();
163
164        glowingPaletteButton = new QRadioButton("Glowing", this);
165        glowingPaletteButton->move(colorPaletteLabel->width(), buttonShift);
166        buttonShift += glowingPaletteButton->height()*1.1f;
167
168        rotationLabel = new QLabel("Camera\nRotation", this);
169        rotationLabel->move(0, buttonShift);
170 //       buttonShift += rotationLabel->height();
171
172        unsigned short utf16Array;
173        utf16Array = 0x00b0;
174        QString degreeSymbol(QString::fromUtf16(&utf16Array, 1));
175        QString zerostr("0" + degreeSymbol);
176        zeroRotationButton = new QRadioButton(zerostr, this);
177        zeroRotationButton->move(rotationLabel->width(), buttonShift);
178        buttonShift += zeroRotationButton->height();
179         QString minus90str("+90" + degreeSymbol);
180        minus90RotationButton = new QRadioButton(minus90str, this);
181        minus90RotationButton->move(rotationLabel->width(), buttonShift);
182        buttonShift += minus90RotationButton->height();
183        QString plus90str("-90"+degreeSymbol);
184        plus90Rotationbutton = new QRadioButton(plus90str, this);
185        plus90Rotationbutton->move(rotationLabel->width(), buttonShift);
186
187
188        scaleGroup = new QButtonGroup(this);
189        colorGroup = new QButtonGroup(this);
190        rotationGroup = new QButtonGroup(this);
191        scaleGroup->addButton(linearButton);
192        scaleGroup->addButton(logButton);
193        colorGroup->addButton(regularPaletteButton);
194        colorGroup->addButton(prettyPaletteButton);
195        colorGroup->addButton(greyScalePaletteButton);
196        colorGroup->addButton(glowingPaletteButton);
197        rotationGroup->addButton(zeroRotationButton);
198        rotationGroup->addButton(minus90RotationButton);
199        rotationGroup->addButton(plus90Rotationbutton);
200
201        linearButton->setChecked(true);
202        regularPaletteButton->setChecked(true);
203//        zeroRotationButton->setChecked(true);
204        minus90RotationButton->setChecked(true);
205//        linearButton->palette.setColor();
206
207        linearButton->setAutoFillBackground(true);
208        logButton->setAutoFillBackground(true);
209        regularPaletteButton->setAutoFillBackground(true);
210        prettyPaletteButton->setAutoFillBackground(true);
211        greyScalePaletteButton->setAutoFillBackground(true);
212        glowingPaletteButton->setAutoFillBackground(true);
213        zeroRotationButton->setAutoFillBackground(true);
214        minus90RotationButton->setAutoFillBackground(true);
215        plus90Rotationbutton->setAutoFillBackground(true);
216        scaleLabel->setAutoFillBackground(true);
217        colorPaletteLabel->setAutoFillBackground(true);
218        rotationLabel->setAutoFillBackground(true);
219
220        linearButton->hide();
221        logButton->hide();
222        regularPaletteButton->hide();
223        prettyPaletteButton->hide();
224        greyScalePaletteButton->hide();
225        glowingPaletteButton->hide();
226        zeroRotationButton->hide();
227        minus90RotationButton->hide();
228        plus90Rotationbutton->hide();
229        scaleLabel->hide();
230        colorPaletteLabel->hide();
231        rotationLabel->hide();
232
233        connect(linearButton, SIGNAL(toggled(bool)),
234                 this, SLOT(linearScalePlease(bool)));
235        connect(logButton, SIGNAL(toggled(bool)),
236                 this, SLOT(logScalePlease(bool)));
237        connect(regularPaletteButton, SIGNAL(toggled(bool)),
238                 this, SLOT(regularPalettePlease(bool)));
239        connect(prettyPaletteButton, SIGNAL(toggled(bool)),
240                 this, SLOT(prettyPalettePlease(bool)));
241        connect(greyScalePaletteButton, SIGNAL(toggled(bool)),
242                 this, SLOT(greyScalePalettePlease(bool)));
243        connect(glowingPaletteButton, SIGNAL(toggled(bool)),
244                 this, SLOT(glowingPalettePlease(bool)));
245        connect(zeroRotationButton, SIGNAL(toggled(bool)),
246                 this, SLOT(zeroRotationPlease(bool)));
247        connect(minus90RotationButton, SIGNAL(toggled(bool)),
248                 this, SLOT(plus90RotationPlease(bool)));
249        connect(plus90Rotationbutton, SIGNAL(toggled(bool)),
250                 this, SLOT(minus90RotationPlease(bool)));
251
252        connect(this, SIGNAL(signalUpdateCamera()),
253                this, SLOT(timedUpdate()));
254    }
255    BasicGlCamera::~BasicGlCamera()
256    {
257    }
258    void BasicGlCamera::assignPixelMap(const PixelMap& map)
259    {
260        fPixelMap = map;
261
262        for (auto it=fPixelMap.begin(); it!=fPixelMap.end(); it++)
263        {
264            hardwareMapping[it->index] = it->hw();
265            softwareMapping[it->hw()]  = it->index;
266        }
267
268        //now construct the correspondance between pixels and patches
269        for (int i=0;i<NTMARK;i++)
270            for (int j=0;j<9;j++)
271                pixelsPatch[softwareMapping[i*9+j]] = i;
272
273        calculatePixelsCoords();
274
275        for (int i=0;i<1440;i++)
276        {
277            for (int j=0;j<6;j++)
278                neighbors[i][j] = -1;
279            updateNeighbors(i);
280        }
281
282        buildVerticesList();
283
284        buildPatchesIndices();
285
286    }
287    void BasicGlCamera::enableText(bool on)
288    {
289        fTextEnabled = on;
290    }
291    void BasicGlCamera::setPatchColor(int id, float color[3])
292    {
293        for (int i=0;i<9;i++)
294            for (int j=0;j<3;j++)
295                pixelsColor[softwareMapping[id*9+i]][j] = color[j];
296    }
297    void BasicGlCamera::setUnits(const string& units)
298    {
299        unitsText = units;
300        pixelColorUpToDate = false;
301        if (isVisible() && autoRefresh)
302            updateGL();
303    }
304    void BasicGlCamera::setTitle(const string& title)
305    {
306        titleText = title;
307        pixelColorUpToDate = false;
308        if (isVisible() && autoRefresh)
309            updateGL();
310    }
311    void BasicGlCamera::SetWhite(int idx)
312    {
313        fWhite = idx;
314        fWhitePatch = pixelsPatch[fWhite];
315        if (isVisible() && autoRefresh)
316            updateGL();
317//         CalculatePatchColor();
318    }
319    void BasicGlCamera::SetMin(int64_t min)
320    {
321//        cout << "min: " << min << endl;
322        fMin = min;
323        pixelColorUpToDate = false;
324        if (isVisible() && autoRefresh)
325            updateGL();
326    }
327    void BasicGlCamera::setAutoscaleLowerLimit(float val)
328    {
329        fScaleLimit = val;
330        if (isVisible() && autoRefresh)
331            updateGL();
332    }
333
334    void BasicGlCamera::SetMax(int64_t max)
335    {
336//        cout << "max: " << max << endl;
337        fMax = max;
338        pixelColorUpToDate = false;
339        if (isVisible() && autoRefresh)
340            updateGL();
341    }
342    void BasicGlCamera::linearScalePlease(bool checked)
343    {
344        if (!checked) return;
345        logScale = false;
346        pixelColorUpToDate = false;
347        emit colorPaletteHasChanged();
348        if (isVisible() && autoRefresh)
349            updateGL();
350    }
351    void BasicGlCamera::UpdateText()
352    {
353        ostringstream str;
354        float min, max, median;
355        int ii=0;
356        for (;ii<ACTUAL_NUM_PIXELS;ii++)
357        {
358            if (finite(fData[ii]))
359            {
360                min = max = fData[ii];
361                break;
362            }
363        }
364        double mean = 0;
365        double rms = 0;
366        median = 0;
367        if (ii==ACTUAL_NUM_PIXELS)
368        {
369            fmin = fmax = fmean = frms = fmedian = 0;
370            return;
371        }
372
373        vector<double> medianVec;
374        medianVec.resize(ACTUAL_NUM_PIXELS);
375        auto it = medianVec.begin();
376        int numSamples = 0;
377        for (int i=0;i<ACTUAL_NUM_PIXELS;i++)
378        {
379            if (!finite(fData[i]))
380                continue;
381            if (fData[i] < min)
382                min = fData[i];
383            if (fData[i] > max)
384                max = fData[i];
385            mean += fData[i];
386            rms += fData[i]*fData[i];
387            //medianSet.insert(fData[i]);
388            *it = fData[i];
389            it++;
390            numSamples++;
391        }
392
393//        vector<double> medianVec;
394//        medianVec.resize(ACTUAL_NUM_PIXELS);
395//        int iii=0;
396//        for (auto it=medianVec.begin(); it != medianVec.end(); it++) {
397//            *it = fData[iii];
398//            iii++;
399//        }
400        sort(medianVec.begin(), medianVec.begin()+numSamples);
401
402
403        mean /= numSamples;
404        rms = sqrt((rms/numSamples) - (mean * mean));
405
406//       multiset<double>::iterator it = medianSet.begin();
407        auto jt = medianVec.begin();
408        for (int i=0;i<(numSamples/2)-1;i++)
409        {
410//            it++;
411            jt++;
412        }
413        median = *jt;
414 //       cout << *it << " " << *jt << endl;
415        if (numSamples%2==0){
416        jt++;
417        median += *jt;
418        median /= 2;}
419
420        str << "Min: " << min << endl << " Max: " << max << " Mean: " << mean << " RMS: " << rms << " Median: " << median;
421        str << " Units: " << unitsText;
422        dataText = str.str();
423
424        fmin = min;
425        fmax = max;
426        fmean = mean;
427        frms = rms;
428        fmedian = median;
429    }
430    void BasicGlCamera::DrawCameraText()
431    {
432        if (!fTextEnabled)
433            return;
434        glPushMatrix();
435        glLoadIdentity();
436//         cout << width() << " " << height() << endl;
437        int textSize = (int)(height()*14/600);
438//        setFont(QFont("Times", textSize));
439        qglColor(QColor(255,223,127));
440        float shiftx = 0.01f;//0.55f;
441        float shifty = 0.01f;//0.65f;
442        renderText(-shownSizex/2.f + shiftx, 0.f, 0.f, QString(dataText.c_str()));//-shownSizey/2.f + shifty, 0.f, QString(dataText.c_str()));
443
444
445//        int textLength = titleText.size();
446        renderText(-shownSizex/2.f + shiftx, shownSizey/2.f - textSize*pixelSize - shifty, 0.f, QString(titleText.c_str()));
447
448        glPopMatrix();
449
450  //      textSize = (int)(600*14/600);
451//        setFont(QFont("Times", textSize));
452    }
453    void BasicGlCamera::DrawScale()
454    {
455        glPushMatrix();
456        glLoadIdentity();
457        glPushAttrib(GL_POLYGON_BIT);
458        glShadeModel(GL_SMOOTH);
459        glBegin(GL_QUADS);
460        float oneX = shownSizex/2.f - shownSizex/50.f;
461        float twoX = shownSizex/2.f;
462        float oneY = -shownSizey/2.f;
463        float twoY = -shownSizey/4.f;
464        float threeY = 0;
465        float fourY = shownSizey/4.f;
466        float fiveY = shownSizey/2.f;
467        glColor3f(rr[0], gg[0], bb[0]);
468        glVertex2f(oneX, oneY);
469        glVertex2f(twoX, oneY);
470        glColor3f(rr[1], gg[1], bb[1]);
471        glVertex2f(twoX, twoY);
472        glVertex2f(oneX, twoY);
473
474        glVertex2f(oneX, twoY);
475        glVertex2f(twoX, twoY);
476        glColor3f(rr[2], gg[2], bb[2]);
477        glVertex2f(twoX, threeY);
478        glVertex2f(oneX, threeY);
479
480        glVertex2f(oneX, threeY);
481        glVertex2f(twoX, threeY);
482        glColor3f(rr[3], gg[3], bb[3]);
483        glVertex2f(twoX, fourY);
484        glVertex2f(oneX, fourY);
485
486        glVertex2f(oneX, fourY);
487        glVertex2f(twoX, fourY);
488        glColor3f(rr[4], gg[4], bb[4]);
489        glVertex2f(twoX, fiveY);
490        glVertex2f(oneX, fiveY);
491        float zeroX = oneX - shownSizex/50.f;
492        float zeroY = fiveY - shownSizey/50.f;
493        glColor3fv(tooHighValueCoulour);
494        glVertex2f(zeroX, fiveY);
495        glVertex2f(oneX, fiveY);
496        glVertex2f(oneX, zeroY);
497        glVertex2f(zeroX, zeroY);
498        glColor3fv(tooLowValueCoulour);
499        glVertex2f(zeroX, -fiveY);
500        glVertex2f(oneX, -fiveY);
501        glVertex2f(oneX, -zeroY);
502        glVertex2f(zeroX, -zeroY);
503        glEnd();
504        glTranslatef(0,0,0.1f);
505
506        //draw linear/log tick marks
507        glColor3f(0.f,0.f,0.f);
508        glBegin(GL_LINES);
509        float value;
510        for (int i=1;i<10;i++)
511        {
512            if (logScale)
513                value = log10(i);
514            else
515                value = (float)(i)/10.f;
516            float yy = -shownSizey/2.f + value*shownSizey;
517            glVertex2f(oneX, yy);
518            glVertex2f(twoX, yy);
519        }
520        glEnd();
521        glPopAttrib();
522        glPopMatrix();
523    }
524    void BasicGlCamera::logScalePlease(bool checked)
525    {
526        if (!checked) return;
527        logScale = true;
528        pixelColorUpToDate = false;
529        emit colorPaletteHasChanged();
530          if (isVisible() && autoRefresh)
531            updateGL();
532    }
533    void BasicGlCamera::regularPalettePlease(bool checked)
534    {
535        if (!checked) return;
536        ss[0] = 0;    ss[1] = 0.25f; ss[2] = 0.5f; ss[3] = 0.75f; ss[4] = 1.0f;
537        rr[0] = 0;    rr[1] = 0;     rr[2] = 0;    rr[3] = 1.0f;  rr[4] = 1;
538        gg[0] = 0;    gg[1] = 1;     gg[2] = 1;    gg[3] = 1;     gg[4] = 0;
539        bb[0] = 0.5f; bb[1] = 1;     bb[2] = 0;    bb[3] = 0;     bb[4] = 0;
540        tooHighValueCoulour[0] = 1.f;
541        tooHighValueCoulour[1] = 1.f;
542        tooHighValueCoulour[2] = 1.f;
543        tooLowValueCoulour[0] = 0.f;
544        tooLowValueCoulour[1] = 0.f;
545        tooLowValueCoulour[2] = 0.f;
546        pixelColorUpToDate = false;
547
548        emit colorPaletteHasChanged();
549
550        if (isVisible() && autoRefresh)
551            updateGL();
552    }
553    void BasicGlCamera::prettyPalettePlease(bool checked)
554    {
555        if (!checked) return;
556        ss[0] = 0.f;    ss[1] = 0.25f; ss[2] = 0.5f; ss[3] = 0.75f; ss[4] = 1.0f;
557        rr[0] = 0.f; rr[1] = 0.35f;     rr[2] = 0.85f;    rr[3] = 1.0f;  rr[4] = 1.f;
558        gg[0] = 0.f; gg[1] = 0.10f;     gg[2] = 0.20f;    gg[3] = 0.73f;     gg[4] = 1.f;
559        bb[0] = 0.f; bb[1] = 0.03f;     bb[2] = 0.06f;    bb[3] = 0.00f;     bb[4] = 1.f;
560        tooHighValueCoulour[0] = 0.f;
561        tooHighValueCoulour[1] = 1.f;
562        tooHighValueCoulour[2] = 0.f;
563        tooLowValueCoulour[0] = 0.f;
564        tooLowValueCoulour[1] = 0.f;
565        tooLowValueCoulour[2] = 1.f;
566        pixelColorUpToDate = false;
567
568        emit colorPaletteHasChanged();
569
570        if (isVisible() && autoRefresh)
571            updateGL();
572    }
573    void BasicGlCamera::greyScalePalettePlease(bool checked)
574    {
575        if (!checked) return;
576        ss[0] = 0;    ss[1] = 0.25f; ss[2] = 0.5f; ss[3] = 0.75f; ss[4] = 1.0f;
577        rr[0] = 0; rr[1] = 0.25f;     rr[2] = 0.5f;    rr[3] = 0.75f;  rr[4] = 1.0f;
578        gg[0] = 0; gg[1] = 0.25f;     gg[2] = 0.5f;    gg[3] = 0.75f;     gg[4] = 1.0f;
579        bb[0] = 0; bb[1] = 0.25f;     bb[2] = 0.5f;    bb[3] = 0.75f;     bb[4] = 1.0f;
580        tooHighValueCoulour[0] = 0.f;
581        tooHighValueCoulour[1] = 1.f;
582        tooHighValueCoulour[2] = 0.f;
583        tooLowValueCoulour[0] = 0.f;
584        tooLowValueCoulour[1] = 0.f;
585        tooLowValueCoulour[2] = 1.f;
586        pixelColorUpToDate = false;
587
588        emit colorPaletteHasChanged();
589
590        if (isVisible() && autoRefresh)
591            updateGL();
592    }
593    void BasicGlCamera::glowingPalettePlease(bool checked)
594    {
595        if (!checked) return;
596        ss[0] = 0;    ss[1] = 0.25f; ss[2] = 0.5f; ss[3] = 0.75f; ss[4] = 1.0f;
597        rr[0] = 0.15; rr[1] = 0.5;     rr[2] = 1.f;    rr[3] = 0.0f;  rr[4] = 1.f;
598        gg[0] = 0.15; gg[1] = 0.5;     gg[2] = 1.f;    gg[3] = 0.5f;     gg[4] = 0.5f;
599        bb[0] = 0.15; bb[1] = 0.5;     bb[2] = 1;      bb[3] = 1.f;     bb[4] = 0.f;
600        tooHighValueCoulour[0] = 1.f;
601        tooHighValueCoulour[1] = 0.f;
602        tooHighValueCoulour[2] = 0.f;
603        tooLowValueCoulour[0] = 0.f;
604        tooLowValueCoulour[1] = 1.f;
605        tooLowValueCoulour[2] = 0.f;
606        pixelColorUpToDate = false;
607
608        emit colorPaletteHasChanged();
609
610        if (isVisible() && autoRefresh)
611            updateGL();
612    }
613    void BasicGlCamera::SetAutoRefresh(bool on)
614    {
615        autoRefresh = on;
616        if (isVisible() && autoRefresh)
617            updateGL();
618    }
619    void BasicGlCamera::zeroRotationPlease(bool checked)
620    {
621        if (!checked) return;
622        cameraRotation = 0;
623        pixelColorUpToDate = false;
624        if (isVisible() && autoRefresh)
625            updateGL();
626    }
627    void BasicGlCamera::plus90RotationPlease(bool checked)
628    {
629        if (!checked) return;
630        cameraRotation = 90;
631        pixelColorUpToDate = false;
632        if (isVisible() && autoRefresh)
633            updateGL();
634    }
635    void BasicGlCamera::minus90RotationPlease(bool checked)
636    {
637        if (!checked) return;
638        cameraRotation = -90;
639        pixelColorUpToDate = false;
640        if (isVisible() && autoRefresh)
641            updateGL();
642    }
643
644    void BasicGlCamera::initializeGL()
645    {
646        qglClearColor(QColor(212,208,200));//25,25,38));
647        glShadeModel(GL_FLAT);
648        glEnable(GL_DEPTH_TEST);
649        glDisable(GL_CULL_FACE);
650
651   //     glEnable (GL_LINE_SMOOTH);
652   //     glEnable (GL_BLEND);
653   //     glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
654   //     glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
655
656    }
657    void BasicGlCamera::resizeGL(int cWidth, int cHeight)
658    {
659        glViewport(0, 0, cWidth, cHeight);
660         glMatrixMode(GL_PROJECTION);
661         glLoadIdentity();
662         GLfloat windowRatio = (float)cWidth/(float)cHeight;
663         if (windowRatio < 1)
664         {
665             windowRatio = 1.0f/windowRatio;
666             gluOrtho2D(-viewSize, viewSize, -viewSize*windowRatio, viewSize*windowRatio);
667             pixelSize = 2*viewSize/(float)cWidth;
668             shownSizex = 2*viewSize;
669             shownSizey = 2*viewSize*windowRatio;
670         }
671         else
672         {
673             gluOrtho2D(-viewSize*windowRatio, viewSize*windowRatio, -viewSize, viewSize);
674             pixelSize = 2*viewSize/(float)cHeight;
675             shownSizex = 2*viewSize*windowRatio;
676             shownSizey = 2*viewSize;
677         }
678         glMatrixMode(GL_MODELVIEW);
679
680         fTextSize = (int)(cWidth*12/600); //want a sized 12 font for a window of 600 pixels width
681         setFont(QFont("Monospace", fTextSize));
682    }
683    void BasicGlCamera::paintGL()
684    {
685         glClear(GL_COLOR_BUFFER_BIT);
686         glLoadIdentity();
687
688         glTranslatef(0,-0.44,0);
689         glScalef(1.5, 1.5, 1.5);
690
691         drawCamera(true);
692
693         drawPatches();
694    }
695    void BasicGlCamera::toggleInterfaceDisplay()
696    {
697        if (linearButton->isVisible())
698        {
699            linearButton->hide();
700            logButton->hide();
701            regularPaletteButton->hide();
702            prettyPaletteButton->hide();
703            greyScalePaletteButton->hide();
704            glowingPaletteButton->hide();
705            zeroRotationButton->hide();
706            minus90RotationButton->hide();
707            plus90Rotationbutton->hide();
708            scaleLabel->hide();
709            colorPaletteLabel->hide();
710            rotationLabel->hide();
711        }
712        else
713        {
714            linearButton->show();
715            logButton->show();
716            regularPaletteButton->show();
717            prettyPaletteButton->show();
718            greyScalePaletteButton->show();
719            glowingPaletteButton->show();
720            zeroRotationButton->show();
721            minus90RotationButton->show();
722            plus90Rotationbutton->show();
723            scaleLabel->show();
724            colorPaletteLabel->show();
725            rotationLabel->show();
726        }
727    }
728
729    void BasicGlCamera::mousePressEvent(QMouseEvent *)
730    {
731
732    }
733    void BasicGlCamera::mouseMoveEvent(QMouseEvent *)
734    {
735
736    }
737    void BasicGlCamera::mouseDoubleClickEvent(QMouseEvent *)
738    {
739
740    }
741    void BasicGlCamera::timedUpdate()
742    {
743        if (isVisible())
744            updateGL();
745    }
746    void BasicGlCamera::updateCamera()
747    {
748        emit signalUpdateCamera();
749    }
750    void BasicGlCamera::drawCamera(bool alsoWire)
751    {
752//        cout << "Super PaintGL" << endl;
753        glColor3f(0.5,0.5,0.5);
754        glLineWidth(1.0);
755        float color;
756
757        for (int i=0;i<ACTUAL_NUM_PIXELS;i++)
758        {
759            color = float(fData[i*fPixelStride+fcSlice]);// + ]eventData[nRoi*i + whichSlice]+(VALUES_SPAN/2))/(float)(VALUES_SPAN-1);
760            int index = 0;
761            while (ss[index] < color)
762                index++;
763            index--;
764            float weight0 = (color-ss[index]) / (ss[index+1]-ss[index]);
765            float weight1 = 1.0f-weight0;
766            pixelsColor[i][0] = weight1*rr[index] + weight0*rr[index+1];
767            pixelsColor[i][1] = weight1*gg[index] + weight0*gg[index+1];
768            pixelsColor[i][2] = weight1*bb[index] + weight0*bb[index+1];
769        }
770
771        for (int i=0;i<ACTUAL_NUM_PIXELS;i++)
772        {
773 //           if (i == 690 ||
774 //               i == 70)
775 //               continue;
776            glColor3fv(pixelsColor[i]);
777            glLoadName(i);
778
779        drawHexagon(i,true);
780
781        }
782        if (!alsoWire)
783            return;
784        glColor3f(0.0f,0.0f,0.0f);
785        for (int i=0;i<ACTUAL_NUM_PIXELS;i++)
786        {
787//            if (i == 690 ||
788//                i == 70)
789//                continue;
790            drawHexagon(i, false);
791        }
792    }
793    void BasicGlCamera::drawPatches()
794    {
795        glLineWidth(2.0f);
796        float backupRadius = hexRadius;
797        hexRadius *= 0.95;
798        glColor3f(0.5f, 0.5f, 0.3f);
799        glBegin(GL_LINES);
800        for (int i=0;i<NTMARK;i++)
801        {
802            for (unsigned int j=0;j<patchesIndices[i].size();j++)
803            {
804                glVertex2fv(verticesList[patchesIndices[i][j].first]);
805                glVertex2fv(verticesList[patchesIndices[i][j].second]);
806            }
807        }
808        glEnd();
809        hexRadius = backupRadius;
810    }
811    int BasicGlCamera::PixelAtPosition(const QPoint &cPos)
812    {
813        const int MaxSize = 512;
814        GLuint buffer[MaxSize];
815        GLint viewport[4];
816
817        makeCurrent();
818
819        glGetIntegerv(GL_VIEWPORT, viewport);
820        glSelectBuffer(MaxSize, buffer);
821        glRenderMode(GL_SELECT);
822
823        glInitNames();
824        glPushName(0);
825
826        glMatrixMode(GL_PROJECTION);
827        glPushMatrix();
828        glLoadIdentity();
829        GLfloat windowRatio = GLfloat(width()) / GLfloat(height());
830        gluPickMatrix(GLdouble(cPos.x()), GLdouble(viewport[3] - cPos.y()),
831                1.0, 1.0, viewport);
832
833        if (windowRatio < 1)
834         {
835             windowRatio = 1.0f/windowRatio;
836             gluOrtho2D(-viewSize, viewSize, -viewSize*windowRatio, viewSize*windowRatio);
837         }
838         else
839         {
840             gluOrtho2D(-viewSize*windowRatio, viewSize*windowRatio, -viewSize, viewSize);
841         }
842
843        glMatrixMode(GL_MODELVIEW);
844        drawCamera(false);
845        glMatrixMode(GL_PROJECTION);
846        glPopMatrix();
847
848        //for some reason that I cannot understand, the push/pop matrix doesn't do the trick here... bizarre
849        //ok, so re-do the resizeGL thing.
850        resizeGL(width(), height());
851
852        if (!glRenderMode(GL_RENDER))
853            return -1;
854
855        return buffer[3];
856    }
857    void BasicGlCamera::drawHexagon(int index, bool solid)
858    {
859/*        float minX, maxX, minY, maxY;
860        minX = minY = 1e10;
861        maxX = maxY = -1e10;
862        for (int i=0;i<1438;i++)
863        {
864            for (int j=0;j<6;j++)
865            {
866                if (verticesList[verticesIndices[i][j]][0] > maxX)
867                    maxX = verticesList[verticesIndices[i][j]][0];
868                if (verticesList[verticesIndices[i][j]][0] < minX)
869                    minX = verticesList[verticesIndices[i][j]][0];
870                if (verticesList[verticesIndices[i][j]][1] > maxY)
871                    maxY = verticesList[verticesIndices[i][j]][1];
872                if (verticesList[verticesIndices[i][j]][1] < minY)
873                    minY = verticesList[verticesIndices[i][j]][1];
874            }
875        }
876        cout << "Min, Max X: " << minX << " " << maxX << endl;
877        cout << "Min, Max Y: " << minY << " " << maxY << endl;
878        exit(0);*/
879        if (solid)
880            glBegin(GL_POLYGON);
881        else
882            glBegin(GL_LINE_LOOP);
883
884        glVertex2fv(verticesList[verticesIndices[index][0]]);
885        glVertex2fv(verticesList[verticesIndices[index][1]]);
886        glVertex2fv(verticesList[verticesIndices[index][2]]);
887        glVertex2fv(verticesList[verticesIndices[index][3]]);
888        glVertex2fv(verticesList[verticesIndices[index][4]]);
889        glVertex2fv(verticesList[verticesIndices[index][5]]);
890        if (solid)
891            glVertex2fv(verticesList[verticesIndices[index][0]]);
892
893        glEnd();
894    }
895
896    void BasicGlCamera::updateNeighbors(int currentPixel)
897    {
898        float squaredDistance = 0;
899        for (int i=0;i<currentPixel;i++)
900        {
901            squaredDistance = (pixelsCoords[i][0] - pixelsCoords[currentPixel][0])*
902                              (pixelsCoords[i][0] - pixelsCoords[currentPixel][0]) +
903                              (pixelsCoords[i][1] - pixelsCoords[currentPixel][1])*
904                              (pixelsCoords[i][1] - pixelsCoords[currentPixel][1]);
905            if (squaredDistance < 4*hexRadius*hexRadius*(1.0f+hexTolerance))//neighbor !
906            {//ok, but which one ?
907                if (fabs(pixelsCoords[i][0] - pixelsCoords[currentPixel][0]) < hexTolerance &&
908                    pixelsCoords[i][1] < pixelsCoords[currentPixel][1]){//top
909                    neighbors[i][0] = currentPixel;
910                    neighbors[currentPixel][3] = i;
911                    continue;}
912                if (fabs(pixelsCoords[i][0] - pixelsCoords[currentPixel][0]) < hexTolerance &&
913                    pixelsCoords[i][1] > pixelsCoords[currentPixel][1]){//bottom
914                    neighbors[i][3] = currentPixel;
915                    neighbors[currentPixel][0] = i;
916                    continue;}
917                if (pixelsCoords[i][0] > pixelsCoords[currentPixel][0] &&
918                    pixelsCoords[i][1] > pixelsCoords[currentPixel][1]){//top right
919                    neighbors[i][4] = currentPixel;
920                    neighbors[currentPixel][1] = i;
921                    continue;}
922                if (pixelsCoords[i][0] > pixelsCoords[currentPixel][0] &&
923                    pixelsCoords[i][1] < pixelsCoords[currentPixel][1]){//bottom right
924                    neighbors[i][5] = currentPixel;
925                    neighbors[currentPixel][2] = i;
926                    continue;}
927                if (pixelsCoords[i][0] < pixelsCoords[currentPixel][0] &&
928                    pixelsCoords[i][1] > pixelsCoords[currentPixel][1]){//top left
929                    neighbors[i][2] = currentPixel;
930                    neighbors[currentPixel][5] = i;
931                    continue;}
932                if (pixelsCoords[i][0] < pixelsCoords[currentPixel][0] &&
933                    pixelsCoords[i][1] < pixelsCoords[currentPixel][1]){//bottom left
934                    neighbors[i][1] = currentPixel;
935                    neighbors[currentPixel][4] = i;
936                    continue;}
937            }
938        }
939    }
940    void BasicGlCamera::skipPixels(int start, int howMany)
941    {
942        for (int i=start;i<MAX_NUM_PIXELS-howMany;i++)
943        {
944            pixelsCoords[i][0] = pixelsCoords[i+howMany][0];
945            pixelsCoords[i][1] = pixelsCoords[i+howMany][1];
946        }
947    }
948    void BasicGlCamera::calculatePixelsCoords()
949    {
950        if (pixelsCoords[0][1] >= (0.299999-hexRadius) && pixelsCoords[0][1] <= (0.300001-hexRadius))
951            return;
952        pixelsCoords[0][0] = 0;
953        pixelsCoords[0][1] = 0.3 - hexRadius;
954        pixelsCoords[0][2] = 0;
955        pixelsCoords[1][0] = 0;
956        pixelsCoords[1][1] = 0.3+hexRadius;
957        pixelsCoords[1][2] = 0;
958        neighbors[0][0] = 1;
959        neighbors[1][3] = 0;
960        //from which side of the previous hexagon are we coming from ?
961        int fromSide = 3;
962        //to which side are we heading to ?
963        int toSide = 0;
964        for (int i=2;i<MAX_NUM_PIXELS;i++)
965        {
966            toSide = fromSide-1;
967            if (toSide < 0)
968                toSide =5;
969            while (neighbors[i-1][toSide] >= 0)
970            {
971                toSide--;
972                if (toSide < 0)
973                    toSide = 5;
974            }
975            fromSide = toSide + 3;
976            if (fromSide > 5)
977                fromSide -= 6;
978            //ok. now we now in which direction we're heading
979            pixelsCoords[i][0] = pixelsCoords[i-1][0];
980            pixelsCoords[i][1] = pixelsCoords[i-1][1];
981            pixelsCoords[i][2] = pixelsCoords[i-1][2];
982            switch (toSide)
983            {
984            case 0:
985                pixelsCoords[i][1] += 2*hexRadius;
986            break;
987            case 1:
988                pixelsCoords[i][0] += (2*hexRadius)*sin(M_PI/3.0);
989                pixelsCoords[i][1] += (2*hexRadius)*cos(M_PI/3.0);
990            break;
991            case 2:
992                pixelsCoords[i][0] += (2*hexRadius)*sin(M_PI/3.0);
993                pixelsCoords[i][1] -= (2*hexRadius)*cos(M_PI/3.0);
994            break;
995            case 3:
996                pixelsCoords[i][1] -= 2*hexRadius;
997            break;
998            case 4:
999                pixelsCoords[i][0] -= (2*hexRadius)*sin(M_PI/3.0);
1000                pixelsCoords[i][1] -= (2*hexRadius)*cos(M_PI/3.0);
1001            break;
1002            case 5:
1003                pixelsCoords[i][0] -= (2*hexRadius)*sin(M_PI/3.0);
1004                pixelsCoords[i][1] += (2*hexRadius)*cos(M_PI/3.0);
1005            break;
1006            };
1007//            pixelsCoords[i][1] -= hexRadius;
1008
1009            updateNeighbors(i);
1010        }
1011        //Ok. So now we've circled around all the way to MAX_NUM_PIXELS
1012        //do the required shifts so that it matches the fact camera up to ACTUAL_NUM_PIXELS pixels
1013        //remember the location pixels 1438 and 1439, and re-assign them later on
1014        GLfloat backupCoords[4];
1015        skipPixels(1200, 1);
1016        skipPixels(1218, 3);
1017        skipPixels(1236, 1);
1018        skipPixels(1256, 1);
1019        skipPixels(1274, 3);
1020        skipPixels(1292, 3);
1021        skipPixels(1309, 6);
1022        skipPixels(1323, 7);
1023        skipPixels(1337, 6);
1024        skipPixels(1354, 6);
1025        skipPixels(1368, 7);
1026        //la c'est dans 1390 qu'il y a 1439
1027         backupCoords[0] = pixelsCoords[1390][0];
1028         backupCoords[1] = pixelsCoords[1390][1];
1029        skipPixels(1382, 9);
1030         skipPixels(1394, 12);
1031        skipPixels(1402, 15);
1032        skipPixels(1410, 12);
1033        //la c'est dans 1422 qu'il y a 1438
1034        backupCoords[2] = pixelsCoords[1422][0];
1035        backupCoords[3] = pixelsCoords[1422][1];
1036        skipPixels(1422, 12);
1037        skipPixels(1430, 15);
1038
1039        pixelsCoords[1438][0] = backupCoords[2];
1040        pixelsCoords[1438][1] = backupCoords[3];
1041        pixelsCoords[1439][0] = backupCoords[0];
1042        pixelsCoords[1439][1] = backupCoords[1];
1043   }
1044    void BasicGlCamera::buildVerticesList()
1045    {
1046        numVertices = 0;
1047         GLfloat cVertex[2];
1048         for (int i=0;i<NPIX;i++)
1049         {
1050             for (int j=0;j<6;j++)
1051             {
1052                 for (int k=0;k<2;k++)
1053                     cVertex[k] = hexcoords[j][k]*hexRadius + pixelsCoords[i][k];
1054
1055                 bool found = false;
1056                 for (int k=0;k<numVertices;k++)
1057                 {
1058                     if ((cVertex[0] - verticesList[k][0])*
1059                         (cVertex[0] - verticesList[k][0]) +
1060                         (cVertex[1] - verticesList[k][1])*
1061                         (cVertex[1] - verticesList[k][1]) < hexTolerance*hexTolerance)
1062                         {
1063                             found = true;
1064                             break;
1065                         }
1066                 }
1067                 if (!found)
1068                 {
1069                     for (int k=0;k<2;k++)
1070                         verticesList[numVertices][k] = cVertex[k];
1071                     numVertices++;
1072                 }
1073             }
1074         }
1075//cout << "numVertices: " << numVertices << endl;
1076         for (int i=0;i<NPIX;i++)
1077         {
1078             for (int j=0;j<6;j++)
1079             {
1080                 for (int k=0;k<2;k++)
1081                     cVertex[k] = hexcoords[j][k]*hexRadius + pixelsCoords[i][k];
1082
1083                 for (int k=0;k<numVertices;k++)
1084                 {
1085                     if ((cVertex[0] - verticesList[k][0])*
1086                          (cVertex[0] - verticesList[k][0]) +
1087                          (cVertex[1] - verticesList[k][1])*
1088                          (cVertex[1] - verticesList[k][1]) < hexTolerance*hexTolerance)
1089                          {
1090                             verticesIndices[i][j] = k;
1091                             break;
1092                          }
1093                 }
1094             }
1095         }
1096    }
1097    void BasicGlCamera::buildPatchesIndices()
1098    {
1099        vector<edge>::iterator it;
1100        bool erased = false;
1101//        patchesIndices.resize(NTMARK);
1102        for (int i=0;i<NTMARK;i++)//for all patches
1103        {
1104            patchesIndices[i].clear();
1105            for (int j=0;j<9;j++)//for all cells of the current patch
1106            {
1107                if (softwareMapping[i*9+j] >= ACTUAL_NUM_PIXELS)
1108                    continue;
1109                for (int k=0;k<6;k++)//for all sides of the current cell
1110                {
1111                    int first = k-1;
1112                    int second = k;
1113                    if (first < 0)
1114                        first = 5;
1115                    erased = false;
1116                    for (it=(patchesIndices[i]).begin(); it != (patchesIndices[i]).end(); it++)//check if this side is here already or not
1117                    {
1118                        const int idx = i*9+j;
1119
1120                        if ((it->first == verticesIndices[softwareMapping[idx]][first] &&
1121                             it->second == verticesIndices[softwareMapping[idx]][second]) ||
1122                            (it->first == verticesIndices[softwareMapping[idx]][second] &&
1123                             it->second == verticesIndices[softwareMapping[idx]][first]))
1124                        {
1125                            patchesIndices[i].erase(it);
1126                            erased = true;
1127                            break;
1128                        }
1129                    }
1130                    if (!erased)
1131                    {
1132                        edge temp;
1133                        temp.first = verticesIndices[softwareMapping[i*9+j]][first];
1134                        temp.second = verticesIndices[softwareMapping[i*9+j]][second];
1135                        patchesIndices[i].push_back(temp);
1136                    }
1137                }
1138            }
1139        }
1140//        for (int i=0;i<NTMARK;i++)
1141//        {
1142//            cout << ".....................patch " << i << " size: " << patchesIndices[i].size() << endl;
1143//            for (unsigned int j=0;j<patchesIndices[i].size();j++)
1144//            {
1145//               if (patchesIndices[i][j].first < 0 || patchesIndices[i][j].first > 3013)
1146//                cout << patchesIndices[i][j].first << " and " << patchesIndices[i][j].second << " and " << j << endl;
1147//            }
1148//        }
1149    }
1150
Note: See TracBrowser for help on using the repository browser.