VTK_Learning_边缘检测_梯度算子__Sobel算子_Canny算子_Laplace算子

矫情吗；* 2023-07-07 08:02 74阅读 0赞

0.概述

边缘检测主要有：梯度算子，Sobel算子，Canny算子,Laplace算子。

1.梯度算子提取图像边缘

图像中不连续的灰度值会产生边缘，图像的边缘检测是基于边界的图像分割方法，如分水岭算法，通常是分割原图的梯度图像，梯度实际上也是反应的图像边缘信息。图像边缘一般常用图像一阶导数和二阶导数来检测。
梯度算子对应于图像一阶导数。图像一阶导数计算一般是通过差分运算来近似的。VTK中可以使用vtkImageGradient计算图像梯度。注意图像梯度是一个向量，具有方向和大小。因此vtkImageGradient的计算结果是一个梯度场，也就是每个像素值都是一个梯度向量。显示梯度图像时需要计算每个像素点的梯度大小，即模值。
下面代码如何利用VTK怎么计算图像梯度： 

  1. #include <vtkAutoInit.h>
  2. VTK_MODULE_INIT(vtkRenderingOpenGL);
  4. #include <vtkSmartPointer.h>
  5. #include <vtkJPEGReader.h>
  6. #include <vtkImageGradient.h>
  7. #include <vtkImageMagnitude.h>
  8. #include <vtkImageData.h>
  9. #include <vtkImageShiftScale.h>
  10. #include <vtkImageActor.h>
  11. #include <vtkRenderer.h>
  12. #include <vtkRenderWindow.h>
  13. #include <vtkRenderWindowInteractor.h>
  14. #include <vtkInteractorStyleImage.h>
  16. int main()
  17. {
  18.     vtkSmartPointer<vtkJPEGReader> reader =
  19.         vtkSmartPointer<vtkJPEGReader>::New();
  20.     reader->SetFileName("lena.jpg");
  21.     reader->Update();
  23.     vtkSmartPointer<vtkImageGradient> imgGradient =
  24.         vtkSmartPointer<vtkImageGradient>::New();
  25.     imgGradient->SetInputConnection(reader->GetOutputPort());
  26.     imgGradient->SetDimensionality(2);//?????
  28.     vtkSmartPointer<vtkImageMagnitude> imgMagnitude =
  29.         vtkSmartPointer<vtkImageMagnitude>::New();
  30.     imgMagnitude->SetInputConnection(imgGradient->GetOutputPort());
  31.     imgMagnitude->Update();
  33.     double Range[2];
  34.     vtkSmartPointer<vtkImageData> getRange =
  35.         vtkSmartPointer<vtkImageData>::New();
  36.     imgMagnitude->GetOutput()->GetScalarRange(Range);//图像灰度范围最小值、最大值
  38.     vtkSmartPointer<vtkImageShiftScale> imgShiftScale =
  39.         vtkSmartPointer<vtkImageShiftScale>::New();
  40.     imgShiftScale->SetOutputScalarTypeToUnsignedChar(); //强制类型转换 0~255
  41.     imgShiftScale->SetScale(255 / Range[1]); //灰度映射间距
  42.     imgShiftScale->SetInputConnection(imgMagnitude->GetOutputPort());
  43.     imgShiftScale->Update();
  45.     /
  46.     vtkSmartPointer<vtkImageActor> origActor =
  47.         vtkSmartPointer<vtkImageActor>::New();
  48.     origActor->SetInputData(reader->GetOutput());
  50.     vtkSmartPointer<vtkImageActor> GradientActor =
  51.         vtkSmartPointer<vtkImageActor>::New();
  52.     GradientActor->SetInputData(imgShiftScale->GetOutput());
  54.     double origView[4] = { 0, 0, 0.5, 1 };
  55.     double gradientView[4] = { 0.5, 0, 1, 1 };
  56.     vtkSmartPointer<vtkRenderer> origRender =
  57.         vtkSmartPointer<vtkRenderer>::New();
  58.     origRender->SetViewport(origView);
  59.     origRender->AddActor(origActor);
  60.     origRender->ResetCamera();
  61.     origRender->SetBackground(1.0, 0, 0);
  63.     vtkSmartPointer<vtkRenderer> gradientRender =
  64.         vtkSmartPointer<vtkRenderer>::New();
  65.     gradientRender->SetViewport(gradientView);
  66.     gradientRender->AddActor(GradientActor);
  67.     gradientRender->ResetCamera();
  68.     gradientRender->SetBackground(1, 1, 1);
  70.     vtkSmartPointer<vtkRenderWindow> rw =
  71.         vtkSmartPointer<vtkRenderWindow>::New();
  72.     rw->AddRenderer(origRender);
  73.     rw->AddRenderer(gradientRender);
  74.     rw->SetSize(640, 320);
  75.     rw->SetWindowName("Image Gradient");
  77.     vtkSmartPointer<vtkRenderWindowInteractor> rwi =
  78.         vtkSmartPointer<vtkRenderWindowInteractor>::New();
  79.     vtkSmartPointer<vtkInteractorStyleImage> style =
  80.         vtkSmartPointer<vtkInteractorStyleImage>::New();
  81.     rwi->SetRenderWindow(rw);
  82.     rwi->SetInteractorStyle(style);
  83.     rwi->Initialize();
  84.     rwi->Start();
  86.     return 0;
  87. }

vtkImageGradient的使用比较简单，只需要设置输入图像即可。
计算梯度时，采用的是中间差分法，即像素在每个方向的差分，都是利用的前后两个像素值之差。这样在图像在边界处的差分计算需要特殊处理。其内部定义了HandleBoundaries变量，通过函数SetHandleBoundaries()定赋值。当HandleBoundaries为真时算子会特殊处理计算边界像素的梯度；当为假时不计算边界像素的梯度值，因此输出图像大小要小于输入图像。
另外函数SetDimensionality()用于设置要计算的图像维数，默认为二维，此时梯度向量也为二维。
前面也提到过，梯度是一个向量，不能直接显示。
因此上面代码中定义了vtkImageMagnitude对象来计算梯度向量的2范数，即向量的模。
利用vtkImageShiftScale将图像的数据范围调整到0-255然后显示。
另外还可以通过vtkImageExtractComponents来提取每个方向的梯度分量进行显示。
注意，彩色图像不能直接用来计算梯度，需要先转换为灰度图像。
本例的执行结果如下图所示。

20170126221503731

2.Sobel算子用于提取图像边缘

Sobel算子也是一种常用的梯度算子。Sobel算子计算稍微复杂，它采用3x3的模板。计算时模板在图像上移动，并在每个位置上计算对应中心像素的梯度值。

20170126231235758

VTK中vtkSobel2D计算图像的sobel算子，使用代码如下：

  1. #include <vtkAutoInit.h>
  2. VTK_MODULE_INIT(vtkRenderingOpenGL);
  4. #include <vtkSmartPointer.h>
  5. #include <vtkJPEGReader.h>
  6. #include <vtkImageSobel2D.h>
  7. #include <vtkImageExtractComponents.h>
  8. #include <vtkImageMathematics.h>
  9. #include <vtkImageData.h>
  10. #include <vtkImageShiftScale.h>
  11. #include <vtkImageActor.h>
  12. #include <vtkRenderer.h>
  13. #include <vtkRenderWindow.h>
  14. #include <vtkRenderWindowInteractor.h>
  15. #include <vtkInteractorStyleImage.h>
  17. int main()
  18. {
  19.     vtkSmartPointer<vtkJPEGReader> reader =
  20.         vtkSmartPointer<vtkJPEGReader>::New();
  21.     reader->SetFileName("lena.jpg");
  22.     reader->Update();
  24.     vtkSmartPointer<vtkImageSobel2D> sobelFilter =
  25.         vtkSmartPointer<vtkImageSobel2D>::New();
  26.     sobelFilter->SetInputConnection(reader->GetOutputPort());//包含横向和竖向边缘
  28.     //提取X向边缘成分
  29.     vtkSmartPointer<vtkImageExtractComponents> xSobel =
  30.         vtkSmartPointer<vtkImageExtractComponents>::New();
  31.     xSobel->SetComponents(0);//提取第一成分即X向梯度
  32.     xSobel->SetInputConnection(sobelFilter->GetOutputPort());
  33.     xSobel->Update();
  35.     vtkSmartPointer<vtkImageMathematics> absFilter =
  36.         vtkSmartPointer<vtkImageMathematics>::New();
  37.     absFilter->SetOperationToAbsoluteValue();//将属性设置为绝对值模式
  38.     absFilter->SetInputConnection(xSobel->GetOutputPort());
  39.     absFilter->Update();
  41.     double xRange[2];
  42.     absFilter->GetOutput()->GetScalarRange(xRange);
  44.     vtkSmartPointer<vtkImageShiftScale> xShiftScale =
  45.         vtkSmartPointer<vtkImageShiftScale>::New();
  46.     xShiftScale->SetOutputScalarTypeToUnsignedChar();//强制类型转换 方便显示
  47.     xShiftScale->SetScale(255 / xRange[1]);//设置属性
  48.     xShiftScale->SetInputConnection(absFilter->GetOutputPort());
  49.     xShiftScale->Update();
  51.     //提取Y向边缘成分
  52.     vtkSmartPointer<vtkImageExtractComponents> ySobel =
  53.         vtkSmartPointer<vtkImageExtractComponents>::New();
  54.     ySobel->SetComponents(1);
  55.     ySobel->SetInputConnection(sobelFilter->GetOutputPort());
  56.     ySobel->Update();
  58.     vtkSmartPointer<vtkImageMathematics> absYsobel =
  59.         vtkSmartPointer<vtkImageMathematics>::New();
  60.     absYsobel->SetOperationToAbsoluteValue();
  61.     absYsobel->SetInputConnection(ySobel->GetOutputPort());
  62.     absYsobel->Update();
  64.     double yRange[2];
  65.     absYsobel->GetOutput()->GetScalarRange(yRange);
  67.     vtkSmartPointer<vtkImageShiftScale> yShiftScale =
  68.         vtkSmartPointer<vtkImageShiftScale>::New();
  69.     yShiftScale->SetOutputScalarTypeToUnsignedChar();
  70.     yShiftScale->SetScale(255 / yRange[1]);
  71.     yShiftScale->SetInputConnection(absYsobel->GetOutputPort());
  72.     yShiftScale->Update();
  74.     vtkSmartPointer<vtkImageActor> origActor =
  75.         vtkSmartPointer<vtkImageActor>::New();
  76.     origActor->SetInputData(reader->GetOutput());
  78.     vtkSmartPointer<vtkImageActor> xSobelActor =
  79.         vtkSmartPointer<vtkImageActor>::New();
  80.     xSobelActor->SetInputData(xShiftScale->GetOutput());
  82.     vtkSmartPointer<vtkImageActor> ySobelActor =
  83.         vtkSmartPointer<vtkImageActor>::New();
  84.     ySobelActor->SetInputData(yShiftScale->GetOutput());
  85.     /
  86.     double origView[4] = { 0, 0, 0.33, 1 };
  87.     double xSobelView[4] = { 0.33, 0, 0.66, 1 };
  88.     double ySobelView[4] = { 0.66, 0, 1, 1 };
  89.     vtkSmartPointer<vtkRenderer> origRender =
  90.         vtkSmartPointer<vtkRenderer>::New();
  91.     origRender->SetViewport(origView);
  92.     origRender->AddActor(origActor);
  93.     origRender->ResetCamera();
  94.     origRender->SetBackground(1, 0, 0);
  96.     vtkSmartPointer<vtkRenderer> xSobelRender =
  97.         vtkSmartPointer<vtkRenderer>::New();
  98.     xSobelRender->SetViewport(xSobelView);
  99.     xSobelRender->AddActor(xSobelActor);
  100.     xSobelRender->ResetCamera();
  101.     xSobelRender->SetBackground(0, 1, 0);
  103.     vtkSmartPointer<vtkRenderer> ySobelRender =
  104.         vtkSmartPointer<vtkRenderer>::New();
  105.     ySobelRender->SetViewport(ySobelView);
  106.     ySobelRender->AddActor(ySobelActor);
  107.     ySobelRender->ResetCamera();
  108.     ySobelRender->SetBackground(0, 0, 1);
  109.     //
  110.     vtkSmartPointer<vtkRenderWindow> rw =
  111.         vtkSmartPointer<vtkRenderWindow>::New();
  112.     rw->AddRenderer(origRender);
  113.     rw->AddRenderer(xSobelRender);
  114.     rw->AddRenderer(ySobelRender);
  115.     rw->SetSize(960, 320);
  116.     rw->SetWindowName("Edge by Soebl");
  118.     vtkSmartPointer<vtkRenderWindowInteractor> rwi =
  119.         vtkSmartPointer<vtkRenderWindowInteractor>::New();
  120.     vtkSmartPointer<vtkInteractorStyleImage> style =
  121.         vtkSmartPointer<vtkInteractorStyleImage>::New();
  122.     rwi->SetInteractorStyle(style);
  123.     rwi->SetRenderWindow(rw);
  124.     rwi->Initialize();
  125.     rwi->Start();
  127.     return 0;
  128. }

该例中计算利用Sobel算子计算图像的梯度图像，然后提取X方向的梯度分量和Y方向的梯度分量。
由于计算Sobel算子的值可能存在负值，因此利用vtkImageMathematics对各个分量图像计算绝对值，再由vtkImageShiftScale将图像的数值范围调节到0-255之间再显示。
执行结果如下：
20170126231346059

3.Canny算子

Canny算子是John Canny于20世纪80年代提出的一种多级边缘检测算法。John Canny研究了最优边缘的特性，即检测到的边缘要尽可能跟实际的边缘接近并尽可能的多，同时，要尽量降低噪声对边缘检测的干扰。其计算步骤如下
1）对源图像进行高斯平滑以消除图像中噪声
2）采用差分法近似计算图像每一个像素的梯度，并计算梯度的模值和方向
3）对梯度进行”非极大抑制”：图像边缘点梯度值通常在梯度方向是极大值，因此检测边缘需要将非极大值赋值0来抑制非边缘点。检测方法就是在一个局部窗口内，如果中心像素点的梯度不比梯度方向上相邻两个像素值大，那么该中心像素点梯度值赋0。
4）双阈值法检测边缘和连接边缘。取两个梯度阈值high和low，将梯度图像中小于high的像素赋0得到边缘图像I1，该图像能够接近图像边缘但是可能会存在间断点；将梯度图像中小于low的像素赋0得到边缘图像I2，该图中受噪声影响比较大，但是边缘信息更多。在连接边缘时，以I1为基础，对非零点进行边缘跟踪，如果追踪过程中出现中断，则从I2对应像素点及其邻域来寻找可以连接的边缘，直至结束。
以上是Canny算子的计算步骤。
在VTK中没有实现一个专门的类来做Canny边缘检测。
但是我们可以根据以上步骤来实现： 

  1. #include <vtkSmartPointer.h>
  2. #include <vtkImageData.h>
  3. #include <vtkImageShiftScale.h>
  4. #include <vtkRenderWindow.h>
  5. #include <vtkRenderWindowInteractor.h>
  6. #include <vtkInteractorStyleImage.h>
  7. #include <vtkRenderer.h>
  8. #include <vtkImageActor.h>
  9. #include <vtkJPEGReader.h>
  10. #include <vtkImageCast.h>
  11. #include <vtkImageGaussianSmooth.h>
  12. #include <vtkImageGradient.h>
  13. #include <vtkImageMagnitude.h>
  14. #include <vtkImageNonMaximumSuppression.h>
  15. #include <vtkImageConstantPad.h>
  16. #include <vtkImageToStructuredPoints.h>
  17. #include <vtkLinkEdgels.h>
  18. #include <vtkThreshold.h>
  19. #include <vtkGeometryFilter.h>
  20. #include <vtkSubPixelPositionEdgels.h>
  21. #include <vtkCamera.h>
  22. #include <vtkProperty.h>
  23. #include <vtkStripper.h>
  24. #include <vtkPolyDataMapper.h>
  26. int main(int argc, char* argv[])
  27. {
  28.     vtkSmartPointer<vtkJPEGReader> reader =
  29.         vtkSmartPointer<vtkJPEGReader>::New();
  30.     reader->SetFileName("lena.jpg");
  31.     reader->Update();
  33.     vtkSmartPointer<vtkImageCast> ic =
  34.         vtkSmartPointer<vtkImageCast>::New();
  35.     ic->SetOutputScalarTypeToFloat();
  36.     ic->SetInputConnection(reader->GetOutputPort());
  38.     vtkSmartPointer<vtkImageGaussianSmooth> gs =
  39.         vtkSmartPointer<vtkImageGaussianSmooth>::New();
  40.     gs->SetInputConnection(ic->GetOutputPort());
  41.     gs->SetDimensionality(2);
  42.     gs->SetRadiusFactors(1, 1, 0);
  44.     vtkSmartPointer<vtkImageGradient> imgGradient =
  45.         vtkSmartPointer<vtkImageGradient>::New();
  46.     imgGradient->SetInputConnection(gs->GetOutputPort());
  47.     imgGradient->SetDimensionality(2);
  49.     vtkSmartPointer<vtkImageMagnitude> imgMagnitude =
  50.         vtkSmartPointer<vtkImageMagnitude>::New();
  51.     imgMagnitude->SetInputConnection(imgGradient->GetOutputPort());
  53.     vtkSmartPointer<vtkImageNonMaximumSuppression> nonMax =
  54.         vtkSmartPointer<vtkImageNonMaximumSuppression>::New();
  55.     nonMax->SetMagnitudeInputData(imgMagnitude->GetOutput());
  56.     nonMax->SetVectorInputData(imgGradient->GetOutput());
  57.     nonMax->SetDimensionality(2);
  59.     vtkSmartPointer<vtkImageConstantPad> pad =
  60.         vtkSmartPointer<vtkImageConstantPad>::New();
  61.     pad->SetInputConnection(imgGradient->GetOutputPort());
  62.     pad->SetOutputNumberOfScalarComponents(3);
  63.     pad->SetConstant(0);
  65.     vtkSmartPointer<vtkImageToStructuredPoints> i2sp1 =
  66.         vtkSmartPointer<vtkImageToStructuredPoints>::New();
  67.     i2sp1->SetInputConnection(nonMax->GetOutputPort());
  68.     i2sp1->SetVectorInputData(pad->GetOutput());
  70.     vtkSmartPointer<vtkLinkEdgels> imgLink =
  71.         vtkSmartPointer<vtkLinkEdgels>::New();
  72.     imgLink->SetInputData(i2sp1->GetOutput());
  73.     imgLink->SetGradientThreshold(2);
  75.     vtkSmartPointer<vtkThreshold> thresholdEdgels =
  76.         vtkSmartPointer<vtkThreshold>::New();
  77.     thresholdEdgels->SetInputConnection(imgLink->GetOutputPort());
  78.     thresholdEdgels->ThresholdByUpper(10);
  79.     thresholdEdgels->AllScalarsOff();
  81.     vtkSmartPointer<vtkGeometryFilter> gf =
  82.         vtkSmartPointer<vtkGeometryFilter>::New();
  83.     gf->SetInputConnection(thresholdEdgels->GetOutputPort());
  85.     vtkSmartPointer<vtkImageToStructuredPoints> i2sp =
  86.         vtkSmartPointer<vtkImageToStructuredPoints>::New();
  87.     i2sp->SetInputConnection(imgMagnitude->GetOutputPort());
  88.     i2sp->SetVectorInputData(pad->GetOutput());
  90.     vtkSmartPointer<vtkSubPixelPositionEdgels> spe =
  91.         vtkSmartPointer<vtkSubPixelPositionEdgels>::New();
  92.     spe->SetInputConnection(gf->GetOutputPort());
  93.     spe->SetGradMapsData(i2sp->GetStructuredPointsOutput());
  95.     vtkSmartPointer<vtkStripper> strip =
  96.         vtkSmartPointer<vtkStripper>::New();
  97.     strip->SetInputConnection(spe->GetOutputPort());
  99.     vtkSmartPointer<vtkPolyDataMapper> dsm =
  100.         vtkSmartPointer<vtkPolyDataMapper>::New();
  101.     dsm->SetInputConnection(strip->GetOutputPort());
  102.     dsm->ScalarVisibilityOff();
  104.     vtkSmartPointer<vtkActor> planeActor =
  105.         vtkSmartPointer<vtkActor>::New();
  106.     planeActor->SetMapper(dsm);
  107.     planeActor->GetProperty()->SetAmbient(1.0);
  108.     planeActor->GetProperty()->SetDiffuse(0.0);
  109.     planeActor->GetProperty()->SetColor(1.0, 0.0, 0.0);
  111.     vtkSmartPointer<vtkImageActor> originalActor =
  112.         vtkSmartPointer<vtkImageActor>::New();
  113.     originalActor->SetInputData(reader->GetOutput());
  115.     double originalViewport[4] = { 0.0, 0.0, 0.5, 1.0 };
  116.     double gradviewport[4] = { 0.5, 0.0, 1.0, 1.0 };
  118.     vtkSmartPointer<vtkRenderer> originalRenderer =
  119.         vtkSmartPointer<vtkRenderer>::New();
  120.     originalRenderer->SetViewport(originalViewport);
  121.     originalRenderer->AddActor(originalActor);
  122.     originalRenderer->ResetCamera();
  123.     originalRenderer->SetBackground(1.0, 1.0, 1.0);
  125.     vtkSmartPointer<vtkRenderer> gradRenderer =
  126.         vtkSmartPointer<vtkRenderer>::New();
  127.     gradRenderer->SetViewport(gradviewport);
  128.     gradRenderer->AddActor(planeActor);
  129.     gradRenderer->ResetCamera();
  130.     gradRenderer->SetBackground(1.0, 1.0, 1.0);
  132.     vtkSmartPointer<vtkRenderWindow> renderWindow =
  133.         vtkSmartPointer<vtkRenderWindow>::New();
  134.     renderWindow->SetSize(900, 300);
  135.     renderWindow->AddRenderer(originalRenderer);
  136.     renderWindow->AddRenderer(gradRenderer);
  137.     renderWindow->Render();
  138.     renderWindow->SetWindowName("CannyExample");
  140.     vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
  141.         vtkSmartPointer<vtkRenderWindowInteractor>::New();
  142.     vtkSmartPointer<vtkInteractorStyleImage> style =
  143.         vtkSmartPointer<vtkInteractorStyleImage>::New();
  145.     renderWindowInteractor->SetInteractorStyle(style);
  146.     renderWindowInteractor->SetRenderWindow(renderWindow);
  147.     renderWindowInteractor->Initialize();
  148.     renderWindowInteractor->Start();
  150.     return EXIT_SUCCESS;
  151. }

该程序比较复杂，处理边缘时将其作为几何数据来进行处理。因此涉及了部分几何数据操作的filter，这里如果不明白可以先放一下，再几何数据处理部分会做详细介绍。
程序首先读入图像，计算图像的梯度和模值。
接下来按照Canny算子的步骤进行处理。
我们详细介绍用到的相应的filter：
vtkImageNonMaximumSuppression将图像中的非局部峰值设置为0,输入和输出类型都是vtkImageData：其中输入有两个，模值图像（magnitude）和向量图像，一个典型的应用就是输入梯度模值图像和梯度向量图像对梯度做非极大值抑制。
vtkImageConstantPad增加图像的大小，其输入和输出都为vtkImageData。其中函数SetOutputNumberOfScalarComponents(3)用于设置输出图像的像素数据组分个数，函数SetConstant(0)用于设置输出图像中扩大的区域像素值。而SetOutputWholeExtent()则用于设置输出图像的范围。这里的作用是将梯度图像像素的组分修改为3，方便下面vtkImageToStructuredPoints使用。
vtkImageToStructuredPoints将vtkImageData格式转换为规则点集。该类的输入类型是vtkImageData，另外还有一个可选的RGB三组分向量图像输入；输出类型是vtkStructuredPoints，当输入向量图像时，向量图像像素数据会转为输出图像的对应点的属性。
vtkLinkEdgels类根据点的相邻关系连接成连续的折线Polyline。其内部阈值变量GradientThreshold，可以用来排除输入点中梯度值小于该阈值的点。当使用vtkLinkEdgels进行Canny算子的双阈值边缘检测时，GradientThreshold可以用作较小的阈值。设置该阈值的函数是SetGradientThreshold(2)。
vtkThreshold用于获取输入任意类型数据的满足阈值条件的单元数据。该类的输入为VTK的任意数据类型，输出数据类型是不规则网格。阈值设置有：大于阈值，小于阈值和介于两个阈值之间。内部提供了两种属性模式AttributeMode设置，即阈值比较时是采用的点属性还是单元属性，默认下是点属性。而当属性为多元数据时，还需要设置阈值比较时使用哪个组分的数据。其中提供了三种模式选择，所有组分都满足阈值条件，任意一个满足阈值条件和用户指定的组分满足阈值条件。当使用点属性数据时，如果设置了AllScalars，那么单元满足阈值条件的前提会是其所有点的属性都满足阈值条件。这里将阈值设置为10，即Canny中双阈值的较大阈值。
vtkGeometryFilter将数据转换为几何数据，输出类型为vtkPolyData。该类从vtkThreshold的输出中提取图像边缘的几何数据。
vtkSubPixelPositionEdgels接收一系列连续曲线及其对应的梯度系信息作为输入，利用梯度信息来调整曲线位置。这里对前面提取的图像边缘再根据其梯度进行调整。
vtkStripper用来将输入的多边形、三角形或者线段生成三角形带或者折线段。输入的多边形数据必须是三角形，否则不会进行带化处理。因此处理多边形数据时，可以先用vtkTriangleFilter进行三角化后再使用本类。如果输入中存在孤立点的话，也不会进行任何处理。默认情况下，该filter处理后会丢弃掉属性数据。

4.拉普拉斯算子

拉普拉斯算子是一个二阶边缘算子，即梯度的散度。拉普拉斯算子的实现也是通过模板实现。常用的拉普拉斯模板定义如下：

拉普拉斯算子计算图像的二阶导数，对于图像噪声比较敏感。拉普拉斯算子的结果为标量，表示边缘的宽度。但是它常产生双像素宽边缘，而且不能提供方向信息，因此较少直接用于边缘检测。在VTK中由vtkImageLaplacian实现。 

  1. #include <vtkAutoInit.h>
  2. VTK_MODULE_INIT(vtkRenderingOpenGL);
  4. #include <vtkSmartPointer.h>
  5. #include <vtkJPEGReader.h>
  6. #include <vtkImageData.h>
  7. #include <vtkImageLaplacian.h>
  8. #include <vtkImageShiftScale.h>
  9. #include <vtkImageActor.h>
  10. #include <vtkRenderer.h>
  11. #include <vtkRenderWindow.h>
  12. #include <vtkRenderWindowInteractor.h>
  13. #include <vtkInteractorStyleImage.h>
  15. int main(int argc, char* argv[])
  16. {
  18.     vtkSmartPointer<vtkJPEGReader> reader =
  19.         vtkSmartPointer<vtkJPEGReader>::New();
  20.     reader->SetFileName("lena.jpg");
  21.     reader->Update();
  23.     vtkSmartPointer<vtkImageLaplacian> lapFilter =
  24.         vtkSmartPointer<vtkImageLaplacian>::New();
  25.     lapFilter->SetInputConnection(reader->GetOutputPort());
  26.     lapFilter->SetDimensionality(2);
  28.     double range[2];
  29.     lapFilter->GetOutput()->GetScalarRange(range);
  31.     vtkSmartPointer<vtkImageShiftScale> ShiftScale =
  32.         vtkSmartPointer<vtkImageShiftScale>::New();
  33.     ShiftScale->SetOutputScalarTypeToUnsignedChar();
  34.     ShiftScale->SetScale(255 / (range[1] - range[0]));
  35.     ShiftScale->SetShift(-range[0]);
  36.     ShiftScale->SetInputConnection(lapFilter->GetOutputPort());
  37.     ShiftScale->Update();
  39.     vtkSmartPointer<vtkImageActor> originalActor =
  40.         vtkSmartPointer<vtkImageActor>::New();
  41.     originalActor->SetInputData(reader->GetOutput());
  43.     vtkSmartPointer<vtkImageActor> gradActor =
  44.         vtkSmartPointer<vtkImageActor>::New();
  45.     gradActor->SetInputData(ShiftScale->GetOutput());
  47.     double originalViewport[4] = { 0.0, 0.0, 0.5, 1.0 };
  48.     double gradviewport[4] = { 0.5, 0.0, 1.0, 1.0 };
  50.     vtkSmartPointer<vtkRenderer> originalRenderer =
  51.         vtkSmartPointer<vtkRenderer>::New();
  52.     originalRenderer->SetViewport(originalViewport);
  53.     originalRenderer->AddActor(originalActor);
  54.     originalRenderer->ResetCamera();
  55.     originalRenderer->SetBackground(1.0, 1.0, 1.0);
  57.     vtkSmartPointer<vtkRenderer> gradRenderer =
  58.         vtkSmartPointer<vtkRenderer>::New();
  59.     gradRenderer->SetViewport(gradviewport);
  60.     gradRenderer->AddActor(gradActor);
  61.     gradRenderer->ResetCamera();
  62.     gradRenderer->SetBackground(1.0, 1.0, 1.0);
  64.     vtkSmartPointer<vtkRenderWindow> rw =
  65.         vtkSmartPointer<vtkRenderWindow>::New();
  66.     rw->AddRenderer(originalRenderer);
  67.     rw->AddRenderer(gradRenderer);
  68.     rw->SetSize(640, 320);
  69.     rw->Render();
  70.     rw->SetWindowName("Edge by Laplacian");
  72.     vtkSmartPointer<vtkRenderWindowInteractor> rwi =
  73.         vtkSmartPointer<vtkRenderWindowInteractor>::New();
  74.     vtkSmartPointer<vtkInteractorStyleImage> style =
  75.         vtkSmartPointer<vtkInteractorStyleImage>::New();
  77.     rwi->SetInteractorStyle(style);
  78.     rwi->SetRenderWindow(renderWindow);
  79.     rwi->Initialize();
  80.     rwi->Start();
  82.     return 0;
  83. }

vtkImageLaplacian输入和输出数据都是vtkImageData，与梯度算子不同，该filter的输出图像像素为标量。函数SetDimensionality用于设置输入图像的维数，默认为2维。计算完毕后，利用vtkImageShiftScale将图像的数据范围变换至0-255之间。

计算结果如下图所示

20170128224427951

发表评论

表情：
评论列表 （有 0 条评论，74人围观）

还没有评论，来说两句吧...

相关阅读

    相关 sobel算子

      彻底理解数字图像处理中的卷积-以Sobel算子为例[https://www.cnblogs.com/freeblues/p/5738987.html][https_www

    迷南。迷南。/ 0 赞/ 282 阅读