VTK/Examples/Cxx/Images/DotProduct

From KitwarePublic
< VTK‎ | Examples‎ | Cxx
Jump to navigationJump to search
VTK Examples Baseline Images TestDotProduct.png

This example demonstrates how to take the pixel-wise dot product of two vector images. The output is a scalar image.

Two images, each 2x2x1, are created and filled with 3-vectors. The dot product of each pair of corresponding pixels is produced by the vtkImageDotProduct filter and output to the screen.

DotProduct.cxx

<source lang="cpp">

  1. include <vtkVersion.h>
  2. include <vtkSmartPointer.h>
  3. include <vtkImageMathematics.h>
  4. include <vtkImageCast.h>
  5. include <vtkImageMapper3D.h>
  6. include <vtkImageActor.h>
  7. include <vtkPointData.h>
  8. include <vtkImageData.h>
  9. include <vtkImageCanvasSource2D.h>
  10. include <vtkImageDotProduct.h>
  11. include <vtkPolyDataMapper.h>
  12. include <vtkActor.h>
  13. include <vtkRenderWindow.h>
  14. include <vtkRenderer.h>
  15. include <vtkRenderWindowInteractor.h>
  16. include <vtkGlyph3DMapper.h>
  17. include <vtkArrowSource.h>
  18. include <vtkXMLImageDataWriter.h>

int main(int, char *[]) {

 // Create an image
 vtkSmartPointer<vtkImageData> image1 = 
   vtkSmartPointer<vtkImageData>::New();
 image1->SetExtent(0, 1, 0, 1, 0, 0);
  1. if VTK_MAJOR_VERSION <= 5
 image1->SetNumberOfScalarComponents(3);
 image1->SetScalarTypeToFloat();
  1. else
 image1->AllocateScalars(VTK_FLOAT,3);
  1. endif
 int coord[3]; float* pixel;
 
 // Fill the image with vectors
 coord[0] = 0; coord[1] = 0; coord[2] = 0;
 pixel = static_cast<float*>(image1->GetScalarPointer(coord));
 pixel[0] = 1.0; pixel[1] = 0.0; pixel[2] = 0.0;
 
 coord[0] = 0; coord[1] = 1; coord[2] = 0;
 pixel = static_cast<float*>(image1->GetScalarPointer(coord));
 pixel[0] = 0.0; pixel[1] = 1.0; pixel[2] = 0.0;
 
 coord[0] = 1; coord[1] = 0; coord[2] = 0;
 pixel = static_cast<float*>(image1->GetScalarPointer(coord));
 pixel[0] = 1.0; pixel[1] = 0.0; pixel[2] = 0.0;
 
 coord[0] = 1; coord[1] = 1; coord[2] = 0;
 pixel = static_cast<float*>(image1->GetScalarPointer(coord));
 pixel[0] = 0.0; pixel[1] = 1.0; pixel[2] = 0.0;
 vtkSmartPointer<vtkXMLImageDataWriter> writer =
   vtkSmartPointer<vtkXMLImageDataWriter>::New();
  1. if VTK_MAJOR_VERSION <= 5
 writer->SetInputConnection(image1->GetProducerPort());
  1. else
 writer->SetInputData(image1);
  1. endif
 writer->SetFileName("test.vti");
 writer->Write();
 
 // Create another image
 vtkSmartPointer<vtkImageData> image2 = 
   vtkSmartPointer<vtkImageData>::New();
 image2->SetExtent(0, 1, 0, 1, 0, 0);
  1. if VTK_MAJOR_VERSION <= 5
 image2->SetNumberOfScalarComponents(3);
 image2->SetScalarTypeToFloat();
  1. else
 image2->AllocateScalars(VTK_FLOAT,3);
  1. endif
 // Fill the image with vectors
 coord[0] = 0; coord[1] = 0; coord[2] = 0;
 pixel = static_cast<float*>(image2->GetScalarPointer(coord));
 pixel[0] = 1.0; pixel[1] = 0.0; pixel[2] = 0.0;
 
 coord[0] = 0; coord[1] = 1; coord[2] = 0;
 pixel = static_cast<float*>(image2->GetScalarPointer(coord));
 pixel[0] = 1.0; pixel[1] = 0.0; pixel[2] = 0.0;
 
 coord[0] = 1; coord[1] = 0; coord[2] = 0;
 pixel = static_cast<float*>(image2->GetScalarPointer(coord));
 pixel[0] = 0.5; pixel[1] = 0.0; pixel[2] = 0.0;
 
 coord[0] = 1; coord[1] = 1; coord[2] = 0;
 pixel = static_cast<float*>(image2->GetScalarPointer(coord));
 pixel[0] = 0.5; pixel[1] = 0.0; pixel[2] = 0.0;
 
 // Compute the dot product of the images pixel wise
 vtkSmartPointer<vtkImageDotProduct> dotProductFilter = 
   vtkSmartPointer<vtkImageDotProduct>::New();
  1. if VTK_MAJOR_VERSION <= 5
 dotProductFilter->SetInput1(image1);
 dotProductFilter->SetInput2(image2);
  1. else
 dotProductFilter->SetInput1Data(image1);
 dotProductFilter->SetInput2Data(image2);
  1. endif
 dotProductFilter->Update();
 std::cout << "output is of type: " << dotProductFilter->GetOutput()->GetScalarTypeAsString() << std::endl;
 vtkSmartPointer<vtkImageMathematics> imageMath =
   vtkSmartPointer<vtkImageMathematics>::New();
 imageMath->SetOperationToMultiplyByK();
 imageMath->SetConstantK(255.0);
 imageMath->SetInputConnection(dotProductFilter->GetOutputPort());
 imageMath->Update();
 vtkSmartPointer<vtkImageCast> imageCast =
   vtkSmartPointer<vtkImageCast>::New();
 imageCast->SetOutputScalarTypeToUnsignedChar();
 imageCast->SetInputConnection(imageMath->GetOutputPort());
 imageCast->Update();
 
 vtkSmartPointer<vtkImageActor> dotProductActor =
   vtkSmartPointer<vtkImageActor>::New();
 dotProductActor->GetMapper()->SetInputConnection(imageCast->GetOutputPort());
 
 // Display output to the terminal
 for(vtkIdType i = 0; i < 2; i++)
   { 
   for(vtkIdType j = 0; j < 2; j++)
     {
     coord[0] = i; coord[1] = j; coord[2] = 0;
     pixel = static_cast<float*>(dotProductFilter->GetOutput()->GetScalarPointer(coord));
     std::cout << "Pixel (" << i << ", " << j << ") : " << pixel[0] << std::endl;
     }
   }
 image1->GetPointData()->SetActiveVectors("ImageScalars");
 image2->GetPointData()->SetActiveVectors("ImageScalars");
 
 vtkSmartPointer<vtkArrowSource> arrowSource =
   vtkSmartPointer<vtkArrowSource>::New();
 vtkSmartPointer<vtkGlyph3DMapper> glyph3Dmapper1 =
   vtkSmartPointer<vtkGlyph3DMapper>::New();
 glyph3Dmapper1->SetSourceConnection(arrowSource->GetOutputPort());
  1. if VTK_MAJOR_VERSION <= 5
 glyph3Dmapper1->SetInputConnection(image1->GetProducerPort());
  1. else
 glyph3Dmapper1->SetInputData(image1);
  1. endif
 glyph3Dmapper1->Update();
 vtkSmartPointer<vtkActor> actor1 =
   vtkSmartPointer<vtkActor>::New();
 actor1->SetMapper(glyph3Dmapper1);
 vtkSmartPointer<vtkGlyph3DMapper> glyph3Dmapper2 =
   vtkSmartPointer<vtkGlyph3DMapper>::New();
 glyph3Dmapper2->SetSourceConnection(arrowSource->GetOutputPort());
  1. if VTK_MAJOR_VERSION <= 5
 glyph3Dmapper2->SetInputConnection(image2->GetProducerPort());
  1. else
 glyph3Dmapper2->SetInputData(image2);
  1. endif
 glyph3Dmapper2->Update();
 vtkSmartPointer<vtkActor> actor2 =
   vtkSmartPointer<vtkActor>::New();
 actor2->SetMapper(glyph3Dmapper2);
 // Define viewport ranges
 // (xmin, ymin, xmax, ymax