精华内容
下载资源
问答
  • 拉普拉斯算法

    2014-04-13 22:39:56
    工作平台是opencv和VS2010,是对于图像处理中拉普拉斯算法学习的总结,希望对初学者有帮助。
  • 拉普拉斯算法matlab实现,拉普拉斯是经典的图像增强算法
  • delphi 之拉普拉斯算法

    2018-04-28 10:57:39
    本文主要是16位灰阶图的拉普拉斯算法做锐化:unit Sharp;interfaceuses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, ieview, imageenview, imageen,...

    本文主要是16位灰阶图的拉普拉斯算法做锐化:
    unit Sharp;
    interface
    uses
      Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
      Dialogs, StdCtrls, ieview, imageenview, imageen,UImageUtils, ComCtrls,
      Buttons;
    type
      TForm1 = class(TForm)
        ImageEn1: TImageEn;
        Button1: TButton;
        dlgOpen1: TOpenDialog;
        ImageEnView1: TImageEnView;
        close: TButton;
        Edit1: TEdit;
        TrackBar1: TTrackBar;
        BitBtn1: TBitBtn;
        procedure Button1Click(Sender: TObject);
        procedure TrackBar1Change(Sender: TObject);
        procedure Edit1Change(Sender: TObject);
        procedure BitBtn1Click(Sender: TObject);
      private
        { Private declarations }
        FImageBuffer: PWord;
        FImageBuffer2: PWord;
        FImageWidth, FImageHeight: Integer;
        Lock: Boolean;
        procedure sharpenImage(gray: PWord; smooth: PWord; width, height: Integer;n : Single);
        procedure sharpenImagex(gray: PWord; smooth: PWord; width, height: Integer);
      public
        { Public declarations }
      end;
    var
      Form1: TForm1;
    implementation
    var
      templates: array[0..24] of Integer =
       (-1, -4, -7, -4, -1,
        -4, -16, -26, -16, -4,
        -7, -26, 505, -26, -7,
        -4, -16, -26, -16, -4,
        -1, -4, -7, -4, -1);
       templates1: array[0..8] of Integer =
       (0, -1, 0,
        -1, 5, -1,
        0, -1, 0);
    {$R *.dfm}
    procedure TForm1.Button1Click(Sender: TObject);
    var
      n : Single;c : Integer;
      t: Cardinal;
    begin
      if not dlgOpen1.Execute then Exit;
       ImageEn1.IO.LoadFromFile(dlgOpen1.FileName);
      // ImageEnView1.IO.LoadFromFile(dlgOpen1.FileName);
       Tiff16BitToBuffer(dlgOpen1.FileName, FImageBuffer, FImageWidth, FImageHeight);

      if Assigned(FImageBuffer2) then
        FreeMem(FImageBuffer2);
      GetMem(FImageBuffer2, FImageWidth * FImageHeight * SizeOf(Word));
        Val(Edit1.Text,n,c);
      t := GetTickCount;
      sharpenImage(FImageBuffer, FImageBuffer2, FImageWidth, FImageHeight,0.95);
      caption := IntToStr(GetTickCount - t);
      BufferToTIFF16bit(FImageBuffer2, FImageWidth, FImageHeight,
        dlgOpen1.FileName + '.123.tif');
      ImageEnView1.IO.LoadFromFile(dlgOpen1.FileName + '.123.tif');
    end;
    procedure TForm1.sharpenImage(gray, smooth: PWord; width, height: Integer;n : Single);
    var
      i,j: Integer;
      index, sum: Integer;
      grayPtr, smoothPtr,grayPtrX: PWord;
    begin
      CopyMemory(smooth, gray, width * height * SizeOf(Word));
       
      for j := 1 to height - 1 do
      begin
        for i := 1 to width - 1 do
        begin
          sum := 0;
          grayPtr:= gray;
          grayPtrX:= gray;
          Inc(grayPtrX, -1*width -1);
          sum := round((grayPtr^  - grayPtrX^)*n)   + grayPtr^;
          if (sum > 65535) then
              sum := 65535;
          if (sum <0) then
              sum := 0;
          smoothPtr := smooth;
          Inc(smoothPtr, j*width+i);
          smoothPtr^ := sum;
        end;
      end;
    end;
    procedure TForm1.TrackBar1Change(Sender: TObject);
    begin
      if not Lock then
      Edit1.Text := Format('%f', [TrackBar1.Position / 100.00]);
    end;
    procedure TForm1.Edit1Change(Sender: TObject);
    var
      n : Single;c : Integer;
      t: Cardinal;
    begin
      Lock := True;
      Val(Edit1.Text,n,c);
      t := GetTickCount;
      sharpenImage(FImageBuffer, FImageBuffer2, FImageWidth, FImageHeight,n);
      caption := IntToStr(GetTickCount - t);
     // BufferToTIFF16bit(FImageBuffer2, FImageWidth, FImageHeight,
      //  dlgOpen1.FileName + '.1.tif');
     // ImageEnView1.IO.LoadFromFile(dlgOpen1.FileName + '.1.tif');
      Lock := False;
    end;
    procedure TForm1.sharpenImagex(gray, smooth: PWord; width,
      height: Integer);
    var
      i,j,m,n,t: Integer;
      index, sum: Integer;
      grayPtr, smoothPtr: PWord;
    begin
      CopyMemory(smooth, gray, width * height * SizeOf(Word));
      t:= 0;
      for j := 1 to height - 2 do
      begin
        for i := 1 to width - 2 do
        begin
          sum := 0; 
          index := 0; 
          for m := j-1 to j+1 do
          begin
            for n := i-1 to i+1 do
            begin
              grayPtr := gray;
              Inc(grayPtr, m*width + n);
              sum := sum + grayPtr^ * templates1[index];
              Inc(index);
            end;
          end;
         // sum := sum div 273;
          if (sum > 65535) then
          begin
            sum := 65535;
            inc(t);
          end;
          if (sum <0) then
          begin
            sum := 0;
          end;
          smoothPtr := smooth;
          Inc(smoothPtr, j*width+i);
          smoothPtr^ := sum;
        end;
      end;
      ShowMessage(IntToStr(t));
    end;
    procedure TForm1.BitBtn1Click(Sender: TObject);
    var
      n : Single;c : Integer;
    begin
      if not dlgOpen1.Execute then Exit;
       ImageEn1.IO.LoadFromFile(dlgOpen1.FileName);
      // ImageEnView1.IO.LoadFromFile(dlgOpen1.FileName);
       Tiff16BitToBuffer(dlgOpen1.FileName, FImageBuffer, FImageWidth, FImageHeight);

      if Assigned(FImageBuffer2) then
        FreeMem(FImageBuffer2);
      GetMem(FImageBuffer2, FImageWidth * FImageHeight * SizeOf(Word));
        Val(Edit1.Text,n,c);
      ShowMessage('a');
      sharpenImageX(FImageBuffer, FImageBuffer2, FImageWidth, FImageHeight);
      ShowMessage('b');
      BufferToTIFF16bit(FImageBuffer2, FImageWidth, FImageHeight,
        dlgOpen1.FileName + '.123.tif');
      ImageEnView1.IO.LoadFromFile(dlgOpen1.FileName + '.123.tif');
    end;
    end.



    要引用的单元:
    unit UImageUtils;
    // 2017-12-5 10:18:28
    interface
    uses
      Windows, SysUtils, imageenview;
    type
      TRGBPixel = record
        B,
        G,
        R: Byte;
      end;
      PRGBPixel = ^TRGBPixel;
    procedure BufferToTIFF16bit(Buffer: PWord; ImageWidth, ImageHeight: Integer;
      FileName: string);
    procedure BufferToTIFF16bitX(Buffer: PWord; ImageWidth, ImageHeight: Integer;
      Dest: TImageEnView);
    procedure BufferToTIFF24bit(Buffer: PRGBPixel; ImageWidth, ImageHeight: Integer;
      FileName: string);
    function Tiff16BitToBuffer(AFileName: string; var AImageBuffer: PWord;
      var AImageWidth, AImageHeight: Integer): Boolean;
    function Tiff24BitToBuffer(AFileName: string; var AImageBuffer: PRGBPixel;
      var AImageWidth, AImageHeight: Integer): Boolean;
    implementation
    uses
      ImageEnIO, HYIEUtils;
    procedure BufferToTIFF16bit(Buffer: PWord; ImageWidth, ImageHeight: Integer;
      FileName: string);
    var
      cIOImage: TImageEnView;
      ii: Integer;
      LImageBufferPtr: PWORD;
    begin
      cIOImage := TImageEnView.Create(nil);
      try
        cIOImage.LegacyBitmap := False;
        cIOImage.IEBitmap.Allocate(ImageWidth, ImageHeight, ie16g);
        cIOImage.io.Params.BitsPerSample := 16;
        cIOImage.io.Params.SamplesPerPixel := 1;
        cIOImage.io.Params.TIFF_ByteOrder := ioLittleEndian;
        cIOImage.io.Params.TIFF_Compression := ioTIFF_UNCOMPRESSED;
        LImageBufferPtr := Buffer;
        for ii := 0 to Pred(ImageHeight) do
        begin
          CopyMemory(cIOImage.IEBitmap.ScanLine[ii], LImageBufferPtr,
            ImageWidth * 2);
          Inc(LImageBufferPtr, ImageWidth);
        end;
        cIOImage.io.SaveToFile(FileName);
      finally
        cIOImage.Free;
      end;
    end;
    procedure BufferToTIFF16bitX(Buffer: PWord; ImageWidth, ImageHeight: Integer;
      Dest: TImageEnView);
    var
      ii: Integer;
      LImageBufferPtr: PWORD;
    begin
        Dest.LegacyBitmap := False;
        Dest.IEBitmap.Allocate(ImageWidth, ImageHeight, ie16g);
        Dest.io.Params.BitsPerSample := 16;
        Dest.io.Params.SamplesPerPixel := 1;
        Dest.io.Params.TIFF_ByteOrder := ioLittleEndian;
        Dest.io.Params.TIFF_Compression := ioTIFF_UNCOMPRESSED;
        LImageBufferPtr := Buffer;
        for ii := 0 to Pred(ImageHeight) do
        begin
          CopyMemory(Dest.IEBitmap.ScanLine[ii], LImageBufferPtr,
            ImageWidth * 2);
          Inc(LImageBufferPtr, ImageWidth);
        end;
    end;
    procedure BufferToTIFF24bit(Buffer: PRGBPixel; ImageWidth, ImageHeight: Integer;
      FileName: string);
    var
      cIOImage: TImageEnView;
      ii: Integer;
      LImageBufferPtr: PRGBPixel;
    begin
      cIOImage := TImageEnView.Create(nil);
      try
        cIOImage.LegacyBitmap := True;
        cIOImage.IEBitmap.Allocate(ImageWidth, ImageHeight ,ie24RGB);
        LImageBufferPtr := Buffer;
        for ii := 0 to Pred(ImageHeight) do
        begin
          CopyMemory(cIOImage.IEBitmap.ScanLine[ii], LImageBufferPtr,
            ImageWidth * 3);
          Inc(LImageBufferPtr, ImageWidth);
        end;
        cIOImage.io.SaveToFile(FileName);
      finally
        cIOImage.Free;
      end;
    end;
    function Tiff16BitToBuffer;
    var
      LBitmapRowPtr: PWord;
      LRow: Integer;
      LImageBufferPtr: PWord;
      LImageIO: TImageEnView;
      FCountOfImageBytes: Integer;
    begin
      Result := False;
      if not FileExists(AFileName) then Exit;
      LImageIO := TImageEnView.Create(nil);
      try
          // 16bit tiff file
          LImageIO.io.ParamsFromFile(AFileName);
          if ((LImageIO.io.Params.FileType = ioTIFF)
            and (LImageIO.io.Params.BitsPerSample = 16)
            and (LImageIO.io.Params.SamplesPerPixel = 1)) then
          begin
            AImageWidth := LImageIO.io.Params.Width;
            AImageHeight := LImageIO.io.Params.Height;
            FCountOfImageBytes := AImageWidth * AImageHeight * 2;
            LImageIO.LegacyBitmap := False;
            LImageIO.IO.NativePixelFormat := True;
            LImageIO.IEBitmap.Allocate(AImageWidth, AImageHeight, ie16g);
            LImageIO.io.Params.TIFF_ByteOrder := ioLittleEndian;
            LImageIO.io.Params.TIFF_Compression := ioTIFF_UNCOMPRESSED;
            LImageIO.IO.LoadFromFileFormat(AFileName, ioTIFF);
            if AImageBuffer <> nil then FreeMem(AImageBuffer);
            AImageBuffer := nil;
            GetMem(AImageBuffer, FCountOfImageBytes);
            LImageBufferPtr := AImageBuffer;
            for LRow := 0 to AImageHeight - 1 do
            begin
              LBitmapRowPtr := PWord(LImageIO.IEBitmap.ScanLine[LRow]);
              CopyMemory(LImageBufferPtr, LBitmapRowPtr, AImageWidth * 2);
              Inc(LImageBufferPtr, AImageWidth);
            end;
          end;
      finally
        LImageIO.Free;
      end;
      Result := True;
    end;
    function Tiff24BitToBuffer(AFileName: string; var AImageBuffer: PRGBPixel;
      var AImageWidth, AImageHeight: Integer): Boolean;
    var
      LBitmapRowPtr: PRGBPixel;
      LRow: Integer;
      LImageBufferPtr: PRGBPixel;
      LImageIO: TImageEnView;
      FCountOfImageBytes: Integer;
    begin
      Result := False;
      if not FileExists(AFileName) then Exit;
      LImageIO := TImageEnView.Create(nil);
      try
          LImageIO.io.ParamsFromFile(AFileName);
          if ((LImageIO.io.Params.FileType = ioTIFF)
            and (LImageIO.io.Params.BitsPerSample = 8)
            and (LImageIO.io.Params.SamplesPerPixel = 3)) then
          begin
            AImageWidth := LImageIO.io.Params.Width;
            AImageHeight := LImageIO.io.Params.Height;
            FCountOfImageBytes := AImageWidth * AImageHeight * 3;
            LImageIO.LegacyBitmap := True;
            LImageIO.IO.LoadFromFile(AFileName);
            if AImageBuffer <> nil then FreeMem(AImageBuffer);
            AImageBuffer := nil;
            GetMem(AImageBuffer, FCountOfImageBytes);
            LImageBufferPtr := AImageBuffer;
            for LRow := 0 to AImageHeight - 1 do
            begin
              LBitmapRowPtr := LImageIO.IEBitmap.ScanLine[LRow];
              CopyMemory(LImageBufferPtr, LBitmapRowPtr, AImageWidth * 3);
              Inc(LImageBufferPtr, AImageWidth);
            end;
          end;
      finally
        LImageIO.Free;
      end;
      Result := True;
    end;
    end.


    展开全文
  • 基于拉普拉斯算法的成像测井图像滤波检测处理方法研究,张健,,通过对超声成像测井过程中为便于对成像结果进行分析、解释和评价而对图像进行边缘检测处理;给出基于高斯 - 拉普拉斯算法并对其特
  • 该文提出了一种基于拉普拉斯算法的图像锐化方法,并在DSP 上实现其算法。首先研究拉普拉斯算子锐化图像的基本原理, 并推导出图像锐化的拉普拉斯算子。其次,根据拉普拉斯算子,在CCS2 软件上运用C 语言编写主函数和...
  • 使用USM算法锐化图像的MATLAB程序,使用了模板相乘卷积的原理,其中更改模板便可以更改算法,比如使用拉普拉斯锐化模板便就改造成了拉普拉斯滤波,可改造性及移植性较好,注释较多,适合初学者。
  • 一、引言 图像锐化处理的作用是使灰度反差增强,从而使模糊图像变得更加清晰。图像模糊的实质就是图像受到平均运算或积分...二、卷积算法2.1卷积原理 因此,锐化处理可选择拉普拉斯算子对原图像进行处理,产生描述灰...

    一、引言

           图像锐化处理的作用是使灰度反差增强,从而使模糊图像变得更加清晰。图像模糊的实质就是图像受到平均运算或积分运算,因此可以对图像进行逆运算,如微分运算能够突出图像细节,使图像变得更为清晰。由于拉普拉斯是一种微分算子,它的应用可增强图像中灰度突变的区域,减弱灰度的缓慢变化区域。

    二、卷积算法

    2.1卷积原理

              因此,锐化处理可选择拉普拉斯算子对原图像进行处理,产生描述灰度突变的图像,再将拉普拉斯图像与原始图像叠加而产生锐化图像。此原理实际为卷积操作,也可以理解为一种图像变换,最常见的图像变换(image transform,即将一幅图像转变成图像数据)就是傅里叶变换(Fourier transform),即将图像转换成源图像数据的另一种表示,而卷积是大多数变换的基础。

    我们可以用方程来表示这个过程。我们首先定义图像为I(x,y),核为G(x,y),

    参考点位于相应核的(ai,aj)坐标上,则卷积H(x,y)定义如下:

    边缘部分使用复制处理,计算方法如下图所示:

    2 .2 opencv卷积函数说明

    void cvFilter2D( const CvArr* src, CvArr* dst,  const CvMat* kernel,  CvPoint  chor=cvPoint(-1,-1));
    src:输入图像
    dst:输出图像
    kernel:卷积核, 单通道浮点矩阵. 如果想要应用不同的核于不同的通道,先用 cvSplit 函数分解图像到单个色彩通道上,然后单独处理。
    anchor:核的锚点表示一个被滤波的点在核内的位置。 锚点应该处于核内部。缺省值 (-1,-1) 表示锚点在核中心。

    其实在利用此卷积函数是,根据核的不同可以产生各种的图像处理,比如:

    [转载]卷积滤波模板

    #include <iostream>  
    #include <opencv2/highgui/highgui.hpp>  
    #include <opencv2/core/core.hpp>  
    #include <opencv/cv.hpp>  
      
    using namespace std;  
    using namespace cv;  
    int main()  
    {  
        string picName="lena.jpg";  
        Mat A=imread (picName,CV_LOAD_IMAGE_COLOR);  
          
        Mat mask=(Mat_<char>(3,3)<<0,-1,0,   -1,5,-1,    0,-1,0);    
          
        Mat B;  
        filter2D (A,B,A.depth (),mask);  
          
        imshow("A的图像",A);  
        imshow("B的图像",B);  
          
        waitKey ();  
        return 0;  
    }

    20131110141151937

    三、拉普拉斯算法

    3.1 拉普拉斯原理说明

            普拉斯算子是最简单的各向同性微分算子,具有旋转不变性。一个二维图像函数 的拉普拉斯变换是各向同性的二阶导数,定义为:

    165749739.jpg?_=1939020

          在一个二维函数f(x,y)中,x,y两个方向的二阶差分分别为,

    CodeCogsEqn(3)

    CodeCogsEqn(4)

           为了更适合于数字图像处理,将该方程表示为离散形式:

    165821853.jpg?_=1939020

    写成filter mask的形式如下,

    165916806.jpg?_=1939020


            注意该(a)的mask的特点,mask在上下左右四个90度的方向上结果相同,也就是说在90度方向上无方向性。为了让该mask在45度的方向上也具有该性质,对该filter mask进行扩展定义为(b)。

             将Laplace算子写成filter mask后,其操作大同小异于其他的空间滤波操作。将filter mask在原图上逐行移动,然后mask中数值与其重合的像素相乘后求和,赋给与mask中心重合的像素,对图像的第一,和最后的行和列无法做上述操作的像素赋值零,就得到了拉普拉斯操作结果。

    3.2 opencv函数应用

    Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT );
    src_gray,输入图像
    dst,Laplace操作结果
    ddepth,输出图像深度,因为输入图像一般为CV_8U,为了避免数据溢出,输出图像深度应该设置为CV_16S
    kernel_size,filter mask的规模,我们的mask时3x3的,所以这里应该设置为3
    scale,delta,BORDER_DEFAULT,默认设置就好
    //load the Original Image and get some informations
    Mat src = imread("012.jpg",0);
    namedWindow("OriginalImage");
    imshow("OriginalImage",src);
    CV_Assert(src.depth() == CV_8U);
    
    //OpenCV solution - Laplacian
    Mat dst,abs_dst_laplace;
    Laplacian(src,dst,CV_16S,3);
    convertScaleAbs(dst,abs_dst_laplace);
    
    //show the result
    namedWindow("result_laplacian");
    imshow("result_laplacian",abs_dst_laplace);

    original810956-20150926131143569-1606809590.jpg

    上图中上图为原图像,有图为拉普拉斯之后的图像。


    转载于:https://www.cnblogs.com/polly333/p/7269843.html

    展开全文
  • 以APMCM2019年的A题,该题目要求我们从这样的图片中提取出二氧化硅晶体。 提取方法 同态滤波 该方法在博客中有详细说明。主要思想是: 图像f(x,y)f(x,y)f(x,y)可由fi(x,y)fr(x,y)f_i(x,y)f_r(x,y)fi​(x,y)fr​(x,y...
  • Opencv中的Laplacian(拉普拉斯算法

    千次阅读 2018-05-17 21:34:20
    下面的代码选自Opencv2.4.9源码文件opencv\sources\...关于拉普拉斯算子的介绍,请看下面的博客: https://www.cnblogs.com/german-iris/p/4840647.html https://blog.csdn.net/dcrmg/article/details/53677739

    下面的代码选自Opencv2.4.9源码文件opencv\sources\modules\imgproc\src文件夹下的deriv.cpp文件,该cpp文件中的Laplacian(…)函数源码,下面只显示了ksize=1or3的情况,

    void cv::Laplacian( InputArray _src, OutputArray _dst, int ddepth, int ksize,
                        double scale, double delta, int borderType )
    {
        Mat src = _src.getMat();
        if (ddepth < 0)
            ddepth = src.depth();
        _dst.create( src.size(), CV_MAKETYPE(ddepth, src.channels()) );
        Mat dst = _dst.getMat();
    
        if( ksize == 1 || ksize == 3 )
        {
            float K[2][9] =
            {{0, 1, 0, 1, -4, 1, 0, 1, 0},
             {2, 0, 2, 0, -8, 0, 2, 0, 2}};
            Mat kernel(3, 3, CV_32F, K[ksize == 3]);
            if( scale != 1 )
                kernel *= scale;
            filter2D( src, dst, ddepth, kernel, Point(-1,-1), delta, borderType );
        }else
        {
    	    //ksize等于其他值的情况
        }
    }
    

    关于拉普拉斯算子的介绍,请看下面的博客:
    https://www.cnblogs.com/german-iris/p/4840647.html
    https://blog.csdn.net/dcrmg/article/details/53677739

    展开全文
  • 由于图像边缘就是灰度发生跳变的区域,所以拉普拉斯模板对边缘检测很有用。 八邻域的表示法为:将算得的值替换原(x,y)处的像素值,可以得到类似边界的地方,然后根据下式得到锐化图像:   大家下面可以...

    在眼底图像处理时,先进行图像的预处理,需要提取血管灰度图像进行分析,但图像可能比较暗,还有噪音。

    需要进行灰度图像增强,对噪音区采取图像平滑,消除图像中噪声的干扰,或者降低对比度。

    对眼底血管的边缘末梢,需要进行图像锐化,提高对比度。

    即当邻域中心像素灰度低于它所在的领域内其它像素的平均灰度时,将此中心像素的灰度应进一步降低,

    当邻域中心像素灰度高于它所在的邻域内其它像素的平均灰度时,将此中心像素的灰度应被进一步提高,

    以此实现图像的锐化处理。

    大家知道,函数的一阶微分描述了函数图像是变化方向,即增长或者降低;

    而二阶微分描述的则是图像变化的速度,急剧增长下降还是平缓的增长下降。

    图像的一阶偏微分和推出的二元函数微分:

    一阶微分法能够用来检测图像边缘是否存在。

    那么二阶微分法,也就是拉普拉斯算子就可以确定边缘的位置。(有的文章中称下式为拉普拉斯掩膜中心系数)

    据此我们可以推出依据二阶微分能够找到图像的色素的过渡程度,例如白色到黑色的过渡就是比较急剧的。

    拉普拉斯锐化图像处理就是这个思想。

    根据图像中某个像素的周围像素到此像素的突变程度有关,我们可以进行图像边缘检测。运用拉普拉斯增强图像的细节,找到图像的边缘。但是有时候会把噪音也给增强了,所以在锐化前对图像进行平滑处理。

    这样可以找到一个模板矩阵:

    这个成为四邻域也就是上面的二阶微分法

    这个是八邻域。

    从上面的两种模板中就可以看出,如果一个黑色平面中有一个白点,那么模板矩阵可以使这个白点更亮。

    由于图像边缘就是灰度发生跳变的区域,所以拉普拉斯模板对边缘检测很有用。

    八邻域的表示法为:将算得的值替换原(x,y)处的像素值,可以得到类似边界的地方,然后根据下式得到锐化图像:

     

    大家下面可以从选取各拉普拉斯算子和执行的结果图像中体会。图1是源图

    图2中间有亮区,因为kernel1算子是小数。图3 没有这个问题,其kernel2算子是整数,

    图6 中部分血管有反常的白点,kernel 5算子中有-1的原因

    def laplasFilter(img_src):
    
        kernel1 = np.array(([0.0625, 0.125, 0.0625],
                           [0.125, 0.25, 0.125],
                           [0.0625, 0.125, 0.0625]),
                          dtype="float32"
                          )
        kernel2 = np.array(([1, 2, 1],
                           [2, 4, 2],
                           [1, 2, 1]),
                          dtype="float32"
                          )
    
        kernel3 = np.array(([1, 2, 1],
                           [2, 8, 2],
                           [1, 2, 1]),
                          dtype="float32"
                          )
    
        kernel4 = np.array(([0, 1, 0],
                           [1, 8, 1],
                           [0, 1, 0]),
                          dtype="float32"
                          )
        kernel5 = np.array(([-1, 1, -1],
                           [-1, 8, -1],
                           [-1, 1, -1]),
                          dtype="float32"
                          )
    
        img_dst1 = cv2.filter2D(img_src, -1, kernel1)      
        image_Enhance1 = img_src + img_dst1
        cv2.imshow("laplas1", image_Enhance1)
    
        img_dst2 = cv2.filter2D(img_src, -1, kernel2)     
        image_Enhance2 = img_src + img_dst2
        cv2.imshow("laplas2", image_Enhance2)
    
        img_dst3 = cv2.filter2D(img_src, -1, kernel3)      
        image_Enhance3 = img_src + img_dst3
        cv2.imshow("laplas3", image_Enhance3)
    
        img_dst4 = cv2.filter2D(img_src, -1, kernel4)     
        image_Enhance4 = img_src + img_dst4
        cv2.imshow("laplas4", image_Enhance4)
    
        img_dst5 = cv2.filter2D(img_src, -1, kernel5)     
        image_Enhance5 = img_src + img_dst5
        cv2.imshow("laplas5", image_Enhance5)
    源图像
    

           
     

    展开全文
  • 拉普拉斯算法实现图像边缘提取(MATLAB实现) clear;clc; a=imread('street.jpg'); e=a(:,:,1); r=e;c=e; [m,n]=size(e); %拉普拉斯算法提取边缘 h=zeros(m-1,n-1); for i=2:m-1 for j=2:n-1 h(i,j)=c(i,j+1)+c(i,j-...
  • 拉普拉斯算子也可以推广为定义在黎曼流形上的椭圆型算子,称为拉普拉斯-贝尔特拉米算子。 2 原理 拉普拉斯算子是二阶微分线性算子,在图像边缘处理中,二阶微分的边缘定位能力更强,锐化效果更好,因此在进行图像...
  • 1、其中Retinex算法具有的功能:动态范围压缩(即滤掉了低频部分,提取了高频)、色调再现(即还有图像色彩);  其中这个算法里使用了log对数域,这个主要原因不是为了扩展低灰度值,压缩高灰度值,而是为了避免负值...
  • Visual C++数字图像处理典型算法及实现,拉普拉斯锐化算法实现
  • 拉普拉斯滤镜算法

    2012-11-21 10:03:53
    本文描述了拉普拉斯滤镜算法,提供给大家分享和使用。
  • 拉普拉斯融合算法

    千次阅读 2018-01-11 18:47:52
    ***无意看到了拉普拉斯的图像融合算法,浏览了几篇博客,终于弄懂了其中的原理,现在作一个记录,方便以后理解使用。*** *算法流程: 1.分别计算待融合的两幅图像的拉普拉斯金字塔 2.计算得到两幅图像最顶层...
  • 利用MATLAB实现拉普拉斯贝叶斯算法,用在压缩感知中,仿真了信号重建的过程,对该过程有进一步的认识
  • 简单图像融合(加权平均、像素选大、像素选小)算法拉普拉斯金字塔算法的Matlab实现 GUI界面 简单图像融合(加权平均、像素选大、像素选小)算法拉普拉斯金字塔算法的Matlab实现 GUI界面
  • 其中拉普拉斯近似算法是用一个高斯分布来近似原始分布,当原始分布比较简单的时候效果会较好。 目标: 用一个高斯分布近似一组连续变量上的概率密度分布。 一维空间: 变量z,假设分布为p(z)=1Zf(z),...
  • 朴素贝叶斯中拉普拉斯平滑算法

    千次阅读 2019-04-17 19:46:33
    什么情况下我们会使用拉普拉斯平滑算法? 当我们在使用朴素贝叶斯算法去解决分类问题时,在训练集上进行训练时我们可以发现有可能出现某些特征的概率P为0的情况,无论是在全文检索中某个字出现的概率,还是在垃圾...
  • 拉普拉斯特征映射算法,简单易懂,降维处理,求流形的必备程序

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,332
精华内容 532
关键字:

拉普拉斯算法