Merge pull request #42 from Digitelektro/develop

Develop

Author: Digitelektro

CMakeLists.txt

@@ -151,7 +151,7 @@ if(UNIX AND NOT APPLE)
         SET(CPACK_GENERATOR "DEB")
         SET(CPACK_PACKAGE_VERSION_MAJOR "2")
         SET(CPACK_PACKAGE_VERSION_MINOR "4")
-        SET(CPACK_PACKAGE_VERSION_PATCH "0")
+        SET(CPACK_PACKAGE_VERSION_PATCH "1")
         SET(CPACK_DEBIAN_PACKAGE_MAINTAINER "Digitelektro")
         SET(CPACK_DEBIAN_PACKAGE_HOMEPAGE "https://github.com/Digitelektro/MeteorDemod")
         SET(CPACK_DEBIAN_PACKAGE_DESCRIPTION "Russian Meteor M2 weather satellite data decoder")

common/version.h

@@ -3,6 +3,6 @@
 
 #define VERSION_MAJOR 2
 #define VERSION_MINOR 4
-#define VERSION_FIX 0
+#define VERSION_FIX 1
 
 #endif // VERSION_H

imageproc/spreadimage.cpp

@@ -309,15 +309,15 @@ cv::Mat SpreadImage::mercatorProjection(const std::list<cv::Mat> &images, const
 
         cv::Mat grayScale1;
         cv::Mat alpha1;
-        cv::bilateralFilter(composite, grayScale1, 19, 75, 75);
+        cv::medianBlur(composite, grayScale1, 5);
         cv::cvtColor(grayScale1, grayScale1, cv::COLOR_BGR2GRAY);
 
         cv::threshold(grayScale1, alpha1, 0, 255, cv::THRESH_BINARY);
         grayScale1.release();
 
         cv::Mat grayScale2;
         cv::Mat alpha2;
-        cv::bilateralFilter(*it, grayScale2, 19, 75, 75);
+        cv::medianBlur(*it, grayScale2, 5);
         cv::cvtColor(grayScale2, grayScale2, cv::COLOR_BGR2GRAY);
 
         cv::threshold(grayScale2, alpha2, 0, 255, cv::THRESH_BINARY);
@@ -565,15 +565,15 @@ cv::Mat SpreadImage::equidistantProjection(const std::list<cv::Mat> &images, con
 
         cv::Mat grayScale1;
         cv::Mat alpha1;
-        cv::bilateralFilter(composite, grayScale1, 19, 75, 75);
+        cv::medianBlur(composite, grayScale1, 5);
         cv::cvtColor(grayScale1, grayScale1, cv::COLOR_BGR2GRAY);
 
         cv::threshold(grayScale1, alpha1, 0, 255, cv::THRESH_BINARY);
         grayScale1.release();
 
         cv::Mat grayScale2;
         cv::Mat alpha2;
-        cv::bilateralFilter(*it, grayScale2, 19, 75, 75);
+        cv::medianBlur(*it, grayScale2, 5);
         cv::cvtColor(grayScale2, grayScale2, cv::COLOR_BGR2GRAY);
 
         cv::threshold(grayScale2, alpha2, 0, 255, cv::THRESH_BINARY);

imageproc/threatimage.cpp

@@ -82,6 +82,31 @@ cv::Mat ThreatImage::irToRain(const cv::Mat &irImage, const cv::Mat &ref)
     return rainImage;
 }
 
+cv::Mat ThreatImage::invertIR(const cv::Mat &image)
+{
+    cv::Mat result = cv::Mat::zeros(image.size(), image.type());
+    cv::Mat grayScale;
+    cv::Mat alpha;
+
+    cv::cvtColor(image, grayScale, cv::COLOR_BGR2GRAY);
+    std::vector<std::vector<cv::Point> > contours;
+    cv::findContours(grayScale, contours, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE);
+    for (std::size_t i = 0; i < contours.size(); i++) {
+        cv::drawContours(grayScale, contours, i, cv::Scalar(255, 255, 255), -1);
+    }
+
+    //create mask
+    cv::threshold(grayScale, alpha, 0, 255, cv::THRESH_BINARY);
+
+    //invert colors
+    cv::bitwise_not(image, image);
+
+    //apply mask
+    cv::bitwise_and(image, image, result, alpha);
+
+    return result;
+}
+
 cv::Mat ThreatImage::addRainOverlay(const cv::Mat &image, const cv::Mat &rain)
 {
     cv::Mat rainImage = cv::Mat::zeros(image.size(), image.type());

imageproc/threatimage.h

@@ -21,6 +21,7 @@ class ThreatImage
     static void fillBlackLines(cv::Mat &image, int minimumHeight, int maximumHeight);
     static cv::Mat irToTemperature(const cv::Mat &irImage, const cv::Mat &ref);
     static cv::Mat irToRain(const cv::Mat &irImage, const cv::Mat &ref);
+    static cv::Mat invertIR(const cv::Mat &image);
     static cv::Mat addRainOverlay(const cv::Mat &image, const cv::Mat &rain);
     static cv::Mat gamma(const cv::Mat &image, double gamma);
     static void drawWatermark(cv::Mat image, const std::string &date);

main.cpp

@@ -7,6 +7,8 @@
 #include "deinterleaver.h"
 #include "pixelgeolocationcalculator.h"
 
+#include <map>
+#include <tuple>
 #include <iostream>
 #include <fstream>
 #include <sstream>
@@ -296,7 +298,7 @@ int main(int argc, char *argv[])
         cv::Mat thermalImage = ThreatImage::irToTemperature(irImage, thermalRef);
         imagesToSpread.push_back(ImageForSpread(thermalImage, "thermal_"));
 
-        cv::bitwise_not(irImage, irImage);
+        irImage = ThreatImage::invertIR(irImage);
         irImage = ThreatImage::gamma(irImage, 1.8);
         imagesToSpread.push_back(ImageForSpread(irImage, "IR_"));
 
@@ -351,7 +353,7 @@ int main(int argc, char *argv[])
         cv::Mat rainRef = cv::imread(mSettings.getResourcesPath() + "rain.bmp");
         cv::Mat rainOverlay = ThreatImage::irToRain(ch68, rainRef);
 
-        cv::bitwise_not(ch68, ch68);
+        ch68 = ThreatImage::invertIR(ch68);
         ch68 = ThreatImage::gamma(ch68, 1.8);
         imagesToSpread.push_back(ImageForSpread(ch68, "IR_"));
 
@@ -506,7 +508,7 @@ int main(int argc, char *argv[])
         if(images68.size() > 1 && images68.size() == geolocationCalculators68.size()) {
             if(mSettings.compositeEquadistantProjection() || mSettings.compositeMercatorProjection()) {
                 for(auto &img : images68) {
-                    cv::bitwise_not(img, img);
+                    img = ThreatImage::invertIR(img);
                     img = ThreatImage::gamma(img, 1.8);
                 }
             }
@@ -569,6 +571,7 @@ int main(int argc, char *argv[])
 void searchForImages(std::list<cv::Mat> &imagesOut, std::list<PixelGeolocationCalculator> &geolocationCalculatorsOut, const std::string &channelName)
 {
     std::time_t now = std::time(nullptr);
+    std::map<std::time_t, std::tuple<std::string, std::string>> map;
 
     for(const auto & entry : fs::directory_iterator(mSettings.getOutputPath())) {
         auto ftime = fs::last_write_time(entry);
@@ -584,27 +587,29 @@ void searchForImages(std::list<cv::Mat> &imagesOut, std::list<PixelGeolocationCa
                 fs::path fileJPG(folder + "/" + fileNameBase + "_" + channelName + ".jpg");
 
                 if(fs::exists(fileJPG)) {
-                    std::cout << "" << fileJPG << " " << std::endl;
-
-                    imagesOut.emplace_back(cv::imread(fileJPG.generic_string()));
-                    geolocationCalculatorsOut.emplace_back(PixelGeolocationCalculator::load(entry.path().generic_string()));
-
+                    map[cftime] = std::make_tuple(entry.path().generic_string(), fileJPG);
                     break;
                 }
 
                 fs::path fileBMP(folder + "/" + fileNameBase + "_" + channelName + ".bmp");
 
                 if(fs::exists(fileBMP)) {
-                    std::cout << "" << fileBMP << " " << std::endl;
-
-                    imagesOut.emplace_back(cv::imread(fileBMP.generic_string()));
-                    geolocationCalculatorsOut.emplace_back(PixelGeolocationCalculator::load(entry.path().generic_string()));
+                    map[cftime] = std::make_tuple(entry.path().generic_string(), fileBMP);
 
                     break;
                 }
             } while(false);
         }
     }
+
+    if(map.size() > 2) {
+        for (auto const &[time, paths] : map) {
+            std::cout << std::get<1>(paths) << std::endl;
+
+            geolocationCalculatorsOut.emplace_back(PixelGeolocationCalculator::load(std::get<0>(paths)));
+            imagesOut.emplace_back(cv::imread(std::get<1>(paths)));
+        }
+    }
 }
 
 void saveImage(const std::string fileName, const cv::Mat &image)