some fixes

Author: peacekeeper228

include/Metric.h

@@ -5,30 +5,44 @@ class Metric
 {
 protected:
     uint64_t a, b, c, d;
+    void hardResolver(cellState state, cellState other_state);
+    void softResolver(cellState state, cellState other_state);
 
 public:
     Metric(/* args */);
-    Metric(const Metric& m) = default;
+    // Metric(const Metric* other);
+    Metric(const Metric &m) = default;
     ~Metric();
-    void calculateVariables(const CellStorage& cellStorage, std::vector<std::pair<int, int>>& realFirePoints, std::vector<std::pair<int, int>>& burntPoints);
-    void calculateVariablesFrom2Storages(const CellStorage& cellStorage, const CellStorage& other);
+    void printConfusionMatrix();
+    void calculateVariables(const CellStorage &cellStorage, std::vector<std::pair<int, int>> &realFirePoints, std::vector<std::pair<int, int>> &burntPoints);
+    void calculateVariablesFrom2Storages(const CellStorage &cellStorage, const CellStorage &other);
     virtual double compute() const = 0;
+    virtual const char* metricName() const = 0;
 };
 
 class SimpsonMetric final : public Metric
 {
 public:
     double compute() const override;
+    SimpsonMetric(const Metric &m);
+    SimpsonMetric() = default;
+    const char* metricName() const;
 };
 
 class JaccardMetric final : public Metric
 {
 public:
     double compute() const override;
+    JaccardMetric(const Metric &m);
+    JaccardMetric() = default;
+    const char* metricName() const;
 };
 
 class SneathMetric final : public Metric
 {
 public:
     double compute() const override;
+    SneathMetric(const Metric &m);
+    SneathMetric() = default;
+    const char* metricName() const;
 };

src/CellStorage.cpp

@@ -95,7 +95,8 @@ void CellStorage::iterateCell(int i, int j)
                 continue;
             };
             double fireKoeff = 0;
-            if (nearestCell->getState() == cellState::Tree)
+            auto state_nearest_cell = nearestCell->getState();
+            if (state_nearest_cell == cellState::Tree)
             {
                 if (formula_->willSpread(iteratedCell, analyzedDirection, iteratedCell->getAltitude() - nearestCell->getAltitude()))
                 {
@@ -107,7 +108,8 @@ void CellStorage::iterateCell(int i, int j)
             {
                 continue;
             };
-            if ((throughCell->getState() == cellState::Tree) && (nearestCell->getState() != cellState::Tree) && ((nearestCell->getState() != cellState::Fire)))
+            auto state_through_cell = throughCell->getState();
+            if ((state_through_cell == cellState::Tree) && (state_nearest_cell != cellState::Tree) && ((state_nearest_cell != cellState::Fire)))
             {
                 if (formula_->willSpreadThroughOne(iteratedCell, analyzedDirection, iteratedCell->getAltitude() - throughCell->getAltitude()))
                 {
@@ -215,7 +217,11 @@ void CellStorage::uploadFromTxt()
     while (std::getline(txt_file, line)) {
         for (size_t i = 0; i < line.size(); i++)
         {
-            terrain_[currentLine][i].get()->setState(static_cast<cellState>(line[i]-'0'));
+            cellState new_state = static_cast<cellState>(line[i]-'0');
+            if (new_state == cellState::Fire){
+                setNewState(cellState::Tree, currentLine, i);
+            }
+            setNewState(new_state, currentLine, i);
         }
         currentLine++;
 

src/Math.cpp

@@ -82,7 +82,7 @@ double Math1::calculateGroundSlopeKoef(directions InvestigatedDirection, int alt
     double result = std::exp(0.5 * coef);
     // SlopeMetaData meta = {bool(static_cast<int>(InvestigatedDirection) / int(2)), altitudeDifference};
     slope_counter_[meta]++;
-    // slope_result_[meta] = result;
+    slope_result_[meta] = result;
 
     clock_t per_iteration = clock() - start;
     slope_timer = per_iteration+slope_timer;
@@ -204,9 +204,9 @@ Math1::Math1()
 
 Math1::~Math1()
 {
-    printf("total time %f, overall counts %d\n", (double)(slope_timer), slope_counter);
-    printf("total time %f, overall counts %d\n", (double)(wind_timer_), wind_counter_);
-    printf("total time %f, overall counts %d\n", (double)(moisture_timer_), moisture_counter_);
+    printf("total slope time %f, overall counts %d\n", (double)(slope_timer), slope_counter);
+    printf("total wind time %f, overall counts %d\n", (double)(wind_timer_), wind_counter_);
+    printf("total moisture time %f, overall counts %d\n", (double)(moisture_timer_), moisture_counter_);
     // printf("slope profiling\n");
     // std::map<int, int> slope_distribution;
 

src/Metric.cpp

@@ -2,15 +2,67 @@
 
 #include "../include/Metric.h"
 #include "../include/Properties.h"
+#include "Metric.h"
+
+void Metric::hardResolver(cellState state, cellState other_state)
+{
+    if ((state == cellState::Fire and other_state == cellState::Fire) or (state == cellState::Burnt and other_state == cellState::Burnt))
+    {
+        ++a;
+    }
+    else if (state == cellState::Fire or state == cellState::Burnt)
+    {
+        ++b;
+    }
+    else if (other_state == cellState::Fire or other_state == cellState::Burnt)
+    {
+        ++c;
+    }
+    else
+    {
+        ++d;
+    }
+}
+
+void Metric::softResolver(cellState state, cellState other_state)
+{
+    if ((state == cellState::Fire or state == cellState::Burnt) and (other_state == cellState::Fire or other_state == cellState::Burnt))
+    {
+        ++a;
+    }
+    else if (state == cellState::Fire or state == cellState::Burnt)
+    {
+        ++b;
+    }
+    else if (other_state == cellState::Fire or other_state == cellState::Burnt)
+    {
+        ++c;
+    }
+    else
+    {
+        ++d;
+    }
+}
 
 Metric::Metric(/* args */)
 {
 }
 
+// Metric::Metric(const Metric *other)
+//     :a(other->a), b(other->b), c(other->c), d(other->d)
+// {
+
+// }
+
 Metric::~Metric()
 {
 }
 
+void Metric::printConfusionMatrix()
+{
+    printf("TP: %ld, FP: %ld, FN: %ld, TN: %ld\n", a, b, c, d);
+}
+
 void Metric::calculateVariables(const CellStorage &cellStorage, std::vector<std::pair<int, int>> &realFirePoints, std::vector<std::pair<int, int>> &burntPoints)
 {
     int64_t allArea = getXArea() * getYArea();
@@ -44,24 +96,8 @@ void Metric::calculateVariablesFrom2Storages(const CellStorage &cellStorage, con
     {
         for (size_t j = 0; j < getYArea(); j++)
         {
-            auto state = cellStorage.getState(i, j);
-            auto other_state = other.getState(i, j);
-            if ((state == cellState::Fire and other_state == cellState::Fire) or (state == cellState::Burnt and other_state == cellState::Burnt))
-            {
-                ++a;
-            }
-            else if (state == cellState::Fire or state == cellState::Burnt)
-            {
-                ++b;
-            }
-            else if (other_state == cellState::Fire or other_state == cellState::Burnt)
-            {
-                ++c;
-            }
-            else
-            {
-                ++d;
-            }
+            this->softResolver(cellStorage.getState(i, j), other.getState(i, j));
+            // this->hardResolver(cellStorage.getState(i, j), other.getState(i, j));
         }
     }
 }
@@ -71,12 +107,36 @@ double SimpsonMetric::compute() const
     return double(a) / double(std::min(a + b, a + c));
 }
 
+SimpsonMetric::SimpsonMetric(const Metric &m)
+    : Metric(m) {}
+
+const char *SimpsonMetric::metricName() const
+{
+    return "Simpson metric";
+}
+
 double JaccardMetric::compute() const
 {
     return double(a) / double(a + b + c);
 }
 
+JaccardMetric::JaccardMetric(const Metric &m)
+    : Metric(m) {}
+
+const char *JaccardMetric::metricName() const
+{
+    return "Jaccard metric";
+}
+
 double SneathMetric::compute() const
 {
     return double(a) / double(a + 2 * b + 2 * c);
+}
+
+SneathMetric::SneathMetric(const Metric &m)
+    : Metric(m) {}
+
+const char *SneathMetric::metricName() const
+{
+    return "Sneath metric";
 }

src/ProfilingDecorator.cpp

@@ -38,27 +38,29 @@ ProfilingDecorator::~ProfilingDecorator()
     std::cout << "Overall: " << this->counter_ << " Positive: " << this->positive_counter_ << std::endl;
 
     std::map<int,int> result_distribution;
-    printf("Results: altitude_difference_, wind_direction_, wind_speed_, investigated_direction_, number_of_calculations\n");
-    for (const auto &pair : results_)
-    {
-        printf("%d,%d,%2.2f,%d;%d \n",
-               pair.first.altitude_difference_,
-               static_cast<int>(pair.first.wind_direction_),
-               pair.first.wind_speed_,
-               static_cast<int>(pair.first.investigated_direction_),
-               pair.second);
-        result_distribution[pair.second]++;
-    };
-    printf("Distribution\n");
-    for (auto &&i : result_distribution)
-    {
-        printf("%d;%d\n", i.first, i.second);
-    };
-    printf("Distribution direction\n");
-    for (auto &&i : results_directions_)
-    {
-        printf("%d;%d\n", static_cast<int>(i.first), i.second);
-    };
+    // printf("Results: altitude_difference_, wind_direction_, wind_speed_, investigated_direction_, number_of_calculations\n");
+    // for (const auto &pair : results_)
+    // {
+    //     printf("%d,%d,%2.2f,%d;%d \n",
+    //            pair.first.altitude_difference_,
+    //            static_cast<int>(pair.first.wind_direction_),
+    //            pair.first.wind_speed_,
+    //            static_cast<int>(pair.first.investigated_direction_),
+    //            pair.second);
+    //     result_distribution[pair.second]++;
+    // };
+    printf("Overall timer: %ld\n", overall_timer_);
+
+    // printf("Distribution\n");
+    // for (auto &&i : result_distribution)
+    // {
+    //     printf("%d;%d\n", i.first, i.second);
+    // };
+    // printf("Distribution direction\n");
+    // for (auto &&i : results_directions_)
+    // {
+    //     printf("%d;%d\n", static_cast<int>(i.first), i.second);
+    // };
 
     primary_class_->~Math();
 }

src/main.cpp

@@ -20,35 +20,34 @@ int main()
 {
 
     printf("Size of cell from %.2ld to %.2ld bytes \n", sizeof(cell), sizeof(cell) + sizeof(Fire) + sizeof(Wind));
-
     Connection c = Connection();
     Math1 formula = Math1();
     auto formulaDecorator = ProfilingDecorator(&formula);
     CellStorage s = CellStorage(&formulaDecorator);
     auto xRange = std::make_pair<int, int>(0, getXArea());
     auto yRange = std::make_pair<int, int>(0, getYArea()/2);
-    auto w = std::make_shared<const Wind>(directions::SouthWest, float(5.0), 80); //Surgut
+    auto w = std::make_shared<const Wind>(directions::SouthWest, float(2.0), 20); //Surgut
     // auto w = std::make_shared<const Wind>(directions::NorthEast, float(2.0)); // Vanderhoof
 
     s.setWindToArea(xRange, yRange, w);
 
     yRange = std::make_pair<int, int>(getYArea()/2, getYArea());
-    w = std::make_shared<const Wind>(directions::SouthEast, float(2.0), 80);
+    w = std::make_shared<const Wind>(directions::SouthWest, float(2.0), 20);
     s.setWindToArea(xRange, yRange, w);
 
-    for (size_t i = 0; i < 10; i++)
-    {
+    // for (size_t i = 0; i < 10; i++)
+    // {
 
     c.setStatesToStorage(s);
 
     clock_t tStart = clock();
     for (size_t i = 0; i < numberOfSimulations(); i++)
     {
         s.iterate();
-        if ((i % 10 == 0) && (i != 0))
-        {
-            std::cout << "we have calculated " << i << " iterations" << std::endl;
-        }
+        // if ((i % 10 == 0) && (i != 0))
+        // {
+        //     std::cout << "we have calculated " << i << " iterations" << std::endl;
+        // }
         // s.printCurrentStates();
     }
     // PROCESS_MEMORY_COUNTERS memCounter;
@@ -57,7 +56,7 @@ int main()
 
     printf("Time taken: %.2fs\n", (double)(clock() - tStart) / CLOCKS_PER_SEC);
 
-    };
+    // };
     s.printCurrentStates();
     // s.saveFiresToJson();
 
@@ -71,11 +70,18 @@ int main()
     // fired.push_back(std::make_pair<int, int>(9, 10));
     CellStorage other_s = CellStorage(&formulaDecorator);
     other_s.uploadFromTxt();
+    other_s.iterate();
+    // other_s.printCurrentStates();
     clock_t tStartMetrics = clock();
     // m->calculateVariables(s, fired, burnt);
 
     m->calculateVariablesFrom2Storages(s, other_s);
     printf("Jaccard metric is equal to: %f\n", m->compute());
+    auto simpson_metric = new SimpsonMetric(*m);
+    printf("%s metric is equal to: %f\n", simpson_metric->metricName(), simpson_metric->compute());
+    auto sneath_metric = new SneathMetric(*m);
+    printf("%s metric is equal to: %f\n", sneath_metric->metricName(), sneath_metric->compute());
+    m->printConfusionMatrix();
     printf("Time taken: %.2fs\n", (double)(clock() - tStartMetrics) / CLOCKS_PER_SEC);
     return 0;
 }