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); }