vtkSmartPointer<vtkPolyData> MatricesToVtk::parsePoints(
const InputVector & inputData, size_t firstColumn,
int vtk_dataType /*= VTK_FLOAT*/)
{
assert(inputData.size() > firstColumn);
auto points = vtkSmartPointer<vtkPoints>::New();
points->SetDataType(vtk_dataType);
size_t nbRows = inputData.at(firstColumn).size();
std::vector<vtkIdType> pointIds(nbRows);
// copy triangle vertexes to VTK point list
for (size_t row = 0; row < nbRows; ++row)
{
pointIds.at(row) = points->InsertNextPoint(inputData[firstColumn][row], inputData[firstColumn + 1][row], inputData[firstColumn + 2][row]);
}
// Create the topology of the point (a vertex)
auto vertices = vtkSmartPointer<vtkCellArray>::New();
vertices->InsertNextCell(nbRows, pointIds.data());
auto resultPolyData = vtkSmartPointer<vtkPolyData>::New();
resultPolyData->SetPoints(points);
resultPolyData->SetVerts(vertices);
return resultPolyData;
}
std::unique_ptr<DataObject> MatricesToVtk::readRawFile(const QString & fileName)
{
InputVector inputVectors;
auto && result = TextFileReader(fileName).read(inputVectors);
if (!result.testFlag(TextFileReader::successful))
{
return nullptr;
}
int numColumns = (int)inputVectors.size();
if (numColumns == 0)
{
return nullptr;
}
int numRows = (int)inputVectors.at(0).size();
if (numRows == 0)
{
return nullptr;
}
bool switchRowsColumns = numColumns > numRows;
if (switchRowsColumns)
{
std::swap(numColumns, numRows);
}
auto dataArray = vtkSmartPointer<vtkFloatArray>::New();
dataArray->SetNumberOfComponents(numColumns);
dataArray->SetNumberOfTuples(numRows);
if (!switchRowsColumns)
{
for (vtkIdType component = 0; component < numColumns; ++component)
{
for (vtkIdType cellId = 0; cellId < numRows; ++cellId)
{
dataArray->SetValue(cellId * numColumns + component,
static_cast<float>(inputVectors.at(component).at(cellId)));
}
}
}
else
{
for (vtkIdType component = 0; component < numColumns; ++component)
{
for (vtkIdType cellId = 0; cellId < numRows; ++cellId)
{
dataArray->SetValue(cellId * numColumns + component,
static_cast<float>(inputVectors.at(cellId).at(component)));
}
}
}
QFileInfo fInfo(fileName);
return std::make_unique<RawVectorData>(fInfo.baseName(), *dataArray);
}
Eigen::Matrix4f Feature::getTransformFromMatches(bool &valid,
const vector_eigen_vector3f &earlier,
const vector_eigen_vector3f &now,
const InputVector &matches,
float max_dist /* = -1.0 */)
{
pcl::TransformationFromCorrespondences tfc;
valid = true;
vector<Eigen::Vector3f> t, f;
for (InputVector::const_iterator it = matches.begin() ; it != matches.end(); it++)
{
int this_id = it->queryIdx;
int earlier_id = it->trainIdx;
Eigen::Vector3f from(now[this_id][0],
now[this_id][1],
now[this_id][2]);
Eigen::Vector3f to(earlier[earlier_id][0],
earlier[earlier_id][1],
earlier[earlier_id][2]);
if (max_dist > 0)
{
// storing is only necessary, if max_dist is given
f.push_back(from);
t.push_back(to);
}
tfc.add(from, to, 1.0 /*/ to(2)*/); //the further, the less weight b/c of accuracy decay
}
// find smallest distance between a point and its neighbour in the same cloud
if (max_dist > 0)
{
//float min_neighbour_dist = 1e6;
Eigen::Matrix4f foo;
valid = true;
for (unsigned int i = 0; i < f.size(); i++)
{
float d_f = (f.at((i + 1) % f.size()) - f.at(i)).norm();
float d_t = (t.at((i + 1) % t.size()) - t.at(i)).norm();
if (abs(d_f - d_t) > max_dist)
{
valid = false;
return Eigen::Matrix4f();
}
}
}
// get relative movement from samples
return tfc.getTransformation().matrix();
}
void BarrelTermPositionIteratorTestCase::testSkipToPositionRandomly()
{
FX_TRACE("Begin testSkipToPositionRandomly");
const static size_t TEST_TIMES = 10000;
for (size_t dataSize = 1; dataSize < TEST_TIMES; dataSize += 123)
{
m_nTestDataSize = dataSize;
FX_TRACE("Test data size: %u", (uint32_t)m_nTestDataSize);
setUpTestData();
InputVector input;
generateInputData(input);
BarrelTermPositionIterator iterator;
iterator.init(m_pDecoder, NULL);
docid_t docId = 0;
for (size_t i = 0; i < input.size(); ++i)
{
size_t testDoc = input[i].first;
docId = m_answer[testDoc].first - 1;
if (docId < 0)
{
docId = 0;
}
docId = iterator.skipTo(docId);
//CPPUNIT_ASSERT_EQUAL(m_answer[testDoc].first, docId);
assert(m_answer[testDoc].first == docId);
CPPUNIT_ASSERT_EQUAL((tf_t)m_answer[testDoc].second.size(), iterator.freq());
ctf_t ctf = 0;
getCTF(m_answer, 0, testDoc, ctf);
FX_TRACE("ctf: %lld", ctf);
for (size_t k = 0; k < input[i].second.size(); ++k)
{
size_t testPos = input[i].second[k];
loc_t t = m_answer[testDoc].second[testPos] - (k % 2);
loc_t pos = iterator.skipToPosition(t);
CPPUNIT_ASSERT_EQUAL(m_answer[testDoc].second[testPos], pos);
// assert(m_answer[testDoc].second[p] == pos);
}
}
docId = m_answer[m_nTestDataSize - 1].first + 3;
docId = iterator.skipTo(docId);
CPPUNIT_ASSERT_EQUAL(INVALID_DOCID, docId);
tearDownTestData();
}
}
vtkSmartPointer<vtkDataArray> MatricesToVtk::parseFloatVector(
const InputVector & inputData, const QString & arrayName, size_t firstColumn, size_t lastColumn,
int vtk_dataType /*= VTK_FLOAT*/)
{
assert(firstColumn <= lastColumn);
assert(inputData.size() > lastColumn);
int numComponents = static_cast<int>(lastColumn - firstColumn + 1);
vtkIdType numTuples = inputData.at(lastColumn).size();
DEBUG_ONLY(for (auto && ax : inputData)
{
assert(ax.size() == size_t(numTuples));
})
void jacobian_transpose_nllsq_impl(Function f, GradFunction fill_jac, InputVector& x, const OutputVector& y, unsigned int max_iter,
LimitFunction impose_limits,
typename vect_traits<InputVector>::value_type abs_tol = typename vect_traits<InputVector>::value_type(1e-6),
typename vect_traits<InputVector>::value_type abs_grad_tol = typename vect_traits<InputVector>::value_type(1e-6)) {
typedef typename vect_traits<InputVector>::value_type ValueType;
using std::sqrt; using std::fabs;
OutputVector y_approx = y;
OutputVector r = y;
mat<ValueType, mat_structure::rectangular> J(y.size(), x.size());
InputVector e = x; e -= x;
OutputVector Je = y;
unsigned int iter = 0;
do {
if(++iter > max_iter)
throw maximum_iteration(max_iter);
x += e;
y_approx = f(x);
r = y; r -= y_approx;
fill_jac(J,x,y_approx);
e = r * J;
Je = J * e;
ValueType alpha = Je * Je;
if(alpha < abs_grad_tol)
return;
alpha = (r * Je) / alpha;
e *= alpha;
impose_limits(x,e);
} while(norm_2(e) > abs_tol);
};
void OperatorItem::initialize()
{
typedef std::vector<const stromx::runtime::Input*> InputVector;
typedef std::vector<const stromx::runtime::Output*> OutputVector;
InputVector inputs = m_model->op()->info().inputs();
qreal firstInputYPos = computeFirstYPos(inputs.size());
qreal yOffset = ConnectorItem::SIZE + CONNECTOR_OFFSET;
qreal inputXPos = -SIZE/2 - ConnectorItem::SIZE/2;
unsigned int i = 0;
for(InputVector::iterator iter = inputs.begin();
iter != inputs.end();
++iter, ++i)
{
ConnectorItem* inputItem = new ConnectorItem(this->m_model, (*iter)->id(), ConnectorItem::INPUT, this);
inputItem->setPos(inputXPos, firstInputYPos + i*yOffset);
m_inputs[(*iter)->id()] = inputItem;
}
OutputVector outputs = m_model->op()->info().outputs();
qreal firstOutputYPos = computeFirstYPos(outputs.size());
qreal outputXPos = SIZE/2 + ConnectorItem::SIZE/2;
i = 0;
for(OutputVector::iterator iter = outputs.begin();
iter != outputs.end();
++iter, ++i)
{
ConnectorItem* outputItem = new ConnectorItem(this->m_model, (*iter)->id(), ConnectorItem::OUTPUT, this);
outputItem->setPos(outputXPos, firstOutputYPos + i*yOffset);
m_outputs[(*iter)->id()] = outputItem;
}
}
/**
* Learning of all internal receptive field with given
* predictor input vector and scalar output result
*/
inline void learning(const InputVector& input,
scalar output)
{
std::cout << "========== LEARN " << input.transpose() << " " << output << std::endl; //TODO
//Forward learnign to all receptive fields
scalar maxWeight = 0.0;
for (size_t i=0;i<_receptiveFields.size();i++) {
scalar weight = _receptiveFields[i].activationWeight(input);
std::cout << "=== Learn " << i << " with " << weight << std::endl; //TODO
_receptiveFields[i].learning(input, output, weight);
if (weight > maxWeight) {
maxWeight = weight;
}
}
//Create new receptive field if no one have been
//activated more than a threshold
if (maxWeight < _weightGen) {
_receptiveFields.push_back(ReceptiveField<inputDim, scalar>(
_forgettingRate, _penaltyShape,
_gradientLearningRate, input, _shapeInit));
}
}
static InputVector::Distance
euclidianSquareDistance(const InputVector& a, const InputVector& b, const InputVector& weights)
{
return a.computeEuclidianSquareDistance(b, weights);
}
void
checkSameDimensions(const InputVector& a, std::size_t inputDimCount)
{
if (a.getNbDimensions() != inputDimCount)
throw Exception("Bad data dimension count");
}
void
checkSameDimensions(const InputVector& a, const InputVector& b)
{
if (!a.hasSameDimension(b))
throw Exception("Bad data dimension count");
}
void NeuralNetworkModel::CreateInputs(InputVector& v1, InputVector& v2, float* inputs) {
const unsigned int vlength = v1.Length();
//these hold onto the previous derivatives to calculate the second derivatives each time
double lastdx1 = v1.X(1) - v1.X(0);
double lastdx2 = v2.X(1) - v2.X(0);
double lastdy1 = v1.Y(1) - v1.Y(0);
double lastdy2 = v2.Y(1) - v2.Y(0);
//these will accumulate the lengths squared
double length1 = sqrt(lastdx1*lastdx1 + lastdy1*lastdy1);
double length2 = sqrt(lastdx2*lastdx2 + lastdy2*lastdy2);
//the rest we'll accumulate in place
inputs[1] = pow(v2.X(0)-v1.X(0), 2) + pow(v2.X(1)-v1.X(1), 2);
inputs[2] = pow(v2.Y(0)-v1.Y(0), 2) + pow(v2.Y(1)-v1.Y(1), 2);
inputs[3] = pow(lastdx2 - lastdx1, 2);
inputs[4] = pow(lastdy2 - lastdy1, 2);
inputs[5] = 0;
inputs[6] = 0;
for(unsigned int i = 2; i < vlength; i++) {
const double newdx1 = v1.X(i) - v1.X(i-1);
const double newdx2 = v2.X(i) - v2.X(i-1);
const double newdy1 = v1.Y(i) - v1.Y(i-1);
const double newdy2 = v2.Y(i) - v2.Y(i-1);
//accumulate lengths
length1 += sqrt(newdx1*newdx1 + newdy1*newdy1);
length2 += sqrt(newdx2*newdx2 + newdy2*newdy2);
//and the others
inputs[1] += pow(v2.X(i)-v1.X(i), 2);
inputs[2] += pow(v2.Y(i)-v1.Y(i), 2);
inputs[3] += pow(newdx2 - newdx1, 2);
inputs[4] += pow(newdy2 - newdy1, 2);
inputs[5] += pow( (newdx2-lastdx2) - (newdx1-lastdx1), 2);
inputs[6] += pow( (newdy2-lastdy2) - (newdy1-lastdy1), 2);
lastdx1 = newdx1;
lastdx2 = newdx2;
lastdy1 = newdy1;
lastdy2 = newdy2;
}
//the length requires scaling
inputs[0] = fabs(length2 - length1);
if( length1 > 0 || length2 > 0 ) { inputs[0] /= max(length1, length2); }
//2-6 are already complete, these can be computed in one shot
inputs[7] = pow(v2.X(0) - v1.X(0), 2);
inputs[8] = pow(v2.Y(0) - v1.Y(0), 2);
inputs[9] = pow(v2.X(-1) - v1.X(-1), 2);
inputs[10] = pow(v2.Y(-1) - v1.Y(-1), 2);
}
int main(int argc, char **argv) {
ParametersVectorType initialParameters;
std::string outPrefix, bmImageName, initFile, initMeansFile, mrfModelFile;
std::string s_minimization = DEFAULT_MRF_ALG;
float lambda1, lambda2;
ProbabilityPixelType atlas_th, mask_th;
unsigned int nClasses, emIterations, mrfIterations;
std::vector<std::string> channels, priors, geometricTerm;
std::string s_mode = "km+em";
std::string outExt = "nii.gz";
std::vector<double> dataOffsets;
std::vector<double> dataFactors;
bool useFile = false;
bool skipMRF = false;
bool usePVE = false;
bool doOutputStats,doSegmentsOutput, doOutputMRFMaps, doOutputMRFIterations,
doOutputSteps, useExplicitPVE, skipNormalization, skipBias, doBiasOutput, doCorrectedOutput,
channelsAreMasked = false;
unsigned int userBucketSize = 0;
boost::unordered_map<std::string, INIT_MODES> modes_map;
modes_map["none"] = NONE;
modes_map["km"] = KMEANS;
modes_map["em"] = EM;
modes_map["km+em"] = KMEANS_EM;
boost::unordered_map<std::string, typename MRFFilter::GCOptimizerType::MINIMIZATION_MODES > minimiz_map;
minimiz_map["expansion"] = MRFFilter::GCOptimizerType::EXPANSION;
minimiz_map["swap"] = MRFFilter::GCOptimizerType::SWAP;
bpo::options_description general("General options");
general.add_options()
("help", "show help message")
("out,o",bpo::value < std::string > (&outPrefix), "prefix for output files")
("out-ext", bpo::value< std::string >( &outExt ), "output format, if supported by ITK")
("brain-mask,x",bpo::value < std::string > (&bmImageName),"brain extracted mask")
("channels-masked,M", bpo::bool_switch(&channelsAreMasked), "set this flag if channels are already masked")
("channels,C", bpo::value< std::vector< std::string > >(&channels)->multitoken()->required(),"list of channels for multivariate segmentation")
("class,n", bpo::value<unsigned int>(&nClasses)->default_value(DEFAULT_NCLASSES), "number of tissue-type classes")
("init,I", bpo::value< std::string >(&s_mode), "operation mode for initialization [none,km,em,km+em]")
("init-file,f",bpo::value < std::string > (&initFile),"use file for initialization of tissue-type means & variances")
("init-means",bpo::value < std::string > (&initMeansFile),"use file for initialization of tissue-type means")
("segments,g", bpo::bool_switch(&doSegmentsOutput),"Output a posteriori probability for each class")
//("pv", bpo::bool_switch(&useExplicitPVE), "Use explicit PVE Gaussian Model between tissues")
("output-stats", bpo::bool_switch(&doOutputStats),"output classes statistics to CSV file")
("output-steps", bpo::bool_switch(&doOutputSteps), "Output intermediate segmentation steps")
("normalize-off,N", bpo::bool_switch(&skipNormalization), "Do not normalize input's intensity range")
("brain-mask-th,t",bpo::value < ProbabilityPixelType > (&mask_th)->default_value(0.0), "mask probability threshold")
("version,v", "show tool version");
bpo::options_description kmeans_desc("Kmeans options");
kmeans_desc.add_options()
("bucket-size", bpo::value< unsigned int >(&userBucketSize), "bucket size for K-means operation");
bpo::options_description em_desc("Expectation-Maximization options");
em_desc.add_options()
("priors,P", bpo::value< std::vector< std::string > >(&priors)->multitoken(),"add prior to list of atlases for initializing segmentation")
("atlas-threshold",bpo::value < ProbabilityPixelType > (&atlas_th)->default_value(DEFAULT_ATLAS_TH), "threshold for atlases")
("em-iterations", bpo::value<unsigned int>(&emIterations)->default_value(DEFAULT_MAX_ITER), "maximum number of iterations");
bpo::options_description bias_desc("Bias estimator options");
bias_desc.add_options()
("bias-skip", bpo::bool_switch(&skipBias), "Do not estimate Bias field")
("bias-output", bpo::bool_switch(&doBiasOutput), "Output estimated Bias field")
("bias-corrected-output", bpo::bool_switch(&doCorrectedOutput), "Output corrected input images with estimated Bias field");
bpo::options_description mrf_desc( "MRF Segmentation options" );
mrf_desc.add_options()
("mrf-lambda,l", bpo::value<float>(&lambda1)->default_value(DEFAULT_LAMBDA),"Regularization weighting. The higher this value is, the higher smoothing. You may use a value around 0.3-1.0 for typical brain images")
("mrf-minimization,m", bpo::value < std::string > (&s_minimization)->default_value(DEFAULT_MRF_ALG), "Minimization algorithm")
("mrf-energy-model,e",bpo::value < std::string > (&mrfModelFile), "Energy Model matrix, basic Pott's Model used if missing" )
("mrf-iterations", bpo::value<unsigned int>(&mrfIterations)->default_value(DEFAULT_MRF_ITERATIONS),"MRF re-estimation iterations")
("mrf-skip,S", bpo::bool_switch(&skipMRF),"Skip MRF step")
("mrf-pve", bpo::bool_switch(&usePVE), "Compute PVE classes")
("mrf-external-lambda", bpo::value<float>(&lambda2)->default_value(1.0),"External field energy weighting. The higher this value is, the higher impact from the external field")
("mrf-external-field,E", bpo::value< std::vector< std::string > >(&geometricTerm)->multitoken(),"External field maps that manipulate the dataterm in MRF energy function")
("mrf-output-maps", bpo::bool_switch(&doOutputMRFMaps), "Output GC probabilities and energy maps")
("mrf-output-it", bpo::bool_switch(&doOutputMRFIterations), "Output intermediate segmentation steps");
bpo::options_description all("Usage");
all.add(general).add(kmeans_desc).add(bias_desc).add(em_desc).add(mrf_desc);
bpo::variables_map vmap;
bpo::store(bpo::command_line_parser(argc, argv).options(all).run(), vmap);
if ( vmap.count("version")) {
std::cout << "MBIS Segmentation tool. Version " << MBIS_VERSION_MAJOR << "." << MBIS_VERSION_MINOR << "-" << MBIS_RELEASE << "." << std::endl;
std::cout << "--------------------------------------------------------"<< std::endl;
std::cout << "Copyright (c) 2012, [email protected] (Oscar Esteban)"<< std::endl;
std::cout << "with Signal Processing Lab 5, EPFL (LTS5-EPFL)"<< std::endl;
std::cout << "and Biomedical Image Technology, UPM (BIT-UPM)"<< std::endl;
std::cout << "All rights reserved."<< std::endl;
return 0;
}
if ( vmap.empty() || vmap.count("help")) {
std::cout << all << std::endl;
return 0;
}
try {
bpo::notify(vmap);
} catch (boost::exception_detail::clone_impl<
boost::exception_detail::error_info_injector<
boost::program_options::required_option> > &err) {
std::cout << "Error parsing options:" << err.what()
<< std::endl;
std::cout << std::endl << all << std::endl;
return EXIT_FAILURE;
}
std::cout << std::endl << "Set-up step --------------------------------------------" << std::endl;
ProbabilityImagePointer bm;
InputVector input;
PriorsVector atlas;
ClassifiedImageType::Pointer solution;
bool useFileMask = vmap.count("brain-mask") && bfs::exists(bmImageName);
bool useImplicitMasks = channelsAreMasked && !useFileMask;
if( useFileMask ) {
ProbabilityImageReader::Pointer r = ProbabilityImageReader::New();
r->SetFileName(bmImageName);
r->Update();
try {
bm = r->GetOutput();
} catch (...) {
std::cout << "Error reading brain mask" << std::endl;
return EXIT_FAILURE;
}
StatisticsImageFilterType::Pointer calc = StatisticsImageFilterType::New();
calc->SetInput(bm);
calc->Update();
ProbabilityPixelType max = calc->GetMaximum();
if (max > 1.0 ){
ProbabilityPixelType min = calc->GetMinimum();
IntensityWindowingImageFilterType::Pointer intensityFilter = IntensityWindowingImageFilterType::New();
intensityFilter->SetInput( bm );
intensityFilter->SetWindowMaximum( max );
intensityFilter->SetWindowMinimum( min );
intensityFilter->SetOutputMaximum( 1.0 );
intensityFilter->SetOutputMinimum( 0.0 );
intensityFilter->Update();
bm = intensityFilter->GetOutput();
}
std::cout << "\t* Mask: read from file " << bmImageName << ".";
if ( mask_th != 0.0 ) {
ThresholdImageFilterType::Pointer th = ThresholdImageFilterType::New();
th->SetInput( bm );
th->ThresholdBelow( mask_th );
th->Update();
bm = th->GetOutput();
std::cout << " Mask Threshold = " << mask_th << ".";
}
std::cout << std::endl;
} else {
if ( useImplicitMasks ) {
std::cout << "\t* Mask: channels are masked." << std::endl;
} else {
std::cout << "\t* Mask: not requested." << std::endl;
}
}
std::cout << "\t* Inputs normalization is " << ((!skipNormalization)?"ON":"OFF") << std::endl;
for (vector<string>::iterator it = channels.begin(); it != channels.end(); it++) {
ChannelReader::Pointer r = ChannelReader::New();
r->SetFileName( *it );
ChannelPointer p = r->GetOutput();
r->Update();
ChannelPixelType max = itk::NumericTraits< ChannelPixelType >::max();
ChannelPixelType min = 0.0;
ChannelPixelType absMin = 0.0;
if ( bm.IsNotNull() ) {
ProbabilityPixelType* mBuff = bm->GetBufferPointer();
ChannelPixelType* cBuff = r->GetOutput()->GetBufferPointer();
size_t nPix = bm->GetLargestPossibleRegion().GetNumberOfPixels();
std::vector< ChannelPixelType > sample;
for( size_t i = 0; i<nPix; i++ ) {
if ( *(mBuff+i) > 0 ) {
sample.push_back( *(cBuff+i) );
}
}
std::sort( sample.begin(), sample.end() );
max = sample[ (size_t) ((sample.size()-1)*0.98) ];
min = sample[ (size_t) ((sample.size()-1)*0.02) ];
absMin = sample[0];
} else {
StatisticsChannelFilterType::Pointer calc = StatisticsChannelFilterType::New();
calc->SetInput(p);
calc->Update();
max = calc->GetMaximum();
min = calc->GetMinimum();
absMin = min;
}
if( !skipNormalization ) {
double factor = NORM_MAX_INTENSITY / (max - min);
double constant = - factor * absMin;
if ( factor!= 1 ) {
typename MultiplyFilter::Pointer multiplier = MultiplyFilter::New();
multiplier->SetInput( p );
multiplier->SetConstant( factor );
multiplier->Update();
p = multiplier->GetOutput();
}
if ( constant!= 0 ) {
typename AddConstantFilter::Pointer adder = AddConstantFilter::New();
adder->SetInput( p );
adder->SetConstant( - constant );
adder->Update();
p = adder->GetOutput();
}
dataOffsets.push_back( constant );
dataFactors.push_back( factor );
if ( bm.IsNotNull() ) {
ChannelImageType::DirectionType dir = bm->GetDirection();
p->SetDirection( dir );
p->SetOrigin( bm->GetOrigin() );
MaskChannelFilterType::Pointer m = MaskChannelFilterType::New();
m->SetInput( p );
m->SetMaskImage( bm );
m->Update();
p = m->GetOutput();
}
if( doOutputSteps ) {
itk::ImageFileWriter< ChannelImageType >::Pointer wc = itk::ImageFileWriter< ChannelImageType >::New();
wc->SetInput( p );
std::stringstream ss;
ss << outPrefix << "_normin_" << input.size() << "." << outExt;
wc->SetFileName( ss.str() );
wc->Update();
}
}
InputComponentConstPointer im;
typename ChannelToComponentCaster::Pointer c = ChannelToComponentCaster::New();
c->SetInput(p);
c->Update();
im = c->GetOutput();
input.push_back( im );
std::cout << "\t* Channel [" << std::setw(2) << input.size() << "] read: " << (*it) << std::endl;
}
if ( useImplicitMasks ) {
bm = ProbabilityImageType::New();
bm->SetRegions( input[0]->GetLargestPossibleRegion() );
bm->CopyInformation( input[0] );
bm->Allocate();
bm->FillBuffer( 1.0 );
bm->Update();
ProbabilityPixelType* buffer = bm->GetBufferPointer();
size_t numberOfPixels = bm->GetLargestPossibleRegion().GetNumberOfPixels();
for ( size_t i = 0; i < input.size(); i++) {
const PixelType* buffer2 = input[i]->GetBufferPointer();
for( size_t offset = 0; offset < numberOfPixels; offset++ ) {
if( *( buffer + offset ) > 0.0 ) {
*( buffer + offset ) = PixelType ( *( buffer2 + offset ) > 1e-5);
}
}
}
if( doOutputSteps ) {
itk::ImageFileWriter< ProbabilityImageType >::Pointer wc = itk::ImageFileWriter< ProbabilityImageType >::New();
wc->SetInput( bm );
std::stringstream ss;
ss << outPrefix << "_mask." << outExt;
wc->SetFileName( ss.str() );
wc->Update();
}
}
unsigned int init_mode = modes_map[s_mode];
unsigned int nComponents = input.size();
unsigned int nElements = nComponents * (1+nComponents);
if( priors.size() > 0 ) {
if (init_mode== KMEANS ) init_mode = MANUAL;
if (init_mode == KMEANS_EM ) init_mode = EM;
for (vector<string>::iterator it = priors.begin(); it != priors.end(); it++) {
ProbabilityImageReader::Pointer r = ProbabilityImageReader::New();
r->SetFileName( *it );
ProbabilityImageType::ConstPointer p = r->GetOutput();
r->Update();
StatisticsImageFilterType::Pointer calc = StatisticsImageFilterType::New();
calc->SetInput(p);
calc->Update();
ProbabilityPixelType max = calc->GetMaximum();
if (max > 1.0 ){
ProbabilityPixelType min = calc->GetMinimum();
IntensityWindowingImageFilterType::Pointer intensityFilter = IntensityWindowingImageFilterType::New();
intensityFilter->SetInput( p );
intensityFilter->SetWindowMaximum( max );
intensityFilter->SetWindowMinimum( min );
intensityFilter->SetOutputMaximum( 1.0 );
intensityFilter->SetOutputMinimum( 0.0 );
intensityFilter->Update();
p = intensityFilter->GetOutput();
}
atlas.push_back(p);
std::cout << "\t* Prior [" << std::setw(2) << atlas.size() << "] read: " << (*it) << std::endl;
ParameterEstimator::Pointer est = ParameterEstimator::New();
est->SetInputVector( input );
est->SetPrior( p );
if ( bm.IsNotNull() ) {
est->SetMaskImage( bm );
}
est->Update();
initialParameters.push_back( est->GetOutputParameters() );
}
}
if ( bfs::exists(initFile)) {
if (init_mode== KMEANS ) init_mode = MANUAL;
if (init_mode == KMEANS_EM ) init_mode = EM;
std::cout << "\t* Parsing tissue parameters file: " << initFile << std::endl;
initialParameters = ReadParametersFile(initFile);
for ( ParametersVectorType::iterator it = initialParameters.begin(); it!=initialParameters.end(); it++) {
size_t n = (*it).size();
if ( n != nElements ) {
std::cerr << "Parameters file is incorrect or badly interpreted" << std::endl;
}
if ( !skipNormalization ) {
for( size_t i = 0; i<nComponents; i++ ) {
(*it)[i] *= dataFactors[i];
(*it)[i] += dataOffsets[i];
}
for( size_t i = nComponents; i<n; i++ ) {
(*it)[i] = dataFactors[i%nComponents] * (*it)[i];
}
}
}
useFile = true;
std::cout << "\t* Manual Parameters: " << std::endl;
for (size_t i = 0; i<initialParameters.size(); i++)
std::cout << "\t\t" << initialParameters[i] << std::endl;
}
if ( bfs::exists(initMeansFile)) {
std::cout << "\t* Parsing tissue means file: " << initMeansFile << std::endl;
initialParameters = ReadParametersFile( initMeansFile );
for ( ParametersVectorType::iterator it = initialParameters.begin(); it!=initialParameters.end(); it++) {
size_t n = (*it).size();
if ( n != nComponents ) {
std::cerr << "Means file is incorrect or badly interpreted" << std::endl;
}
if ( !skipNormalization ) {
for( size_t i = 0; i<n; i++ ) {
(*it)[i] *= dataFactors[i];
(*it)[i] += dataOffsets[i];
}
}
}
useFile = true;
std::cout << "\t* Manual Parameters: " << std::endl;
for (size_t i = 0; i<initialParameters.size(); i++)
std::cout << "\t\t" << initialParameters[i] << std::endl;
}
EMFilter::Pointer em_filter;
KMeansFilter::Pointer kmeans;
if (init_mode == KMEANS || init_mode == KMEANS_EM ) {
std::cout << std::endl << "Kmeans step --------------------------------------------" << std::endl;
kmeans = KMeansFilter::New();
kmeans->SetInputVector( input );
if ( bm.IsNotNull() ) kmeans->SetMaskImage( bm );
kmeans->SetNumberOfClasses(nClasses);
if(vmap.count("bucket-size")) {
kmeans->SetUserBucketSize(userBucketSize);
}
if( useFile ) {
kmeans->SetInitialParameters( initialParameters );
}
kmeans->Compute();
initialParameters = kmeans->GetOutputParameters();
if (doOutputStats) {
stringstream s;
s << outPrefix << "_stats_kmeans.csv";
std::ofstream outputCSVfile ( s.str().c_str() );
for ( unsigned int i = 0; i < initialParameters.size(); i++)
outputCSVfile << initialParameters[i] << "\n";
outputCSVfile.close();
}
kmeans->Update();
}
// Check for sanity initial parameters
if( initialParameters.size()!=nClasses ) {
std::cerr << "Error: initial parameters size (" << initialParameters.size() << ") doesn't match number of classes (" << (int) nClasses << std::endl;
} else if ( initialParameters[0].size() != nElements ) {
typename MLClassifierFilter::Pointer ml_classifier = MLClassifierFilter::New();
ml_classifier->SetInputVector( input );
if ( bm.IsNotNull() ) ml_classifier->SetMaskImage(bm);
ml_classifier->SetParameters( initialParameters );
ml_classifier->Update();
solution = ml_classifier->GetOutput();
if ( doOutputSteps ) {
ClassifiedImageWriter::Pointer w = ClassifiedImageWriter::New();
w->SetInput( solution );
w->SetFileName(outPrefix + "_means." + outExt );
w->Update();
}
ProbabilityImagePointer unoImage = ProbabilityImageType::New();
unoImage->SetRegions( input[0]->GetLargestPossibleRegion() );
unoImage->CopyInformation( input[0] );
unoImage->Allocate();
unoImage->FillBuffer( 1.0 );
unoImage->Update();
// Initialize Covariance matrix --------------------------------------
ParameterEstimator::Pointer est = ParameterEstimator::New();
est->SetInputVector( input );
typedef itk::LabelImageToLabelMapFilter< ClassifiedImageType > ClassifiedToLabelMapFilter;
typedef typename ClassifiedToLabelMapFilter::OutputImageType LabelMap;
typedef itk::LabelMapMaskImageFilter< LabelMap, ProbabilityImageType > LabelMapMaskFilter;
unsigned int maskOffset = (unsigned int) bm.IsNotNull();
for ( typename ClassifiedImageType::PixelType i = 0 ; i < nClasses ; i++ ) {
typename ClassifiedToLabelMapFilter::Pointer lfilter = ClassifiedToLabelMapFilter::New();
lfilter->SetInput( solution );
lfilter->Update();
typename LabelMapMaskFilter::Pointer lmask = LabelMapMaskFilter::New();
lmask->SetInput1( lfilter->GetOutput() );
lmask->SetInput2( unoImage );
lmask->SetLabel( i + maskOffset );
lmask->Update();
est->SetPrior( lmask->GetOutput());
est->Update();
initialParameters[i] = est->GetOutputParameters();
}
// End initialize covariance matrix -------------------------------------------
}
if (init_mode == EM || init_mode == KMEANS_EM ) {
std::cout << std::endl << "E-M Step -----------------------------------------------" << std::endl;
em_filter = EMFilter::New();
em_filter->SetMaskImage( bm );
em_filter->SetNumberOfClasses( nClasses );
em_filter->SetMaximumIteration( emIterations );
em_filter->SetMaxBiasEstimationIterations( 5 );
em_filter->SetInputVector( input );
em_filter->SetInitialParameters( initialParameters );
em_filter->SetUseExplicitPVModel( useExplicitPVE );
em_filter->SetUseBiasCorrection( !skipBias );
if ( atlas.size() != 0 ) {
em_filter->SetPriors( atlas );
em_filter->SetUsePriorProbabilityImages( true );
}
em_filter->Update();
// TODO change to GetModelParameters()
initialParameters = em_filter->GetInitialParameters();
solution = em_filter->GetOutput();
if ( doOutputSteps || skipMRF ) {
ClassifiedImageWriter::Pointer w = ClassifiedImageWriter::New();
w->SetInput( solution );
w->SetFileName(outPrefix + "_em." + outExt );
w->Update();
}
//
// Output file with initial stats if switch is true
//
if (doOutputStats) {
stringstream s;
s << outPrefix << "_stats_em.csv";
std::ofstream outputCSVfile ( s.str().c_str() );
for ( unsigned int i = 0; i < initialParameters.size(); i++)
outputCSVfile << initialParameters[i] << "\n";
outputCSVfile.close();
}
if( em_filter->GetUseBiasCorrection() ) {
typedef typename EMFilter::EstimatorType::InputVectorImageType VectorImage;
typedef typename itk::ImageFileWriter< ChannelImageType > ChannelWriter;
typedef itk::VectorIndexSelectionCastImageFilter< VectorImage, ChannelImageType> SelectorType;
typename VectorImage::ConstPointer vec = em_filter->GetEstimator()->GetCorrectedInput();
for( int channel = 0; channel< input.size(); channel++ ) {
typename SelectorType::Pointer channelSelector = SelectorType::New();
channelSelector->SetInput( vec );
channelSelector->SetIndex( channel );
channelSelector->Update();
channelSelector->GetOutput()->SetRegions( vec->GetRequestedRegion() );
input[channel] = channelSelector->GetOutput();
if ( doCorrectedOutput ) {
char name[50];
sprintf(name, "_corrected_ch%02d.%s" , channel, outExt.c_str() );
typename ChannelWriter::Pointer chW = ChannelWriter::New();
chW->SetInput(input[channel]);
chW->SetFileName( outPrefix + name );
chW->Update();
}
}
if( doBiasOutput ) {
typedef typename EMFilter::EstimatorType::InputVectorImageType VectorImage;
typedef typename itk::ImageFileWriter< ChannelImageType > ChannelWriter;
typename VectorImage::ConstPointer bias = em_filter->GetEstimator()->GetCurrentBias();
for( int channel = 0; channel< input.size(); channel++ ) {
typename SelectorType::Pointer channelSelector = SelectorType::New();
channelSelector->SetInput( bias );
channelSelector->SetIndex( channel );
channelSelector->Update();
channelSelector->GetOutput()->SetRegions( bias->GetRequestedRegion() );
char name[50];
sprintf(name, "_bias_ch%02d.%s" , channel, outExt.c_str() );
typename ChannelWriter::Pointer chW = ChannelWriter::New();
chW->SetInput(channelSelector->GetOutput());
chW->SetFileName( outPrefix + name );
chW->Update();
}
}
}
}
//
// MRF Segmentation
//
if( !skipMRF ) {
std::cout << std::endl << "MRF Step -----------------------------------------------" << std::endl;
MRFFilter::Pointer mrf = MRFFilter::New();
mrf->SetUseExplicitPVModel( useExplicitPVE );
mrf->SetNumberOfClasses( nClasses );
mrf->SetMaskImage( bm );
mrf->SetInputVector( input );
mrf->SetLambda( lambda1 );
mrf->SetExternalLambda( lambda2 );
mrf->SetUseOutputPriors( doSegmentsOutput );
mrf->SetInitialParameters( initialParameters );
mrf->SetMRFIterations( mrfIterations );
mrf->SetMinimizationMode( minimiz_map[s_minimization] );
mrf->SetOutputPrefix( outPrefix );
if( doOutputMRFIterations ) {
typedef itk::SimpleMemberCommand< MRFFilter > ObserverType;
ObserverType::Pointer obs = ObserverType::New();
obs->SetCallbackFunction( mrf, &MRFFilter::WriteIteration );
mrf->AddObserver( itk::IterationEvent(), obs );
}
if( doOutputMRFMaps ) {
typedef itk::SimpleMemberCommand< MRFFilter > ObserverType;
ObserverType::Pointer obs = ObserverType::New();
obs->SetCallbackFunction( mrf, &MRFFilter::WriteMaps );
mrf->AddObserver( itk::IterationEvent(), obs );
}
if ( doOutputSteps && init_mode == NONE ) {
EMFilter::Pointer em_classifier = EMFilter::New();
em_classifier->SetMaskImage( bm );
em_classifier->SetNumberOfClasses( nClasses );
em_classifier->SetInputVector( input );
em_classifier->SetInitialParameters( initialParameters );
em_classifier->SetUseExplicitPVModel( useExplicitPVE );
em_classifier->SetUseOnlyClassify(true);
em_classifier->Update();
ClassifiedImageWriter::Pointer w = ClassifiedImageWriter::New();
w->SetInput( em_classifier->GetOutput() );
w->SetFileName(outPrefix + "_mrf_initialization." + outExt );
w->Update();
}
if( bfs::exists( mrfModelFile ) ) {
std::cout << "\t* Loading Energy Model Matrix: " << mrfModelFile << std::endl;
mrf->SetMatrixFile( mrfModelFile );
}
for (vector<string>::iterator it = geometricTerm.begin(); it != geometricTerm.end(); it++) {
if( bfs::exists(*it) ) {
size_t label = (it - geometricTerm.begin()) + 1;
ProbabilityImageReader::Pointer r = ProbabilityImageReader::New();
r->SetFileName( *it );
ProbabilityImageType::Pointer p = r->GetOutput();
r->Update();
mrf->SetSpatialEnergyMap(label, p );
std::cout << "\t* Geometrical constraint [" << std::setw(2) << label << "] read: " << (*it) << std::endl;
}
}
mrf->Update();
solution = mrf->GetOutput();
ClassifiedImageWriter::Pointer w2 = ClassifiedImageWriter::New();
w2->SetInput( solution );
w2->SetFileName(outPrefix + "_mrf." + outExt );
w2->Update();
if ( doSegmentsOutput ) {
for ( unsigned int i = 1; i<=nClasses; i++ ) {
ProbabilityImageWriter::Pointer wProb = ProbabilityImageWriter::New();
wProb->SetInput( mrf->GetPosteriorProbabilityImage(i) );
char name[50];
sprintf(name, "_mrf_seg%02d.%s" , i, outExt.c_str() );
wProb->SetFileName( outPrefix + name );
wProb->Update();
}
}
if (doOutputStats) {
initialParameters = mrf->GetInitialParameters();
stringstream s;
s << outPrefix << "_stats_final.csv";
std::ofstream outputCSVfile ( s.str().c_str() );
for ( unsigned int i = 0; i < initialParameters.size(); i++)
outputCSVfile << initialParameters[i] << "\n";
outputCSVfile.close();
}
}
return EXIT_SUCCESS;
}
int levenberg_marquardt_nllsq_impl(Function f, JacobianFunction fill_jac,
InputVector& x, const OutputVector& y,
LinearSolver lin_solve, LimitFunction impose_limits, unsigned int max_iter,
T tau, T epsj, T epsx, T epsy)
{
typedef typename vect_traits<InputVector>::value_type ValueType;
typedef typename vect_traits<InputVector>::size_type SizeType;
/* Check if the problem is defined properly */
if (y.size() < x.size())
throw improper_problem("Levenberg-Marquardt requires M > N!");
mat<ValueType,mat_structure::rectangular> J(y.size(),x.size());
mat<ValueType,mat_structure::square> JtJ(x.size());
mat<ValueType,mat_structure::diagonal> diag_JtJ(x.size());
mat<ValueType,mat_structure::scalar> mu(x.size(),0.0);
InputVector Jte = x;
InputVector Dp = x; Dp -= x;
mat_vect_adaptor<InputVector> Dp_mat(Dp);
InputVector pDp = x;
impose_limits(x,Dp); // make sure the initial solution is feasible.
x += Dp;
if(tau <= 0.0)
tau = 1E-03;
if(epsj <= 0.0)
epsj = 1E-17;
if(epsx <= 0.0)
epsx = 1E-17;
ValueType epsx_sq = epsx * epsx;
if(epsy <= 0.0)
epsy = 1E-17;
if(max_iter <= 1)
max_iter = 2;
/* compute e=x - f(p) and its L2 norm */
OutputVector y_approx = f(x);
OutputVector e = y; e -= y_approx;
OutputVector e_tmp = e;
ValueType p_eL2 = e * e;
unsigned int nu = 2;
for(unsigned int k = 0; k < max_iter; ++k) {
if(p_eL2 < epsy)
return 1; //residual is too small.
fill_jac(J,x,y_approx);
/* J^T J, J^T e */
for(SizeType i = 0; i < J.get_col_count(); ++i) {
for(SizeType j = i; j < J.get_col_count(); ++j) {
ValueType tmp(0.0);
for(SizeType l = 0; l < J.get_row_count(); ++l)
tmp += J(l,i) * J(l,j);
JtJ(i,j) = JtJ(j,i) = tmp;
};
};
Jte = e * J;
ValueType p_L2 = x * x;
/* check for convergence */
if( norm_inf(mat_vect_adaptor<InputVector>(Jte)) < epsj)
return 2; //Jacobian is too small.
/* compute initial damping factor */
if( k == 0 ) {
ValueType tmp = std::numeric_limits<ValueType>::min();
for(SizeType i=0; i < JtJ.get_row_count(); ++i)
if(JtJ(i,i) > tmp)
tmp = JtJ(i,i); /* find max diagonal element */
mu = mat<ValueType,mat_structure::scalar>(x.size(), tau * tmp);
};
/* determine increment using adaptive damping */
while(true) {
/* solve augmented equations */
try {
lin_solve(make_damped_matrix(JtJ,mu),Dp_mat,mat_vect_adaptor<InputVector>(Jte),epsj);
impose_limits(x,Dp);
ValueType Dp_L2 = Dp * Dp;
pDp = x; pDp += Dp;
if(Dp_L2 < epsx_sq * p_L2) /* relative change in p is small, stop */
return 3; //steps are too small.
if( Dp_L2 >= (p_L2 + epsx) / ( std::numeric_limits<ValueType>::epsilon() * std::numeric_limits<ValueType>::epsilon() ) )
throw 42; //signal to throw a singularity-error (see below).
e_tmp = y; e_tmp -= f(pDp);
ValueType pDp_eL2 = e_tmp * e_tmp;
ValueType dL = mu(0,0) * Dp_L2 + Dp * Jte;
ValueType dF = p_eL2 - pDp_eL2;
if( (dL < 0.0) || (dF < 0.0) )
throw singularity_error("reject inc.");
// reduction in error, increment is accepted
ValueType tmp = ( ValueType(2.0) * dF / dL - ValueType(1.0));
tmp = 1.0 - tmp * tmp * tmp;
mu *= ( ( tmp >= ValueType(1.0 / 3.0) ) ? tmp : ValueType(1.0 / 3.0) );
nu = 2;
x = pDp;
y_approx = y; y_approx -= e_tmp;
e = e_tmp;
p_eL2 = pDp_eL2;
break; //the step is accepted and the loop is broken.
} catch(singularity_error&) {
//the increment must be rejected (either by singularity in damped matrix or no-redux by the step.
mu *= ValueType(nu);
nu <<= 1; // 2*nu;
if( nu == 0 ) /* nu has overflown. */
throw infeasible_problem("Levenberg-Marquardt method cannot reduce the function further, matrix damping has overflown!");
} catch(int i) {
if(i == 42)
throw singularity_error("Levenberg-Marquardt method has detected a near-singularity in the Jacobian matrix!");
else
throw i; //just in case there might be another integer thrown (very unlikely).
};
}; /* inner loop */
};
//if this point is reached, it means we have reached the maximum iterations.
throw maximum_iteration(max_iter);
};
