void mitk::TimeGeometry::UpdateBoundingBox ()
{
assert(m_BoundingBox.IsNotNull());
typedef BoundingBox::PointsContainer ContainerType;
unsigned long lastModifiedTime = 0;
unsigned long currentModifiedTime = 0;
ContainerType::Pointer points = ContainerType::New();
points->reserve(2*CountTimeSteps());
for (TimeStepType step = 0; step <CountTimeSteps(); ++step)
{
currentModifiedTime = GetGeometryForTimeStep(step)->GetMTime();
if (currentModifiedTime > lastModifiedTime)
lastModifiedTime = currentModifiedTime;
for (int i=0; i < 8; ++i)
{
Point3D cornerPoint = GetGeometryForTimeStep(step)->GetCornerPoint(i);
points->push_back(cornerPoint);
}
}
m_BoundingBox->SetPoints(points);
m_BoundingBox->ComputeBoundingBox();
if (this->GetMTime() < lastModifiedTime)
this->Modified();
}
mitk::TimeGeometry::TimeGeometry() :
m_BoundingBox(BoundingBox::New())
{
typedef BoundingBox::PointsContainer ContainerType;
ContainerType::Pointer points = ContainerType::New();
m_BoundingBox->SetPoints(points.GetPointer());
}
void TractsToDWIImageFilter::GenerateParticleGrid()
{
MITK_INFO << "Generating particle grid from fiber bundle";
m_ParticleGrid = mitk::ParticleGrid::New();
float* bounds = m_FiberBundle->GetBounds();
int size[] = {(int)bounds[0],(int)bounds[1],(int)bounds[2]};
m_ParticleGrid->SetSize(size);
typedef itk::Point<float,3> ContainerPointType; //no need to init, is no smartpointer
typedef itk::VectorContainer<unsigned int, ContainerPointType> ContainerTractType;
typedef itk::VectorContainer< unsigned int, ContainerTractType::Pointer > ContainerType; //init via smartpointer
ContainerType::Pointer tractContainer = m_FiberBundle->GetTractContainer();
for (int i=0; i<tractContainer->Size(); i++)
{
ContainerTractType::Pointer tract = tractContainer->GetElement(i);
for (int j=0; j<tract->Size(); j++)
{
vnl_vector_fixed<float,3> pos = tract->GetElement(j).GetVnlVector();
vnl_vector_fixed<float,3> next;
vnl_vector_fixed<float,3> dir;
if (j<tract->Size()-1)
next = tract->GetElement(j+1).GetVnlVector();
else
next = tract->GetElement(j-1).GetVnlVector();
dir = next-pos;
dir.normalize();
mitk::Particle* p = new mitk::Particle();
p->SetPosition(pos);
p->SetDirection(dir);
m_ParticleGrid->AddParticle(p);
}
}
}
void TractsToFiberEndingsImageFilter< TInputImage, TOutputPixelType >
::GenerateData()
{
MITK_INFO << "Generating 2D fiber endings image";
if(&typeid(TOutputPixelType) != &typeid(unsigned char))
{
MITK_INFO << "Only 'unsigned char' and 'itk::RGBAPixel<unsigned char> supported as OutputPixelType";
return;
}
mitk::Geometry3D::Pointer geometry = m_FiberBundle->GetGeometry();
typename OutputImageType::Pointer outImage =
static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
outImage->SetSpacing( geometry->GetSpacing()/m_UpsamplingFactor ); // Set the image spacing
mitk::Point3D origin = geometry->GetOrigin();
mitk::Point3D indexOrigin;
geometry->WorldToIndex(origin, indexOrigin);
indexOrigin[0] = indexOrigin[0] - .5 * (1.0-1.0/m_UpsamplingFactor);
indexOrigin[1] = indexOrigin[1] - .5 * (1.0-1.0/m_UpsamplingFactor);
indexOrigin[2] = indexOrigin[2] - .5 * (1.0-1.0/m_UpsamplingFactor);
mitk::Point3D newOrigin;
geometry->IndexToWorld(indexOrigin, newOrigin);
outImage->SetOrigin( newOrigin ); // Set the image origin
itk::Matrix<double, 3, 3> matrix;
for (int i=0; i<3; i++)
for (int j=0; j<3; j++)
matrix[j][i] = geometry->GetMatrixColumn(i)[j]/geometry->GetSpacing().GetElement(i);
outImage->SetDirection( matrix ); // Set the image direction
float* bounds = m_FiberBundle->GetBounds();
ImageRegion<3> upsampledRegion;
upsampledRegion.SetSize(0, bounds[0]);
upsampledRegion.SetSize(1, bounds[1]);
upsampledRegion.SetSize(2, bounds[2]);
typename InputImageType::RegionType::SizeType upsampledSize = upsampledRegion.GetSize();
for (unsigned int n = 0; n < 3; n++)
{
upsampledSize[n] = upsampledSize[n] * m_UpsamplingFactor;
}
upsampledRegion.SetSize( upsampledSize );
outImage->SetRegions( upsampledRegion );
outImage->Allocate();
int w = upsampledSize[0];
int h = upsampledSize[1];
int d = upsampledSize[2];
unsigned char* accuout;
accuout = reinterpret_cast<unsigned char*>(outImage->GetBufferPointer());
for (int i=0; i<w*h*d; i++) accuout[i] = 0;
typedef mitk::FiberBundle::ContainerTractType ContainerTractType;
typedef mitk::FiberBundle::ContainerType ContainerType;
typedef mitk::FiberBundle::ContainerPointType ContainerPointType;
ContainerType::Pointer tractContainer = m_FiberBundle->GetTractContainer();
for (int i=0; i<tractContainer->Size(); i++)
{
ContainerTractType::Pointer tract = tractContainer->GetElement(i);
int tractsize = tract->Size();
if (tractsize>1)
{
ContainerPointType start = tract->GetElement(0);
ContainerPointType end = tract->GetElement(tractsize-1);
start[0] = (start[0]+0.5) * m_UpsamplingFactor;
start[1] = (start[1]+0.5) * m_UpsamplingFactor;
start[2] = (start[2]+0.5) * m_UpsamplingFactor;
// int coordinates inside image?
int px = (int) (start[0]);
if (px < 0 || px >= w)
continue;
int py = (int) (start[1]);
if (py < 0 || py >= h)
continue;
int pz = (int) (start[2]);
if (pz < 0 || pz >= d)
continue;
accuout[( px + w*(py + h*pz ))] += 1;
end[0] = (end[0]+0.5) * m_UpsamplingFactor;
end[1] = (end[1]+0.5) * m_UpsamplingFactor;
end[2] = (end[2]+0.5) * m_UpsamplingFactor;
// int coordinates inside image?
px = (int) (end[0]);
if (px < 0 || px >= w)
continue;
py = (int) (end[1]);
if (py < 0 || py >= h)
continue;
pz = (int) (end[2]);
if (pz < 0 || pz >= d)
continue;
accuout[( px + w*(py + h*pz ))] += 1;
}
}
MITK_INFO << "2D fiber endings image generated";
}
void FiberBundleReader::GenerateOutputInformation()
{
m_OutputCache = OutputType::New();
std::string ext = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
ext = itksys::SystemTools::LowerCase(ext);
if ( m_FileName == "")
{
}
else if (ext == ".fib")
{
try
{
TiXmlDocument doc( m_FileName );
doc.LoadFile();
TiXmlHandle hDoc(&doc);
TiXmlElement* pElem;
TiXmlHandle hRoot(0);
pElem = hDoc.FirstChildElement().Element();
// save this for later
hRoot = TiXmlHandle(pElem);
pElem = hRoot.FirstChildElement(FiberBundleReader::XML_GEOMETRY).Element();
// read geometry
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
// read origin
mitk::Point3D origin;
double temp = 0;
pElem->Attribute(FiberBundleReader::XML_ORIGIN_X, &temp);
origin[0] = temp;
pElem->Attribute(FiberBundleReader::XML_ORIGIN_Y, &temp);
origin[1] = temp;
pElem->Attribute(FiberBundleReader::XML_ORIGIN_Z, &temp);
origin[2] = temp;
geometry->SetOrigin(origin);
// read spacing
float spacing[3];
pElem->Attribute(FiberBundleReader::XML_SPACING_X, &temp);
spacing[0] = temp;
pElem->Attribute(FiberBundleReader::XML_SPACING_Y, &temp);
spacing[1] = temp;
pElem->Attribute(FiberBundleReader::XML_SPACING_Z, &temp);
spacing[2] = temp;
geometry->SetSpacing(spacing);
// read transform
vtkMatrix4x4* m = vtkMatrix4x4::New();
pElem->Attribute(FiberBundleReader::XML_MATRIX_XX, &temp);
m->SetElement(0,0,temp);
pElem->Attribute(FiberBundleReader::XML_MATRIX_XY, &temp);
m->SetElement(1,0,temp);
pElem->Attribute(FiberBundleReader::XML_MATRIX_XZ, &temp);
m->SetElement(2,0,temp);
pElem->Attribute(FiberBundleReader::XML_MATRIX_YX, &temp);
m->SetElement(0,1,temp);
pElem->Attribute(FiberBundleReader::XML_MATRIX_YY, &temp);
m->SetElement(1,1,temp);
pElem->Attribute(FiberBundleReader::XML_MATRIX_YZ, &temp);
m->SetElement(2,1,temp);
pElem->Attribute(FiberBundleReader::XML_MATRIX_ZX, &temp);
m->SetElement(0,2,temp);
pElem->Attribute(FiberBundleReader::XML_MATRIX_ZY, &temp);
m->SetElement(1,2,temp);
pElem->Attribute(FiberBundleReader::XML_MATRIX_ZZ, &temp);
m->SetElement(2,2,temp);
m->SetElement(0,3,origin[0]);
m->SetElement(1,3,origin[1]);
m->SetElement(2,3,origin[2]);
m->SetElement(3,3,1);
geometry->SetIndexToWorldTransformByVtkMatrix(m);
// read bounds
float bounds[] = {0, 0, 0, 0, 0, 0};
pElem->Attribute(FiberBundleReader::XML_SIZE_X, &temp);
bounds[1] = temp;
pElem->Attribute(FiberBundleReader::XML_SIZE_Y, &temp);
bounds[3] = temp;
pElem->Attribute(FiberBundleReader::XML_SIZE_Z, &temp);
bounds[5] = temp;
geometry->SetFloatBounds(bounds);
// read bounds
float bounds2[] = {0, 0, 0};
bounds2[0] = bounds[1];
bounds2[1] = bounds[3];
bounds2[2] = bounds[5];
m_OutputCache->SetBounds(bounds2);
geometry->SetImageGeometry(true);
m_OutputCache->SetGeometry(geometry);
// generate tract container
ContainerType::Pointer tractContainer = ContainerType::New();
int fiberID = 0;
pElem = hRoot.FirstChildElement(FiberBundleReader::XML_FIBER_BUNDLE).FirstChild().Element();
for( pElem; pElem; pElem=pElem->NextSiblingElement())
{
TiXmlElement* pElem2 = pElem->FirstChildElement();
ContainerTractType::Pointer tract = ContainerTractType::New();
for( pElem2; pElem2; pElem2=pElem2->NextSiblingElement())
{
ContainerPointType point;
pElem2->Attribute(FiberBundleReader::XML_POS_X, &temp);
point[0] = temp;
pElem2->Attribute(FiberBundleReader::XML_POS_Y, &temp);
point[1] = temp;
pElem2->Attribute(FiberBundleReader::XML_POS_Z, &temp);
point[2] = temp;
tract->InsertElement(tract->Size(), point);
}
pElem->Attribute(FiberBundleReader::XML_ID, &fiberID);
tractContainer->CreateIndex(fiberID);
tractContainer->SetElement(fiberID, tract);
}
m_OutputCache->addTractContainer(tractContainer);
m_OutputCache->initFiberGroup();
MITK_INFO << "Fiber bundle read";
}
catch(...)
{
MITK_INFO << "Could not read file ";
}
}
else if (ext == ".vfib")
{
// generate tract container
ContainerType::Pointer tractContainer = ContainerType::New();
mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
///We create a Generic Reader to test de .vtk/
vtkDataReader *chooser=vtkDataReader::New();
chooser->SetFileName(m_FileName.c_str() );
if( chooser->IsFilePolyData())
{
vtkPolyDataReader *reader = vtkPolyDataReader::New();
reader->SetFileName( m_FileName.c_str() );
reader->Update();
if ( reader->GetOutput() != NULL )
{
vtkPolyData* output = reader->GetOutput();
output->ComputeBounds();
double bounds[3];
output->GetBounds(bounds);
double center[3];
output->GetCenter(center);
Point3D origin;
origin.SetElement(0, -center[0]);
origin.SetElement(1, -center[1]);
origin.SetElement(2, -center[2]);
MITK_INFO << origin;
mitk::Surface::Pointer surf = mitk::Surface::New();
surf->SetVtkPolyData(output);
mitk::Geometry3D* geom = surf->GetGeometry();
//geom->SetOrigin(origin);
geom->SetImageGeometry(true);
m_OutputCache->SetBounds(bounds);
m_OutputCache->SetGeometry(geom);
vtkCellArray* cells = output->GetLines();
cells->InitTraversal();
for (int i=0; i<output->GetNumberOfCells(); i++)
{
ContainerTractType::Pointer tract = ContainerTractType::New();
vtkCell* cell = output->GetCell(i);
int p = cell->GetNumberOfPoints();
vtkPoints* points = cell->GetPoints();
for (int j=0; j<p; j++)
{
double p[3];
points->GetPoint(j, p);
ContainerPointType point;
point[0] = p[0];
point[1] = p[1];
point[2] = p[2];
tract->InsertElement(tract->Size(), point);
}
tractContainer->InsertElement(i, tract);
}
}
reader->Delete();
}
chooser->Delete();
m_OutputCache->addTractContainer(tractContainer);
m_OutputCache->initFiberGroup();
MITK_INFO << "Fiber bundle read";
}
}