[Insight-users] How can I view a metamesh.txt mesh file that I created with an itk::SpatialObjectWriter

[John Drozd]

Hello,

How can I view a metamesh.txt mesh file that I created with an
itk::SpatialObjectWriter.

I modified itk's example DeformableModel1.cxx to create the "metamesh.txt"
file using a binary image that I segmented using the FuzzyConnectedness
segmentation example in itk.

I suspect I can use paraview to view a metamesh.txt file but I don't know
the steps.

Can anyone help?

To illustrate my case, below are snippets of the contents of my metamesh.txt
file:

ObjectType = Scene
NDims = 3
NObjects = 1
ObjectType = Mesh
NDims = 3
BinaryData = False
TransformMatrix = 1 0 0 0 1 0 0 0 1
Offset = 0 0 0
CenterOfRotation = 0 0 0
ElementSpacing = 1 1 1
PointType = MET_FLOAT
PointDataType = MET_SHORT
CellDataType = MET_SHORT
NCellTypes = 1
PointDim = ID x y ...
NPoints = 22863
Points =
0 321.712 160.777 68.8275
1 322.185 160.305 68.8275
2 322.185 160.777 68.2237
3 322.658 160.777 68.8275
4 321.712 161.723 68.8275
5 322.185 161.723 68.2237
6 322.658 161.723 68.8275
7 321.712 162.669 68.8275
8 322.185 162.669 68.2237

.............................

22855 319.821 164.088 132.221
22856 320.294 164.561 132.221
22857 319.348 165.506 132.221
22858 319.821 165.033 132.221
22859 320.294 165.506 132.221
22860 320.294 166.452 132.221
22861 319.821 165.979 132.221
22862 320.294 167.398 132.221
CellType = TRI
NCells = 45574
Cells =
0 0 2 1
1 3 1 2
2 4 5 0
3 2 0 5
4 6 3 5
5 2 5 3
6 7 8 4
7 5 4 8
8 9 6 8
9 5 8 6
10 10 11 7
11 8 7 11
12 12 9 11

.........................................

45567 22859 22793 22860
45568 22801 22797 22862
45569 22860 22862 22797
45570 22804 22862 22799
45571 22860 22799 22862
45572 22801 22862 22806
45573 22804 22806 22862
NCellData = 45574
CellDataSize = 273444
CellData =

(binary data)


And Here is the code that generates my metamesh.txt file:

#include <iostream>


//  Software Guide : BeginLatex
//
//  We start by including the headers of the main classes required for this
//  example. The BinaryMask3DMeshSource is used to produce an initial
//  approximation of the shape to be segmented. This filter takes a binary
//  image as input and produces a Mesh as output using the marching cube
//  isocontouring algorithm.
//
//  \index{itk::BinaryMask3DMeshSource!Header}
//
//  Software Guide : EndLatex

// Software Guide : BeginCodeSnippet
#include "itkBinaryMask3DMeshSource.h"
// Software Guide : EndCodeSnippet


//  Software Guide : BeginLatex
//
//  Then we include the header of the DeformableMesh3DFilter that
//  implements the deformable model algorithm.
//
//  \index{itk::DeformableMesh3DFilter!Header}
//
//  Software Guide : EndLatex

//  Software Guide : BeginCodeSnippet
#include "itkDeformableMesh3DFilter.h"
//  Software Guide : EndCodeSnippet


//  Software Guide : BeginLatex
//
//  We also need the headers of the gradient filters that will be used for
//  computing the vector field. In our case they are the
//  GradientMagnitudeRecursiveGaussianImageFilter and
//  GradientRecursiveGaussianImageFilter.
//
//  Software Guide : EndLatex

//  Software Guide : BeginCodeSnippet
#include "itkGradientRecursiveGaussianImageFilter.h"
#include "itkGradientMagnitudeRecursiveGaussianImageFilter.h"
//  Software Guide : EndCodeSnippet


//  Software Guide : BeginLatex
//
//  The main data structures required in this example are the Image
//  and the Mesh classes. The deformable model \emph{per se} is
//  represented as a Mesh.
//
//  Software Guide : EndLatex

//  Software Guide : BeginCodeSnippet
#include "itkImage.h"
#include "itkMesh.h"
//  Software Guide : EndCodeSnippet


//  Software Guide : BeginLatex
//
//  The \code{PixelType} of the image derivatives is represented with a
//  \doxygen{CovariantVector}. We include its header in the following line.
//
//  Software Guide : EndLatex

//  Software Guide : BeginCodeSnippet
#include "itkCovariantVector.h"
//  Software Guide : EndCodeSnippet

//  Software Guide : BeginLatex
//
//  The deformed mesh is converted into a binary image using the
//  \doxygen{PointSetToImageFilter}.
//
//  Software Guide : EndLatex

//  Software Guide : BeginCodeSnippet
#include "itkPointSetToImageFilter.h"
//  Software Guide : EndCodeSnippet

//  Software Guide : BeginLatex
//
//  In order to read both the input image and the mask image, we need the
//  \doxygen{ImageFileReader} class. We also need the
\doxygen{ImageFileWriter}
//  to save the resulting deformed mask image.
//
//  Software Guide : EndLatex

//  Software Guide : BeginCodeSnippet
#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
//  Software Guide : EndCodeSnippet

//added by jd
//http://www.slideshare.net/kitware/itk-tutorial-presentation-slides948
#include "itkSpatialObjectWriter.h"
#include "itkMeshSpatialObject.h"
#include "itkDefaultDynamicMeshTraits.h"
//end of added code

int main( int argc, char *argv[] )
{

  if( argc < 4 )
    {
    std::cerr << "Missing Parameters " << std::endl;
    std::cerr << "Usage: " << argv[0];
    std::cerr << " InputImage  BinaryImage DeformedMaskImage" << std::endl;
    return 1;
    }


  //  Software Guide : BeginLatex
  //
  //  Here we declare the type of the image to be processed. This implies a
  //  decision about the \code{PixelType} and the dimension. The
  //  DeformableMesh3DFilter is specialized for $3D$, so the choice
  //  is clear in our case.
  //
  //  Software Guide : EndLatex

  // Software Guide : BeginCodeSnippet

  const     unsigned int    Dimension = 3;

  typedef   signed short                         PixelType;

  typedef itk::Image<PixelType, Dimension> ImageType;
  // Software Guide : EndCodeSnippet


  //  Software Guide : BeginLatex
  //
  //  The input to BinaryMask3DMeshSource is a binary mask that we
  //  will read from a file. This mask could be the result of a rough
  //  segmentation algorithm applied previously to the same anatomical
  //  structure. We declare below the type of the binary mask image.
  //
  //  Software Guide : EndLatex

  // Software Guide : BeginCodeSnippet

  typedef itk::Image< signed short, Dimension >   BinaryImageType;

  // Software Guide : EndCodeSnippet


  //  Software Guide : BeginLatex
  //
  //  Then we define the type of the deformable mesh. We represent the
  //  deformable model using the Mesh class. The \code{signed short} type
used as
  //  template parameter here is to be used to assign values to every point
  //  of the Mesh.
  //
  //  Software Guide : EndLatex

  // Software Guide : BeginCodeSnippet

  typedef  itk::Mesh<signed short>     MeshType;

  // Software Guide : EndCodeSnippet


  //  Software Guide : BeginLatex
  //
  //  The filter implementing the isocontouring algorithm is the
  //  BinaryMask3DMeshSource filter.
  //
  //  \index{itk::BinaryMask3DMeshSource!Instantiation}
  //
  //  Software Guide : EndLatex

  //  Software Guide : BeginCodeSnippet
  typedef itk::BinaryMask3DMeshSource< BinaryImageType, MeshType >
MeshSourceType;


  //  Software Guide : BeginLatex
  //
  //  Let's declare two readers. The first will read the image to be
  //  segmented. The second will read the binary mask containing a first
  //  approximation of the segmentation that will be used to initialize a
  //  mesh for the deformable model.
  //
  //  Software Guide : EndLatex

  // Software Guide : BeginCodeSnippet
  typedef itk::ImageFileReader< ImageType       >  ReaderType;
  typedef itk::ImageFileReader< BinaryImageType >  BinaryReaderType;
  ReaderType::Pointer       imageReader   =  ReaderType::New();
  BinaryReaderType::Pointer maskReader    =  BinaryReaderType::New();
  // Software Guide : EndCodeSnippet


  //  Software Guide : BeginLatex
  //
  //  In this example we take the filenames of the input image and the
binary
  //  mask from the command line arguments.
  //
  //  Software Guide : EndLatex

  //  Software Guide : BeginCodeSnippet
  imageReader->SetFileName( argv[1] );
  maskReader->SetFileName(  argv[2] );
  //  Software Guide : EndCodeSnippet




  //  Software Guide : BeginLatex
  //
  //  Now we can construct the mesh source filter that implements the
  //  isocontouring algorithm.
  //
  //  \index{BinaryMask3DMeshSource!New()}
  //  \index{BinaryMask3DMeshSource!Pointer}
  //
  //  Software Guide : EndLatex

  // Software Guide : BeginCodeSnippet
  MeshSourceType::Pointer meshSource = MeshSourceType::New();

  BinaryImageType::Pointer mask = maskReader->GetOutput();
  meshSource->SetInput( mask );

  meshSource->SetObjectValue( 1 );

  std::cout << "Creating mesh..." << std::endl;
  try
    {
    meshSource->Update();
    }
  catch( itk::ExceptionObject & excep )
    {
    std::cerr << "Exception Caught !" << std::endl;
    std::cerr << excep << std::endl;
    }

  meshSource->GetOutput()->Print(std::cout);

  //from slideshare website

  typedef itk::MeshSpatialObject<MeshType>MeshSpatialObjectType;

  MeshSpatialObjectType::Pointer meshSO = MeshSpatialObjectType::New();
  meshSO->SetMesh(meshSource->GetOutput());

  typedef MeshSourceType::OutputMeshType OutputMeshType;

  typedef itk::SpatialObjectWriter<3,signed
short,OutputMeshType::MeshTraits>WriterType;
  WriterType::Pointer writer=WriterType::New();
  writer->SetInput(meshSO);
  writer->SetFileName("metamesh.txt");
  writer->Update();
  //end of added code

  std::cout << "Deformable mesh created using Marching Cube!" << std::endl;

return EXIT_SUCCESS;
}


Any help in giving me suggestions to view this mesh would be appreciated.


Thank you,
John
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.itk.org/pipermail/insight-users/attachments/20100628/8b330f4f/attachment-0001.htm>