diff --git a/src/Cxx/ImageData/IntersectLine.md b/src/Cxx/ImageData/IntersectLine.md
index 8252476e19a45b484c5e123145951e5f163d960a..e7a59953452bdaf69078072f8fad75851f160b3b 100644
--- a/src/Cxx/ImageData/IntersectLine.md
+++ b/src/Cxx/ImageData/IntersectLine.md
@@ -1,2 +1,3 @@
### Description
+
This example demonstrates a (rather manual) way of finding which cells of a vtkImageData a finite line intersects. Note that this is not exact - a cell-centric approach is used. That is, a discrete line (DDA-like http://en.wikipedia.org/wiki/Digital_differential_analyzer_%28graphics_algorithm%29) is followed on the cell grid between the cells that contain the intersection points of the line with the bounding box of the image. These are all not necessarily the exact same cells as the line actually intersects, but it gives a reasonable "path" of cells through the image which might be suitable for some applications.
diff --git a/src/Cxx/ImageProcessing/Attenuation.cxx b/src/Cxx/ImageProcessing/Attenuation.cxx
index 7d21d47a2e67fdbc879c24bac0ea0deeeef41bc2..3ba034eb2f6a5c609c452706957cbb905d9fea37 100644
--- a/src/Cxx/ImageProcessing/Attenuation.cxx
+++ b/src/Cxx/ImageProcessing/Attenuation.cxx
@@ -1,7 +1,5 @@
#include <vtkImageActor.h>
#include <vtkImageCast.h>
-#include <vtkImageCast.h>
-#include <vtkImageGaussianSmooth.h>
#include <vtkImageGaussianSmooth.h>
#include <vtkImageMapper3D.h>
#include <vtkImageMathematics.h>
@@ -10,81 +8,69 @@
#include <vtkImageReader2Factory.h>
#include <vtkImageShiftScale.h>
#include <vtkInteractorStyleImage.h>
-#include <vtkInteractorStyleImage.h>
#include <vtkNamedColors.h>
-#include <vtkRenderer.h>
+#include <vtkNew.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
#include <vtkSampleFunction.h>
-#include <vtkSmartPointer.h>
#include <vtkSphere.h>
-int main (int argc, char *argv[])
+int main(int argc, char* argv[])
{
// Verify input arguments
- if ( argc != 2 )
+ if (argc != 2)
{
- std::cout << "Usage: " << argv[0]
- << " Filename" << std::endl;
+ std::cout << "Usage: " << argv[0] << " Filename e.g. AttenuationArtifact.pg"
+ << std::endl;
return EXIT_FAILURE;
}
// Read the image
- vtkSmartPointer<vtkImageReader2Factory> readerFactory =
- vtkSmartPointer<vtkImageReader2Factory>::New();
+ vtkNew<vtkImageReader2Factory> readerFactory;
vtkSmartPointer<vtkImageReader2> reader;
- reader.TakeReference(
- readerFactory->CreateImageReader2(argv[1]));
+ reader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
reader->SetFileName(argv[1]);
- vtkSmartPointer<vtkImageCast> cast =
- vtkSmartPointer<vtkImageCast>::New();
+ vtkNew<vtkImageCast> cast;
cast->SetInputConnection(reader->GetOutputPort());
cast->SetOutputScalarTypeToDouble();
-// get rid of discrete scalars);
- vtkSmartPointer<vtkImageGaussianSmooth> smooth =
- vtkSmartPointer<vtkImageGaussianSmooth>::New();
+ // get rid of discrete scalars);
+ vtkNew<vtkImageGaussianSmooth> smooth;
smooth->SetInputConnection(cast->GetOutputPort());
smooth->SetStandardDeviations(0.8, 0.8, 0);
- vtkSmartPointer<vtkSphere> m1 =
- vtkSmartPointer<vtkSphere>::New();
+ vtkNew<vtkSphere> m1;
m1->SetCenter(310, 130, 0);
m1->SetRadius(0);
- vtkSmartPointer<vtkSampleFunction> m2 =
- vtkSmartPointer<vtkSampleFunction>::New();
+ vtkNew<vtkSampleFunction> m2;
m2->SetImplicitFunction(m1);
m2->SetModelBounds(0, 264, 0, 264, 0, 1);
m2->SetSampleDimensions(264, 264, 1);
- vtkSmartPointer<vtkImageShiftScale> m3 =
- vtkSmartPointer<vtkImageShiftScale>::New();
+ vtkNew<vtkImageShiftScale> m3;
m3->SetInputConnection(m2->GetOutputPort());
m3->SetScale(0.000095);
- vtkSmartPointer<vtkImageMathematics> div =
- vtkSmartPointer<vtkImageMathematics>::New();
+ vtkNew<vtkImageMathematics> div;
div->SetInputConnection(0, smooth->GetOutputPort());
div->SetInputConnection(1, m3->GetOutputPort());
div->SetOperationToMultiply();
// Create actors
- vtkSmartPointer<vtkNamedColors> colors =
- vtkSmartPointer<vtkNamedColors>::New();
+ vtkNew<vtkNamedColors> colors;
double colorWindow = 256.0;
double colorLevel = 127.5;
- vtkSmartPointer<vtkImageActor> originalActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> originalActor;
originalActor->GetMapper()->SetInputConnection(cast->GetOutputPort());
originalActor->GetProperty()->SetColorWindow(colorWindow);
originalActor->GetProperty()->SetColorLevel(colorLevel);
- vtkSmartPointer<vtkImageActor> filteredActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> filteredActor;
filteredActor->GetMapper()->SetInputConnection(div->GetOutputPort());
// Define viewport ranges
@@ -93,30 +79,27 @@ int main (int argc, char *argv[])
double filteredViewport[4] = {0.5, 0.0, 1.0, 1.0};
// Setup renderers
- vtkSmartPointer<vtkRenderer> originalRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> originalRenderer;
originalRenderer->SetViewport(originalViewport);
originalRenderer->AddActor(originalActor);
originalRenderer->ResetCamera();
originalRenderer->SetBackground(colors->GetColor3d("SlateGray").GetData());
- vtkSmartPointer<vtkRenderer> filteredRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> filteredRenderer;
filteredRenderer->SetViewport(filteredViewport);
filteredRenderer->AddActor(filteredActor);
filteredRenderer->ResetCamera();
- filteredRenderer->SetBackground(colors->GetColor3d("LightSlateGray").GetData());
+ filteredRenderer->SetBackground(
+ colors->GetColor3d("LightSlateGray").GetData());
- vtkSmartPointer<vtkRenderWindow> renderWindow =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renderWindow;
renderWindow->SetSize(600, 300);
renderWindow->AddRenderer(originalRenderer);
renderWindow->AddRenderer(filteredRenderer);
+ renderWindow->SetWindowName("Attenuation");
- vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
- vtkSmartPointer<vtkInteractorStyleImage> style =
- vtkSmartPointer<vtkInteractorStyleImage>::New();
+ vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+ vtkNew<vtkInteractorStyleImage> style;
renderWindowInteractor->SetInteractorStyle(style);
diff --git a/src/Cxx/ImageProcessing/EnhanceEdges.cxx b/src/Cxx/ImageProcessing/EnhanceEdges.cxx
index e12d89bfa50f18d20329db416d466a67ff60c490..db0870fd69ce2ab01cee84dcc0dd37ec90c95059 100644
--- a/src/Cxx/ImageProcessing/EnhanceEdges.cxx
+++ b/src/Cxx/ImageProcessing/EnhanceEdges.cxx
@@ -13,6 +13,7 @@
#include <vtkImageReader2Factory.h>
#include <vtkImageThreshold.h>
#include <vtkInteractorStyleImage.h>
+#include <vtkNew.h>
#include <vtkPointData.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
@@ -24,12 +25,12 @@ int main(int argc, char* argv[])
// Verify input arguments
if (argc != 2)
{
- std::cout << "Usage: " << argv[0] << " Filename" << std::endl;
+ std::cout << "Usage: " << argv[0] << " Filename e.g. FullHead.mhd" << std::endl;
return EXIT_FAILURE;
}
// Read the image
- auto readerFactory = vtkSmartPointer<vtkImageReader2Factory>::New();
+ vtkNew<vtkImageReader2Factory> readerFactory;
vtkSmartPointer<vtkImageReader2> reader;
reader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
reader->SetFileName(argv[1]);
@@ -50,16 +51,16 @@ int main(int argc, char* argv[])
auto middleSlice = 22;
// Work with triple images
- auto cast = vtkSmartPointer<vtkImageCast>::New();
+ vtkNew<vtkImageCast> cast;
cast->SetInputConnection(reader->GetOutputPort());
cast->SetOutputScalarTypeToDouble();
cast->Update();
- auto laplacian = vtkSmartPointer<vtkImageLaplacian>::New();
+ vtkNew<vtkImageLaplacian> laplacian;
laplacian->SetInputConnection(cast->GetOutputPort());
laplacian->SetDimensionality(3);
- auto enhance = vtkSmartPointer<vtkImageMathematics>::New();
+ vtkNew<vtkImageMathematics> enhance;
enhance->SetInputConnection(0, cast->GetOutputPort());
enhance->SetInputConnection(1, laplacian->GetOutputPort());
enhance->SetOperationToSubtract();
@@ -68,12 +69,12 @@ int main(int argc, char* argv[])
int colorLevel = colorWindow / 2;
// Map the image through the lookup table
- auto originalColor = vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
+ vtkNew<vtkImageMapToWindowLevelColors> originalColor;
originalColor->SetWindow(colorWindow);
originalColor->SetLevel(colorLevel);
originalColor->SetInputConnection(reader->GetOutputPort());
- auto originalActor = vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> originalActor;
originalActor->GetMapper()->SetInputConnection(
originalColor->GetOutputPort());
originalActor->GetProperty()->SetInterpolationTypeToNearest();
@@ -82,34 +83,34 @@ int main(int argc, char* argv[])
reader->GetDataExtent()[2], reader->GetDataExtent()[3], middleSlice,
middleSlice);
- auto laplacianColor = vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
+ vtkNew<vtkImageMapToWindowLevelColors> laplacianColor;
laplacianColor->SetWindow(1000);
laplacianColor->SetLevel(0);
laplacianColor->SetInputConnection(laplacian->GetOutputPort());
- auto laplacianActor = vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> laplacianActor;
laplacianActor->GetMapper()->SetInputConnection(
laplacianColor->GetOutputPort());
laplacianActor->GetProperty()->SetInterpolationTypeToNearest();
laplacianActor->SetDisplayExtent(originalActor->GetDisplayExtent());
- auto enhancedColor = vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
+ vtkNew<vtkImageMapToWindowLevelColors> enhancedColor;
enhancedColor->SetWindow(colorWindow);
enhancedColor->SetLevel(colorLevel);
enhancedColor->SetInputConnection(enhance->GetOutputPort());
- auto enhancedActor = vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> enhancedActor;
enhancedActor->GetMapper()->SetInputConnection(
enhancedColor->GetOutputPort());
enhancedActor->GetProperty()->SetInterpolationTypeToNearest();
enhancedActor->SetDisplayExtent(originalActor->GetDisplayExtent());
// Setup renderers
- auto originalRenderer = vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> originalRenderer;
originalRenderer->AddActor(originalActor);
- auto laplacianRenderer = vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> laplacianRenderer;
laplacianRenderer->AddActor(laplacianActor);
- auto enhancedRenderer = vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> enhancedRenderer;
enhancedRenderer->AddActor(enhancedActor);
std::vector<vtkSmartPointer<vtkRenderer>> renderers;
@@ -122,7 +123,7 @@ int main(int argc, char* argv[])
unsigned int xGridDimensions = 3;
unsigned int yGridDimensions = 1;
- auto renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renderWindow;
renderWindow->SetSize(rendererSize * xGridDimensions,
rendererSize * yGridDimensions);
for (int row = 0; row < static_cast<int>(yGridDimensions); row++)
@@ -140,10 +141,10 @@ int main(int argc, char* argv[])
renderWindow->AddRenderer(renderers[index]);
}
}
+ renderWindow->SetWindowName("EnhanceEdges");
- auto renderWindowInteractor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
- auto style = vtkSmartPointer<vtkInteractorStyleImage>::New();
+ vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+ vtkNew<vtkInteractorStyleImage> style;
renderWindowInteractor->SetInteractorStyle(style);
renderWindowInteractor->SetRenderWindow(renderWindow);
diff --git a/src/Cxx/ImageProcessing/EnhanceEdges.md b/src/Cxx/ImageProcessing/EnhanceEdges.md
index ce63567493dd53820eb244bcaf49dae7f2ca49a9..d241ef3d58155a72ccc28d1b7c1e8f2e64de7ae5 100644
--- a/src/Cxx/ImageProcessing/EnhanceEdges.md
+++ b/src/Cxx/ImageProcessing/EnhanceEdges.md
@@ -1,4 +1,5 @@
### Description
+
High-pass filters can also be used to compress the range of an image. Since low frequencies account for much of the dynamic range of an image but carry little information, a high-pass filter can significantly decrease an image’s scalar range and emphasize hidden details. The Laplacian filter, which is a second derivative operation, is one implementation of a high-pass filter. It eliminates constant and low frequencies leaving only high-frequency edges. The output of the Laplacian can be subtracted from the original image to produce edge enhancement or sharpening of an image.
This example subtracts the Laplacian (middle) from the original image (left) resulting in edge enhancement or a sharpening operation (right).
diff --git a/src/Cxx/ImageProcessing/GaussianSmooth.cxx b/src/Cxx/ImageProcessing/GaussianSmooth.cxx
index c400c9332b7732e284c9c3f1520877377439ce19..f77f3c2d01f9215c24867c19fbad8bd2de48b61a 100644
--- a/src/Cxx/ImageProcessing/GaussianSmooth.cxx
+++ b/src/Cxx/ImageProcessing/GaussianSmooth.cxx
@@ -7,58 +7,49 @@
#include <vtkImageReader2.h>
#include <vtkImageReader2Factory.h>
#include <vtkInteractorStyleImage.h>
-#include <vtkInteractorStyleImage.h>
#include <vtkNamedColors.h>
-#include <vtkRenderer.h>
+#include <vtkNew.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
#include <vtkSmartPointer.h>
-int main( int argc, char *argv[])
+int main(int argc, char* argv[])
{
// Verify input arguments
- if ( argc != 2 )
+ if (argc != 2)
{
- std::cout << "Usage: " << argv[0]
- << " Filename" << std::endl;
+ std::cout << "Usage: " << argv[0] << " Filename e.g. Gourds.png"
+ << std::endl;
return EXIT_FAILURE;
}
// Read the image
- vtkSmartPointer<vtkImageReader2Factory> readerFactory =
- vtkSmartPointer<vtkImageReader2Factory>::New();
+ vtkNew<vtkImageReader2Factory> readerFactory;
vtkSmartPointer<vtkImageReader2> reader;
- reader.TakeReference(
- readerFactory->CreateImageReader2(argv[1]));
+ reader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
reader->SetFileName(argv[1]);
reader->Update();
- // Process the
- vtkSmartPointer<vtkImageCast> cast =
- vtkSmartPointer<vtkImageCast>::New();
+ // Process the
+ vtkNew<vtkImageCast> cast;
cast->SetInputConnection(reader->GetOutputPort());
cast->SetOutputScalarTypeToFloat();
- vtkSmartPointer<vtkImageGaussianSmooth> filter =
- vtkSmartPointer<vtkImageGaussianSmooth>::New();
+ vtkNew<vtkImageGaussianSmooth> filter;
filter->SetDimensionality(2);
filter->SetInputConnection(cast->GetOutputPort());
filter->SetStandardDeviations(4.0, 4.0);
filter->SetRadiusFactors(2.0, 2.0);
-
+
// Create actors
- vtkSmartPointer<vtkNamedColors> colors =
- vtkSmartPointer<vtkNamedColors>::New();
+ vtkNew<vtkNamedColors> colors;
- vtkSmartPointer<vtkImageActor> originalActor =
- vtkSmartPointer<vtkImageActor>::New();
- originalActor->GetMapper()->SetInputConnection(
- reader->GetOutputPort());
+ vtkNew<vtkImageActor> originalActor;
+ originalActor->GetMapper()->SetInputConnection(reader->GetOutputPort());
- vtkSmartPointer<vtkImageActor> filteredActor =
- vtkSmartPointer<vtkImageActor>::New();
- filteredActor->GetMapper()->SetInputConnection(
- filter->GetOutputPort());
+ vtkNew<vtkImageActor> filteredActor;
+ filteredActor->GetMapper()->SetInputConnection(filter->GetOutputPort());
// Define viewport ranges
// (xmin, ymin, xmax, ymax)
@@ -66,30 +57,27 @@ int main( int argc, char *argv[])
double filteredViewport[4] = {0.5, 0.0, 1.0, 1.0};
// Setup renderers
- vtkSmartPointer<vtkRenderer> originalRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> originalRenderer;
originalRenderer->SetViewport(originalViewport);
originalRenderer->AddActor(originalActor);
originalRenderer->ResetCamera();
originalRenderer->SetBackground(colors->GetColor3d("SlateGray").GetData());
- vtkSmartPointer<vtkRenderer> filteredRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> filteredRenderer;
filteredRenderer->SetViewport(filteredViewport);
filteredRenderer->AddActor(filteredActor);
filteredRenderer->ResetCamera();
- filteredRenderer->SetBackground(colors->GetColor3d("LightSlateGray").GetData());
+ filteredRenderer->SetBackground(
+ colors->GetColor3d("LightSlateGray").GetData());
- vtkSmartPointer<vtkRenderWindow> renderWindow =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renderWindow;
renderWindow->SetSize(600, 300);
+ renderWindow->SetWindowName("GaussianSmooth");
renderWindow->AddRenderer(originalRenderer);
renderWindow->AddRenderer(filteredRenderer);
- vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
- vtkSmartPointer<vtkInteractorStyleImage> style =
- vtkSmartPointer<vtkInteractorStyleImage>::New();
+ vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+ vtkNew<vtkInteractorStyleImage> style;
renderWindowInteractor->SetInteractorStyle(style);
diff --git a/src/Cxx/ImageProcessing/HybridMedianComparison.cxx b/src/Cxx/ImageProcessing/HybridMedianComparison.cxx
index ccb3173189e5ae0b0353f388b44bd3cffb3bd74b..b749e0a78b247043f81d1e2e4ab1b531b6f77cf2 100644
--- a/src/Cxx/ImageProcessing/HybridMedianComparison.cxx
+++ b/src/Cxx/ImageProcessing/HybridMedianComparison.cxx
@@ -13,111 +13,98 @@
#include <vtkImageReader2Factory.h>
#include <vtkImageThreshold.h>
#include <vtkInteractorStyleImage.h>
+#include <vtkNew.h>
#include <vtkPointData.h>
-#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
#include <vtkSmartPointer.h>
#include <vector>
-namespace
-{
-void AddShotNoise(vtkSmartPointer<vtkImageData> &inputImage,
- vtkSmartPointer<vtkImageData> &outputImage,
- double amplitude,
- double noiseFraction,
- int extent[6]);
+namespace {
+void AddShotNoise(vtkImageData* inputImage, vtkImageData* outputImage,
+ double noiseAmplitude, double noiseFraction, int extent[6]);
}
-int main (int argc, char *argv[])
+
+int main(int argc, char* argv[])
{
// Verify input arguments
- if ( argc != 2 )
+ if (argc != 2)
{
- std::cout << "Usage: " << argv[0]
- << " Filename" << std::endl;
+ std::cout << "Usage: " << argv[0] << " Filename e.g. TestPattern.png"
+ << std::endl;
return EXIT_FAILURE;
}
// Read the image
- vtkSmartPointer<vtkImageReader2Factory> readerFactory =
- vtkSmartPointer<vtkImageReader2Factory>::New();
+ vtkNew<vtkImageReader2Factory> readerFactory;
vtkSmartPointer<vtkImageReader2> reader;
- reader.TakeReference(
- readerFactory->CreateImageReader2(argv[1]));
+ reader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
reader->SetFileName(argv[1]);
reader->Update();
int scalarRange[2];
scalarRange[0] =
- reader->GetOutput()->GetPointData()->GetScalars()->GetRange()[0];
+ reader->GetOutput()->GetPointData()->GetScalars()->GetRange()[0];
scalarRange[1] =
- reader->GetOutput()->GetPointData()->GetScalars()->GetRange()[1];
- std::cout << "Range: "
- << scalarRange[0] << ", " << scalarRange[1]
+ reader->GetOutput()->GetPointData()->GetScalars()->GetRange()[1];
+ std::cout << "Range: " << scalarRange[0] << ", " << scalarRange[1]
<< std::endl;
int middleSlice = (reader->GetOutput()->GetExtent()[5] -
- reader->GetOutput()->GetExtent()[4]) / 2;
+ reader->GetOutput()->GetExtent()[4]) /
+ 2;
// Work with double images
- vtkSmartPointer<vtkImageCast> cast =
- vtkSmartPointer<vtkImageCast>::New();
+ vtkNew<vtkImageCast> cast;
cast->SetInputConnection(reader->GetOutputPort());
cast->SetOutputScalarTypeToDouble();
cast->Update();
- vtkSmartPointer<vtkImageData> originalData =
- vtkSmartPointer<vtkImageData>::New();
+ vtkNew<vtkImageData> originalData;
originalData->DeepCopy(cast->GetOutput());
- vtkSmartPointer<vtkImageData> noisyData =
- vtkSmartPointer<vtkImageData>::New();
+ vtkNew<vtkImageData> noisyData;
- AddShotNoise(originalData, noisyData,
- 2000.0, .1, reader->GetOutput()->GetExtent());
- vtkSmartPointer<vtkImageMedian3D> median =
- vtkSmartPointer<vtkImageMedian3D>::New();
+ AddShotNoise(originalData, noisyData, 2000.0, .1,
+ reader->GetOutput()->GetExtent());
+ vtkNew<vtkImageMedian3D> median;
median->SetInputData(noisyData);
median->SetKernelSize(5, 5, 1);
- vtkSmartPointer<vtkImageHybridMedian2D> hybridMedian1 =
- vtkSmartPointer<vtkImageHybridMedian2D>::New();
+ vtkNew<vtkImageHybridMedian2D> hybridMedian1;
hybridMedian1->SetInputData(noisyData);
- vtkSmartPointer<vtkImageHybridMedian2D> hybridMedian =
- vtkSmartPointer<vtkImageHybridMedian2D>::New();
+ vtkNew<vtkImageHybridMedian2D> hybridMedian;
hybridMedian->SetInputConnection(hybridMedian1->GetOutputPort());
int colorWindow = (scalarRange[1] - scalarRange[0]);
int colorLevel = colorWindow / 2;
- vtkSmartPointer<vtkImageActor> originalActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> originalActor;
originalActor->GetMapper()->SetInputData(originalData);
originalActor->GetProperty()->SetColorWindow(colorWindow);
originalActor->GetProperty()->SetColorLevel(colorLevel);
originalActor->GetProperty()->SetInterpolationTypeToNearest();
originalActor->SetDisplayExtent(
- reader->GetDataExtent()[0], reader->GetDataExtent()[1],
- reader->GetDataExtent()[2], reader->GetDataExtent()[3],
- middleSlice, middleSlice);
+ reader->GetDataExtent()[0], reader->GetDataExtent()[1],
+ reader->GetDataExtent()[2], reader->GetDataExtent()[3], middleSlice,
+ middleSlice);
- vtkSmartPointer<vtkImageActor> noisyActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> noisyActor;
noisyActor->GetMapper()->SetInputData(noisyData);
noisyActor->GetProperty()->SetColorWindow(colorWindow);
noisyActor->GetProperty()->SetColorLevel(colorLevel);
noisyActor->GetProperty()->SetInterpolationTypeToNearest();
noisyActor->SetDisplayExtent(originalActor->GetDisplayExtent());
- vtkSmartPointer<vtkImageActor> hybridMedianActor =
- vtkSmartPointer<vtkImageActor>::New();
- hybridMedianActor->GetMapper()->SetInputConnection(hybridMedian->GetOutputPort());
+ vtkNew<vtkImageActor> hybridMedianActor;
+ hybridMedianActor->GetMapper()->SetInputConnection(
+ hybridMedian->GetOutputPort());
hybridMedianActor->GetProperty()->SetColorWindow(colorWindow);
hybridMedianActor->GetProperty()->SetColorLevel(colorLevel);
hybridMedianActor->GetProperty()->SetInterpolationTypeToNearest();
hybridMedianActor->SetDisplayExtent(originalActor->GetDisplayExtent());
- vtkSmartPointer<vtkImageActor> medianActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> medianActor;
medianActor->GetMapper()->SetInputConnection(median->GetOutputPort());
medianActor->GetProperty()->SetColorWindow(colorWindow);
medianActor->GetProperty()->SetColorLevel(colorLevel);
@@ -125,20 +112,16 @@ int main (int argc, char *argv[])
medianActor->SetDisplayExtent(originalActor->GetDisplayExtent());
// Setup renderers
- vtkSmartPointer<vtkRenderer> originalRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> originalRenderer;
originalRenderer->AddActor(originalActor);
- vtkSmartPointer<vtkRenderer> noisyRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> noisyRenderer;
noisyRenderer->AddActor(noisyActor);
- vtkSmartPointer<vtkRenderer> hybridRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> hybridRenderer;
hybridRenderer->AddActor(hybridMedianActor);
- vtkSmartPointer<vtkRenderer> medianRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> medianRenderer;
medianRenderer->AddActor(medianActor);
- std::vector<vtkSmartPointer<vtkRenderer> > renderers;
+ std::vector<vtkSmartPointer<vtkRenderer>> renderers;
renderers.push_back(originalRenderer);
renderers.push_back(noisyRenderer);
renderers.push_back(hybridRenderer);
@@ -149,30 +132,28 @@ int main (int argc, char *argv[])
unsigned int xGridDimensions = 2;
unsigned int yGridDimensions = 2;
- vtkSmartPointer<vtkRenderWindow> renderWindow =
- vtkSmartPointer<vtkRenderWindow>::New();
- renderWindow->SetSize(
- rendererSize * xGridDimensions, rendererSize * yGridDimensions);
+ vtkNew<vtkRenderWindow> renderWindow;
+ renderWindow->SetSize(rendererSize * xGridDimensions,
+ rendererSize * yGridDimensions);
for (int row = 0; row < static_cast<int>(yGridDimensions); row++)
{
for (int col = 0; col < static_cast<int>(xGridDimensions); col++)
{
int index = row * xGridDimensions + col;
// (xmin, ymin, xmax, ymax)
- double viewport[4] = {
- static_cast<double>(col) / xGridDimensions,
- static_cast<double>(yGridDimensions - (row + 1)) / yGridDimensions,
- static_cast<double>(col + 1) / xGridDimensions,
- static_cast<double>(yGridDimensions - row) / yGridDimensions};
+ double viewport[4] = {
+ static_cast<double>(col) / xGridDimensions,
+ static_cast<double>(yGridDimensions - (row + 1)) / yGridDimensions,
+ static_cast<double>(col + 1) / xGridDimensions,
+ static_cast<double>(yGridDimensions - row) / yGridDimensions};
renderers[index]->SetViewport(viewport);
renderWindow->AddRenderer(renderers[index]);
}
}
+ renderWindow->SetWindowName("HybridMedianComparison");
- vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
- vtkSmartPointer<vtkInteractorStyleImage> style =
- vtkSmartPointer<vtkInteractorStyleImage>::New();
+ vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+ vtkNew<vtkInteractorStyleImage> style;
renderWindowInteractor->SetInteractorStyle(style);
renderWindowInteractor->SetRenderWindow(renderWindow);
@@ -189,49 +170,39 @@ int main (int argc, char *argv[])
renderWindowInteractor->Initialize();
renderWindowInteractor->Start();
-
return EXIT_SUCCESS;
}
-namespace
-{
-void AddShotNoise(vtkSmartPointer<vtkImageData> &inputImage,
- vtkSmartPointer<vtkImageData> &outputImage,
- double noiseAmplitude,
- double noiseFraction,
- int extent[6])
+namespace {
+void AddShotNoise(vtkImageData* inputImage, vtkImageData* outputImage,
+ double noiseAmplitude, double noiseFraction, int extent[6])
{
- vtkSmartPointer<vtkImageNoiseSource> shotNoiseSource =
- vtkSmartPointer<vtkImageNoiseSource>::New();
+ vtkNew<vtkImageNoiseSource> shotNoiseSource;
shotNoiseSource->SetWholeExtent(extent);
shotNoiseSource->SetMinimum(0.0);
shotNoiseSource->SetMaximum(1.0);
-
- vtkSmartPointer<vtkImageThreshold> shotNoiseThresh1 =
- vtkSmartPointer<vtkImageThreshold>::New();
+
+ vtkNew<vtkImageThreshold> shotNoiseThresh1;
shotNoiseThresh1->SetInputConnection(shotNoiseSource->GetOutputPort());
shotNoiseThresh1->ThresholdByLower(1.0 - noiseFraction);
shotNoiseThresh1->SetInValue(0);
shotNoiseThresh1->SetOutValue(noiseAmplitude);
- vtkSmartPointer<vtkImageThreshold> shotNoiseThresh2 =
- vtkSmartPointer<vtkImageThreshold>::New();
+ vtkNew<vtkImageThreshold> shotNoiseThresh2;
shotNoiseThresh2->SetInputConnection(shotNoiseSource->GetOutputPort());
shotNoiseThresh2->ThresholdByLower(noiseFraction);
shotNoiseThresh2->SetInValue(1.0 - noiseAmplitude);
shotNoiseThresh2->SetOutValue(0.0);
- vtkSmartPointer<vtkImageMathematics> shotNoise =
- vtkSmartPointer<vtkImageMathematics>::New();
+ vtkNew<vtkImageMathematics> shotNoise;
shotNoise->SetInputConnection(0, shotNoiseThresh1->GetOutputPort());
shotNoise->SetInputConnection(1, shotNoiseThresh2->GetOutputPort());
shotNoise->SetOperationToAdd();
- vtkSmartPointer<vtkImageMathematics> add =
- vtkSmartPointer<vtkImageMathematics>::New();
+ vtkNew<vtkImageMathematics> add;
add->SetInputData(0, inputImage);
add->SetInputConnection(1, shotNoise->GetOutputPort());
add->SetOperationToAdd();
add->Update();
outputImage->DeepCopy(add->GetOutput());
}
-}
+} // namespace
diff --git a/src/Cxx/ImageProcessing/IdealHighPass.cxx b/src/Cxx/ImageProcessing/IdealHighPass.cxx
index d3b3ca84813b7463e1ead0c247bebf76c155423b..9b765dbcbdddcb007b89db60dbfb90a2742c74a8 100644
--- a/src/Cxx/ImageProcessing/IdealHighPass.cxx
+++ b/src/Cxx/ImageProcessing/IdealHighPass.cxx
@@ -4,123 +4,108 @@
#include <vtkImageExtractComponents.h>
#include <vtkImageFFT.h>
#include <vtkImageIdealHighPass.h>
-#include <vtkImageMapper3D.h>
#include <vtkImageMapToWindowLevelColors.h>
+#include <vtkImageMapper3D.h>
#include <vtkImageProperty.h>
+#include <vtkImageRFFT.h>
#include <vtkImageReader2.h>
#include <vtkImageReader2Factory.h>
-#include <vtkImageRFFT.h>
#include <vtkInteractorStyleImage.h>
#include <vtkNamedColors.h>
-#include <vtkRenderer.h>
+#include <vtkNew.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
#include <vtkSmartPointer.h>
- int main (int argc, char *argv[])
+int main(int argc, char* argv[])
{
// Verify input arguments
- if ( argc < 2 )
+ if (argc < 2)
{
- std::cout << "Usage: " << argv[0]
- << " Filename" << std::endl;
+ std::cout << "Usage: " << argv[0] << " Filename e.g. fullhead15.png"
+ << std::endl;
return EXIT_FAILURE;
}
// Read the image
- vtkSmartPointer<vtkImageReader2Factory> readerFactory =
- vtkSmartPointer<vtkImageReader2Factory>::New();
+ vtkNew<vtkImageReader2Factory> readerFactory;
vtkSmartPointer<vtkImageReader2> reader;
- reader.TakeReference(
- readerFactory->CreateImageReader2(argv[1]));
+ reader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
reader->SetFileName(argv[1]);
reader->Update();
- vtkSmartPointer<vtkImageFFT> fft =
- vtkSmartPointer<vtkImageFFT>::New();
+ vtkNew<vtkImageFFT> fft;
fft->SetInputConnection(reader->GetOutputPort());
- vtkSmartPointer<vtkImageIdealHighPass> idealHighPass =
- vtkSmartPointer<vtkImageIdealHighPass>::New();
+ vtkNew<vtkImageIdealHighPass> idealHighPass;
idealHighPass->SetInputConnection(fft->GetOutputPort());
idealHighPass->SetXCutOff(0.1);
idealHighPass->SetYCutOff(0.1);
- vtkSmartPointer<vtkImageRFFT> idealRfft =
- vtkSmartPointer<vtkImageRFFT>::New();
+ vtkNew<vtkImageRFFT> idealRfft;
idealRfft->SetInputConnection(idealHighPass->GetOutputPort());
-
- vtkSmartPointer<vtkImageExtractComponents> idealReal =
- vtkSmartPointer<vtkImageExtractComponents>::New();
+
+ vtkNew<vtkImageExtractComponents> idealReal;
idealReal->SetInputConnection(idealRfft->GetOutputPort());
idealReal->SetComponents(0);
- vtkSmartPointer<vtkImageButterworthHighPass> butterworthHighPass =
- vtkSmartPointer<vtkImageButterworthHighPass>::New();
+ vtkNew<vtkImageButterworthHighPass> butterworthHighPass;
butterworthHighPass->SetInputConnection(fft->GetOutputPort());
butterworthHighPass->SetXCutOff(0.1);
butterworthHighPass->SetYCutOff(0.1);
- vtkSmartPointer<vtkImageRFFT> butterworthRfft =
- vtkSmartPointer<vtkImageRFFT>::New();
+ vtkNew<vtkImageRFFT> butterworthRfft;
butterworthRfft->SetInputConnection(butterworthHighPass->GetOutputPort());
-
- vtkSmartPointer<vtkImageExtractComponents> butterworthReal =
- vtkSmartPointer<vtkImageExtractComponents>::New();
+
+ vtkNew<vtkImageExtractComponents> butterworthReal;
butterworthReal->SetInputConnection(butterworthRfft->GetOutputPort());
butterworthReal->SetComponents(0);
// Create actors
- vtkSmartPointer<vtkNamedColors> colors =
- vtkSmartPointer<vtkNamedColors>::New();
+ vtkNew<vtkNamedColors> colors;
- vtkSmartPointer<vtkImageMapToWindowLevelColors> idealColor =
- vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
+ vtkNew<vtkImageMapToWindowLevelColors> idealColor;
idealColor->SetWindow(500);
idealColor->SetLevel(0);
idealColor->SetInputConnection(idealReal->GetOutputPort());
- vtkSmartPointer<vtkImageActor> idealActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> idealActor;
idealActor->GetMapper()->SetInputConnection(idealColor->GetOutputPort());
idealActor->GetProperty()->SetInterpolationTypeToNearest();
- vtkSmartPointer<vtkImageMapToWindowLevelColors> butterworthColor =
- vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
+ vtkNew<vtkImageMapToWindowLevelColors> butterworthColor;
butterworthColor->SetWindow(500);
butterworthColor->SetLevel(0);
butterworthColor->SetInputConnection(butterworthReal->GetOutputPort());
- vtkSmartPointer<vtkImageActor> butterworthActor =
- vtkSmartPointer<vtkImageActor>::New();
- butterworthActor->GetMapper()->SetInputConnection(butterworthColor->GetOutputPort());
+ vtkNew<vtkImageActor> butterworthActor;
+ butterworthActor->GetMapper()->SetInputConnection(
+ butterworthColor->GetOutputPort());
butterworthActor->GetProperty()->SetInterpolationTypeToNearest();
// Setup renderers
- vtkSmartPointer<vtkRenderer> idealRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> idealRenderer;
idealRenderer->SetViewport(0.0, 0.0, 0.5, 1.0);
idealRenderer->AddActor(idealActor);
idealRenderer->ResetCamera();
idealRenderer->SetBackground(colors->GetColor3d("SlateGray").GetData());
- vtkSmartPointer<vtkRenderer> butterworthRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> butterworthRenderer;
butterworthRenderer->SetViewport(0.5, 0.0, 1.0, 1.0);
butterworthRenderer->AddActor(butterworthActor);
butterworthRenderer->SetActiveCamera(idealRenderer->GetActiveCamera());
- butterworthRenderer->SetBackground(colors->GetColor3d("LightSlateGray").GetData());
+ butterworthRenderer->SetBackground(
+ colors->GetColor3d("LightSlateGray").GetData());
- vtkSmartPointer<vtkRenderWindow> renderWindow =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renderWindow;
renderWindow->SetSize(600, 300);
+ renderWindow->SetWindowName("IdealHighPass");
renderWindow->AddRenderer(idealRenderer);
renderWindow->AddRenderer(butterworthRenderer);
- vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
- vtkSmartPointer<vtkInteractorStyleImage> style =
- vtkSmartPointer<vtkInteractorStyleImage>::New();
+ vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+ vtkNew<vtkInteractorStyleImage> style;
renderWindowInteractor->SetInteractorStyle(style);
diff --git a/src/Cxx/ImageProcessing/IdealHighPass.md b/src/Cxx/ImageProcessing/IdealHighPass.md
index c0029e059d95c433ad05a6c94042091e57471d2e..b6f8d0329a34f9fce5e1a7a6c7476af5025fe7a3 100644
--- a/src/Cxx/ImageProcessing/IdealHighPass.md
+++ b/src/Cxx/ImageProcessing/IdealHighPass.md
@@ -1,4 +1,5 @@
### Description
+
Low-pass and high-pass filtering become trivial in the frequency domain. A portion of the pixels are simply masked or attenuated. This example shows a high pass Butterworth filter that attenuates the frequency domain image with the function `out(i, j) = 1 / (1 + pow(CutOff/Freq(i,j), 2*Order))`.
The gradual attenuation of the filter is important. The ideal high-pass filter, shown in the same exaample, simply masks a set of pixels in the frequency domain. The abrupt transition causes a ringing effect in the spatial domain.
diff --git a/src/Cxx/ImageProcessing/IsoSubsample.cxx b/src/Cxx/ImageProcessing/IsoSubsample.cxx
index 0de8f7ac84c29ce46859390193e985a4e900b857..ea718e9bdbd59a7d50e183e03c5b24d897db611c 100644
--- a/src/Cxx/ImageProcessing/IsoSubsample.cxx
+++ b/src/Cxx/ImageProcessing/IsoSubsample.cxx
@@ -6,110 +6,96 @@
#include <vtkImageReader2Factory.h>
#include <vtkImageShrink3D.h>
#include <vtkNamedColors.h>
+#include <vtkNew.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
-#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
#include <vtkSmartPointer.h>
-#include <array>
+//#include <array>
-int main (int argc, char *argv[])
+int main(int argc, char* argv[])
{
// Verify input arguments
- if ( argc != 2 )
+ if (argc != 2)
{
- std::cout << "Usage: " << argv[0]
- << " Filename" << std::endl;
+ std::cout << "Usage: " << argv[0] << " Filename e.g FullHead.mhd"
+ << std::endl;
return EXIT_FAILURE;
}
- vtkSmartPointer<vtkNamedColors> colors =
- vtkSmartPointer<vtkNamedColors>::New();
+ vtkNew<vtkNamedColors> colors;
- std::array<unsigned char , 4> actorColor{{235, 235, 235, 255}};
- colors->SetColor("ActorColor", actorColor.data());
+ // std::array<unsigned char , 4> actorColor{{235, 235, 235, 255}};
+ // colors->SetColor("ActorColor", actorColor.data());
// Read the image
- vtkSmartPointer<vtkImageReader2Factory> readerFactory =
- vtkSmartPointer<vtkImageReader2Factory>::New();
+ vtkNew<vtkImageReader2Factory> readerFactory;
vtkSmartPointer<vtkImageReader2> reader;
- reader.TakeReference(
- readerFactory->CreateImageReader2(argv[1]));
+ reader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
reader->SetFileName(argv[1]);
reader->Update();
// Smoothed pipeline
- vtkSmartPointer<vtkImageGaussianSmooth> smooth =
- vtkSmartPointer<vtkImageGaussianSmooth>::New();
+ vtkNew<vtkImageGaussianSmooth> smooth;
smooth->SetDimensionality(3);
smooth->SetInputConnection(reader->GetOutputPort());
smooth->SetStandardDeviations(1.75, 1.75, 0.0);
smooth->SetRadiusFactor(2);
- vtkSmartPointer<vtkImageShrink3D> subsampleSmoothed =
- vtkSmartPointer<vtkImageShrink3D>::New();
+ vtkNew<vtkImageShrink3D> subsampleSmoothed;
subsampleSmoothed->SetInputConnection(smooth->GetOutputPort());
subsampleSmoothed->SetShrinkFactors(4, 4, 1);
- vtkSmartPointer<vtkImageMarchingCubes> isoSmoothed =
- vtkSmartPointer<vtkImageMarchingCubes>::New();
+ vtkNew<vtkImageMarchingCubes> isoSmoothed;
isoSmoothed->SetInputConnection(smooth->GetOutputPort());
isoSmoothed->SetValue(0, 1150);
- vtkSmartPointer<vtkPolyDataMapper> isoSmoothedMapper =
- vtkSmartPointer<vtkPolyDataMapper>::New();
+ vtkNew<vtkPolyDataMapper> isoSmoothedMapper;
isoSmoothedMapper->SetInputConnection(isoSmoothed->GetOutputPort());
isoSmoothedMapper->ScalarVisibilityOff();
- vtkSmartPointer<vtkActor> isoSmoothedActor =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> isoSmoothedActor;
isoSmoothedActor->SetMapper(isoSmoothedMapper);
- isoSmoothedActor->GetProperty()->SetColor(colors->GetColor3d("ActorColor").GetData());
+ isoSmoothedActor->GetProperty()->SetColor(
+ colors->GetColor3d("Ivory").GetData());
// Unsmoothed pipeline
// Sub sample the data
- vtkSmartPointer<vtkImageShrink3D> subsample =
- vtkSmartPointer<vtkImageShrink3D>::New();
+ vtkNew<vtkImageShrink3D> subsample;
subsample->SetInputConnection(reader->GetOutputPort());
subsample->SetShrinkFactors(4, 4, 1);
- vtkSmartPointer<vtkImageMarchingCubes> iso =
- vtkSmartPointer<vtkImageMarchingCubes>::New();
+ vtkNew<vtkImageMarchingCubes> iso;
iso->SetInputConnection(subsample->GetOutputPort());
iso->SetValue(0, 1150);
- vtkSmartPointer<vtkPolyDataMapper> isoMapper =
- vtkSmartPointer<vtkPolyDataMapper>::New();
+ vtkNew<vtkPolyDataMapper> isoMapper;
isoMapper->SetInputConnection(iso->GetOutputPort());
isoMapper->ScalarVisibilityOff();
- vtkSmartPointer<vtkActor> isoActor =
- vtkSmartPointer<vtkActor>::New();
+ vtkNew<vtkActor> isoActor;
isoActor->SetMapper(isoMapper);
- isoActor->GetProperty()->SetColor(colors->GetColor3d("ActorColor").GetData());
+ isoActor->GetProperty()->SetColor(colors->GetColor3d("Ivory").GetData());
// Rendering Pipeline
// Setup render window, renderer, and interactor
double leftViewport[4] = {0.0, 0.0, 0.5, 1.0};
double rightViewport[4] = {0.5, 0.0, 1.0, 1.0};
- vtkSmartPointer<vtkRenderer> rendererLeft =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> rendererLeft;
rendererLeft->SetViewport(leftViewport);
- vtkSmartPointer<vtkRenderer> rendererRight =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> rendererRight;
rendererRight->SetViewport(rightViewport);
- vtkSmartPointer<vtkRenderWindow> renderWindow =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renderWindow;
renderWindow->AddRenderer(rendererLeft);
renderWindow->AddRenderer(rendererRight);
- vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
+ vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
renderWindowInteractor->SetRenderWindow(renderWindow);
rendererLeft->AddActor(isoActor);
@@ -128,6 +114,7 @@ int main (int argc, char *argv[])
rendererRight->SetActiveCamera(rendererLeft->GetActiveCamera());
renderWindow->SetSize(640, 480);
+ renderWindow->SetWindowName("IsoSubsample");
renderWindow->Render();
renderWindowInteractor->Start();
diff --git a/src/Cxx/ImageProcessing/IsoSubsample.md b/src/Cxx/ImageProcessing/IsoSubsample.md
index eb1660c033482b368a1745cb8c2dde06751f4845..ad3df96ca7ef53d7445c87f57308fb459e540f19 100644
--- a/src/Cxx/ImageProcessing/IsoSubsample.md
+++ b/src/Cxx/ImageProcessing/IsoSubsample.md
@@ -1,4 +1,5 @@
### Description
+
An artifact called aliasing occurs when sub-sampling and is often associated with stair-stepping edges. Sampling theory proves that discrete sampled signals with spacing S, completely describe continuous functions composed of frequencies less than S/2. When a signal is sub-sampled, its capacity to hold high frequency information is reduced. However, the high frequency energy does not disappear. It wraps around the frequency spectrum appearing as a low frequency alias artifact. The solution, which eliminates this artifact, is to low-pass filter before sub-sampling.
Low-pass smoothing reduces the high frequency range of an image that would cause aliasing. The same aliasing phenomena occurs when acquiring data. If a signal from an analog source contains high frequencies, saving the analog data in a discrete form requires sub-sampling that will introduce alias artifacts. For this reason, it is common practice to acquire data at high resolutions,then smooth and subsample to reduce the image to a manageable size.
diff --git a/src/Cxx/ImageProcessing/MedianComparison.cxx b/src/Cxx/ImageProcessing/MedianComparison.cxx
index 131d639faf37eaa452e1947796dfa0a2d110026c..f1fcce64e2e8818247902f7db4545e2826bb8914 100644
--- a/src/Cxx/ImageProcessing/MedianComparison.cxx
+++ b/src/Cxx/ImageProcessing/MedianComparison.cxx
@@ -1,3 +1,4 @@
+#include <vtkCamera.h>
#include <vtkDataArray.h>
#include <vtkImageActor.h>
#include <vtkImageCast.h>
@@ -12,75 +13,65 @@
#include <vtkImageReader2Factory.h>
#include <vtkImageThreshold.h>
#include <vtkInteractorStyleImage.h>
+#include <vtkNew.h>
#include <vtkPointData.h>
-#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
#include <vtkSmartPointer.h>
#include <vector>
-namespace
-{
-void AddShotNoise(vtkSmartPointer<vtkImageData> &inputImage,
- vtkSmartPointer<vtkImageData> &outputImage,
- double amplitude,
- double noiseFraction,
- int extent[6]);
+namespace {
+void AddShotNoise(vtkImageData* inputImage, vtkImageData* outputImage,
+ double noiseAmplitude, double noiseFraction, int extent[6]);
}
-int main (int argc, char *argv[])
+
+int main(int argc, char* argv[])
{
// Verify input arguments
- if ( argc != 2 )
+ if (argc != 2)
{
- std::cout << "Usage: " << argv[0]
- << " Filename" << std::endl;
+ std::cout << "Usage: " << argv[0] << " Filename e.g. FullHead.mhd" << std::endl;
return EXIT_FAILURE;
}
// Read the image
- vtkSmartPointer<vtkImageReader2Factory> readerFactory =
- vtkSmartPointer<vtkImageReader2Factory>::New();
+ vtkNew<vtkImageReader2Factory> readerFactory;
vtkSmartPointer<vtkImageReader2> reader;
- reader.TakeReference(
- readerFactory->CreateImageReader2(argv[1]));
+ reader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
reader->SetFileName(argv[1]);
reader->Update();
int scalarRange[2];
scalarRange[0] =
- reader->GetOutput()->GetPointData()->GetScalars()->GetRange()[0];
+ reader->GetOutput()->GetPointData()->GetScalars()->GetRange()[0];
scalarRange[1] =
- reader->GetOutput()->GetPointData()->GetScalars()->GetRange()[1];
- std::cout << "Range: "
- << scalarRange[0] << ", " << scalarRange[1]
+ reader->GetOutput()->GetPointData()->GetScalars()->GetRange()[1];
+ std::cout << "Range: " << scalarRange[0] << ", " << scalarRange[1]
<< std::endl;
int middleSlice = (reader->GetOutput()->GetExtent()[5] -
- reader->GetOutput()->GetExtent()[4]) / 2;
+ reader->GetOutput()->GetExtent()[4]) /
+ 2;
// Work with double images
- vtkSmartPointer<vtkImageCast> cast =
- vtkSmartPointer<vtkImageCast>::New();
+ vtkNew<vtkImageCast> cast;
cast->SetInputConnection(reader->GetOutputPort());
cast->SetOutputScalarTypeToDouble();
cast->Update();
- vtkSmartPointer<vtkImageData> originalData =
- vtkSmartPointer<vtkImageData>::New();
+ vtkNew<vtkImageData> originalData;
originalData->DeepCopy(cast->GetOutput());
- vtkSmartPointer<vtkImageData> noisyData =
- vtkSmartPointer<vtkImageData>::New();
+ vtkNew<vtkImageData> noisyData;
- AddShotNoise(originalData, noisyData,
- 2000.0, .1, reader->GetOutput()->GetExtent());
- vtkSmartPointer<vtkImageMedian3D> median =
- vtkSmartPointer<vtkImageMedian3D>::New();
+ AddShotNoise(originalData, noisyData, 2000.0, .1,
+ reader->GetOutput()->GetExtent());
+ vtkNew<vtkImageMedian3D> median;
median->SetInputData(noisyData);
median->SetKernelSize(5, 5, 1);
- vtkSmartPointer<vtkImageGaussianSmooth> gaussian =
- vtkSmartPointer<vtkImageGaussianSmooth>::New();
+ vtkNew<vtkImageGaussianSmooth> gaussian;
gaussian->SetDimensionality(2);
gaussian->SetInputData(noisyData);
gaussian->SetStandardDeviations(2.0, 2.0);
@@ -88,32 +79,28 @@ int main (int argc, char *argv[])
int colorWindow = (scalarRange[1] - scalarRange[0]) * .8;
int colorLevel = colorWindow / 2;
- vtkSmartPointer<vtkImageActor> originalActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> originalActor;
originalActor->GetMapper()->SetInputData(originalData);
originalActor->GetProperty()->SetColorWindow(colorWindow);
originalActor->GetProperty()->SetColorLevel(colorLevel);
originalActor->GetProperty()->SetInterpolationTypeToNearest();
originalActor->SetZSlice(middleSlice);
- vtkSmartPointer<vtkImageActor> noisyActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> noisyActor;
noisyActor->GetMapper()->SetInputData(noisyData);
noisyActor->GetProperty()->SetColorWindow(colorWindow);
noisyActor->GetProperty()->SetColorLevel(colorLevel);
noisyActor->GetProperty()->SetInterpolationTypeToNearest();
noisyActor->SetZSlice(middleSlice);
- vtkSmartPointer<vtkImageActor> gaussianActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> gaussianActor;
gaussianActor->GetMapper()->SetInputConnection(gaussian->GetOutputPort());
gaussianActor->GetProperty()->SetColorWindow(colorWindow);
gaussianActor->GetProperty()->SetColorLevel(colorLevel);
gaussianActor->GetProperty()->SetInterpolationTypeToNearest();
gaussianActor->SetZSlice(middleSlice);
- vtkSmartPointer<vtkImageActor> medianActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> medianActor;
medianActor->GetMapper()->SetInputConnection(median->GetOutputPort());
medianActor->GetProperty()->SetColorWindow(colorWindow);
medianActor->GetProperty()->SetColorLevel(colorLevel);
@@ -121,20 +108,16 @@ int main (int argc, char *argv[])
medianActor->SetZSlice(middleSlice);
// Setup renderers
- vtkSmartPointer<vtkRenderer> originalRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> originalRenderer;
originalRenderer->AddActor(originalActor);
- vtkSmartPointer<vtkRenderer> noisyRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> noisyRenderer;
noisyRenderer->AddActor(noisyActor);
- vtkSmartPointer<vtkRenderer> gaussRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> gaussRenderer;
gaussRenderer->AddActor(gaussianActor);
- vtkSmartPointer<vtkRenderer> medianRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> medianRenderer;
medianRenderer->AddActor(medianActor);
- std::vector<vtkSmartPointer<vtkRenderer> > renderers;
+ std::vector<vtkSmartPointer<vtkRenderer>> renderers;
renderers.push_back(originalRenderer);
renderers.push_back(noisyRenderer);
renderers.push_back(gaussRenderer);
@@ -145,10 +128,9 @@ int main (int argc, char *argv[])
unsigned int xGridDimensions = 2;
unsigned int yGridDimensions = 2;
- vtkSmartPointer<vtkRenderWindow> renderWindow =
- vtkSmartPointer<vtkRenderWindow>::New();
- renderWindow->SetSize(
- rendererSize * xGridDimensions, rendererSize * yGridDimensions);
+ vtkNew<vtkRenderWindow> renderWindow;
+ renderWindow->SetSize(rendererSize * xGridDimensions,
+ rendererSize * yGridDimensions);
for (int row = 0; row < static_cast<int>(yGridDimensions); row++)
{
for (int col = 0; col < static_cast<int>(xGridDimensions); col++)
@@ -156,25 +138,26 @@ int main (int argc, char *argv[])
int index = row * xGridDimensions + col;
// (xmin, ymin, xmax, ymax)
double viewport[4] = {
- static_cast<double>(col) / xGridDimensions,
- static_cast<double>(yGridDimensions - (row + 1)) / yGridDimensions,
- static_cast<double>(col + 1) / xGridDimensions,
- static_cast<double>(yGridDimensions - row) / yGridDimensions};
+ static_cast<double>(col) / xGridDimensions,
+ static_cast<double>(yGridDimensions - (row + 1)) / yGridDimensions,
+ static_cast<double>(col + 1) / xGridDimensions,
+ static_cast<double>(yGridDimensions - row) / yGridDimensions};
renderers[index]->SetViewport(viewport);
renderWindow->AddRenderer(renderers[index]);
}
}
+ renderWindow->SetWindowName("MedianComparison");
- vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
- vtkSmartPointer<vtkInteractorStyleImage> style =
- vtkSmartPointer<vtkInteractorStyleImage>::New();
+ vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+ vtkNew<vtkInteractorStyleImage> style;
renderWindowInteractor->SetInteractorStyle(style);
renderWindowInteractor->SetRenderWindow(renderWindow);
// Renderers share one camera
renderWindow->Render();
+ renderers[0]->GetActiveCamera()->Dolly(1.5);
+ renderers[0]->ResetCameraClippingRange();
for (size_t r = 1; r < renderers.size(); ++r)
{
renderers[r]->SetActiveCamera(renderers[0]->GetActiveCamera());
@@ -184,46 +167,37 @@ int main (int argc, char *argv[])
return EXIT_SUCCESS;
}
-namespace
+namespace {
+void AddShotNoise(vtkImageData* inputImage, vtkImageData* outputImage,
+ double noiseAmplitude, double noiseFraction, int extent[6])
{
-void AddShotNoise(vtkSmartPointer<vtkImageData> &inputImage,
- vtkSmartPointer<vtkImageData> &outputImage,
- double noiseAmplitude,
- double noiseFraction,
- int extent[6])
-{
- vtkSmartPointer<vtkImageNoiseSource> shotNoiseSource =
- vtkSmartPointer<vtkImageNoiseSource>::New();
+ vtkNew<vtkImageNoiseSource> shotNoiseSource;
shotNoiseSource->SetWholeExtent(extent);
shotNoiseSource->SetMinimum(0.0);
shotNoiseSource->SetMaximum(1.0);
-
- vtkSmartPointer<vtkImageThreshold> shotNoiseThresh1 =
- vtkSmartPointer<vtkImageThreshold>::New();
+
+ vtkNew<vtkImageThreshold> shotNoiseThresh1;
shotNoiseThresh1->SetInputConnection(shotNoiseSource->GetOutputPort());
shotNoiseThresh1->ThresholdByLower(1.0 - noiseFraction);
shotNoiseThresh1->SetInValue(0);
shotNoiseThresh1->SetOutValue(noiseAmplitude);
- vtkSmartPointer<vtkImageThreshold> shotNoiseThresh2 =
- vtkSmartPointer<vtkImageThreshold>::New();
+ vtkNew<vtkImageThreshold> shotNoiseThresh2;
shotNoiseThresh2->SetInputConnection(shotNoiseSource->GetOutputPort());
shotNoiseThresh2->ThresholdByLower(noiseFraction);
shotNoiseThresh2->SetInValue(1.0 - noiseAmplitude);
shotNoiseThresh2->SetOutValue(0.0);
- vtkSmartPointer<vtkImageMathematics> shotNoise =
- vtkSmartPointer<vtkImageMathematics>::New();
+ vtkNew<vtkImageMathematics> shotNoise;
shotNoise->SetInputConnection(0, shotNoiseThresh1->GetOutputPort());
shotNoise->SetInputConnection(1, shotNoiseThresh2->GetOutputPort());
shotNoise->SetOperationToAdd();
- vtkSmartPointer<vtkImageMathematics> add =
- vtkSmartPointer<vtkImageMathematics>::New();
+ vtkNew<vtkImageMathematics> add;
add->SetInputData(0, inputImage);
add->SetInputConnection(1, shotNoise->GetOutputPort());
add->SetOperationToAdd();
add->Update();
outputImage->DeepCopy(add->GetOutput());
}
-}
+} // namespace
diff --git a/src/Cxx/ImageProcessing/MorphologyComparison.cxx b/src/Cxx/ImageProcessing/MorphologyComparison.cxx
index ab22436c7b25c6009e8d00d66818b65941bfb295..7053dd798012498fbf54f82d8b76da42f2ca51e9 100644
--- a/src/Cxx/ImageProcessing/MorphologyComparison.cxx
+++ b/src/Cxx/ImageProcessing/MorphologyComparison.cxx
@@ -9,81 +9,73 @@
#include <vtkImageReader2Factory.h>
#include <vtkImageSeedConnectivity.h>
#include <vtkInteractorStyleImage.h>
+#include <vtkNew.h>
#include <vtkPointData.h>
-#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
#include <vtkSmartPointer.h>
#include <vector>
-int main (int argc, char *argv[])
+int main(int argc, char* argv[])
{
// Verify input arguments
- if ( argc != 2 )
+ if (argc != 2)
{
- std::cout << "Usage: " << argv[0]
- << " Filename" << std::endl;
+ std::cout << "Usage: " << argv[0] << " Filename e.g. binary.pgm"
+ << std::endl;
return EXIT_FAILURE;
}
// Read the image
- vtkSmartPointer<vtkImageReader2Factory> readerFactory =
- vtkSmartPointer<vtkImageReader2Factory>::New();
+ vtkNew<vtkImageReader2Factory> readerFactory;
vtkSmartPointer<vtkImageReader2> reader;
- reader.TakeReference(
- readerFactory->CreateImageReader2(argv[1]));
+ reader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
reader->SetFileName(argv[1]);
// Dilate
- vtkSmartPointer<vtkImageDilateErode3D> dilate =
- vtkSmartPointer<vtkImageDilateErode3D>::New();
+ vtkNew<vtkImageDilateErode3D> dilate;
dilate->SetInputConnection(reader->GetOutputPort());
dilate->SetDilateValue(0);
dilate->SetErodeValue(255);
dilate->SetKernelSize(31, 31, 1);
// Erode
- vtkSmartPointer<vtkImageDilateErode3D> erode =
- vtkSmartPointer<vtkImageDilateErode3D>::New();
+ vtkNew<vtkImageDilateErode3D> erode;
erode->SetInputConnection(reader->GetOutputPort());
erode->SetDilateValue(255);
erode->SetErodeValue(0);
erode->SetKernelSize(31, 31, 1);
// Opening - dilate then erode
- vtkSmartPointer<vtkImageDilateErode3D> dilate1 =
- vtkSmartPointer<vtkImageDilateErode3D>::New();
+ vtkNew<vtkImageDilateErode3D> dilate1;
dilate1->SetInputConnection(reader->GetOutputPort());
dilate1->SetDilateValue(0);
dilate1->SetErodeValue(255);
dilate1->SetKernelSize(31, 31, 1);
- vtkSmartPointer<vtkImageDilateErode3D> erode1 =
- vtkSmartPointer<vtkImageDilateErode3D>::New();
+ vtkNew<vtkImageDilateErode3D> erode1;
erode1->SetInputConnection(dilate1->GetOutputPort());
erode1->SetDilateValue(255);
erode1->SetErodeValue(0);
erode1->SetKernelSize(31, 31, 1);
// Closing - erode then dilate
- vtkSmartPointer<vtkImageDilateErode3D> erode2 =
- vtkSmartPointer<vtkImageDilateErode3D>::New();
+ vtkNew<vtkImageDilateErode3D> erode2;
erode2->SetInputConnection(reader->GetOutputPort());
erode2->SetDilateValue(255);
erode2->SetErodeValue(0);
erode2->SetKernelSize(31, 31, 1);
- vtkSmartPointer<vtkImageDilateErode3D> dilate2 =
- vtkSmartPointer<vtkImageDilateErode3D>::New();
+ vtkNew<vtkImageDilateErode3D> dilate2;
dilate2->SetInputConnection(erode2->GetOutputPort());
dilate2->SetDilateValue(0);
dilate2->SetErodeValue(255);
dilate2->SetKernelSize(31, 31, 1);
// Connectivity
- vtkSmartPointer<vtkImageSeedConnectivity> con =
- vtkSmartPointer<vtkImageSeedConnectivity>::New();
+ vtkNew<vtkImageSeedConnectivity> con;
con->SetInputConnection(reader->GetOutputPort());
con->AddSeed(300, 200);
con->SetInputConnectValue(0);
@@ -91,93 +83,79 @@ int main (int argc, char *argv[])
con->SetOutputUnconnectedValue(255);
// Actors
- vtkSmartPointer<vtkImageActor> originalActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> originalActor;
originalActor->GetMapper()->SetInputConnection(reader->GetOutputPort());
originalActor->GetProperty()->SetInterpolationTypeToNearest();
- vtkSmartPointer<vtkImageActor> connectedActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> connectedActor;
connectedActor->GetMapper()->SetInputConnection(con->GetOutputPort());
connectedActor->GetProperty()->SetInterpolationTypeToNearest();
- vtkSmartPointer<vtkImageActor> erodeActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> erodeActor;
erodeActor->GetMapper()->SetInputConnection(erode->GetOutputPort());
erodeActor->GetProperty()->SetInterpolationTypeToNearest();
- vtkSmartPointer<vtkImageActor> dilateActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> dilateActor;
dilateActor->GetMapper()->SetInputConnection(dilate->GetOutputPort());
dilateActor->GetProperty()->SetInterpolationTypeToNearest();
- vtkSmartPointer<vtkImageActor> openingActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> openingActor;
openingActor->GetMapper()->SetInputConnection(dilate2->GetOutputPort());
openingActor->GetProperty()->SetInterpolationTypeToNearest();
- vtkSmartPointer<vtkImageActor> closingActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> closingActor;
closingActor->GetMapper()->SetInputConnection(erode1->GetOutputPort());
closingActor->GetProperty()->SetInterpolationTypeToNearest();
// Setup renderers
- vtkSmartPointer<vtkRenderer> originalRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> originalRenderer;
originalRenderer->AddActor(originalActor);
- vtkSmartPointer<vtkRenderer> connectedRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> connectedRenderer;
connectedRenderer->AddActor(connectedActor);
- vtkSmartPointer<vtkRenderer> dilateRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> dilateRenderer;
dilateRenderer->AddActor(dilateActor);
- vtkSmartPointer<vtkRenderer> erodeRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> erodeRenderer;
erodeRenderer->AddActor(erodeActor);
- vtkSmartPointer<vtkRenderer> closingRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> closingRenderer;
closingRenderer->AddActor(closingActor);
- vtkSmartPointer<vtkRenderer> openingRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> openingRenderer;
openingRenderer->AddActor(openingActor);
- std::vector<vtkSmartPointer<vtkRenderer> > renderers;
+ std::vector<vtkSmartPointer<vtkRenderer>> renderers;
renderers.push_back(originalRenderer);
renderers.push_back(connectedRenderer);
renderers.push_back(erodeRenderer);
renderers.push_back(dilateRenderer);
renderers.push_back(openingRenderer);
- renderers.push_back(closingRenderer);
+ renderers.push_back(closingRenderer);
// Setup viewports for the renderers
int rendererSize = 300;
unsigned int xGridDimensions = 2;
unsigned int yGridDimensions = 3;
- vtkSmartPointer<vtkRenderWindow> renderWindow =
- vtkSmartPointer<vtkRenderWindow>::New();
- renderWindow->SetSize(
- rendererSize * xGridDimensions, rendererSize * yGridDimensions);
+ vtkNew<vtkRenderWindow> renderWindow;
+ renderWindow->SetSize(rendererSize * xGridDimensions,
+ rendererSize * yGridDimensions);
for (int row = 0; row < static_cast<int>(yGridDimensions); row++)
{
for (int col = 0; col < static_cast<int>(xGridDimensions); col++)
{
int index = row * xGridDimensions + col;
// (xmin, ymin, xmax, ymax)
- double viewport[4] = {
- static_cast<double>(col) / xGridDimensions,
- static_cast<double>(yGridDimensions - (row + 1)) / yGridDimensions,
- static_cast<double>(col + 1) / xGridDimensions,
- static_cast<double>(yGridDimensions - row) / yGridDimensions};
+ double viewport[4] = {
+ static_cast<double>(col) / xGridDimensions,
+ static_cast<double>(yGridDimensions - (row + 1)) / yGridDimensions,
+ static_cast<double>(col + 1) / xGridDimensions,
+ static_cast<double>(yGridDimensions - row) / yGridDimensions};
renderers[index]->SetViewport(viewport);
renderWindow->AddRenderer(renderers[index]);
}
}
+ renderWindow->SetWindowName("MorphologyComparison");
- vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
- vtkSmartPointer<vtkInteractorStyleImage> style =
- vtkSmartPointer<vtkInteractorStyleImage>::New();
+ vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+ vtkNew<vtkInteractorStyleImage> style;
renderWindowInteractor->SetInteractorStyle(style);
renderWindowInteractor->SetRenderWindow(renderWindow);
diff --git a/src/Cxx/ImageProcessing/Pad.cxx b/src/Cxx/ImageProcessing/Pad.cxx
index 65ebb964e2664faf1b69bd73840ae3a660a26a5c..f0622e08461ae75d4496a143fa652235b3fe54e5 100644
--- a/src/Cxx/ImageProcessing/Pad.cxx
+++ b/src/Cxx/ImageProcessing/Pad.cxx
@@ -13,6 +13,7 @@
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSmartPointer.h>
+#include <vtkNew.h>
int main (int argc, char *argv[])
{
@@ -20,84 +21,72 @@
if ( argc < 2 )
{
std::cout << "Usage: " << argv[0]
- << " Filename" << std::endl;
+ << " Filename e.g. FullHead.mhd" << std::endl;
return EXIT_FAILURE;
}
// Read the image
- vtkSmartPointer<vtkImageReader2Factory> readerFactory =
- vtkSmartPointer<vtkImageReader2Factory>::New();
+ vtkNew<vtkImageReader2Factory> readerFactory;
vtkSmartPointer<vtkImageReader2> reader;
- reader.TakeReference(
- readerFactory->CreateImageReader2(argv[1]));
+ reader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
reader->SetFileName(argv[1]);
reader->Update();
// Pipelines
- vtkSmartPointer<vtkImageConstantPad> constantPad =
- vtkSmartPointer<vtkImageConstantPad>::New();
+ vtkNew<vtkImageConstantPad> constantPad;
constantPad->SetInputConnection(reader->GetOutputPort());
constantPad->SetConstant(800);
constantPad->SetOutputWholeExtent(-127, 383, -127, 383, 22, 22);
- vtkSmartPointer<vtkImageMirrorPad> mirrorPad =
- vtkSmartPointer<vtkImageMirrorPad>::New();
+ vtkNew<vtkImageMirrorPad> mirrorPad;
mirrorPad->SetInputConnection(reader->GetOutputPort());
mirrorPad->SetOutputWholeExtent(constantPad->GetOutputWholeExtent());
// Create actors
- vtkSmartPointer<vtkNamedColors> colors =
- vtkSmartPointer<vtkNamedColors>::New();
+ vtkNew<vtkNamedColors> colors;
- vtkSmartPointer<vtkImageMapToWindowLevelColors> constantPadColor =
- vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
+ vtkNew<vtkImageMapToWindowLevelColors> constantPadColor;
constantPadColor->SetWindow(2000);
constantPadColor->SetLevel(1000);
constantPadColor->SetInputConnection(constantPad->GetOutputPort());
- vtkSmartPointer<vtkImageActor> constantPadActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> constantPadActor;
constantPadActor->GetMapper()->SetInputConnection(
- constantPadColor->GetOutputPort());
+ constantPadColor->GetOutputPort());
constantPadActor->GetProperty()->SetInterpolationTypeToNearest();
- vtkSmartPointer<vtkImageMapToWindowLevelColors> mirrorPadColor =
- vtkSmartPointer<vtkImageMapToWindowLevelColors>::New();
+ vtkNew<vtkImageMapToWindowLevelColors> mirrorPadColor;
mirrorPadColor->SetWindow(2000);
mirrorPadColor->SetLevel(1000);
mirrorPadColor->SetInputConnection(mirrorPad->GetOutputPort());
- vtkSmartPointer<vtkImageActor> mirrorPadActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> mirrorPadActor;
mirrorPadActor->GetMapper()->SetInputConnection(
- mirrorPadColor->GetOutputPort());
+ mirrorPadColor->GetOutputPort());
mirrorPadActor->GetProperty()->SetInterpolationTypeToNearest();
// Setup renderers
- vtkSmartPointer<vtkRenderer> constantPadRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> constantPadRenderer;
constantPadRenderer->SetViewport(0.0, 0.0, 0.5, 1.0);
constantPadRenderer->AddActor(constantPadActor);
constantPadRenderer->ResetCamera();
constantPadRenderer->SetBackground(colors->GetColor3d("SlateGray").GetData());
- vtkSmartPointer<vtkRenderer> mirrorPadRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> mirrorPadRenderer;
mirrorPadRenderer->SetViewport(0.5, 0.0, 1.0, 1.0);
mirrorPadRenderer->AddActor(mirrorPadActor);
mirrorPadRenderer->SetActiveCamera(constantPadRenderer->GetActiveCamera());
- mirrorPadRenderer->SetBackground(colors->GetColor3d("LightSlateGray").GetData());
+ mirrorPadRenderer->SetBackground(
+ colors->GetColor3d("LightSlateGray").GetData());
- vtkSmartPointer<vtkRenderWindow> renderWindow =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renderWindow;
renderWindow->SetSize(600, 300);
+ renderWindow->SetWindowName("Pad");
renderWindow->AddRenderer(constantPadRenderer);
renderWindow->AddRenderer(mirrorPadRenderer);
- vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
- vtkSmartPointer<vtkInteractorStyleImage> style =
- vtkSmartPointer<vtkInteractorStyleImage>::New();
+ vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+ vtkNew<vtkInteractorStyleImage> style;
renderWindowInteractor->SetInteractorStyle(style);
diff --git a/src/Cxx/ImageProcessing/Pad.md b/src/Cxx/ImageProcessing/Pad.md
index cbad2978e9914db923a063092dbcf417f7f4cbc5..b1d5fb7df3247288d5de04aa40795394830cb58a 100644
--- a/src/Cxx/ImageProcessing/Pad.md
+++ b/src/Cxx/ImageProcessing/Pad.md
@@ -1,4 +1,5 @@
### Description
+
An important point about the discrete Fourier transform is that it treats the image as a periodic function. This means the pixels on the right border are adjacent to pixels on the left border. Since there is usually no physical relationship between these pixels, the artificial horizontal and vertical edges can distort the frequency spectrum and subsequent processing. To reduce these artifacts, the original image can be multiplied by a window function that becomes zero at the borders.
Another approach removes these artificial edges by smoothing only along the borders.
diff --git a/src/Cxx/ImageProcessing/RescaleAnImage.cxx b/src/Cxx/ImageProcessing/RescaleAnImage.cxx
index c869a267d2b7435c24d25906c9729e0abcdb8c49..d5a3952c4cb9da5187ab99360e620be4d1b02f7e 100644
--- a/src/Cxx/ImageProcessing/RescaleAnImage.cxx
+++ b/src/Cxx/ImageProcessing/RescaleAnImage.cxx
@@ -1,41 +1,53 @@
#include <vtkImageData.h>
#include <vtkImageShiftScale.h>
#include <vtkMath.h>
-#include <vtkSmartPointer.h>
+#include <vtkNew.h>
-static void CreateImage(vtkImageData* const image);
+namespace
+{
+ void CreateImage(vtkImageData* const image);
+}
-int main(int, char *[])
+int main(int, char*[])
{
- vtkSmartPointer<vtkImageData> image = vtkSmartPointer<vtkImageData>::New();
+ vtkNew<vtkImageData> image;
CreateImage(image);
- vtkSmartPointer<vtkImageShiftScale> shiftScaleFilter =
- vtkSmartPointer<vtkImageShiftScale>::New();
+ vtkNew<vtkImageShiftScale> shiftScaleFilter;
shiftScaleFilter->SetOutputScalarTypeToUnsignedChar();
shiftScaleFilter->SetInputData(image);
- shiftScaleFilter->SetShift(-1.0f * image->GetScalarRange()[0]); // brings the lower bound to 0
+ shiftScaleFilter->SetShift(
+ -1.0f * image->GetScalarRange()[0]); // brings the lower bound to 0
float oldRange = image->GetScalarRange()[1] - image->GetScalarRange()[0];
- std::cout << "Old range: [" << image->GetScalarRange()[0] << ", " << image->GetScalarRange()[1] << "]" << std::endl;
+ std::cout << "Old range: [" << image->GetScalarRange()[0] << ", "
+ << image->GetScalarRange()[1] << "]" << std::endl;
std::cout << "Old range magnitude: " << oldRange << std::endl;
float newRange = 255; // We want the output [0,255]
- shiftScaleFilter->SetScale(newRange/oldRange);
+ shiftScaleFilter->SetScale(newRange / oldRange);
shiftScaleFilter->Update();
- std::cout << "New range: [" << shiftScaleFilter->GetOutput()->GetScalarRange()[1] << ", " << shiftScaleFilter->GetOutput()->GetScalarRange()[1] << "]" << std::endl;
+ std::cout << "New range: ["
+ << shiftScaleFilter->GetOutput()->GetScalarRange()[1] << ", "
+ << shiftScaleFilter->GetOutput()->GetScalarRange()[1] << "]"
+ << std::endl;
+
return EXIT_SUCCESS;
}
+namespace {
+
void CreateImage(vtkImageData* const image)
{
// Specify the size of the image data
- image->SetDimensions(2,3,1);
- image->AllocateScalars(VTK_DOUBLE,1);
+ image->SetDimensions(2, 3, 1);
+ image->AllocateScalars(VTK_DOUBLE, 1);
int* dims = image->GetDimensions();
- std::cout << "Dims: " << " x: " << dims[0] << " y: " << dims[1] << " z: " << dims[2] << std::endl;
+ std::cout << "Dims: "
+ << " x: " << dims[0] << " y: " << dims[1] << " z: " << dims[2]
+ << std::endl;
for (int z = 0; z < dims[2]; z++)
{
@@ -43,9 +55,11 @@ void CreateImage(vtkImageData* const image)
{
for (int x = 0; x < dims[0]; x++)
{
- double* pixel = static_cast<double*>(image->GetScalarPointer(x,y,z));
- pixel[0] =vtkMath::Random(0.0,2000.0);
+ double* pixel = static_cast<double*>(image->GetScalarPointer(x, y, z));
+ pixel[0] = vtkMath::Random(0.0, 2000.0);
}
}
}
}
+
+} // namespace
diff --git a/src/Cxx/ImageProcessing/VTKSpectrum.cxx b/src/Cxx/ImageProcessing/VTKSpectrum.cxx
index 44688b7e75608fb536a4c4a209b4905b0eb4aae7..610030f2738a17bc93aa03d7b97d9179697b3cc8 100644
--- a/src/Cxx/ImageProcessing/VTKSpectrum.cxx
+++ b/src/Cxx/ImageProcessing/VTKSpectrum.cxx
@@ -4,74 +4,65 @@
#include <vtkImageFourierCenter.h>
#include <vtkImageLogarithmicScale.h>
#include <vtkImageMagnitude.h>
-#include <vtkImageMapper3D.h>
#include <vtkImageMapToColors.h>
+#include <vtkImageMapper3D.h>
#include <vtkImageProperty.h>
#include <vtkImageReader2.h>
#include <vtkImageReader2Factory.h>
#include <vtkInteractorStyleImage.h>
#include <vtkNamedColors.h>
-#include <vtkRenderer.h>
+#include <vtkNew.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
#include <vtkSmartPointer.h>
#include <vtkWindowLevelLookupTable.h>
-namespace
-{
-void CreateImageActor(vtkSmartPointer<vtkImageActor> &actor,
- double colorWindow, double colorLevel);
+namespace {
+
+void CreateImageActor(vtkImageActor* actor, double colorWindow,
+ double colorLevel);
}
- int main (int argc, char *argv[])
+
+int main(int argc, char* argv[])
{
// Verify input arguments
- if ( argc != 2 )
+ if (argc != 2)
{
- std::cout << "Usage: " << argv[0]
- << " Filename" << std::endl;
+ std::cout << "Usage: " << argv[0] << " Filename e.g. vtks.pgm" << std::endl;
return EXIT_FAILURE;
}
// Read the image
- vtkSmartPointer<vtkImageReader2Factory> readerFactory =
- vtkSmartPointer<vtkImageReader2Factory>::New();
+ vtkNew<vtkImageReader2Factory> readerFactory;
vtkSmartPointer<vtkImageReader2> reader;
- reader.TakeReference(
- readerFactory->CreateImageReader2(argv[1]));
+ reader.TakeReference(readerFactory->CreateImageReader2(argv[1]));
reader->SetFileName(argv[1]);
reader->Update();
-
- vtkSmartPointer<vtkImageFFT> fft =
- vtkSmartPointer<vtkImageFFT>::New();
-// fft->SetFilteredAxes $VTK_IMAGE_X_AXIS $VTK_IMAGE_Y_AXIS
+ vtkNew<vtkImageFFT> fft;
+ // fft->SetFilteredAxes $VTK_IMAGE_X_AXIS $VTK_IMAGE_Y_AXIS
fft->SetInputConnection(reader->GetOutputPort());
- vtkSmartPointer<vtkImageMagnitude> mag =
- vtkSmartPointer<vtkImageMagnitude>::New();
+ vtkNew<vtkImageMagnitude> mag;
mag->SetInputConnection(fft->GetOutputPort());
- vtkSmartPointer<vtkImageFourierCenter> center =
- vtkSmartPointer<vtkImageFourierCenter>::New();
+ vtkNew<vtkImageFourierCenter> center;
center->SetInputConnection(mag->GetOutputPort());
-
- vtkSmartPointer<vtkImageLogarithmicScale> compress =
- vtkSmartPointer<vtkImageLogarithmicScale>::New();
+
+ vtkNew<vtkImageLogarithmicScale> compress;
compress->SetInputConnection(center->GetOutputPort());
compress->SetConstant(15);
compress->Update();
// Create actors
- vtkSmartPointer<vtkNamedColors> colors =
- vtkSmartPointer<vtkNamedColors>::New();
+ vtkNew<vtkNamedColors> colors;
- vtkSmartPointer<vtkImageActor> originalActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> originalActor;
originalActor->GetMapper()->SetInputConnection(reader->GetOutputPort());
originalActor->GetProperty()->SetInterpolationTypeToNearest();
- vtkSmartPointer<vtkImageActor> compressedActor =
- vtkSmartPointer<vtkImageActor>::New();
+ vtkNew<vtkImageActor> compressedActor;
compressedActor->GetMapper()->SetInputConnection(compress->GetOutputPort());
compressedActor->GetProperty()->SetInterpolationTypeToNearest();
CreateImageActor(compressedActor, 160, 120);
@@ -82,30 +73,27 @@ void CreateImageActor(vtkSmartPointer<vtkImageActor> &actor,
double compressedViewport[4] = {0.5, 0.0, 1.0, 1.0};
// Setup renderers
- vtkSmartPointer<vtkRenderer> originalRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> originalRenderer;
originalRenderer->SetViewport(originalViewport);
originalRenderer->AddActor(originalActor);
originalRenderer->ResetCamera();
originalRenderer->SetBackground(colors->GetColor3d("SlateGray").GetData());
- vtkSmartPointer<vtkRenderer> compressedRenderer =
- vtkSmartPointer<vtkRenderer>::New();
+ vtkNew<vtkRenderer> compressedRenderer;
compressedRenderer->SetViewport(compressedViewport);
compressedRenderer->AddActor(compressedActor);
compressedRenderer->ResetCamera();
- compressedRenderer->SetBackground(colors->GetColor3d("LightSlateGray").GetData());
+ compressedRenderer->SetBackground(
+ colors->GetColor3d("LightSlateGray").GetData());
- vtkSmartPointer<vtkRenderWindow> renderWindow =
- vtkSmartPointer<vtkRenderWindow>::New();
+ vtkNew<vtkRenderWindow> renderWindow;
renderWindow->SetSize(600, 300);
+ renderWindow->SetWindowName("VTKSpectrum");
renderWindow->AddRenderer(originalRenderer);
renderWindow->AddRenderer(compressedRenderer);
- vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
- vtkSmartPointer<vtkRenderWindowInteractor>::New();
- vtkSmartPointer<vtkInteractorStyleImage> style =
- vtkSmartPointer<vtkInteractorStyleImage>::New();
+ vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
+ vtkNew<vtkInteractorStyleImage> style;
renderWindowInteractor->SetInteractorStyle(style);
@@ -118,24 +106,23 @@ void CreateImageActor(vtkSmartPointer<vtkImageActor> &actor,
return EXIT_SUCCESS;
}
-namespace
-{
-void CreateImageActor(vtkSmartPointer<vtkImageActor> &actor,
- double colorWindow, double colorLevel)
+namespace {
+
+void CreateImageActor(vtkImageActor* actor, double colorWindow,
+ double colorLevel)
{
- vtkSmartPointer<vtkWindowLevelLookupTable> wlut =
- vtkSmartPointer<vtkWindowLevelLookupTable>::New();
+ vtkNew<vtkWindowLevelLookupTable> wlut;
wlut->SetWindow(colorWindow);
wlut->SetLevel(colorLevel);
wlut->Build();
// Map the image through the lookup table
- vtkSmartPointer<vtkImageMapToColors> color =
- vtkSmartPointer<vtkImageMapToColors>::New();
+ vtkNew<vtkImageMapToColors> color;
color->SetLookupTable(wlut);
color->SetInputData(actor->GetMapper()->GetInput());
actor->GetMapper()->SetInputConnection(color->GetOutputPort());
return;
}
-}
+
+} // namespace
diff --git a/src/Cxx/ImageProcessing/VTKSpectrum.md b/src/Cxx/ImageProcessing/VTKSpectrum.md
index c8aab47d5960d4fa60af959862607158090dc8e0..269649f60e07eb1dfc798ce0f910dfa7f68d188b 100644
--- a/src/Cxx/ImageProcessing/VTKSpectrum.md
+++ b/src/Cxx/ImageProcessing/VTKSpectrum.md
@@ -1,4 +1,5 @@
### Description
+
The discrete Fourier transform changes an image from the spatial domain into the frequency domain, where each pixel represents a sinusoidal function. This example shows an image and its power spectrum displayed using a logarithmic transfer function.
!!! info
diff --git a/src/Python/ImageProcessing/Attenuation.md b/src/Python/ImageProcessing/Attenuation.md
new file mode 100644
index 0000000000000000000000000000000000000000..f625d8cc4177df9a9927c758f418522a6d607852
--- /dev/null
+++ b/src/Python/ImageProcessing/Attenuation.md
@@ -0,0 +1,6 @@
+### Description
+
+This MRI image illustrates attenuation that can occur due to sensor position. The artifact is removed by dividing by the attenuation profile determined manually. This histograms shows how the artifact hides information in the form of scalar value clusters.
+
+!!! info
+ See [this figure](/VTKBook/10Chapter10/#Figure%2010-6) in [Chapter 10](/VTKBook/10Chapter10) the [VTK Textbook](/VTKBook/01Chapter1).
diff --git a/src/Python/ImageProcessing/Attenuation.py b/src/Python/ImageProcessing/Attenuation.py
index 6a6d2baa8c147ae6cffde0613721917daee62148..3eb3b44701575f2bdc473c1ece53715cf0e92406 100755
--- a/src/Python/ImageProcessing/Attenuation.py
+++ b/src/Python/ImageProcessing/Attenuation.py
@@ -77,6 +77,7 @@ def main():
renderWindow.SetSize(600, 300)
renderWindow.AddRenderer(originalRenderer)
renderWindow.AddRenderer(filteredRenderer)
+ renderWindow.SetWindowName('Attenuation')
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
diff --git a/src/Python/ImageProcessing/EnhanceEdges.md b/src/Python/ImageProcessing/EnhanceEdges.md
index b882d91a8058775022b6b0cdc974efd906314e30..d241ef3d58155a72ccc28d1b7c1e8f2e64de7ae5 100644
--- a/src/Python/ImageProcessing/EnhanceEdges.md
+++ b/src/Python/ImageProcessing/EnhanceEdges.md
@@ -1,4 +1,8 @@
### Description
+
High-pass filters can also be used to compress the range of an image. Since low frequencies account for much of the dynamic range of an image but carry little information, a high-pass filter can significantly decrease an image’s scalar range and emphasize hidden details. The Laplacian filter, which is a second derivative operation, is one implementation of a high-pass filter. It eliminates constant and low frequencies leaving only high-frequency edges. The output of the Laplacian can be subtracted from the original image to produce edge enhancement or sharpening of an image.
-This example subtracts the Laplacian (middle) from the original image (left) resulting in edge enhancement or a sharpening operation (right).
\ No newline at end of file
+This example subtracts the Laplacian (middle) from the original image (left) resulting in edge enhancement or a sharpening operation (right).
+
+!!! info
+ See [this figure](/VTKBook/10Chapter10/#Figure%2010-9) in [Chapter 10](/VTKBook/10Chapter10) the [VTK Textbook](/VTKBook/01Chapter1).
diff --git a/src/Python/ImageProcessing/EnhanceEdges.py b/src/Python/ImageProcessing/EnhanceEdges.py
index b76739b48d5b08523cd8b10bf4fe9f372eb5ecc0..334e59bea2856ad232e98ebd999c4bf2ca76c43f 100755
--- a/src/Python/ImageProcessing/EnhanceEdges.py
+++ b/src/Python/ImageProcessing/EnhanceEdges.py
@@ -103,6 +103,7 @@ def main():
float(col + 1) / xGridDimensions, float(yGridDimensions - row) / yGridDimensions]
renderers[index].SetViewport(viewport)
renderWindow.AddRenderer(renderers[index])
+ renderWindow.SetWindowName('EnhanceEdges')
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
diff --git a/src/Python/ImageProcessing/GaussianSmooth.md b/src/Python/ImageProcessing/GaussianSmooth.md
new file mode 100644
index 0000000000000000000000000000000000000000..96e94afb4623dffbd0d595c1312aad2594dd0008
--- /dev/null
+++ b/src/Python/ImageProcessing/GaussianSmooth.md
@@ -0,0 +1,6 @@
+### Description
+
+Low-pass filters can be implemented as convolution with a Gaussian kernel. The Gaussian kernel displayed on top has been magnified for this figure.
+
+!!! info
+ See [this figure](/VTKBook/10Chapter10/#Figure%2010-2) in [Chapter 10](/VTKBook/10Chapter10) the [VTK Textbook](/VTKBook/01Chapter1).
diff --git a/src/Python/ImageProcessing/GaussianSmooth.py b/src/Python/ImageProcessing/GaussianSmooth.py
index 0c04ebfa578da7dc701b01c08b71fcba4670fd3a..a8d56432ed10188c4c8a9677f1ce3dc47516e726 100755
--- a/src/Python/ImageProcessing/GaussianSmooth.py
+++ b/src/Python/ImageProcessing/GaussianSmooth.py
@@ -57,6 +57,7 @@ def main():
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(600, 300)
+ renderWindow.SetWindowName('GaussianSmooth')
renderWindow.AddRenderer(originalRenderer)
renderWindow.AddRenderer(filteredRenderer)
diff --git a/src/Python/ImageProcessing/HybridMedianComparison.md b/src/Python/ImageProcessing/HybridMedianComparison.md
new file mode 100644
index 0000000000000000000000000000000000000000..e236812b3da343e46af303e0689a0a8c50c3c54f
--- /dev/null
+++ b/src/Python/ImageProcessing/HybridMedianComparison.md
@@ -0,0 +1,6 @@
+### Description
+
+Comparison of median and hybrid-median filters. The hybrid filter preserves corners and thin lines, better than the median filter. The lower patterns represent the three neighborhoods used to compute the hybrid median.
+
+!!! info
+ See [this figure](/VTKBook/10Chapter10/#Figure%2010-4) in [Chapter 10](/VTKBook/10Chapter10) the [VTK Textbook](/VTKBook/01Chapter1).
diff --git a/src/Python/ImageProcessing/HybridMedianComparison.py b/src/Python/ImageProcessing/HybridMedianComparison.py
index 7962358777d2b37d7e4ec24083c77e9caab4836c..4be372fcdc7a7c600978fdabe0067cc82ff1d098 100755
--- a/src/Python/ImageProcessing/HybridMedianComparison.py
+++ b/src/Python/ImageProcessing/HybridMedianComparison.py
@@ -106,6 +106,7 @@ def main():
float(col + 1) / xGridDimensions, float(yGridDimensions - row) / yGridDimensions]
renderers[index].SetViewport(viewport)
renderWindow.AddRenderer(renderers[index])
+ renderWindow.SetWindowName('HybridMedianComparison')
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
@@ -115,6 +116,8 @@ def main():
# The renderers share one camera.
renderWindow.Render()
+ renderers[0].GetActiveCamera().Dolly(1.5)
+ renderers[0].ResetCameraClippingRange()
for r in range(1, len(renderers)):
renderers[r].SetActiveCamera(renderers[0].GetActiveCamera())
renderWindowInteractor.Initialize()
diff --git a/src/Python/ImageProcessing/IdealHighPass.md b/src/Python/ImageProcessing/IdealHighPass.md
index 4194707ef549f71906921ea63e2b6e632070e785..b6f8d0329a34f9fce5e1a7a6c7476af5025fe7a3 100644
--- a/src/Python/ImageProcessing/IdealHighPass.md
+++ b/src/Python/ImageProcessing/IdealHighPass.md
@@ -1,4 +1,9 @@
### Description
+
Low-pass and high-pass filtering become trivial in the frequency domain. A portion of the pixels are simply masked or attenuated. This example shows a high pass Butterworth filter that attenuates the frequency domain image with the function `out(i, j) = 1 / (1 + pow(CutOff/Freq(i,j), 2*Order))`.
-The gradual attenuation of the filter is important. The ideal high-pass filter, shown in the same exaample, simply masks a set of pixels in the frequency domain. The abrupt transition causes a ringing effect in the spatial domain.
\ No newline at end of file
+The gradual attenuation of the filter is important. The ideal high-pass filter, shown in the same exaample, simply masks a set of pixels in the frequency domain. The abrupt transition causes a ringing effect in the spatial domain.
+
+!!! info
+ See [this figure](/VTKBook/10Chapter10/#Figure%2010-11) in [Chapter 10](/VTKBook/10Chapter10) the [VTK Textbook](/VTKBook/01Chapter1).
+
diff --git a/src/Python/ImageProcessing/IdealHighPass.py b/src/Python/ImageProcessing/IdealHighPass.py
index 3c27dc3c5ae0180be8014c9c34b6707c9392a0bc..6616caa6696cb147668ccaad47ff3ea6bebae575 100755
--- a/src/Python/ImageProcessing/IdealHighPass.py
+++ b/src/Python/ImageProcessing/IdealHighPass.py
@@ -78,6 +78,7 @@ def main():
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(600, 300)
+ renderWindow.SetWindowName('IdealHighPass')
renderWindow.AddRenderer(idealRenderer)
renderWindow.AddRenderer(butterworthRenderer)
diff --git a/src/Python/ImageProcessing/IsoSubsample.md b/src/Python/ImageProcessing/IsoSubsample.md
index 800e446e31e5f24c580401f8eccc28d4e3ce315b..ad3df96ca7ef53d7445c87f57308fb459e540f19 100644
--- a/src/Python/ImageProcessing/IsoSubsample.md
+++ b/src/Python/ImageProcessing/IsoSubsample.md
@@ -1,4 +1,5 @@
### Description
+
An artifact called aliasing occurs when sub-sampling and is often associated with stair-stepping edges. Sampling theory proves that discrete sampled signals with spacing S, completely describe continuous functions composed of frequencies less than S/2. When a signal is sub-sampled, its capacity to hold high frequency information is reduced. However, the high frequency energy does not disappear. It wraps around the frequency spectrum appearing as a low frequency alias artifact. The solution, which eliminates this artifact, is to low-pass filter before sub-sampling.
Low-pass smoothing reduces the high frequency range of an image that would cause aliasing. The same aliasing phenomena occurs when acquiring data. If a signal from an analog source contains high frequencies, saving the analog data in a discrete form requires sub-sampling that will introduce alias artifacts. For this reason, it is common practice to acquire data at high resolutions,then smooth and subsample to reduce the image to a manageable size.
@@ -6,4 +7,7 @@ Low-pass smoothing reduces the high frequency range of an image that would cause
This example demonstrates aliasing that occurs when a high-frequency signal is sub-sampled. High frequencies appear as low frequency artifacts. The left image is an isosurface of a skull after sub-sampling. The right image used a low-pass filter before sub-sampling to reduce aliasing.
!!! note
- This example uses the [FullHead.mhd](https://github.com/lorensen/VTKExamples/blob/master/src/Testing/Data/FullHead.mhd), [FullHead.raw.gz](https://github.com/lorensen/VTKExamples/blob/master/src/Testing/Data/FullHead.raw.gz) dataset.
\ No newline at end of file
+ This example uses the [FullHead.mhd](https://github.com/lorensen/VTKExamples/blob/master/src/Testing/Data/FullHead.mhd), [FullHead.raw.gz](https://github.com/lorensen/VTKExamples/blob/master/src/Testing/Data/FullHead.raw.gz) dataset.
+
+!!! info
+ See [this figure](/VTKBook/10Chapter10/#Figure%2010-5) in [Chapter 10](/VTKBook/10Chapter10) the [VTK Textbook](/VTKBook/01Chapter1).
diff --git a/src/Python/ImageProcessing/IsoSubsample.py b/src/Python/ImageProcessing/IsoSubsample.py
index 26d9fce7f43db95cc0fb8551ed0889cd6e375056..170c6804458abaa8314cee2191f80adf0a9c9436 100755
--- a/src/Python/ImageProcessing/IsoSubsample.py
+++ b/src/Python/ImageProcessing/IsoSubsample.py
@@ -8,9 +8,7 @@ import vtk
def main():
colors = vtk.vtkNamedColors()
-
- colors.SetColor("ActorColor", [235, 235, 235, 255])
-
+ # colors.SetColor("ActorColor", [235, 235, 235, 255])
fileName = get_program_parameters()
@@ -41,7 +39,7 @@ def main():
isoSmoothedActor = vtk.vtkActor()
isoSmoothedActor.SetMapper(isoSmoothedMapper)
- isoSmoothedActor.GetProperty().SetColor(colors.GetColor3d("ActorColor"))
+ isoSmoothedActor.GetProperty().SetColor(colors.GetColor3d("Ivory"))
# Unsmoothed pipeline.
# Sub sample the data.
@@ -59,7 +57,7 @@ def main():
isoActor = vtk.vtkActor()
isoActor.SetMapper(isoMapper)
- isoActor.GetProperty().SetColor(colors.GetColor3d("ActorColor"))
+ isoActor.GetProperty().SetColor(colors.GetColor3d("Ivory"))
# The rendering Pipeline.
@@ -96,6 +94,7 @@ def main():
rendererRight.SetActiveCamera(rendererLeft.GetActiveCamera())
renderWindow.SetSize(640, 480)
+ renderWindow.SetWindowName('IsoSubsample')
renderWindow.Render()
renderWindowInteractor.Start()
diff --git a/src/Python/ImageProcessing/MedianComparison.md b/src/Python/ImageProcessing/MedianComparison.md
new file mode 100644
index 0000000000000000000000000000000000000000..6d972f2ea1e1caab999468c38b6520bd983cac50
--- /dev/null
+++ b/src/Python/ImageProcessing/MedianComparison.md
@@ -0,0 +1,6 @@
+### Description
+
+Comparison of Gaussian and Median smoothing for reducing low-probability high-amplitude noise.
+
+!!! info
+ See [this figure](/VTKBook/10Chapter10/#Figure%2010-3) in [Chapter 10](/VTKBook/10Chapter10) the [VTK Textbook](/VTKBook/01Chapter1).
diff --git a/src/Python/ImageProcessing/MedianComparison.py b/src/Python/ImageProcessing/MedianComparison.py
index 02c85d786e9120201a65c516a9ca82b079c79176..ebe2e753a726bf3855db9afecc35d3830fd132a4 100755
--- a/src/Python/ImageProcessing/MedianComparison.py
+++ b/src/Python/ImageProcessing/MedianComparison.py
@@ -107,6 +107,7 @@ def main():
float(col + 1) / xGridDimensions, float(yGridDimensions - row) / yGridDimensions]
renderers[index].SetViewport(viewport)
renderWindow.AddRenderer(renderers[index])
+ renderWindow.SetWindowName('MedianComparison')
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
@@ -116,6 +117,8 @@ def main():
# The renderers share one camera.
renderWindow.Render()
+ renderers[0].GetActiveCamera().Dolly(1.5)
+ renderers[0].ResetCameraClippingRange()
for r in range(1, len(renderers)):
renderers[r].SetActiveCamera(renderers[0].GetActiveCamera())
renderWindowInteractor.Initialize()
diff --git a/src/Python/ImageProcessing/MorphologyComparison.md b/src/Python/ImageProcessing/MorphologyComparison.md
index 0071d009ff7f5bb49d002019da9453accea12b69..df4b02b0ec7983193202aff8b214f5f9d830aa12 100644
--- a/src/Python/ImageProcessing/MorphologyComparison.md
+++ b/src/Python/ImageProcessing/MorphologyComparison.md
@@ -14,3 +14,6 @@ Connectivity filters can also remove small regions without affecting the remaini
This example demonstrates various binary filters that can alter the shape of
segmented regions. From left to right, top to bottom: original image, connectivity, erosion, dilation, opeoing, closing.
+
+!!! info
+ See [this figure](/VTKBook/10Chapter10/#Figure%2010-14) in [Chapter 10](/VTKBook/10Chapter10) the [VTK Textbook](/VTKBook/01Chapter1).
diff --git a/src/Python/ImageProcessing/MorphologyComparison.py b/src/Python/ImageProcessing/MorphologyComparison.py
index ddacb1ad5be4a5d4d5178e76395746dfb5e6d8df..870175341eaccf2a00bca9240e7a53d8696efd52 100755
--- a/src/Python/ImageProcessing/MorphologyComparison.py
+++ b/src/Python/ImageProcessing/MorphologyComparison.py
@@ -128,6 +128,7 @@ def main():
float(col + 1) / xGridDimensions, float(yGridDimensions - row) / yGridDimensions]
renderers[index].SetViewport(viewport)
renderWindow.AddRenderer(renderers[index])
+ renderWindow.SetWindowName('MorphologyComparison')
renderWindowInteractor = vtk.vtkRenderWindowInteractor()
style = vtk.vtkInteractorStyleImage()
diff --git a/src/Python/ImageProcessing/Pad.md b/src/Python/ImageProcessing/Pad.md
index f8f0dfa175b2508834578618d1ec098b347c8a90..b1d5fb7df3247288d5de04aa40795394830cb58a 100644
--- a/src/Python/ImageProcessing/Pad.md
+++ b/src/Python/ImageProcessing/Pad.md
@@ -1,4 +1,5 @@
### Description
+
An important point about the discrete Fourier transform is that it treats the image as a periodic function. This means the pixels on the right border are adjacent to pixels on the left border. Since there is usually no physical relationship between these pixels, the artificial horizontal and vertical edges can distort the frequency spectrum and subsequent processing. To reduce these artifacts, the original image can be multiplied by a window function that becomes zero at the borders.
Another approach removes these artificial edges by smoothing only along the borders.
@@ -6,3 +7,6 @@ Another approach removes these artificial edges by smoothing only along the bord
In both of these approaches, a portion of the original image is lost, so only the central portion of an image can be processed. If this is unacceptable, another solution is to double the dimensions of the original image with a mirror-padding filter. The intermediate image is periodic and continuous.
The lower-left image has been padded with a constant (800). On the right, mirror padding has been used to remove artificial edges introduced by borders.
+
+!!! info
+ See [Figure 10-12](/VTKBook/10Chapter10/#Figure%2010-12) in [Chapter 10](/VTKBook/10Chapter10) the [VTK Textbook](/VTKBook/01Chapter1).
diff --git a/src/Python/ImageProcessing/Pad.py b/src/Python/ImageProcessing/Pad.py
index f2485a3fa50f0d994f83d1f6461f37c807cbe701..3c695969095051bbb43e64ccdfe8a3bf0fa1875f 100755
--- a/src/Python/ImageProcessing/Pad.py
+++ b/src/Python/ImageProcessing/Pad.py
@@ -63,6 +63,7 @@ def main():
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(600, 300)
+ renderWindow.SetWindowName('Pad')
renderWindow.AddRenderer(constantPadRenderer)
renderWindow.AddRenderer(mirrorPadRenderer)
diff --git a/src/Python/ImageProcessing/VTKSpectrum.md b/src/Python/ImageProcessing/VTKSpectrum.md
index e6e2f83cfca7ab6086d080cfbe564913cc32188f..269649f60e07eb1dfc798ce0f910dfa7f68d188b 100644
--- a/src/Python/ImageProcessing/VTKSpectrum.md
+++ b/src/Python/ImageProcessing/VTKSpectrum.md
@@ -1,2 +1,6 @@
### Description
+
The discrete Fourier transform changes an image from the spatial domain into the frequency domain, where each pixel represents a sinusoidal function. This example shows an image and its power spectrum displayed using a logarithmic transfer function.
+
+!!! info
+ See [Figure 10-10](/VTKBook/10Chapter10/#Figure%2010-10) in [Chapter 10](/VTKBook/10Chapter10) the [VTK Textbook](/VTKBook/01Chapter1).
diff --git a/src/Python/ImageProcessing/VTKSpectrum.py b/src/Python/ImageProcessing/VTKSpectrum.py
index 6774571d09744baa1906458f192e9c906fb59c8c..df530d9d1def9110bd517bf7068d3bf57ee00a14 100755
--- a/src/Python/ImageProcessing/VTKSpectrum.py
+++ b/src/Python/ImageProcessing/VTKSpectrum.py
@@ -61,6 +61,7 @@ def main():
renderWindow = vtk.vtkRenderWindow()
renderWindow.SetSize(600, 300)
+ renderWindow.SetWindowName('VTKSpectrum')
renderWindow.AddRenderer(originalRenderer)
renderWindow.AddRenderer(compressedRenderer)