POL5650 new wholeslide workflow (PolusAI#261)

Author: friskluft

CMakeLists.txt

@@ -207,10 +207,10 @@ set(SOURCE
 	src/nyx/gpucache.cpp
 	src/nyx/globals.cpp
 	src/nyx/image_loader.cpp
+	src/nyx/output_2_apache.cpp
 	src/nyx/output_2_buffer.cpp
 	src/nyx/output_2_csv.cpp
 	src/nyx/output_writers.cpp
-	src/nyx/parallel.cpp
 	src/nyx/phase1.cpp
 	src/nyx/phase2.cpp
 	src/nyx/phase3.cpp
@@ -222,7 +222,11 @@ set(SOURCE
 	src/nyx/roi_cache.cpp
 	src/nyx/roi_cache_basic.cpp
 	src/nyx/scan_fastloader_way.cpp
+	src/nyx/slideprops.cpp
 	src/nyx/strpat.cpp
+	src/nyx/workflow_3d.cpp
+	src/nyx/workflow_segmented.cpp
+	src/nyx/workflow_wholeslide.cpp
 )
 
 # CLI

src/nyx/arrow_output_stream.cpp

@@ -1,15 +1,6 @@
 #include <iostream>
 #include "arrow_output_stream.h"
-
-#if __has_include(<filesystem>)
-  #include <filesystem>
-  namespace fs = std::filesystem;
-#elif __has_include(<experimental/filesystem>)
-  #include <experimental/filesystem> 
-  namespace fs = std::experimental::filesystem;
-#else
-  error "Missing the <filesystem> header."
-#endif
+#include "helpers/fsystem.h"
 
 namespace Nyxus {
 

src/nyx/cli_nested_roi_options.cpp

@@ -7,15 +7,7 @@
 #include "globals.h"
 #include "nested_roi.h"
 #include "results_cache.h"
-#if __has_include(<filesystem>)
-#include <filesystem>
-namespace fs = std::filesystem;
-#elif __has_include(<experimental/filesystem>)
-#include <experimental/filesystem> 
-namespace fs = std::experimental::filesystem;
-#else
-error "Missing the <filesystem> header."
-#endif
+#include "helpers/fsystem.h"
 
 bool NestedRoiOptions::empty()
 {

src/nyx/dirs_and_files.cpp

@@ -4,15 +4,7 @@
 
 #include <fstream>
 #include <string>
-#if __has_include(<filesystem>)
-  #include <filesystem>
-  namespace fs = std::filesystem;
-#elif __has_include(<experimental/filesystem>)
-  #include <experimental/filesystem> 
-  namespace fs = std::experimental::filesystem;
-#else
-  error "Missing the <filesystem> header."
-#endif
+#include "helpers/fsystem.h"
 
 #include <vector>
 #include <iostream>
@@ -40,10 +32,7 @@ namespace Nyxus
 		{
 			// Skip hidden objects, e.g. directories '.DS_store' in OSX
 			if (entry.path().filename().string()[0] == '.')
-			{
-				std::cout << "Skipping " << entry.path().filename().string() << "\n";
 				continue; 
-			}
 
 			std::string fullPath = entry.path().string(),
 				pureFname = entry.path().filename().string();
@@ -79,7 +68,6 @@ namespace Nyxus
 			return 1;
 		}
 
-
 		// Check directories
 
 		if (!existsOnFilesystem(dirIntens))
@@ -88,8 +76,6 @@ namespace Nyxus
 			return 1;
 		}
 
-
-
 		if (intLabMappingFile.empty())
 		{
 			std::vector<std::string> purefnames_i, purefnames_m; // we need these temp sets to check the 1:1 matching
@@ -239,8 +225,6 @@ namespace Nyxus
 		}
 		else { throw (std::runtime_error("Tile Loader ERROR: The file can not be opened.")); }
 	}
-
-
 
 	bool readDirectoryFiles_3D (const std::string & dir, const StringPattern & filePatt, std::vector <Imgfile3D_layoutA> & files)
 	{
@@ -259,7 +243,7 @@ namespace Nyxus
 			std::string ermsg;
 			if (!filePatt.match(pureFname, imgDirs, ermsg))
 			{
-				std::cerr << "Error parsing file name " << pureFname << ": " << ermsg << '\n';
+				std::cerr << "Error parsing file name " << fpath << " : " << ermsg << '\n';
 				break;
 			}
 

src/nyx/env_features.cpp

@@ -39,15 +39,22 @@
 #include "features/3d_gldzm.h"
 #include "features/3d_glrlm.h"
 #include "features/3d_glszm.h"
+#include "features/radial_distribution.h"
 #include "features/roi_radius.h"
+#include "features/zernike.h"
 #include "helpers/helpers.h"
 #include "helpers/system_resource.h"
 #include "helpers/timing.h"
 #include "version.h"
 
 using namespace Nyxus;
 
-bool Environment::spellcheck_raw_featurelist(const std::string& comma_separated_fnames, std::vector<std::string>& fnames)
+// The purpose of this methos is checking user's feature request but not changing the state of the Environment instance.
+// Specifically, it:
+// (1) splits 'comma_separated_fnames' into identifiers, 
+// (2) checks if they are known feature and group names in the corresponding context (2D or 3D), and 
+// (3) saves them in vector 'fnames'
+bool Environment::spellcheck_raw_featurelist (const std::string & comma_separated_fnames, std::vector<std::string> & fnames)
 {
 	fnames.clear();
 
@@ -76,58 +83,59 @@ bool Environment::spellcheck_raw_featurelist(const std::string& comma_separated_
 
 	}
 
-	// Chop the CS-list
+	// Chop the comma-separated feature list
 	bool success = true;
 	std::vector<std::string> strings;
-	parse_delimited_string(comma_separated_fnames, ",", strings);
+	parse_delimited_string (comma_separated_fnames, ",", strings);
 
 	// Check names of features and feature-groups
-	for (const std::string& s : strings)
+	for (const std::string & s : strings)
 	{
 		// Forgive user's typos of consecutive commas e.g. MIN,MAX,,MEDIAN
 		if (s.empty())
 			continue;
 
 		auto s_uppr = Nyxus::toupper(s);
+
 		if (dim() == 2)
 		{
-			// Is feature found among 2D features?
-			int fg; // signed Fgroup2D
-			bool gnameExists = theFeatureSet.find_2D_GroupByString (s_uppr, fg);
-
-			// Intercept an error: 2D feature group exists but requested in the non-2D mode
-			if (gnameExists && dim() != 2)
+			//==== feature group ?
+			
+			int _; // feature code, unused
+			bool gfound1 = theFeatureSet.find_2D_GroupByString (s_uppr, _),
+				gfound2 = theFeatureSet.find_IMQ_GroupByString (s_uppr, _);
+
+			// if 's' is recognized as a group, register it and skip checking it as an individual feature name
+			if (gfound1 || gfound2)
 			{
-				success = false;
-				std::cerr << "Error: 2D feature group '" << s << "' in non-2D mode\n";
-				continue;
-			}
+				// set the IMQ flag if applicable
+				if (gfound2)
+					theEnvironment.set_imq (true);
 
-			// If a group is found, register it
-			if (gnameExists)
-			{
-				fnames.push_back(s_uppr);
+				fnames.push_back (s_uppr);
 				continue;
 			}
 
-			int fcode;	// signed Feature2D
-			bool fnameExists = theFeatureSet.find_2D_FeatureByString (s_uppr, fcode);
+			//==== individual feature ?
 
-			// 2D feature group requested on a non-2D mode ?
-			if (fnameExists && dim() != 2)
-			{
-				success = false;
-				std::cerr << "Error: 2D feature '" << s << "' in non-2D mode\n";
-				continue;
-			}
+			bool ffound1 = theFeatureSet.find_2D_FeatureByString (s_uppr, _),
+				ffound2 = theFeatureSet.find_IMQ_FeatureByString (s_uppr, _);
 
-			if (!fnameExists)
+			// if a feature is found, register it
+			if (! (ffound1 || ffound2))
 			{
 				success = false;
-				std::cerr << "Error: expecting '" + s + "' to be a proper 2D feature name or feature file path\n";
+				std::cerr << "Error: expecting " + s + " to be a proper 2D feature name or feature file path\n";
 			}
 			else
+			{
+				// set the IMQ flag if applicable
+				if (ffound2)
+					theEnvironment.set_imq (true);
+
 				fnames.push_back(s_uppr);
+			}
+
 		} // 2D
 
 		if (dim() == 3)
@@ -136,39 +144,23 @@ bool Environment::spellcheck_raw_featurelist(const std::string& comma_separated_
 			int afg; // signed Fgroup3D
 			bool gnameExists = theFeatureSet.find_3D_GroupByString (s_uppr, afg);
 
-			// Intercept an error: 3D feature group exists but requested in the non-3D mode
-			if (gnameExists && dim() != 3)
-			{
-				success = false;
-				std::cerr << "Error: 3D feature group '" << s << "' in non-3D mode\n";
-				continue;
-			}
-
 			// If a group is found, register it
 			if (gnameExists)
 			{
-				fnames.push_back(s_uppr);
+				fnames.push_back (s_uppr);
 				continue;
 			}
 
 			int af; // signed Feature3D
 			bool fnameExists = theFeatureSet.find_3D_FeatureByString (s_uppr, af);
 
-			// 3D feature group requested on a non-3D mode ?
-			if (fnameExists && dim() != 3)
-			{
-				success = false;
-				std::cerr << "Error: 3D feature '" << s << "' in non-3D mode\n";
-				continue;
-			}
-
-			if (!fnameExists)
+			if (! fnameExists)
 			{
 				success = false;
 				std::cerr << "Error: expecting '" << s << "' to be a proper 3D feature name or feature file path\n";
 			}
 			else
-				fnames.push_back(s_uppr);
+				fnames.push_back (s_uppr);
 		} // 3D
 	}
 
@@ -204,51 +196,26 @@ bool Environment::expand_2D_featuregroup (const std::string & s)
 
 	if ((Fgroup2D)fgcode == Fgroup2D::FG2_ALL)
 	{
-		Nyxus::theFeatureSet.enableAll (enable);
+		// enable just the 2D part of the feature set
+		for (int i = (int) Nyxus::Feature2D::_FIRST_; i < (int) Nyxus::Feature2D::_COUNT_; i++)
+			Nyxus::theFeatureSet.enableFeature (i);
 		return true; 
 	}
 
 	if ((Fgroup2D)fgcode == Fgroup2D::FG2_WHOLESLIDE)
 	{
-		Nyxus::theFeatureSet.enableAll(enable);
-
-		// Handle whole-slide mode differently: disable features irrelevant to this mode (shape, neighbors, etc)
-		std::cout << box_text(
-			"Activating whole slide (aka single-ROI) mode\n"
-			"Using GPU is advised!\n"
-			"ATTENTION: disabling inappplicable and time-sonsuming features:\n"
-			" - morphological features\n"
-			" - neighbor features\n"
-			" - GLDZM");
-
-		theFeatureSet.disableFeatures (BasicMorphologyFeatures::featureset);
-		theFeatureSet.disableFeatures (EnclosingInscribingCircumscribingCircleFeature::featureset);
-		// enabling ContourFeature (builds a special trivial wholeslide contour)
-		theFeatureSet.disableFeatures (ConvexHullFeature::featureset);				// depends on ContourFeature
-		theFeatureSet.disableFeatures (FractalDimensionFeature::featureset);		// depends on ContourFeature
-		theFeatureSet.disableFeatures (GeodeticLengthThicknessFeature::featureset);	// depends on ContourFeature
-		theFeatureSet.disableFeatures (NeighborsFeature::featureset);				// no neighbors for whole slide; depends on ContourFeature
-		theFeatureSet.disableFeatures (RoiRadiusFeature::featureset);				// depends on ContourFeature
-		theFeatureSet.disableFeatures (EllipseFittingFeature::featureset);
-		theFeatureSet.disableFeatures (EulerNumberFeature::featureset);
-		theFeatureSet.disableFeatures (ExtremaFeature::featureset);
-		theFeatureSet.disableFeatures (ErosionPixelsFeature::featureset);
-		theFeatureSet.disableFeatures (CaliperFeretFeature::featureset);
-		theFeatureSet.disableFeatures (CaliperMartinFeature::featureset);
-		theFeatureSet.disableFeatures (CaliperNassensteinFeature::featureset);
-		theFeatureSet.disableFeatures (ChordsFeature::featureset);
-
-		// enabling GaborFeature
-		// enabling only intensity image moments
-		theFeatureSet.disableFeatures (Smoms2D_feature::featureset);
-		// enabling GLCMFeature
-		// enabling GLDMFeature
-		theFeatureSet.disableFeatures (GLDZMFeature::featureset);	// costs about 82 %
-		// enabling GLRLMFeature 
-		// enabling GLSZMFeature
-		// enabling NGLDMfeature
-		// enabling NGTDMFeature
-
+		theFeatureSet.enableFeatures (ContourFeature::featureset, enable);
+		theFeatureSet.enableFeatures (PixelIntensityFeatures::featureset, enable);
+		theFeatureSet.enableFeatures (GLCMFeature::featureset, enable);
+		theFeatureSet.enableFeatures (GLDMFeature::featureset, enable);
+		theFeatureSet.enableFeatures (GLRLMFeature::featureset, enable);
+		theFeatureSet.enableFeatures (GLSZMFeature::featureset, enable);
+		theFeatureSet.enableFeatures (NGLDMfeature::featureset, enable);
+		theFeatureSet.enableFeatures (NGTDMFeature::featureset, enable);
+		theFeatureSet.enableFeatures (GaborFeature::featureset, enable);
+		theFeatureSet.enableFeatures(Imoms2D_feature::featureset, enable);
+		theFeatureSet.enableFeatures (RadialDistributionFeature::featureset, enable);
+		theFeatureSet.enableFeatures (ZernikeFeature::featureset, enable);
 		return true;
 	}
 
@@ -533,11 +500,11 @@ void Environment::expand_featuregroups()
 			if (expand_IMQ_featuregroup (s)) 
 				return;
 
-			FeatureIMQ a;
+			int a;
 			if (!theFeatureSet.find_IMQ_FeatureByString(s, a))
 				throw std::invalid_argument("Error: '" + s + "' is not a valid Image Quality feature name \n");
 
-			theFeatureSet.enableFeature (int(a));
+			theFeatureSet.enableFeature (a);
 			continue;
 		}
 
@@ -571,10 +538,9 @@ void Environment::expand_featuregroups()
 		if (dim() == 3)
 		{
 			int a; // signed Feature3D
-			if (!Nyxus::theFeatureSet.find_3D_FeatureByString(s, a))
+			if (!theFeatureSet.find_3D_FeatureByString(s, a))
 				throw std::invalid_argument("Error: '" + s + "' is not a valid 3D feature name \n");
-
-			Nyxus::theFeatureSet.enableFeature (int(a));
+			theFeatureSet.enableFeature (a);
 			continue;
 		}
 	}