void mitk::CreateDistanceImageFromSurfaceFilter::PrintEquationSystem()
{
std::ofstream esfile;
esfile.open("C:/Users/fetzer/Desktop/equationSystem/es.txt");
esfile<<"Nummber of rows: "<<m_SolutionMatrix.rows()<<" ****** Number of columns: "<<m_SolutionMatrix.columns()<<endl;
esfile<<"[ ";
for (unsigned int i = 0; i < m_SolutionMatrix.rows(); i++)
{
for (unsigned int j = 0; j < m_SolutionMatrix.columns(); j++)
{
esfile<<m_SolutionMatrix(i,j)<<" ";
}
esfile<<";"<<endl;
}
esfile<<" ]";
esfile.close();
std::ofstream centersFile;
centersFile.open("C:/Users/fetzer/Desktop/equationSystem/centers.txt");
for (unsigned int i = 0; i < m_Centers.size(); i++)
{
centersFile<<m_Centers.at(i)<<";"<<endl;
}
centersFile.close();
}
void mitk::CreateDistanceImageFromSurfaceFilter::PrintEquationSystem()
{
std::stringstream out;
out<<"Nummber of rows: "<<m_SolutionMatrix.rows()<<" ****** Number of columns: "<<m_SolutionMatrix.cols()<<endl;
out<<"[ ";
for (int i = 0; i < m_SolutionMatrix.rows(); i++)
{
for (int j = 0; j < m_SolutionMatrix.cols(); j++)
{
out<<m_SolutionMatrix(i,j)<<" ";
}
out<<";"<<endl;
}
out<<" ]\n\n\n";
for (unsigned int i = 0; i < m_Centers.size(); i++)
{
out<<m_Centers.at(i)<<";"<<endl;
}
std::cout<<"Equation system: \n\n\n"<<out.str();
}
void mitk::CreateDistanceImageFromSurfaceFilter::CreateSolutionMatrixAndFunctionValues()
{
unsigned int numberOfInputs = this->GetNumberOfInputs();
if (numberOfInputs == 0)
{
MITK_ERROR << "mitk::CreateDistanceImageFromSurfaceFilter: No input available. Please set an input!" << std::endl;
itkExceptionMacro("mitk::CreateDistanceImageFromSurfaceFilter: No input available. Please set an input!");
return;
}
//First of all we have to extract the nomals and the surface points.
//Duplicated points can be eliminated
Surface* currentSurface;
vtkSmartPointer<vtkPolyData> polyData;
vtkSmartPointer<vtkDoubleArray> currentCellNormals;
vtkSmartPointer<vtkCellArray> existingPolys;
vtkSmartPointer<vtkPoints> existingPoints;
double p[3];
PointType currentPoint;
PointType normal;
for (unsigned int i = 0; i < numberOfInputs; i++)
{
currentSurface = const_cast<Surface*>( this->GetInput(i) );
polyData = currentSurface->GetVtkPolyData();
if (polyData->GetNumberOfPolys() == 0)
{
MITK_INFO << "mitk::CreateDistanceImageFromSurfaceFilter: No input-polygons available. Please be sure the input surface consists of polygons!" << std::endl;
}
currentCellNormals = vtkDoubleArray::SafeDownCast(polyData->GetCellData()->GetNormals());
existingPolys = polyData->GetPolys();
existingPoints = polyData->GetPoints();
existingPolys->InitTraversal();
vtkIdType* cell (NULL);
vtkIdType cellSize (0);
for( existingPolys->InitTraversal(); existingPolys->GetNextCell(cellSize, cell);)
{
for ( unsigned int j = 0; j < cellSize; j++ )
{
existingPoints->GetPoint(cell[j], p);
currentPoint.copy_in(p);
int count = std::count(m_Centers.begin() ,m_Centers.end(),currentPoint);
if (count == 0)
{
double currentNormal[3];
currentCellNormals->GetTuple(cell[j], currentNormal);
normal.copy_in(currentNormal);
m_Normals.push_back(normal);
m_Centers.push_back(currentPoint);
}
}//end for all points
}//end for all cells
}//end for all outputs
//For we can now calculate the exact size of the centers we initialize the data structures
unsigned int numberOfCenters = m_Centers.size();
m_Centers.reserve(numberOfCenters*3);
m_FunctionValues.set_size(numberOfCenters*3);
m_FunctionValues.fill(0);
//Create inner points
for (unsigned int i = 0; i < numberOfCenters; i++)
{
currentPoint = m_Centers.at(i);
normal = m_Normals.at(i);
currentPoint[0] = currentPoint[0] - normal[0];
currentPoint[1] = currentPoint[1] - normal[1];
currentPoint[2] = currentPoint[2] - normal[2];
m_Centers.push_back(currentPoint);
m_FunctionValues.put(numberOfCenters+i, -1);
}
//Create outer points
for (unsigned int i = 0; i < numberOfCenters; i++)
{
currentPoint = m_Centers.at(i);
normal = m_Normals.at(i);
currentPoint[0] = currentPoint[0] + normal[0];
currentPoint[1] = currentPoint[1] + normal[1];
currentPoint[2] = currentPoint[2] + normal[2];
m_Centers.push_back(currentPoint);
m_FunctionValues.put(numberOfCenters*2+i, 1);
}
//Now we have created all centers and all function values. Next step is to create the solution matrix
numberOfCenters = m_Centers.size();
m_SolutionMatrix.set_size(numberOfCenters, numberOfCenters);
m_Weights.set_size(numberOfCenters);
PointType p1;
PointType p2;
double norm;
for (unsigned int i = 0; i < numberOfCenters; i++)
{
for (unsigned int j = 0; j < numberOfCenters; j++)
{
//Calculate the RBF value. Currently using Phi(r) = r with r is the euclidian distance between two points
p1 = m_Centers.at(i);
p2 = m_Centers.at(j);
p1 = p1 - p2;
norm = p1.two_norm();
m_SolutionMatrix(i,j) = norm;
}
}
}
void mitk::CreateDistanceImageFromSurfaceFilter::CreateSolutionMatrixAndFunctionValues()
{
//For we can now calculate the exact size of the centers we initialize the data structures
unsigned int numberOfCenters = m_Centers.size();
m_Centers.reserve(numberOfCenters*3);
m_FunctionValues.resize(numberOfCenters*3);
m_FunctionValues.fill(0);
PointType currentPoint;
PointType normal;
//Create inner points
for (unsigned int i = 0; i < numberOfCenters; i++)
{
currentPoint = m_Centers.at(i);
normal = m_Normals.at(i);
currentPoint[0] = currentPoint[0] - normal[0]*m_DistanceImageSpacing;
currentPoint[1] = currentPoint[1] - normal[1]*m_DistanceImageSpacing;
currentPoint[2] = currentPoint[2] - normal[2]*m_DistanceImageSpacing;
m_Centers.push_back(currentPoint);
m_FunctionValues[numberOfCenters+i] = -m_DistanceImageSpacing;
}
//Create outer points
for (unsigned int i = 0; i < numberOfCenters; i++)
{
currentPoint = m_Centers.at(i);
normal = m_Normals.at(i);
currentPoint[0] = currentPoint[0] + normal[0]*m_DistanceImageSpacing;
currentPoint[1] = currentPoint[1] + normal[1]*m_DistanceImageSpacing;
currentPoint[2] = currentPoint[2] + normal[2]*m_DistanceImageSpacing;
m_Centers.push_back(currentPoint);
m_FunctionValues[numberOfCenters*2+i] = m_DistanceImageSpacing;
}
//Now we have created all centers and all function values. Next step is to create the solution matrix
numberOfCenters = m_Centers.size();
m_SolutionMatrix.resize(numberOfCenters, numberOfCenters);
m_Weights.resize(numberOfCenters);
PointType p1;
PointType p2;
double norm;
for (unsigned int i = 0; i < numberOfCenters; i++)
{
for (unsigned int j = 0; j < numberOfCenters; j++)
{
//Calculate the RBF value. Currently using Phi(r) = r with r is the euclidian distance between two points
p1 = m_Centers.at(i);
p2 = m_Centers.at(j);
p1 = p1 - p2;
norm = p1.two_norm();
m_SolutionMatrix(i,j) = norm;
}
}
}
