Changeset 18621 for trunk/FACT++/drive/FilterLed.cc

Timestamp:

09/18/16 14:46:35 (8 years ago)

Author:

tbretz

Message:

Removed references to root, replaced with basic types.

File:

• trunk/FACT++/drive/FilterLed.cc (modified) (32 diffs)

trunk/FACT++/drive/FilterLed.cc

@@ -5 +5 @@
 #include <iostream> // cout
 
-#include <TMath.h>
-
 #include "Led.h"
-#include "Leds.h"
 #include "Ring.h"
 
-#include "MGMap.h"
-
-ClassImp(FilterLed);
+#include "MGImage.h"
 
 using namespace std;
@@ -20 +15 @@
 {
 private:
-    byte *fImg;
-
-    UInt_t fW;
-    UInt_t fH;
-
-    Int_t fX0;
-    Int_t fX1;
-
-    Int_t fY0;
-    Int_t fY1;
-
-    UInt_t fLimitingSize;
-
-    UInt_t fCount;
-    Float_t fSumX;
-    Float_t fSumY;
-
-    Float_t FindCluster(Int_t x, Int_t y)
+    uint8_t *fImg;
+
+    uint32_t fW;
+    uint32_t fH;
+
+    int32_t fX0;
+    int32_t fX1;
+
+    int32_t fY0;
+    int32_t fY1;
+
+    uint32_t fLimitingSize;
+
+    uint32_t fCount;
+    float fSumX;
+    float fSumY;
+
+    float FindCluster(int32_t x, int32_t y)
     {
         // if edge is touched stop finding cluster
@@ -47 +42 @@
 
         // get the value
-        Float_t val = fImg[y*fW+x];
+        float val = fImg[y*fW+x];
 
         // if its empty we have found the border of the cluster
@@ -60 +55 @@
         fCount++;
 
-        Float_t rc[4];
+        float rc[4];
         rc[0] = FindCluster(x+1, y  );
         rc[1] = FindCluster(x,   y+1);
@@ -78 +73 @@
 
 public:
-    ClusterFinder(byte *img, UInt_t w, UInt_t h) : fImg(0), fLimitingSize(999)
+    ClusterFinder(uint8_t *img, uint32_t w, uint32_t h) : fImg(0), fLimitingSize(999)
     {
         fW = w;
@@ -88 +83 @@
         fY1 = fH;
 
-        fImg = new byte[fW*fH];
+        fImg = new uint8_t[fW*fH];
 
         memcpy(fImg, img, fW*fH);
@@ -100 +95 @@
     Double_t GetSumY() const { return fSumY; }
 
-    UInt_t GetCount() const { return fCount; }
-
-    void SetLimitingSize(UInt_t lim) { fLimitingSize=lim; }
-
-    Float_t FindClusterAt(Int_t x, Int_t y)
+    uint32_t GetCount() const { return fCount; }
+
+    void SetLimitingSize(uint32_t lim) { fLimitingSize=lim; }
+
+    float FindClusterAt(int32_t x, int32_t y)
     {
         fCount = 0;
@@ -113 +108 @@
     }
 
-    void SetRange(Int_t x0=0, Int_t y0=0, Int_t x1=0, Int_t y1=0)
+    void SetRange(int32_t x0=0, int32_t y0=0, int32_t x1=0, int32_t y1=0)
     {
         fX0 = x0;
@@ -121 +116 @@
     }
 
-    void FindCluster(Leds &leds, Int_t x0=0, Int_t y0=0, Int_t x1=0, Int_t y1=0)
+    void FindCluster(vector<Led> &leds, int32_t x0=0, int32_t y0=0, int32_t x1=0, int32_t y1=0)
     {
         fX0 = x0;
@@ -128 +123 @@
         fY1 = y1==0?fH:y1;
 
-        for (Int_t x=fX0; x<fX1; x++)
-            for (Int_t y=fY0; y<fY1; y++)
+        for (int32_t x=fX0; x<fX1; x++)
+            for (int32_t y=fY0; y<fY1; y++)
             {
-                const byte &b = fImg[y*fW+x];
+                const uint8_t &b = fImg[y*fW+x];
                 if (b==0)
                     continue;
 
-                const Float_t mag = FindClusterAt(x, y);
+                const float mag = FindClusterAt(x, y);
                 if (fCount>999)
                 {
@@ -142 +137 @@
                 }
 
-                if (mag>0 && fCount>6)
-                    leds.Add(fSumX/mag, fSumY/mag, 0, 0, mag);
+                if (mag>0 && fCount>4)
+                    leds.push_back(Led(fSumX/mag, fSumY/mag, 0, mag));
             }
-        leds.Compress();
+        //leds.Compress();
     }
 };
@@ -154 +149 @@
                         const int col) const
 {
-    MGMap::DrawBox(fImg, 768, 576, x1, y1, x2, y2, col);
-}
-
-void FilterLed::MarkPoint(Float_t px, Float_t py, Float_t mag) const
+    MGImage::DrawBox(fImg, 768, 576, x1, y1, x2, y2, col);
+}
+
+void FilterLed::MarkPoint(float px, float py, float mag) const
 {
     const int x = (int)(px+.5);
@@ -172 +167 @@
 {
     /*
-    Int_t M = (int)(log(led.GetMag())*20);
+    int32_t M = (int)(log(led.GetMag())*20);
 
     cout << led.GetMag() << endl;
@@ -188 +183 @@
 }
 
-void FilterLed::DrawCircle(float cx, float cy, float r, byte col) const
-{
-    MGMap::DrawCircle(fImg, 768, 576, cx, cy, r, col);
-}
-
-void FilterLed::DrawHexagon(float cx, float cy, float r, byte col) const
-{
-    MGMap::DrawHexagon(fImg, 768, 576, cx, cy, r, col);
-}
-
-void FilterLed::DrawCircle(const Ring &l, byte col) const
+void FilterLed::DrawCircle(float cx, float cy, float r, uint8_t col) const
+{
+    MGImage::DrawCircle(fImg, 768, 576, cx, cy, r, col);
+}
+
+void FilterLed::DrawHexagon(float cx, float cy, float r, uint8_t col) const
+{
+    MGImage::DrawHexagon(fImg, 768, 576, cx, cy, r, col);
+}
+
+void FilterLed::DrawCircle(const Ring &l, uint8_t col) const
 {
     DrawCircle(l.GetX(), l.GetY(), l.GetR(), col);
 }
 
-void FilterLed::DrawCircle(const Ring &l, double r, byte col) const
+void FilterLed::DrawCircle(const Ring &l, double r, uint8_t col) const
 {
     DrawCircle(l.GetX(), l.GetY(), r, col);
 }
 
-void FilterLed::DrawHexagon(const Ring &l, double r, byte col) const
+void FilterLed::DrawHexagon(const Ring &l, double r, uint8_t col) const
 {
     DrawHexagon(l.GetX(), l.GetY(), r, col);
 }
 
-void FilterLed::GetMinMax(const int offset, byte *min, byte *max) const
+void FilterLed::GetMinMax(const int offset, uint8_t *min, uint8_t *max) const
 {
     *min = fImg[0];
     *max = fImg[0];
 
-    byte *s = (byte*)fImg;
-    const byte *e0 = s+fW*fH;
+    uint8_t *s = (uint8_t*)fImg;
+    const uint8_t *e0 = s+fW*fH;
 
     //
@@ -226 +221 @@
     while (s<e0)
     {
-        const byte *e = s+fH-offset;
+        const uint8_t *e = s+fH-offset;
         s += offset;
 
@@ -260 +255 @@
         for (int dy=y-boxy; dy<y+boxy+1; dy++)
         {
-            const byte &m = fImg[dy*fW+dx];
+            const uint8_t &m = fImg[dy*fW+dx];
 
             sumx += m*dx;
@@ -287 +282 @@
     // Improved algorithm:
     // 1. Look for the largest five-pixel-cross signal inside the box
-    int x0 = TMath::Max(x-boxx+1,   0);
-    int y0 = TMath::Max(y-boxy+1,   0);
-
-    int x1 = TMath::Min(x+boxx+1-1, fW);
-    int y1 = TMath::Min(y+boxy+1-1, fH);
+    int x0 = max(x-boxx+1,   0);
+    int y0 = max(y-boxy+1,   0);
+
+    int x1 = min(x+boxx+1-1, fW);
+    int y1 = min(y+boxy+1-1, fH);
 
     int maxx=0;
@@ -323 +318 @@
     find.SetRange(x0, y0, x1, y1);
 
-    const Float_t mag = find.FindClusterAt(maxx, maxy);
+    const float mag = find.FindClusterAt(maxx, maxy);
 
     mx = find.GetSumX()/mag;
@@ -341 +336 @@
 }
 
-void FilterLed::ExecuteAndMark(Leds &leds, int xc, int yc) const
-{
-    const Int_t first = leds.GetEntriesFast();
-
-    Execute(leds, xc, yc);
- 
-    // Mark Stars in image
-    for (int i=first; i<leds.GetEntriesFast(); i++)
-        MarkPoint(leds(i));
-}
-
-
-void FilterLed::ExecuteAndMark(Leds &leds, int xc, int yc, double &bright) const
-{
-    const Int_t first = leds.GetEntriesFast();
-
-    Execute(leds, xc, yc, bright);
- 
-    // Mark Stars in image
-    for (int i=first; i<leds.GetEntriesFast(); i++)
-        MarkPoint(leds(i));
-}
-
-void FilterLed::Execute(int xc, int yc) const
-{
-    Leds leds;
-    ExecuteAndMark(leds, xc, yc);
-}
-
-void FilterLed::Execute(Leds &leds, int xc, int yc) const
+void FilterLed::Execute(vector<Led> &leds, int xc, int yc) const
 {
     double bright;
@@ -376 +342 @@
 }
 
-void FilterLed::Execute(Leds &leds, int xc, int yc, double &bright) const
-{
-    const int x0 = TMath::Max(xc-fBoxX, 0);
-    const int y0 = TMath::Max(yc-fBoxY, 0);
-    const int x1 = TMath::Min(xc+fBoxX, fW);
-    const int y1 = TMath::Min(yc+fBoxY, fH);
+void FilterLed::Execute(vector<Led> &leds, int xc, int yc, double &bright) const
+{
+    const int x0 = max(xc-fBoxX, 0);
+    const int y0 = max(yc-fBoxY, 0);
+    const int x1 = min(xc+fBoxX, fW);
+    const int y1 = min(yc+fBoxY, fH);
 
     const int wx = x1-x0;
@@ -392 +358 @@
         for (int y=y0; y<y1; y++)
         {
-            byte &b = fImg[y*fW+x];
+            uint8_t &b = fImg[y*fW+x];
 
             // Skip saturating pixels
@@ -410 +376 @@
     // 254 because b<=max and not b<max
     const double sdev = sqrt(sq-sum*sum);
-    const byte   max  = sum+fCut*sdev>254 ? 254 : (byte)(sum+fCut*sdev);
+    const uint8_t   max  = sum+fCut*sdev>254 ? 254 : (uint8_t)(sum+fCut*sdev);
 
     //
@@ -419 +385 @@
         for (int y=y0; y<y1; y++)
         {
-            byte &b = fImg[y*fW+x];
+            uint8_t &b = fImg[y*fW+x];
             if (b<=max)
                 b = 0;
@@ -428 +394 @@
 }
 
-void FilterLed::FindStar(Leds &leds, int xc, int yc, bool box) const
+void FilterLed::FindStar(vector<Led> &leds, int xc, int yc, bool box) const
 {
     // fBox: radius of the inner (signal) box
@@ -436 +402 @@
     // Define inner box in which to search the signal
     //
-    const int x0 = TMath::Max(xc-fBoxX, 0);
-    const int y0 = TMath::Max(yc-fBoxY, 0);
-    const int x1 = TMath::Min(xc+fBoxX, fW);
-    const int y1 = TMath::Min(yc+fBoxY, fH);
+    const int x0 = max(xc-fBoxX, 0);
+    const int y0 = max(yc-fBoxY, 0);
+    const int x1 = min(xc+fBoxX, fW);
+    const int y1 = min(yc+fBoxY, fH);
 
     //
@@ -448 +414 @@
     const double sqrt2 = sqrt(2.);
 
-    const int xa = TMath::Max(xc-TMath::Nint(fBoxX*sqrt2), 0);
-    const int ya = TMath::Max(yc-TMath::Nint(fBoxY*sqrt2), 0);
-    const int xb = TMath::Min(xc+TMath::Nint(fBoxX*sqrt2), fW);
-    const int yb = TMath::Min(yc+TMath::Nint(fBoxY*sqrt2), fH);
+    const int xa = max(xc-(int)nearbyint(fBoxX*sqrt2), 0);
+    const int ya = max(yc-(int)nearbyint(fBoxY*sqrt2), 0);
+    const int xb = min(xc+(int)nearbyint(fBoxX*sqrt2), fW);
+    const int yb = min(yc+(int)nearbyint(fBoxY*sqrt2), fH);
 
     //
@@ -468 +434 @@
                 continue;
 
-            byte &b = fImg[y*fW+x];
+            uint8_t &b = fImg[y*fW+x];
 
             sum += b;
@@ -480 +446 @@
     // 254 because b<=max and not b<max
     const double sdev = sqrt(sq-sum*sum);
-    const byte   max  = sum+fCut*sdev>254 ? 254 : (byte)(sum+fCut*sdev);
+    const uint8_t   max  = sum+fCut*sdev>254 ? 254 : (uint8_t)(sum+fCut*sdev);
 
     //
@@ -490 +456 @@
         for (int y=y0; y<y1; y++)
         {
-            byte &b = fImg[y*fW+x];
+            uint8_t &b = fImg[y*fW+x];
             if (b<=max)
                 b = 0;
@@ -531 +497 @@
     //    cout << "Sum/n = " << sum << "/" << n << " = " << (n==0?0:mag/n) << endl;
 
-    leds.Add(mx, my, 0, 0, -2.5*log10((float)mag)+13.7);
+    leds.push_back(Led(mx, my, 0, -2.5*log10((float)mag)+13.7));
 }
 
 void FilterLed::Stretch() const
 {
-    byte min, max;
+    uint8_t min, max;
     GetMinMax(25, &min, &max);
 
@@ -544 +510 @@
     const float scale = 255./(max-min);
 
-    byte *b = fImg;
-    const byte *e = fImg+fW*fH;
+    uint8_t *b = fImg;
+    const uint8_t *e = fImg+fW*fH;
 
     while (b<e)
@@ -559 +525 @@
             continue;
         }
-        *b = (byte)((*b-min)*scale);
+        *b = (uint8_t)((*b-min)*scale);
         b++;
     }