Changeset 18621 for trunk/FACT++


Ignore:
Timestamp:
09/18/16 14:46:35 (8 years ago)
Author:
tbretz
Message:
Removed references to root, replaced with basic types.
Location:
trunk/FACT++/drive
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/FACT++/drive/FilterLed.cc

    r18618 r18621  
    55#include <iostream> // cout
    66
    7 #include <TMath.h>
    8 
    97#include "Led.h"
    10 #include "Leds.h"
    118#include "Ring.h"
    129
    13 #include "MGMap.h"
    14 
    15 ClassImp(FilterLed);
     10#include "MGImage.h"
    1611
    1712using namespace std;
    … …  
    2015{
    2116private:
    22     byte *fImg;
    23 
    24     UInt_t fW;
    25     UInt_t fH;
    26 
    27     Int_t fX0;
    28     Int_t fX1;
    29 
    30     Int_t fY0;
    31     Int_t fY1;
    32 
    33     UInt_t fLimitingSize;
    34 
    35     UInt_t fCount;
    36     Float_t fSumX;
    37     Float_t fSumY;
    38 
    39     Float_t FindCluster(Int_t x, Int_t y)
     17    uint8_t *fImg;
     18
     19    uint32_t fW;
     20    uint32_t fH;
     21
     22    int32_t fX0;
     23    int32_t fX1;
     24
     25    int32_t fY0;
     26    int32_t fY1;
     27
     28    uint32_t fLimitingSize;
     29
     30    uint32_t fCount;
     31    float fSumX;
     32    float fSumY;
     33
     34    float FindCluster(int32_t x, int32_t y)
    4035    {
    4136        // if edge is touched stop finding cluster
    … …  
    4742
    4843        // get the value
    49         Float_t val = fImg[y*fW+x];
     44        float val = fImg[y*fW+x];
    5045
    5146        // if its empty we have found the border of the cluster
    … …  
    6055        fCount++;
    6156
    62         Float_t rc[4];
     57        float rc[4];
    6358        rc[0] = FindCluster(x+1, y  );
    6459        rc[1] = FindCluster(x,   y+1);
    … …  
    7873
    7974public:
    80     ClusterFinder(byte *img, UInt_t w, UInt_t h) : fImg(0), fLimitingSize(999)
     75    ClusterFinder(uint8_t *img, uint32_t w, uint32_t h) : fImg(0), fLimitingSize(999)
    8176    {
    8277        fW = w;
    … …  
    8883        fY1 = fH;
    8984
    90         fImg = new byte[fW*fH];
     85        fImg = new uint8_t[fW*fH];
    9186
    9287        memcpy(fImg, img, fW*fH);
    … …  
    10095    Double_t GetSumY() const { return fSumY; }
    10196
    102     UInt_t GetCount() const { return fCount; }
    103 
    104     void SetLimitingSize(UInt_t lim) { fLimitingSize=lim; }
    105 
    106     Float_t FindClusterAt(Int_t x, Int_t y)
     97    uint32_t GetCount() const { return fCount; }
     98
     99    void SetLimitingSize(uint32_t lim) { fLimitingSize=lim; }
     100
     101    float FindClusterAt(int32_t x, int32_t y)
    107102    {
    108103        fCount = 0;
    … …  
    113108    }
    114109
    115     void SetRange(Int_t x0=0, Int_t y0=0, Int_t x1=0, Int_t y1=0)
     110    void SetRange(int32_t x0=0, int32_t y0=0, int32_t x1=0, int32_t y1=0)
    116111    {
    117112        fX0 = x0;
    … …  
    121116    }
    122117
    123     void FindCluster(Leds &leds, Int_t x0=0, Int_t y0=0, Int_t x1=0, Int_t y1=0)
     118    void FindCluster(vector<Led> &leds, int32_t x0=0, int32_t y0=0, int32_t x1=0, int32_t y1=0)
    124119    {
    125120        fX0 = x0;
    … …  
    128123        fY1 = y1==0?fH:y1;
    129124
    130         for (Int_t x=fX0; x<fX1; x++)
    131             for (Int_t y=fY0; y<fY1; y++)
     125        for (int32_t x=fX0; x<fX1; x++)
     126            for (int32_t y=fY0; y<fY1; y++)
    132127            {
    133                 const byte &b = fImg[y*fW+x];
     128                const uint8_t &b = fImg[y*fW+x];
    134129                if (b==0)
    135130                    continue;
    136131
    137                 const Float_t mag = FindClusterAt(x, y);
     132                const float mag = FindClusterAt(x, y);
    138133                if (fCount>999)
    139134                {
    … …  
    142137                }
    143138
    144                 if (mag>0 && fCount>6)
    145                     leds.Add(fSumX/mag, fSumY/mag, 0, 0, mag);
     139                if (mag>0 && fCount>4)
     140                    leds.push_back(Led(fSumX/mag, fSumY/mag, 0, mag));
    146141            }
    147         leds.Compress();
     142        //leds.Compress();
    148143    }
    149144};
    … …  
    154149                        const int col) const
    155150{
    156     MGMap::DrawBox(fImg, 768, 576, x1, y1, x2, y2, col);
    157 }
    158 
    159 void FilterLed::MarkPoint(Float_t px, Float_t py, Float_t mag) const
     151    MGImage::DrawBox(fImg, 768, 576, x1, y1, x2, y2, col);
     152}
     153
     154void FilterLed::MarkPoint(float px, float py, float mag) const
    160155{
    161156    const int x = (int)(px+.5);
    … …  
    172167{
    173168    /*
    174     Int_t M = (int)(log(led.GetMag())*20);
     169    int32_t M = (int)(log(led.GetMag())*20);
    175170
    176171    cout << led.GetMag() << endl;
    … …  
    188183}
    189184
    190 void FilterLed::DrawCircle(float cx, float cy, float r, byte col) const
    191 {
    192     MGMap::DrawCircle(fImg, 768, 576, cx, cy, r, col);
    193 }
    194 
    195 void FilterLed::DrawHexagon(float cx, float cy, float r, byte col) const
    196 {
    197     MGMap::DrawHexagon(fImg, 768, 576, cx, cy, r, col);
    198 }
    199 
    200 void FilterLed::DrawCircle(const Ring &l, byte col) const
     185void FilterLed::DrawCircle(float cx, float cy, float r, uint8_t col) const
     186{
     187    MGImage::DrawCircle(fImg, 768, 576, cx, cy, r, col);
     188}
     189
     190void FilterLed::DrawHexagon(float cx, float cy, float r, uint8_t col) const
     191{
     192    MGImage::DrawHexagon(fImg, 768, 576, cx, cy, r, col);
     193}
     194
     195void FilterLed::DrawCircle(const Ring &l, uint8_t col) const
    201196{
    202197    DrawCircle(l.GetX(), l.GetY(), l.GetR(), col);
    203198}
    204199
    205 void FilterLed::DrawCircle(const Ring &l, double r, byte col) const
     200void FilterLed::DrawCircle(const Ring &l, double r, uint8_t col) const
    206201{
    207202    DrawCircle(l.GetX(), l.GetY(), r, col);
    208203}
    209204
    210 void FilterLed::DrawHexagon(const Ring &l, double r, byte col) const
     205void FilterLed::DrawHexagon(const Ring &l, double r, uint8_t col) const
    211206{
    212207    DrawHexagon(l.GetX(), l.GetY(), r, col);
    213208}
    214209
    215 void FilterLed::GetMinMax(const int offset, byte *min, byte *max) const
     210void FilterLed::GetMinMax(const int offset, uint8_t *min, uint8_t *max) const
    216211{
    217212    *min = fImg[0];
    218213    *max = fImg[0];
    219214
    220     byte *s = (byte*)fImg;
    221     const byte *e0 = s+fW*fH;
     215    uint8_t *s = (uint8_t*)fImg;
     216    const uint8_t *e0 = s+fW*fH;
    222217
    223218    //
    … …  
    226221    while (s<e0)
    227222    {
    228         const byte *e = s+fH-offset;
     223        const uint8_t *e = s+fH-offset;
    229224        s += offset;
    230225
    … …  
    260255        for (int dy=y-boxy; dy<y+boxy+1; dy++)
    261256        {
    262             const byte &m = fImg[dy*fW+dx];
     257            const uint8_t &m = fImg[dy*fW+dx];
    263258
    264259            sumx += m*dx;
    … …  
    287282    // Improved algorithm:
    288283    // 1. Look for the largest five-pixel-cross signal inside the box
    289     int x0 = TMath::Max(x-boxx+1,   0);
    290     int y0 = TMath::Max(y-boxy+1,   0);
    291 
    292     int x1 = TMath::Min(x+boxx+1-1, fW);
    293     int y1 = TMath::Min(y+boxy+1-1, fH);
     284    int x0 = max(x-boxx+1,   0);
     285    int y0 = max(y-boxy+1,   0);
     286
     287    int x1 = min(x+boxx+1-1, fW);
     288    int y1 = min(y+boxy+1-1, fH);
    294289
    295290    int maxx=0;
    … …  
    323318    find.SetRange(x0, y0, x1, y1);
    324319
    325     const Float_t mag = find.FindClusterAt(maxx, maxy);
     320    const float mag = find.FindClusterAt(maxx, maxy);
    326321
    327322    mx = find.GetSumX()/mag;
    … …  
    341336}
    342337
    343 void FilterLed::ExecuteAndMark(Leds &leds, int xc, int yc) const
    344 {
    345     const Int_t first = leds.GetEntriesFast();
    346 
    347     Execute(leds, xc, yc);
    348  
    349     // Mark Stars in image
    350     for (int i=first; i<leds.GetEntriesFast(); i++)
    351         MarkPoint(leds(i));
    352 }
    353 
    354 
    355 void FilterLed::ExecuteAndMark(Leds &leds, int xc, int yc, double &bright) const
    356 {
    357     const Int_t first = leds.GetEntriesFast();
    358 
    359     Execute(leds, xc, yc, bright);
    360  
    361     // Mark Stars in image
    362     for (int i=first; i<leds.GetEntriesFast(); i++)
    363         MarkPoint(leds(i));
    364 }
    365 
    366 void FilterLed::Execute(int xc, int yc) const
    367 {
    368     Leds leds;
    369     ExecuteAndMark(leds, xc, yc);
    370 }
    371 
    372 void FilterLed::Execute(Leds &leds, int xc, int yc) const
     338void FilterLed::Execute(vector<Led> &leds, int xc, int yc) const
    373339{
    374340    double bright;
    … …  
    376342}
    377343
    378 void FilterLed::Execute(Leds &leds, int xc, int yc, double &bright) const
    379 {
    380     const int x0 = TMath::Max(xc-fBoxX, 0);
    381     const int y0 = TMath::Max(yc-fBoxY, 0);
    382     const int x1 = TMath::Min(xc+fBoxX, fW);
    383     const int y1 = TMath::Min(yc+fBoxY, fH);
     344void FilterLed::Execute(vector<Led> &leds, int xc, int yc, double &bright) const
     345{
     346    const int x0 = max(xc-fBoxX, 0);
     347    const int y0 = max(yc-fBoxY, 0);
     348    const int x1 = min(xc+fBoxX, fW);
     349    const int y1 = min(yc+fBoxY, fH);
    384350
    385351    const int wx = x1-x0;
    … …  
    392358        for (int y=y0; y<y1; y++)
    393359        {
    394             byte &b = fImg[y*fW+x];
     360            uint8_t &b = fImg[y*fW+x];
    395361
    396362            // Skip saturating pixels
    … …  
    410376    // 254 because b<=max and not b<max
    411377    const double sdev = sqrt(sq-sum*sum);
    412     const byte   max  = sum+fCut*sdev>254 ? 254 : (byte)(sum+fCut*sdev);
     378    const uint8_t   max  = sum+fCut*sdev>254 ? 254 : (uint8_t)(sum+fCut*sdev);
    413379
    414380    //
    … …  
    419385        for (int y=y0; y<y1; y++)
    420386        {
    421             byte &b = fImg[y*fW+x];
     387            uint8_t &b = fImg[y*fW+x];
    422388            if (b<=max)
    423389                b = 0;
    … …  
    428394}
    429395
    430 void FilterLed::FindStar(Leds &leds, int xc, int yc, bool box) const
     396void FilterLed::FindStar(vector<Led> &leds, int xc, int yc, bool box) const
    431397{
    432398    // fBox: radius of the inner (signal) box
    … …  
    436402    // Define inner box in which to search the signal
    437403    //
    438     const int x0 = TMath::Max(xc-fBoxX, 0);
    439     const int y0 = TMath::Max(yc-fBoxY, 0);
    440     const int x1 = TMath::Min(xc+fBoxX, fW);
    441     const int y1 = TMath::Min(yc+fBoxY, fH);
     404    const int x0 = max(xc-fBoxX, 0);
     405    const int y0 = max(yc-fBoxY, 0);
     406    const int x1 = min(xc+fBoxX, fW);
     407    const int y1 = min(yc+fBoxY, fH);
    442408
    443409    //
    … …  
    448414    const double sqrt2 = sqrt(2.);
    449415
    450     const int xa = TMath::Max(xc-TMath::Nint(fBoxX*sqrt2), 0);
    451     const int ya = TMath::Max(yc-TMath::Nint(fBoxY*sqrt2), 0);
    452     const int xb = TMath::Min(xc+TMath::Nint(fBoxX*sqrt2), fW);
    453     const int yb = TMath::Min(yc+TMath::Nint(fBoxY*sqrt2), fH);
     416    const int xa = max(xc-(int)nearbyint(fBoxX*sqrt2), 0);
     417    const int ya = max(yc-(int)nearbyint(fBoxY*sqrt2), 0);
     418    const int xb = min(xc+(int)nearbyint(fBoxX*sqrt2), fW);
     419    const int yb = min(yc+(int)nearbyint(fBoxY*sqrt2), fH);
    454420
    455421    //
    … …  
    468434                continue;
    469435
    470             byte &b = fImg[y*fW+x];
     436            uint8_t &b = fImg[y*fW+x];
    471437
    472438            sum += b;
    … …  
    480446    // 254 because b<=max and not b<max
    481447    const double sdev = sqrt(sq-sum*sum);
    482     const byte   max  = sum+fCut*sdev>254 ? 254 : (byte)(sum+fCut*sdev);
     448    const uint8_t   max  = sum+fCut*sdev>254 ? 254 : (uint8_t)(sum+fCut*sdev);
    483449
    484450    //
    … …  
    490456        for (int y=y0; y<y1; y++)
    491457        {
    492             byte &b = fImg[y*fW+x];
     458            uint8_t &b = fImg[y*fW+x];
    493459            if (b<=max)
    494460                b = 0;
    … …  
    531497    //    cout << "Sum/n = " << sum << "/" << n << " = " << (n==0?0:mag/n) << endl;
    532498
    533     leds.Add(mx, my, 0, 0, -2.5*log10((float)mag)+13.7);
     499    leds.push_back(Led(mx, my, 0, -2.5*log10((float)mag)+13.7));
    534500}
    535501
    536502void FilterLed::Stretch() const
    537503{
    538     byte min, max;
     504    uint8_t min, max;
    539505    GetMinMax(25, &min, &max);
    540506
    … …  
    544510    const float scale = 255./(max-min);
    545511
    546     byte *b = fImg;
    547     const byte *e = fImg+fW*fH;
     512    uint8_t *b = fImg;
     513    const uint8_t *e = fImg+fW*fH;
    548514
    549515    while (b<e)
    … …  
    559525            continue;
    560526        }
    561         *b = (byte)((*b-min)*scale);
     527        *b = (uint8_t)((*b-min)*scale);
    562528        b++;
    563529    }

  • trunk/FACT++/drive/FilterLed.h

    r18618 r18621  
    22#define CAOS_FilterLed
    33
    4 #ifndef __CINT__
    5 #include <TROOT.h>
    6 #endif
    7 
    8 typedef unsigned char byte;
     4#include <stdint.h>
     5#include <vector>
    96
    107class Led;
    11 class Leds;
    128class Ring;
    139
    1410class FilterLed
    1511{
    16     byte *fImg;
     12    uint8_t *fImg;
    1713    int fW;
    1814    int fH;
    … …  
    2117    float fCut;
    2218
    23     Float_t FindCluster(int &cnt, float *sum, UInt_t x, UInt_t y,
    24                         UInt_t x0, UInt_t y0, UInt_t x1, UInt_t y1) const;
     19    float FindCluster(int &cnt, float *sum, uint32_t x, uint32_t y,
     20                        uint32_t x0, uint32_t y0, uint32_t x1, uint32_t y1) const;
    2521
    26     void GetMinMax(const int offset, byte *min, byte *max) const;
     22    void GetMinMax(const int offset, uint8_t *min, uint8_t *max) const;
    2723    int  GetMeanPosition(const int x, const int y, const int boxx, const int boxy) const;
    2824    int  GetMeanPosition(const int x, const int y, const int boxx, const int boxy,
    … …  
    4036
    4137public:
    42     FilterLed(byte *img, int w, int h, double cut=2.5)
    43       : fImg(img), fW(w), fH(h), fBoxX(w), fBoxY(h), fCut(cut)
     38    FilterLed(uint8_t *img, int w, int h, double cut=2.5) : fImg(img),
     39        fW(w), fH(h), fBoxX(w), fBoxY(h), fCut(cut)
    4440    {
    4541    }
    4642
    47     FilterLed(byte *img, int w, int h, int boxx, int boxy, double cut=2.5)
    48       : fImg(img), fW(w), fH(h), fBoxX(boxx), fBoxY(boxy), fCut(cut)
     43    FilterLed(uint8_t *img, int w, int h, int boxx, int boxy, double cut=2.5) : fImg(img),
     44        fW(w), fH(h), fBoxX(boxx), fBoxY(boxy), fCut(cut)
    4945    {
    5046    }
    … …  
    5349    void SetBox(int box)   { fBoxX = fBoxY = box; }
    5450    void SetBox(int boxx, int boxy)   { fBoxX = boxx; fBoxY = boxy; }
    55     void SetCut(float cut) { fCut = cut; }
    56     void FindStar(Leds &leds, int xc, int yc, bool circle=false) const;
    57    
    58     void Execute(Leds &leds, int xc, int yc, double &bright) const;
    59     void Execute(Leds &leds, int xc, int yc) const;
    60     void Execute(Leds &leds) const { Execute(leds, fW/2, fH/2); }
    61     void ExecuteAndMark(Leds &leds, int xc, int yc) const;
    62     void ExecuteAndMark(Leds &leds, int xc, int yc, double &bright) const;
    63     void ExecuteAndMark(Leds &leds) const { ExecuteAndMark(leds, fW/2, fH/2); }
    64     void Execute(int xc, int yc) const;
    65     void Execute() const { Execute(fW/2, fH/2); }
     51    void SetCut(float cut) { fCut = cut; }
     52    void FindStar(std::vector<Led> &leds, int xc, int yc, bool circle=false) const;
     53
     54    void Execute(std::vector<Led> &leds, int xc, int yc, double &bright) const;
     55    void Execute(std::vector<Led> &leds, int xc, int yc) const;
     56    void Execute(std::vector<Led> &leds) const { Execute(leds, fW/2, fH/2); }
     57
    6658    void MarkPoint(const Led &led) const;
    67     void MarkPoint(Float_t x, Float_t y, Float_t mag) const;
     59    void MarkPoint(float x, float y, float mag) const;
    6860    void Stretch() const;
    69     void DrawCircle(float cx, float cy, float r, byte col=0x40) const;
    70     void DrawCircle(float r, byte col=0x40) const { DrawCircle(fW/2, fH/2, r, col); }
    71     void DrawCircle(const Ring &c, byte col=0x40) const;
    72     void DrawCircle(const Ring &c, double r, byte col) const;
    73     void DrawHexagon(float cx, float cy, float r, byte col=0x40) const;
    74     void DrawHexagon(const Ring &c, double r, byte col) const;
    7561
    76     ClassDef(FilterLed, 0)
     62    void DrawCircle(float cx, float cy, float r, uint8_t col=0x40) const;
     63    void DrawCircle(float r, uint8_t col=0x40) const { DrawCircle(fW/2, fH/2, r, col); }
     64    void DrawCircle(const Ring &c, uint8_t col=0x40) const;
     65    void DrawCircle(const Ring &c, double r, uint8_t col) const;
     66    void DrawHexagon(float cx, float cy, float r, uint8_t col=0x40) const;
     67    void DrawHexagon(const Ring &c, double r, uint8_t col) const;
    7768};
    7869
Note: See TracChangeset for help on using the changeset viewer.