New Local Thresholding Algorithm

.vscode/settings.json

@@ -47,6 +47,21 @@
         "streambuf": "cpp",
         "cinttypes": "cpp",
         "typeinfo": "cpp",
-        "files.eol": "\n"
+        "files.eol": "\n",
+        "regex": "cpp",
+        "bitset": "cpp",
+        "chrono": "cpp",
+        "complex": "cpp",
+        "condition_variable": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "set": "cpp",
+        "ratio": "cpp",
+        "future": "cpp",
+        "iomanip": "cpp",
+        "mutex": "cpp",
+        "shared_mutex": "cpp",
+        "thread": "cpp",
+        "variant": "cpp"
     }
 }

src/centroiders.cpp

@@ -14,7 +14,7 @@
 
 namespace lost {
 
-// DUMMY
+// DUMMYS
 
 std::vector<Star> DummyCentroidAlgorithm::Go(unsigned char *image, int imageWidth, int imageHeight) const {
     std::vector<Star> result;
@@ -92,6 +92,81 @@ int BasicThreshold(unsigned char *image, int imageWidth, int imageHeight) {
     return mean + (std * 5);
 }
 
+// Local Basic Thresholding with divisions as parameter, returns a vector containing thresholds 
+// corresponding to different divisions.
+// Divisions are horizontally based
+// Uses the same statistical algorithm as BasicThresholding
+std::vector<int> LocalBasicThresholding(unsigned char *image, int imageWidth, int imageHeight, int subdivisions) {
+    // run Basic Threshold on all elements in certain subdivisions
+    int div = imageHeight / subdivisions; // Minimum number of lines for each division
+    int leftover = imageHeight % subdivisions; // Determines the first few lines that have 1 more line
+    int totalPixels = imageWidth * imageHeight;
+    int totalMag = 0;
+    float std = 0;
+    float mean = 0;
+    std::vector<int> standardDeviations;
+    // Sets threshold for the first few subdivisions that have 1 more line than the rest
+    for(int i = 0; i < leftover; i++) {
+        totalMag = 0;
+        std = 0;
+        mean = 0;
+        for(int j = i * (div + 1) * imageWidth; j < (i+1) * (div + 1) * imageWidth; j++) {
+            totalMag += image[j];
+        }
+        mean = totalMag / ((div + 1) * imageWidth);
+        for (long j = i * (div + 1) * imageWidth; j < (i+1) * (div + 1) * imageWidth; j++) {
+                std += std::pow(image[j] - mean, 2);
+            }
+        std = std::sqrt(std / ((div + 1) * imageWidth));
+        standardDeviations.push_back(mean + (std * 5));
+    }
+    // Sets thresholds for remaining subdivisions, which have one less line than before
+    for(int i = leftover; i < subdivisions; i++) {
+        totalMag = 0;
+        std = 0;
+        mean = 0;
+        for(int j = i * (div) * imageWidth; j < (i+1) * (div) * imageWidth; j++) {
+            totalMag += image[j];
+        }
+        mean = totalMag / (div * imageWidth); // Currently divides by 0 at 1000 subdivisions for 7qPnoi1.png
+        for (long j = i * (div) * imageWidth; j < (i+1) * (div) * imageWidth; j++) {
+                std += std::pow(image[j] - mean, 2);
+            }
+        std = std::sqrt(std / (div * imageWidth));
+        standardDeviations.push_back(mean + (std * 5));
+    }
+    /*
+    for(int i = 0; i < subdivisions; i++) {
+        totalMag = 0;
+        std = 0;
+        mean = 0;
+        if(i != subdivisions - 1) {
+            for(int j = i * div * imageWidth; j < (i+1) * div * imageWidth; j++) {
+                totalMag += image[j];
+            }
+            mean = totalMag / (div * imageWidth);
+            for (long j = i * div * imageWidth; j < (i+1) * div * imageWidth; j++) {
+                std += std::pow(image[j] - mean, 2);
+            }
+            std = std::sqrt(std / (div * imageWidth));
+        } else { // For the case that the end has more lines than the rest
+            for(int j = i * div * imageWidth; j < sizeof(image); j++) {
+                totalMag += image[j];
+            }
+            mean = totalMag / (sizeof(image) - i * div * imageWidth + 1);
+            for (long j = i * div * imageWidth; j < sizeof(image); j++) {
+                std += std::pow(image[j] - mean, 2);
+            }
+            std = std::sqrt(std / (sizeof(image) - i * div * imageWidth + 1));
+        }
+        standardDeviations.push_back(mean + (std * 5));
+    }
+    standardDeviations.push_back(mean + (std * 5));
+    */
+    // Return values of previous method as a vector
+    return standardDeviations;
+}
+
 // basic thresholding, but do it faster (trade off of some accuracy?)
 int BasicThresholdOnePass(unsigned char *image, int imageWidth, int imageHeight) {
     unsigned long totalMag = 0;
@@ -117,14 +192,27 @@ struct CentroidParams {
     int yMin;
     int yMax;
     int cutoff;
+    std::vector<int> localCutoff;
     bool isValid;
     std::unordered_set<int> checkedIndices;
 };
 
+// For a given i and picture dimensions, determines which subdivision i is in (Zero Based)
+int subdivision(long i, int imageWidth, int imageHeight, int subdivisions) {
+    int div = imageHeight / subdivisions;
+    int leftover = imageHeight % subdivisions;
+    if(i < (div + 1) * leftover * imageWidth) {
+        return i / ((div + 1) * imageWidth);
+    } else {
+        return leftover + (i - (div + 1) * leftover * imageWidth) / (div * imageWidth);
+    }
+    return 0;
+}
+
 //recursive helper here
-void CogHelper(CentroidParams &p, long i, unsigned char *image, int imageWidth, int imageHeight) {
+void CogHelper(CentroidParams &p, long i, unsigned char *image, int imageWidth, int imageHeight, int subdivisions) {
 
-    if (i >= 0 && i < imageWidth * imageHeight && image[i] >= p.cutoff && p.checkedIndices.count(i) == 0) {
+    if (i >= 0 && i < imageWidth * imageHeight && image[i] >= p.localCutoff.at(subdivision(i, imageWidth, imageHeight, subdivisions)) && p.checkedIndices.count(i) == 0) {
         //check if pixel is on the edge of the image, if it is, we dont want to centroid this star
         if (i % imageWidth == 0 || i % imageWidth == imageWidth - 1 || i / imageWidth == 0 || i / imageWidth == imageHeight - 1) {
             p.isValid = false;
@@ -144,16 +232,16 @@ void CogHelper(CentroidParams &p, long i, unsigned char *image, int imageWidth,
         p.xCoordMagSum += ((i % imageWidth)) * image[i];
         p.yCoordMagSum += ((i / imageWidth)) * image[i];
         if(i % imageWidth != imageWidth - 1) {
-            CogHelper(p, i + 1, image, imageWidth, imageHeight);
+            CogHelper(p, i + 1, image, imageWidth, imageHeight, subdivisions);
         }
         if (i % imageWidth != 0) {
-            CogHelper(p, i - 1, image, imageWidth, imageHeight);
+            CogHelper(p, i - 1, image, imageWidth, imageHeight, subdivisions);
         }
-        CogHelper(p, i + imageWidth, image, imageWidth, imageHeight);
-        CogHelper(p, i - imageWidth, image, imageWidth, imageHeight);
+        CogHelper(p, i + imageWidth, image, imageWidth, imageHeight, subdivisions);
+        CogHelper(p, i - imageWidth, image, imageWidth, imageHeight, subdivisions);
     }
 }
-
+/*
 std::vector<Star> CenterOfGravityAlgorithm::Go(unsigned char *image, int imageWidth, int imageHeight) const {
     CentroidParams p;
 
@@ -193,6 +281,50 @@ std::vector<Star> CenterOfGravityAlgorithm::Go(unsigned char *image, int imageWi
     }
     return result;
 }
+*/
+//Copy of CenterOfGravityAlgorithm, except the threshold changes depending on the vertical height in the image
+//Subdivisions refers to how many horizontal sections with different thresholds are present
+std::vector<Star> CenterOfGravityAlgorithm::Go(unsigned char *image, int imageWidth, int imageHeight) const {
+    CentroidParams p;
+    // Program will use divisions to represent the subdivisions
+    int divisions = subdivisions;
+    if(subdivisions > imageHeight) {
+        divisions = imageHeight;
+    }
+    std::vector<Star> result;
+    p.localCutoff = LocalBasicThresholding(image, imageWidth, imageHeight, divisions);
+    for (long i = 0; i < imageHeight * imageWidth; i++) {
+        if (image[i] >= p.localCutoff.at(subdivision(i, imageWidth, imageHeight, divisions)) && p.checkedIndices.count(i) == 0) {
+            //iterate over pixels that are part of the star
+            int xDiameter = 0; //radius of current star
+            int yDiameter = 0;
+            p.yCoordMagSum = 0; //y coordinate of current star
+            p.xCoordMagSum = 0; //x coordinate of current star
+            p.magSum = 0; //sum of magnitudes of current star
+
+            p.xMax = i % imageWidth;
+            p.xMin = i % imageWidth;
+            p.yMax = i / imageWidth;
+            p.yMin = i / imageWidth;
+            p.isValid = true;
+
+            int sizeBefore = p.checkedIndices.size();
+
+            CogHelper(p, i, image, imageWidth, imageHeight, divisions);
+            xDiameter = (p.xMax - p.xMin) + 1;
+            yDiameter = (p.yMax - p.yMin) + 1;
+
+            //use the sums to finish CoG equation and add stars to the result
+            float xCoord = (p.xCoordMagSum / (p.magSum * 1.0));      
+            float yCoord = (p.yCoordMagSum / (p.magSum * 1.0));
+
+            if (p.isValid) {
+                result.push_back(Star(xCoord + 0.5f, yCoord + 0.5f, ((float)(xDiameter))/2.0f, ((float)(yDiameter))/2.0f, p.checkedIndices.size() - sizeBefore));
+            }
+        }
+    }
+    return result;
+}
 
 //Determines how accurate and how much iteration is done by the IWCoG algorithm,
 //smaller means more accurate and more iterations.

src/centroiders.hpp

@@ -24,8 +24,10 @@ class DummyCentroidAlgorithm: public CentroidAlgorithm {
 
 class CenterOfGravityAlgorithm : public CentroidAlgorithm {
     public:
-        CenterOfGravityAlgorithm() { };
+        CenterOfGravityAlgorithm(int subdivisions) : subdivisions(subdivisions) { };
         Stars Go(unsigned char *image, int imageWidth, int imageHeight) const override;
+    private:
+        int subdivisions;
 };
 
 class IterativeWeightedCenterOfGravityAlgorithm : public CentroidAlgorithm {

src/io.cpp

@@ -268,7 +268,8 @@ CentroidAlgorithm *DummyCentroidAlgorithmPrompt() {
 }
 
 CentroidAlgorithm *CoGCentroidAlgorithmPrompt() {
-    return new CenterOfGravityAlgorithm();
+    int subdivisions = Prompt<int>("How many subdivisions to use");
+    return new CenterOfGravityAlgorithm(subdivisions);
 }
 
 CentroidAlgorithm *IWCoGCentroidAlgorithmPrompt() {