void Imageset::writeXMLToStream(XMLSerializer& xml_stream) const
{
// output Imageset tag
xml_stream.openTag("Imageset")
.attribute("Name", d_name)
.attribute("Imagefile", d_textureFilename);
if (d_nativeHorzRes != DefaultNativeHorzRes)
xml_stream.attribute("NativeHorzRes",
PropertyHelper::uintToString(static_cast<uint>(d_nativeHorzRes)));
if (d_nativeVertRes != DefaultNativeVertRes)
xml_stream.attribute("NativeVertRes",
PropertyHelper::uintToString(static_cast<uint>(d_nativeVertRes)));
if (d_autoScale)
xml_stream.attribute("AutoScaled", "true");
// output images
ImageIterator image = getIterator();
while (!image.isAtEnd())
{
image.getCurrentValue().writeXMLToStream(xml_stream);
++image;
}
// output closing tag
xml_stream.closeTag();
}
void Imageset::writeXMLToStream(OutStream& out_stream) const
{
// output opening tag
out_stream << "<Imageset Name=\"" << d_name << "\" ";
out_stream << "Filename=\"" << d_textureFilename << "\" ";
if (d_nativeHorzRes != DefaultNativeHorzRes)
out_stream << "NativeHorzRes=\"" << static_cast<uint>(d_nativeHorzRes) << "\" ";
if (d_nativeVertRes != DefaultNativeVertRes)
out_stream << "NativeVertRes=\"" << static_cast<uint>(d_nativeVertRes) << "\" ";
if (d_autoScale)
out_stream << "AutoScaled=\"True\" ";
out_stream << ">" << std::endl;
// output images
ImageIterator image = getIterator();
while (!image.isAtEnd())
{
image.getCurrentValue().writeXMLToStream(out_stream);
++image;
}
// output closing tag
out_stream << "</Imageset>" << std::endl;
}
void mitk::CreateDistanceImageFromSurfaceFilter::FillImageRegion(DistanceImageType::RegionType reqRegion,
DistanceImageType::PixelType pixelValue, DistanceImageType::Pointer image)
{
image->SetRequestedRegion(reqRegion);
ImageIterator it (image, image->GetRequestedRegion());
while (!it.IsAtEnd())
{
it.Set(pixelValue);
++it;
}
}
SPString SUIPictureList::SaveAsString()
{
SPString result;
result += SPStringHelper::XMLSurroundWith(SScriptHelper::VariablesToString(properties), L"Properties");
result += L"<MPS>";
ImageIterator iter = mixImages.begin();
while(iter != mixImages.end())
{
result += iter->SaveAsString();
iter++;
}
result += L"</MPS>";
result = SPStringHelper::XMLSurroundWith(result, L"SUIPL");
return result;
}
void mitk::CreateDistanceImageFromSurfaceFilter::CreateDistanceImage()
{
typedef itk::Image<double, 3> DistanceImageType;
typedef itk::ImageRegionIteratorWithIndex<DistanceImageType> ImageIterator;
typedef itk::NeighborhoodIterator<DistanceImageType> NeighborhoodImageIterator;
DistanceImageType::Pointer distanceImg = DistanceImageType::New();
//Determin the bounding box of the delineated contours
double xmin = m_Centers.at(0)[0];
double ymin = m_Centers.at(0)[1];
double zmin = m_Centers.at(0)[2];
double xmax = m_Centers.at(0)[0];
double ymax = m_Centers.at(0)[1];
double zmax = m_Centers.at(0)[2];
for (unsigned int i = 1; i < m_Centers.size(); i++)
{
if (xmin > m_Centers.at(i)[0])
{
xmin = m_Centers.at(i)[0];
}
if (ymin > m_Centers.at(i)[1])
{
ymin = m_Centers.at(i)[1];
}
if (zmin > m_Centers.at(i)[2])
{
zmin = m_Centers.at(i)[2];
}
if (xmax < m_Centers.at(i)[0])
{
xmax = m_Centers.at(i)[0];
}
if (ymax < m_Centers.at(i)[1])
{
ymax = m_Centers.at(i)[1];
}
if (zmax < m_Centers.at(i)[2])
{
zmax = m_Centers.at(i)[2];
}
}
Vector3D extentMM;
extentMM[0] = xmax - xmin + 2;
extentMM[1] = ymax - ymin + 2;
extentMM[2] = zmax - zmin + 2;
//Shifting the distance image's offest to achieve an exact distance calculation
xmin = xmin - 2;
ymin = ymin - 2;
zmin = zmin - 2;
/*
Now create an empty distance image. The create image will always have the same size, independent from
the original image (e.g. always consists of 500000 pixels) and will have an isotropic spacing.
The spacing is calculated like the following:
The image's volume = 500000 Pixels = extentX*spacing*extentY*spacing*extentZ*spacing
So the spacing is: spacing = ( 500000 / extentX*extentY*extentZ )^(1/3)
*/
double basis = (extentMM[0]*extentMM[1]*extentMM[2]) / m_DistanceImageVolume;
double exponent = 1.0/3.0;
double distImgSpacing = pow(basis, exponent);
int tempSpacing = (distImgSpacing+0.05)*10;
m_DistanceImageSpacing = (double)tempSpacing/10.0;
unsigned int numberOfXPixel = extentMM[0] / m_DistanceImageSpacing;
unsigned int numberOfYPixel = extentMM[1] / m_DistanceImageSpacing;
unsigned int numberOfZPixel = extentMM[2] / m_DistanceImageSpacing;
DistanceImageType::SizeType size;
//Increase the distance image's size a little bit to achieve an exact distance calculation
size[0] = numberOfXPixel + 5;
size[1] = numberOfYPixel + 5;
size[2] = numberOfZPixel + 5;
DistanceImageType::IndexType start;
start[0] = 0;
start[1] = 0;
start[2] = 0;
DistanceImageType::RegionType lpRegion;
lpRegion.SetSize(size);
lpRegion.SetIndex(start);
distanceImg->SetRegions( lpRegion );
distanceImg->SetSpacing( m_DistanceImageSpacing );
distanceImg->Allocate();
//First of all the image is initialized with the value 10 for each pixel
distanceImg->FillBuffer(10);
/*
Now we must caculate the distance for each pixel. But instead of calculating the distance value
for all of the image's pixels we proceed similar to the region growing algorithm:
1. Take the first pixel from the narrowband_point_list and calculate the distance for each neighbor (6er)
2. If the current index's distance value is below a certain threshold push it into the list
3. Next iteration take the next index from the list and start with 1. again
This is done until the narrowband_point_list is empty.
*/
std::queue<DistanceImageType::IndexType> narrowbandPoints;
PointType currentPoint = m_Centers.at(0);
double distance = this->CalculateDistanceValue(currentPoint);
DistanceImageType::IndexType currentIndex;
currentIndex[0] = ( currentPoint[0]-xmin ) / m_DistanceImageSpacing;
currentIndex[1] = ( currentPoint[1]-ymin ) / m_DistanceImageSpacing;
currentIndex[2] = ( currentPoint[2]-zmin ) / m_DistanceImageSpacing;
narrowbandPoints.push(currentIndex);
distanceImg->SetPixel(currentIndex, distance);
NeighborhoodImageIterator::RadiusType radius;
radius.Fill(1);
NeighborhoodImageIterator nIt(radius, distanceImg, distanceImg->GetLargestPossibleRegion());
unsigned int relativeNbIdx[] = {4, 10, 12, 14, 16, 22};
bool isInBounds = false;
while ( !narrowbandPoints.empty() )
{
nIt.SetLocation(narrowbandPoints.front());
narrowbandPoints.pop();
for (int i = 0; i < 6; i++)
{
nIt.GetPixel(relativeNbIdx[i], isInBounds);
if( isInBounds && nIt.GetPixel(relativeNbIdx[i]) == 10)
{
currentIndex = nIt.GetIndex(relativeNbIdx[i]);
currentPoint[0] = currentIndex[0]*m_DistanceImageSpacing + xmin;
currentPoint[1] = currentIndex[1]*m_DistanceImageSpacing + ymin;
currentPoint[2] = currentIndex[2]*m_DistanceImageSpacing + zmin;
distance = this->CalculateDistanceValue(currentPoint);
if ( abs(distance) <= m_DistanceImageSpacing*2 )
{
nIt.SetPixel(relativeNbIdx[i], distance);
narrowbandPoints.push(currentIndex);
}
}
}
}
ImageIterator imgRegionIterator (distanceImg, distanceImg->GetLargestPossibleRegion());
imgRegionIterator.GoToBegin();
double prevPixelVal = 1;
unsigned int _size[3] = { (unsigned int)(size[0] - 1), (unsigned int)(size[1] - 1), (unsigned int)(size[2] - 1) };
//Set every pixel inside the surface to -10 except the edge point (so that the received surface is closed)
while (!imgRegionIterator.IsAtEnd()) {
if ( imgRegionIterator.Get() == 10 && prevPixelVal < 0 )
{
while (imgRegionIterator.Get() == 10)
{
if (imgRegionIterator.GetIndex()[0] == _size[0] || imgRegionIterator.GetIndex()[1] == _size[1] || imgRegionIterator.GetIndex()[2] == _size[2]
|| imgRegionIterator.GetIndex()[0] == 0U || imgRegionIterator.GetIndex()[1] == 0U || imgRegionIterator.GetIndex()[2] == 0U )
{
imgRegionIterator.Set(10);
prevPixelVal = 10;
++imgRegionIterator;
break;
}
else
{
imgRegionIterator.Set(-10);
++imgRegionIterator;
prevPixelVal = -10;
}
}
}
else if (imgRegionIterator.GetIndex()[0] == _size[0] || imgRegionIterator.GetIndex()[1] == _size[1] || imgRegionIterator.GetIndex()[2] == _size[2]
|| imgRegionIterator.GetIndex()[0] == 0U || imgRegionIterator.GetIndex()[1] == 0U || imgRegionIterator.GetIndex()[2] == 0U)
{
imgRegionIterator.Set(10);
prevPixelVal = 10;
++imgRegionIterator;
}
else {
prevPixelVal = imgRegionIterator.Get();
++imgRegionIterator;
}
}
Image::Pointer resultImage = this->GetOutput();
Point3D origin;
origin[0] = xmin;
origin[1] = ymin;
origin[2] = zmin;
CastToMitkImage(distanceImg, resultImage);
resultImage->GetGeometry()->SetOrigin(origin);
resultImage->SetOrigin(origin);
}
void Interstitial::voronoi(const ISO& iso, const Symmetry& symmetry, double tol)
{
// Clear space
clear();
// Output
Output::newline();
Output::print("Searching for interstitial sites using Voronoi method");
Output::increase();
// Set up image iterator
ImageIterator images;
images.setCell(iso.basis(), 12);
// Loop over unique atoms in the structure
int i, j, k;
List<double> weights;
OList<Vector3D> points;
OList<Vector3D> vertices;
Linked<Vector3D> intPoints;
for (i = 0; i < symmetry.orbits().length(); ++i)
{
// Reset variables
weights.length(0);
points.length(0);
vertices.length(0);
// Loop over atoms in the structure
for (j = 0; j < iso.atoms().length(); ++j)
{
for (k = 0; k < iso.atoms()[j].length(); ++k)
{
// Loop over images
images.reset(symmetry.orbits()[i].atoms()[0]->fractional(), iso.atoms()[j][k].fractional());
while (!images.finished())
{
// Skip if atoms are the same
if (++images < 1e-8)
continue;
// Save current point
points += symmetry.orbits()[i].atoms()[0]->cartesian() + images.cartVector();
weights += 0.5;
}
}
}
// Calculate Voronoi volume
symmetry.orbits()[i].atoms()[0]->cartesian().voronoi(points, weights, tol, &vertices);
// Save points
for (j = 0; j < vertices.length(); ++j)
{
intPoints += iso.basis().getFractional(vertices[j]);
ISO::moveIntoCell(*intPoints.last());
}
}
// Reduce points to unique ones
bool found;
double curDistance;
Vector3D rotPoint;
Vector3D equivPoint;
Vector3D origin(0.0);
Linked<double> distances;
Linked<double>::iterator itDist;
Linked<Vector3D>::iterator it;
Linked<Vector3D> uniquePoints;
Linked<Vector3D>::iterator itUnique;
for (it = intPoints.begin(); it != intPoints.end(); ++it)
{
// Get current distance to origin
curDistance = iso.basis().distance(*it, FRACTIONAL, origin, FRACTIONAL);
// Loop over points that were already saved
found = false;
itDist = distances.begin();
itUnique = uniquePoints.begin();
for (; itDist != distances.end(); ++itDist, ++itUnique)
{
// Current points are not the same
if (Num<double>::abs(curDistance - *itDist) <= tol)
{
if (iso.basis().distance(*it, FRACTIONAL, *itUnique, FRACTIONAL) <= tol)
{
found = true;
break;
}
}
// Loop over symmetry operations
for (i = 0; i < symmetry.operations().length(); ++i)
{
// Loop over translations
rotPoint = symmetry.operations()[i].rotation() * *it;
for (j = 0; j < symmetry.operations()[i].translations().length(); ++j)
{
// Check if points are the same
equivPoint = rotPoint;
equivPoint += symmetry.operations()[i].translations()[j];
if (iso.basis().distance(equivPoint, FRACTIONAL, *itUnique, FRACTIONAL) <= tol)
{
found = true;
break;
}
}
if (found)
break;
}
if (found)
break;
}
// Found a new point
if (!found)
{
distances += curDistance;
uniquePoints += *it;
}
}
// Save unique points
_sites.length(uniquePoints.length());
for (i = 0, it = uniquePoints.begin(); it != uniquePoints.end(); ++i, ++it)
_sites[i] = *it;
// Output
Output::newline();
Output::print("Found ");
Output::print(_sites.length());
Output::print(" possible interstitial site");
if (_sites.length() != 1)
Output::print("s");
Output::increase();
for (i = 0; i < _sites.length(); ++i)
{
Output::newline();
Output::print("Site ");
Output::print(i+1);
Output::print(":");
for (j = 0; j < 3; ++j)
{
Output::print(" ");
Output::print(_sites[i][j], 8);
}
}
Output::decrease();
// Output
Output::decrease();
}
Vector3D Interstitial::getStep(const ISO& iso, const Vector3D& point, Vector3D& deriv, Matrix3D& H, double scale)
{
// Clear data
deriv = 0.0;
H = 0.0;
// Get fractional coordinates of current point
Vector3D fracPoint = iso.basis().getFractional(point);
ISO::moveIntoCell(fracPoint);
// Loop over atoms
int i, j, k;
double dis;
double norm;
double denom;
double cutoff;
double exponent;
Vector3D dif;
ImageIterator images;
for (i = 0; i < iso.atoms().length(); ++i)
{
// Set cutoff for current element
norm = scale * iso.atoms()[i][0].element().radius();
cutoff = -log(1e-8) * norm;
// Set image iterator
images.setCell(iso.basis(), cutoff);
// Loop over atoms of current element
for (j = 0; j < iso.atoms()[i].length(); ++j)
{
// Reset image iterator for current atom
images.reset(fracPoint, iso.atoms()[i][j].fractional());
// Loop over images
while (!images.finished())
{
// Get current value
dis = ++images;
if (dis < 1e-8)
continue;
exponent = exp(-dis / norm);
// Get derivative vector
dif = images.cartVector();
dif *= -1;
for (k = 0; k < 3; ++k)
deriv[k] += -exponent * dif[k] / (norm * dis);
// Get second derivative vector
denom = norm * norm * pow(dis, 3);
H(0, 0) += exponent * (dif[0]*dif[0]*dis - norm * (dif[1]*dif[1] + dif[2]*dif[2])) / denom;
H(1, 1) += exponent * (dif[1]*dif[1]*dis - norm * (dif[0]*dif[0] + dif[2]*dif[2])) / denom;
H(2, 2) += exponent * (dif[2]*dif[2]*dis - norm * (dif[0]*dif[0] + dif[1]*dif[1])) / denom;
// Add to Hessian
H(0, 1) += exponent * dif[0]*dif[1] * (norm + dis) / denom;
H(0, 2) += exponent * dif[0]*dif[2] * (norm + dis) / denom;
H(1, 2) += exponent * dif[1]*dif[2] * (norm + dis) / denom;
}
}
}
// Finish building Hessian
H(1, 0) = H(0, 1);
H(2, 0) = H(0, 2);
H(2, 1) = H(1, 2);
// Return Newton step
return H.inverse() * deriv;
}
void mitk::CreateDistanceImageFromSurfaceFilter::FillDistanceImage()
{
/*
* Now we must calculate the distance for each pixel. But instead of calculating the distance value
* for all of the image's pixels we proceed similar to the region growing algorithm:
*
* 1. Take the first pixel from the narrowband_point_list and calculate the distance for each neighbor (6er)
* 2. If the current index's distance value is below a certain threshold push it into the list
* 3. Next iteration take the next index from the list and originAsIndex with 1. again
*
* This is done until the narrowband_point_list is empty.
*/
typedef itk::ImageRegionIteratorWithIndex<DistanceImageType> ImageIterator;
typedef itk::NeighborhoodIterator<DistanceImageType> NeighborhoodImageIterator;
std::queue<DistanceImageType::IndexType> narrowbandPoints;
PointType currentPoint = m_Centers.at(0);
double distance = this->CalculateDistanceValue(currentPoint);
// create itk::Point from vnl_vector
DistanceImageType::PointType currentPointAsPoint;
currentPointAsPoint[0] = currentPoint[0];
currentPointAsPoint[1] = currentPoint[1];
currentPointAsPoint[2] = currentPoint[2];
// Transform the input point in world-coordinates to index-coordinates
DistanceImageType::IndexType currentIndex;
m_DistanceImageITK->TransformPhysicalPointToIndex( currentPointAsPoint, currentIndex );
assert( m_DistanceImageITK->GetLargestPossibleRegion().IsInside(currentIndex) ); // we are quite certain this should hold
narrowbandPoints.push(currentIndex);
m_DistanceImageITK->SetPixel(currentIndex, distance);
NeighborhoodImageIterator::RadiusType radius;
radius.Fill(1);
NeighborhoodImageIterator nIt(radius, m_DistanceImageITK, m_DistanceImageITK->GetLargestPossibleRegion());
unsigned int relativeNbIdx[] = {4, 10, 12, 14, 16, 22};
bool isInBounds = false;
while ( !narrowbandPoints.empty() )
{
nIt.SetLocation(narrowbandPoints.front());
narrowbandPoints.pop();
unsigned int* relativeNb = &relativeNbIdx[0];
for (int i = 0; i < 6; i++)
{
nIt.GetPixel(*relativeNb, isInBounds);
if( isInBounds && nIt.GetPixel(*relativeNb) == m_DistanceImageDefaultBufferValue)
{
currentIndex = nIt.GetIndex(*relativeNb);
// Transform the currently checked point from index-coordinates to
// world-coordinates
m_DistanceImageITK->TransformIndexToPhysicalPoint( currentIndex, currentPointAsPoint );
// create a vnl_vector
currentPoint[0] = currentPointAsPoint[0];
currentPoint[1] = currentPointAsPoint[1];
currentPoint[2] = currentPointAsPoint[2];
// and check the distance
distance = this->CalculateDistanceValue(currentPoint);
if ( std::fabs(distance) <= m_DistanceImageSpacing*2 )
{
nIt.SetPixel(*relativeNb, distance);
narrowbandPoints.push(currentIndex);
}
}
relativeNb++;
}
}
ImageIterator imgRegionIterator (m_DistanceImageITK, m_DistanceImageITK->GetLargestPossibleRegion());
imgRegionIterator.GoToBegin();
double prevPixelVal = 1;
DistanceImageType::IndexType _size;
_size.Fill(-1);
_size += m_DistanceImageITK->GetLargestPossibleRegion().GetSize();
//Set every pixel inside the surface to -m_DistanceImageDefaultBufferValue except the edge point (so that the received surface is closed)
while (!imgRegionIterator.IsAtEnd()) {
if ( imgRegionIterator.Get() == m_DistanceImageDefaultBufferValue && prevPixelVal < 0 )
{
while (imgRegionIterator.Get() == m_DistanceImageDefaultBufferValue)
{
if (imgRegionIterator.GetIndex()[0] == _size[0] || imgRegionIterator.GetIndex()[1] == _size[1] || imgRegionIterator.GetIndex()[2] == _size[2]
|| imgRegionIterator.GetIndex()[0] == 0U || imgRegionIterator.GetIndex()[1] == 0U || imgRegionIterator.GetIndex()[2] == 0U )
{
imgRegionIterator.Set(m_DistanceImageDefaultBufferValue);
prevPixelVal = m_DistanceImageDefaultBufferValue;
++imgRegionIterator;
break;
}
else
{
imgRegionIterator.Set((-1)*m_DistanceImageDefaultBufferValue);
++imgRegionIterator;
prevPixelVal = (-1)*m_DistanceImageDefaultBufferValue;
}
}
}
else if (imgRegionIterator.GetIndex()[0] == _size[0] || imgRegionIterator.GetIndex()[1] == _size[1] || imgRegionIterator.GetIndex()[2] == _size[2]
|| imgRegionIterator.GetIndex()[0] == 0U || imgRegionIterator.GetIndex()[1] == 0U || imgRegionIterator.GetIndex()[2] == 0U)
{
imgRegionIterator.Set(m_DistanceImageDefaultBufferValue);
prevPixelVal = m_DistanceImageDefaultBufferValue;
++imgRegionIterator;
}
else
{
prevPixelVal = imgRegionIterator.Get();
++imgRegionIterator;
}
}
Image::Pointer resultImage = this->GetOutput();
// Cast the created distance-Image from itk::Image to the mitk::Image
// that is our output.
CastToMitkImage(m_DistanceImageITK, resultImage);
}
