VTK/Examples/Cxx/Images/DotProduct

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