diff --git a/Modules/PhotoacousticsLib/MitkSpectralUnmixing/SpectralUnmixingApp.cpp b/Modules/PhotoacousticsLib/MitkSpectralUnmixing/SpectralUnmixingApp.cpp index 537fc52ed8..c87a60cd41 100644 --- a/Modules/PhotoacousticsLib/MitkSpectralUnmixing/SpectralUnmixingApp.cpp +++ b/Modules/PhotoacousticsLib/MitkSpectralUnmixing/SpectralUnmixingApp.cpp @@ -1,327 +1,283 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -//#include #include #include - #include "mitkPALinearSpectralUnmixingFilter.h" #include "mitkPASpectralUnmixingFilterBase.h" #include "mitkPASpectralUnmixingFilterVigra.h" #include "mitkPASpectralUnmixingSO2.h" - #include #include #include #include - #include - - #include "mitkPreferenceListReaderOptionsFunctor.h" struct InputParameters { - std::string inputPath; - std::string outputPath; - std::string inputWavelengths; + std::string inputFilename; + std::string outputFileStruct; std::string inputAlg; - std::string inputWeights; - mitkCommandLineParser::StringContainerType test; + mitkCommandLineParser::StringContainerType inputWavelengths; + mitkCommandLineParser::StringContainerType inputWeights; }; InputParameters parseInput(int argc, char *argv[]) { MITK_INFO << "Parsing arguments..."; mitkCommandLineParser parser; parser.setCategory("MITK-Photoacoustics"); parser.setTitle("Mitk Spectral Unmixing App"); parser.setDescription("Batch processing for spectral unmixing."); parser.setContributor("Computer Assisted Medical Interventions, DKFZ"); parser.setArgumentPrefix("--", "-"); parser.beginGroup("Required parameters"); - parser.addArgument("inputPath", + parser.addArgument("inputFilename", "i", mitkCommandLineParser::InputDirectory, - "Input folder (directory)", - "input folder", + "Input Filename (NAME.nrrd)", + "input filename", us::Any(), false); - parser.addArgument("outputPath", + parser.addArgument("outputFileStruct", "o", mitkCommandLineParser::OutputDirectory, - "Input save folder (directory)", - "input save folder", + "Input save name (name without ending!)", + "input save name", us::Any(), false); parser.addArgument("inputWavelengths", "l", - mitkCommandLineParser::String, - "Input wavelengths (string)", + mitkCommandLineParser::StringList, + "Input wavelengths (123 124 125 ... int blank int blank)", "input wavelengths", us::Any(), false); parser.addArgument("inputAlg", "a", mitkCommandLineParser::String, "Input algorithm (string)", "input algorithm", us::Any(), false); parser.addArgument("inputWeights", "w", mitkCommandLineParser::String, - "Input weights (string)", + "Input weights (123 124 125 ... int in % blank int in % blank)", "input weights", us::Any(), true); - parser.addArgument("test", - "t", - mitkCommandLineParser::StringList, - "Input tes (string)", - "input tes", - us::Any(), - true); parser.endGroup(); - InputParameters input; - std::map parsedArgs = parser.parseArguments(argc, argv); if (argc == 0) exit(-1); for (int i = 0; i < argc; ++i) { MITK_INFO << argv[i]; } - if (parsedArgs.count("inputPath")) + if (parsedArgs.count("inputFilename")) { - input.inputPath = us::any_cast(parsedArgs["inputPath"]); + input.inputFilename = us::any_cast(parsedArgs["inputFilename"]); } else { - MITK_ERROR << "Error: No inputPath"; - mitkThrow() << "Error: No inputPath"; + MITK_ERROR << "Error: No input"; + mitkThrow() << "Error: No input"; } - if (parsedArgs.count("outputPath")) + if (parsedArgs.count("outputFileStruct")) { - input.outputPath = us::any_cast(parsedArgs["outputPath"]); + input.outputFileStruct = us::any_cast(parsedArgs["outputFileStruct"]); } else { - MITK_ERROR << "Error: No outputPath"; - mitkThrow() << "Error: No outputPath"; + MITK_ERROR << "Error: No output"; + mitkThrow() << "Error: No output"; } if (parsedArgs.count("inputWavelengths")) { - input.inputWavelengths = us::any_cast(parsedArgs["inputWavelengths"]); + input.inputWavelengths = us::any_cast(parsedArgs["inputWavelengths"]); } else { MITK_ERROR << "Error: No wavelengths"; mitkThrow() << "Error: No wavelengths"; } if (parsedArgs.count("inputAlg")) { input.inputAlg = us::any_cast(parsedArgs["inputAlg"]); } else { MITK_ERROR << "Error: No algorithm"; mitkThrow() << "Error: No algorithm"; } if (parsedArgs.count("inputWeights")) { - input.inputWeights = us::any_cast(parsedArgs["inputWeights"]); - } - - if (parsedArgs.count("test")) - { - input.test = us::any_cast(parsedArgs["test"]); + input.inputWeights = us::any_cast(parsedArgs["inputWeights"]); } MITK_INFO << "Parsing arguments...[Done]"; return input; } mitk::pa::SpectralUnmixingFilterBase::Pointer GetFilterInstance(std::string algorithm, std::vector weights = std::vector()) { mitk::pa::SpectralUnmixingFilterBase::Pointer spectralUnmixingFilter; if (algorithm == "QR") { spectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New(); dynamic_cast(spectralUnmixingFilter.GetPointer()) ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::HOUSEHOLDERQR); } else if (algorithm == "SVD") { spectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New(); dynamic_cast(spectralUnmixingFilter.GetPointer()) ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::JACOBISVD); } else if (algorithm == "LU") { spectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New(); dynamic_cast(spectralUnmixingFilter.GetPointer()) ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::FULLPIVLU); } else if (algorithm == "NNLS") { spectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterVigra::New(); dynamic_cast(spectralUnmixingFilter.GetPointer()) ->SetAlgorithm(mitk::pa::SpectralUnmixingFilterVigra::VigraAlgortihmType::LARS); } else if (algorithm == "WLS") { spectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterVigra::New(); dynamic_cast(spectralUnmixingFilter.GetPointer()) ->SetAlgorithm(mitk::pa::SpectralUnmixingFilterVigra::VigraAlgortihmType::WEIGHTED); std::vector weigthVec = weights; for (int i = 0; i < 3; ++i) { dynamic_cast(spectralUnmixingFilter.GetPointer()) ->AddWeight(weigthVec[i]/100); } } return spectralUnmixingFilter; } -std::vector inputWavelengthGenerator(std::string input) -{ - std::vector output; - - - for (int i = 0; i < input.size(); ++i) - { - if (input[i] == ',') - { - std::string foo; - foo.push_back(input[i-3]); - foo.push_back(input[i-2]); - foo.push_back(input[i-1]); - output.push_back(std::stoi(foo)); - } - } - std::string foo; - foo.push_back(input[input.size() - 3]); - foo.push_back(input[input.size() - 2]); - foo.push_back(input[input.size()-1]); - output.push_back(std::stoi(foo)); - - return output; -} - int main(int argc, char *argv[]) { auto input = parseInput(argc, argv); + std::string algo = input.inputAlg; + std::string inputImage = input.inputFilename; + std::string outputDir = input.outputFileStruct; + auto inputWls = input.inputWavelengths; - auto tst = input.test; - - for (int s = 0; s < tst.size(); ++s) + std::vector wavelengths; + for (int s = 0; s < inputWls.size(); ++s) { - MITK_INFO << " s:" << s << "trs: " << tst[s] << "\n"; - int sdh = std::stoi(tst[s]); - MITK_INFO << "int: " << sdh << "\n"; + int wl = std::stoi(inputWls[s]); + wavelengths.push_back(wl); + MITK_INFO << "Wavelength: " << wl << "\n"; } + auto m_inputImage = mitk::IOUtil::Load(inputImage); + mitk::pa::SpectralUnmixingFilterBase::Pointer m_SpectralUnmixingFilter; - std::string inputImage = input.inputPath; - std::string outputDir = input.outputPath; - std::string inputWls = input.inputWavelengths; - std::vector wavelengths = inputWavelengthGenerator(inputWls); - std::string algo = input.inputAlg; - - - - auto m_inputImage = mitk::IOUtil::Load(inputImage); + if (algo == "WLS") + { + auto inputW = input.inputWeights; - mitk::pa::SpectralUnmixingFilterBase::Pointer m_SpectralUnmixingFilter; + std::vector Weights; + for (int s = 0; s < inputW.size(); ++s) + { + int w = std::stoi(inputW[s]); + Weights.push_back(w); + MITK_INFO << "Weights: " << w << "\n"; + } - if (algo == "WLS") - { - std::vector Weights = inputWavelengthGenerator(input.inputWeights); - m_SpectralUnmixingFilter = GetFilterInstance(algo, Weights); - } - else - { - m_SpectralUnmixingFilter = GetFilterInstance(algo); - } + m_SpectralUnmixingFilter = GetFilterInstance(algo, Weights); + } + else + { + m_SpectralUnmixingFilter = GetFilterInstance(algo); + } - m_SpectralUnmixingFilter->SetInput(m_inputImage); + m_SpectralUnmixingFilter->SetInput(m_inputImage); - m_SpectralUnmixingFilter->Verbose(false); - m_SpectralUnmixingFilter->RelativeError(false); - m_SpectralUnmixingFilter->AddChromophore(mitk::pa::PropertyCalculator::ChromophoreType::OXYGENATED); - m_SpectralUnmixingFilter->AddChromophore(mitk::pa::PropertyCalculator::ChromophoreType::DEOXYGENATED); - m_SpectralUnmixingFilter->AddOutputs(2); + m_SpectralUnmixingFilter->Verbose(false); + m_SpectralUnmixingFilter->RelativeError(false); + m_SpectralUnmixingFilter->AddChromophore(mitk::pa::PropertyCalculator::ChromophoreType::OXYGENATED); + m_SpectralUnmixingFilter->AddChromophore(mitk::pa::PropertyCalculator::ChromophoreType::DEOXYGENATED); + m_SpectralUnmixingFilter->AddOutputs(2); - for (int wIdx = 0; wIdx < wavelengths.size(); ++wIdx) - { - m_SpectralUnmixingFilter->AddWavelength(wavelengths[wIdx]); - MITK_INFO << wavelengths[wIdx]; - } + for (int wIdx = 0; wIdx < wavelengths.size(); ++wIdx) + { + m_SpectralUnmixingFilter->AddWavelength(wavelengths[wIdx]); + MITK_INFO << wavelengths[wIdx]; + } - m_SpectralUnmixingFilter->Update(); + m_SpectralUnmixingFilter->Update(); - auto output1 = m_SpectralUnmixingFilter->GetOutput(0); - auto output2 = m_SpectralUnmixingFilter->GetOutput(1); - output1->SetSpacing(m_inputImage->GetGeometry()->GetSpacing()); - output2->SetSpacing(m_inputImage->GetGeometry()->GetSpacing()); - - std::string unmixingOutputHbO2 = outputDir + "_HbO2_SU_.nrrd"; - std::string unmixingOutputHb = outputDir + "_Hb_SU_.nrrd"; - mitk::IOUtil::Save(output1, unmixingOutputHbO2); - mitk::IOUtil::Save(output2, unmixingOutputHb); - - auto m_sO2 = mitk::pa::SpectralUnmixingSO2::New(); - m_sO2->Verbose(false); + auto output1 = m_SpectralUnmixingFilter->GetOutput(0); + auto output2 = m_SpectralUnmixingFilter->GetOutput(1); + output1->SetSpacing(m_inputImage->GetGeometry()->GetSpacing()); + output2->SetSpacing(m_inputImage->GetGeometry()->GetSpacing()); + + std::string unmixingOutputHbO2 = outputDir + "_HbO2_SU_.nrrd"; + std::string unmixingOutputHb = outputDir + "_Hb_SU_.nrrd"; + mitk::IOUtil::Save(output1, unmixingOutputHbO2); + mitk::IOUtil::Save(output2, unmixingOutputHb); + + auto m_sO2 = mitk::pa::SpectralUnmixingSO2::New(); + m_sO2->Verbose(false); - m_sO2->SetInput(0, output1); - m_sO2->SetInput(1, output2); + m_sO2->SetInput(0, output1); + m_sO2->SetInput(1, output2); - m_sO2->Update(); + m_sO2->Update(); - mitk::Image::Pointer sO2 = m_sO2->GetOutput(0); - sO2->SetSpacing(m_inputImage->GetGeometry()->GetSpacing()); + mitk::Image::Pointer sO2 = m_sO2->GetOutput(0); + sO2->SetSpacing(m_inputImage->GetGeometry()->GetSpacing()); - std::string outputSo2 = outputDir + "_sO2_.nrrd"; - mitk::IOUtil::Save(sO2, outputSo2); + std::string outputSo2 = outputDir + "_sO2_.nrrd"; + mitk::IOUtil::Save(sO2, outputSo2); - m_sO2 = nullptr; - m_SpectralUnmixingFilter = nullptr; + m_sO2 = nullptr; + m_SpectralUnmixingFilter = nullptr; - MITK_INFO << "Spectral Unmixing DONE"; + MITK_INFO << "Spectral Unmixing DONE"; }