void updateLcd(void){
char buffer[4];
int integerPart;
int decimalPart;
// RELAY
LCD_gotoXY(13,0);
if(currentStatus)LCD_sendString("ON ");
else LCD_sendString("OFF");
// current temp
LCD_gotoXY(2,0);
splitDouble(¤tTemp,1,&integerPart,&decimalPart);
sprintf(buffer,"%3d.%1d",integerPart, decimalPart);
LCD_sendString(buffer);
// current setpoint
LCD_gotoXY(2,1);
splitDouble(¤tTempSetPoint,1,&integerPart,&decimalPart);
sprintf(buffer,"%3d.%1d",integerPart, decimalPart);
LCD_sendString(buffer);
// current hist
LCD_gotoXY(11,1);
splitDouble(¤tHistSetPoint,1,&integerPart,&decimalPart);
sprintf(buffer,"%3d.%1d",integerPart, decimalPart);
LCD_sendString(buffer);
}
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
// required params
parser.addArgument("image", "i", mitkCommandLineParser::InputImage, "Input Image", "Path to the input VTK polydata", us::Any(), false);
parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output text file", "Target file. The output statistic is appended to this file.", us::Any(), false);
parser.addArgument("gaussian","g",mitkCommandLineParser::String, "Gaussian Filtering of the input images", "Gaussian Filter. Followed by the used variances seperated by ';' ",us::Any());
parser.addArgument("difference-of-gaussian","dog",mitkCommandLineParser::String, "Difference of Gaussian Filtering of the input images", "Difference of Gaussian Filter. Followed by the used variances seperated by ';' ",us::Any());
parser.addArgument("laplace-of-gauss","log",mitkCommandLineParser::String, "Laplacian of Gaussian Filtering", "Laplacian of Gaussian Filter. Followed by the used variances seperated by ';' ",us::Any());
parser.addArgument("hessian-of-gauss","hog",mitkCommandLineParser::String, "Hessian of Gaussian Filtering", "Hessian of Gaussian Filter. Followed by the used variances seperated by ';' ",us::Any());
parser.addArgument("local-histogram", "lh", mitkCommandLineParser::String, "Local Histograms", "Calculate the local histogram based feature. Specify Offset and Delta, for exampel -3;0.6 ", us::Any());
// Miniapp Infos
parser.setCategory("Classification Tools");
parser.setTitle("Global Image Feature calculator");
parser.setDescription("Calculates different global statistics for a given segmentation / image combination");
parser.setContributor("MBI");
std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
{
return EXIT_FAILURE;
}
if ( parsedArgs.count("help") || parsedArgs.count("h"))
{
return EXIT_SUCCESS;
}
bool useCooc = parsedArgs.count("cooccurence");
mitk::Image::Pointer image = mitk::IOUtil::LoadImage(parsedArgs["image"].ToString());
std::string filename=parsedArgs["output"].ToString();
////////////////////////////////////////////////////////////////
// CAlculate Gaussian Features
////////////////////////////////////////////////////////////////
MITK_INFO << "Check for Local Histogram...";
if (parsedArgs.count("local-histogram"))
{
std::vector<mitk::Image::Pointer> outs;
auto ranges = splitDouble(parsedArgs["local-histogram"].ToString(), ';');
if (ranges.size() < 2)
{
MITK_INFO << "Missing Delta and Offset for Local Histogram";
}
else
{
AccessByItk_3(image, LocalHistograms, outs, ranges[0], ranges[1]);
for (int i = 0; i < outs.size(); ++i)
{
std::string name = filename + "-lh" + us::any_value_to_string<int>(i)+".nii.gz";
mitk::IOUtil::SaveImage(outs[i], name);
}
}
}
////////////////////////////////////////////////////////////////
// CAlculate Gaussian Features
////////////////////////////////////////////////////////////////
MITK_INFO << "Check for Gaussian...";
if (parsedArgs.count("gaussian"))
{
MITK_INFO << "Calculate Gaussian... " << parsedArgs["gaussian"].ToString();
auto ranges = splitDouble(parsedArgs["gaussian"].ToString(),';');
for (int i = 0; i < ranges.size(); ++i)
{
mitk::Image::Pointer output;
AccessByItk_2(image, GaussianFilter, ranges[i], output);
std::string name = filename + "-gaussian-" + us::any_value_to_string(ranges[i])+".nii.gz";
mitk::IOUtil::SaveImage(output, name);
}
}
////////////////////////////////////////////////////////////////
// CAlculate Difference of Gaussian Features
////////////////////////////////////////////////////////////////
MITK_INFO << "Check for DoG...";
if (parsedArgs.count("difference-of-gaussian"))
{
MITK_INFO << "Calculate Difference of Gaussian... " << parsedArgs["difference-of-gaussian"].ToString();
auto ranges = splitDouble(parsedArgs["difference-of-gaussian"].ToString(),';');
for (int i = 0; i < ranges.size(); ++i)
{
mitk::Image::Pointer output;
AccessByItk_2(image, DifferenceOfGaussFilter, ranges[i], output);
std::string name = filename + "-dog-" + us::any_value_to_string(ranges[i])+".nii.gz";
mitk::IOUtil::SaveImage(output, name);
}
}
MITK_INFO << "Check for LoG...";
////////////////////////////////////////////////////////////////
// CAlculate Laplacian Of Gauss Features
////////////////////////////////////////////////////////////////
if (parsedArgs.count("laplace-of-gauss"))
{
MITK_INFO << "Calculate LoG... " << parsedArgs["laplace-of-gauss"].ToString();
auto ranges = splitDouble(parsedArgs["laplace-of-gauss"].ToString(),';');
for (int i = 0; i < ranges.size(); ++i)
{
mitk::Image::Pointer output;
AccessByItk_2(image, LaplacianOfGaussianFilter, ranges[i], output);
std::string name = filename + "-log-" + us::any_value_to_string(ranges[i])+".nii.gz";
mitk::IOUtil::SaveImage(output, name);
}
}
MITK_INFO << "Check for HoG...";
////////////////////////////////////////////////////////////////
// CAlculate Hessian Of Gauss Features
////////////////////////////////////////////////////////////////
if (parsedArgs.count("hessian-of-gauss"))
{
MITK_INFO << "Calculate HoG... " << parsedArgs["hessian-of-gauss"].ToString();
auto ranges = splitDouble(parsedArgs["hessian-of-gauss"].ToString(),';');
for (int i = 0; i < ranges.size(); ++i)
{
std::vector<mitk::Image::Pointer> outs;
outs.push_back(mitk::Image::New());
outs.push_back(mitk::Image::New());
outs.push_back(mitk::Image::New());
AccessByItk_2(image, HessianOfGaussianFilter, ranges[i], outs);
std::string name = filename + "-hog0-" + us::any_value_to_string(ranges[i])+".nii.gz";
mitk::IOUtil::SaveImage(outs[0], name);
name = filename + "-hog1-" + us::any_value_to_string(ranges[i])+".nii.gz";
mitk::IOUtil::SaveImage(outs[1], name);
name = filename + "-hog2-" + us::any_value_to_string(ranges[i])+".nii.gz";
mitk::IOUtil::SaveImage(outs[2], name);
}
}
return 0;
}
int main(int argc, char* argv[])
{
mitkCommandLineParser parser;
parser.setArgumentPrefix("--", "-");
// required params
parser.addArgument("image", "i", mitkCommandLineParser::InputImage, "Input Image", "Path to the input VTK polydata", us::Any(), false);
parser.addArgument("mask", "m", mitkCommandLineParser::InputImage, "Input Mask", "Mask Image that specifies the area over for the statistic, (Values = 1)", us::Any(), false);
parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output text file", "Target file. The output statistic is appended to this file.", us::Any(), false);
parser.addArgument("cooccurence","cooc",mitkCommandLineParser::String, "Use Co-occurence matrix", "calculates Co-occurence based features",us::Any());
parser.addArgument("run-length","rl",mitkCommandLineParser::String, "Use Co-occurence matrix", "calculates Co-occurence based features",us::Any());
parser.addArgument("first-order","fo",mitkCommandLineParser::String, "Use First Order Features", "calculates First order based features",us::Any());
parser.addArgument("header","head",mitkCommandLineParser::String,"Add Header (Labels) to output","",us::Any());
// Miniapp Infos
parser.setCategory("Classification Tools");
parser.setTitle("Global Image Feature calculator");
parser.setDescription("Calculates different global statistics for a given segmentation / image combination");
parser.setContributor("MBI");
map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
if (parsedArgs.size()==0)
{
return EXIT_FAILURE;
}
if ( parsedArgs.count("help") || parsedArgs.count("h"))
{
return EXIT_SUCCESS;
}
bool useCooc = parsedArgs.count("cooccurence");
mitk::Image::Pointer image = mitk::IOUtil::LoadImage(parsedArgs["image"].ToString());
mitk::Image::Pointer mask = mitk::IOUtil::LoadImage(parsedArgs["mask"].ToString());
mitk::AbstractGlobalImageFeature::FeatureListType stats;
////////////////////////////////////////////////////////////////
// CAlculate First Order Features
////////////////////////////////////////////////////////////////
if (parsedArgs.count("first-order"))
{
mitk::GIFFirstOrderStatistics firstOrderCalculator;
auto localResults = firstOrderCalculator.CalculateFeatures(image, mask);
stats.insert(stats.end(), localResults.begin(), localResults.end());
}
////////////////////////////////////////////////////////////////
// CAlculate Co-occurence Features
////////////////////////////////////////////////////////////////
if (parsedArgs.count("cooccurence"))
{
auto ranges = splitDouble(parsedArgs["cooccurence"].ToString(),';');
for (int i = 0; i < ranges.size(); ++i)
{
mitk::GIFCooccurenceMatrix coocCalculator;
coocCalculator.SetRange(ranges[i]);
auto localResults = coocCalculator.CalculateFeatures(image, mask);
stats.insert(stats.end(), localResults.begin(), localResults.end());
}
}
////////////////////////////////////////////////////////////////
// CAlculate Run-Length Features
////////////////////////////////////////////////////////////////
if (parsedArgs.count("run-length"))
{
auto ranges = splitDouble(parsedArgs["run-length"].ToString(),';');
for (int i = 0; i < ranges.size(); ++i)
{
mitk::GIFGrayLevelRunLength calculator;
calculator.SetRange(ranges[i]);
auto localResults = calculator.CalculateFeatures(image, mask);
stats.insert(stats.end(), localResults.begin(), localResults.end());
}
}
for (int i = 0; i < stats.size(); ++i)
{
std::cout << stats[i].first << " - " << stats[i].second <<std::endl;
}
std::ofstream output(parsedArgs["output"].ToString(),std::ios::app);
if ( parsedArgs.count("header") )
{
for (int i = 0; i < stats.size(); ++i)
{
output << stats[i].first << ";";
}
output << std::endl;
}
for (int i = 0; i < stats.size(); ++i)
{
output << stats[i].second << ";";
}
output << std::endl;
output.close();
return 0;
}
