sobel 梯度计算

最新推荐文章于 2024-03-23 23:20:02 发布
最新推荐文章于 2024-03-23 23:20:02 发布
阅读量1.8k 收藏 1
点赞数
CC 4.0 BY-SA版权
文章标签： OpenGL sobel 梯度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhg2507/article/details/16827731

#include<stdio.h> 
#include<memory.h>
#include<math.h>
#include <iostream>

////////////////////////////////体数据//////////////////////////////////
#define WIDTH 256
#define HEIGHT 256
#define DEPTH 225
#define volumeType unsigned char
#define maxScalarData 255.0
int width_height=WIDTH*HEIGHT;
int totalLength=width_height*DEPTH;

float * volumeData= new float [totalLength];
float * gradientX = new float [totalLength];
float * gradientY = new float [totalLength];
float * gradientZ = new float [totalLength];
float * gradient_Length = new float [totalLength];

float * grad   = new float [totalLength*3];

///////////////////////////////////////////SOBEL 算子/////////////////////////////////////////////
float  X_OPERATOR_MATRIX[27]={-1,0,1,-3,0,3,-1,0,1,-3,0,3,-6,0,6,-3,0,3,-1,0,1,-3,0,3,-1,0,1};
float  Y_OPERATOR_MATRIX[27]={-1,-3,-1,0,0,0,1,3,1,-3,-6,-3,0,0,0,3,6,3,-1,-3,-1,0,0,0,1,3,1};
float  Z_OPERATOR_MATRIX[27]={-1,-3,-1,-3,-6,-3,-1,-3,-1,0,0,0,0,0,0,0,0,0,1,3,1,3,6,3,1,3,1};

//////////////////////////////////////////判断出界算子///////////////////////////////////////////
float  BELOW_X_MIN_BORDER[27]={0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1};
float  ABOVE_X_MAX_BORDER[27]={1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0};
float  BELOW_Y_MIN_BORDER[27]={0,0,0,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1};
float  ABOVE_Y_MAX_BORDER[27]={1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,0,0,0};
float  BELOW_Z_MIN_BORDER[27]={0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
float  ABOVE_Z_MAX_BORDER[27]={1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0};

bool readInFile(char* FileName);
bool combine_operator(float destination_array[],float operator_array[]);
bool writeFile(float a[],int leg,char* FileName);

int main()             
{
 if(!readInFile("head256.raw"))  printf("Read File ERROR!");//foot 256x256x256 8bits/feet_8bits.raw

 memset(gradientX, 0, sizeof(float)*totalLength);   //初始化
 memset(gradientY, 0, sizeof(float)*totalLength);
 memset(gradientZ, 0, sizeof(float)*totalLength);
 memset(gradient_Length, 0, sizeof(float)*totalLength);

// printf("%d",readInFile("head.raw"));
 int i,j,k,w,h,d,temp;
 float current_x_operator[27];
 float current_y_operator[27];
 float current_z_operator[27];
 int current_volume;
//  float max_x = 0,max_y = 0,max_z = 0,max_g = 0;
//  float min_x = 0,min_y = 0,min_z = 0,min_g = 0;
    float max_g = 0,  min_g = 0;

 for(i=0;i<27;i++) current_x_operator[i]=X_OPERATOR_MATRIX[i];
 for(i=0;i<27;i++) current_y_operator[i]=Y_OPERATOR_MATRIX[i];
 for(i=0;i<27;i++) current_z_operator[i]=Z_OPERATOR_MATRIX[i];

 for(w=0;w<WIDTH;w++)
 {  

  for(h=0;h<HEIGHT;h++)
  {
   
   
   for(d=0;d<DEPTH;d++)
   {
    //////////////////////////判断出界情况，用算子记录/////////////////////
    if(w==0)
    {
     combine_operator(current_x_operator,BELOW_X_MIN_BORDER);
     combine_operator(current_y_operator,BELOW_X_MIN_BORDER);
     combine_operator(current_z_operator,BELOW_X_MIN_BORDER);
    }
    if(w==(WIDTH-1))
    {
     combine_operator(current_x_operator,ABOVE_X_MAX_BORDER);
     combine_operator(current_y_operator,ABOVE_X_MAX_BORDER);
     combine_operator(current_z_operator,ABOVE_X_MAX_BORDER);
    }
    if(h==0)
    {
     combine_operator(current_x_operator,BELOW_Y_MIN_BORDER);
     combine_operator(current_y_operator,BELOW_Y_MIN_BORDER);
     combine_operator(current_z_operator,BELOW_Y_MIN_BORDER);
    }
    if(h==(HEIGHT-1))
    {
     combine_operator(current_x_operator,ABOVE_Y_MAX_BORDER);
     combine_operator(current_y_operator,ABOVE_Y_MAX_BORDER);
     combine_operator(current_z_operator,ABOVE_Y_MAX_BORDER);
    }
    if(d==0)
    {
     combine_operator(current_x_operator,BELOW_Z_MIN_BORDER);
     combine_operator(current_y_operator,BELOW_Z_MIN_BORDER);
     combine_operator(current_z_operator,BELOW_Z_MIN_BORDER);
    }
    if(d==(DEPTH-1))
    {
     combine_operator(current_x_operator,ABOVE_Z_MAX_BORDER);
     combine_operator(current_y_operator,ABOVE_Z_MAX_BORDER);
     combine_operator(current_z_operator,ABOVE_Z_MAX_BORDER);
    }


    //////////////////////////////当前点算子确定后，下面与体数据加权计算当前点的梯度///////////////
    temp=w+h*WIDTH+d*width_height;
    for(k=0;k<3;k++)
    {
     for(j=0;j<3;j++)
     {
      for(i=0;i<3;i++)
      {
       if( current_x_operator[i+j*3+k*9]==-13 )
                            {
                                continue;//////////////算子判断出界
                            }
       current_volume=w+i-1+(h+j-1)*WIDTH+(d+k-1)*width_height;

       if( !volumeData[current_volume] )
                            {
                                continue;
                            }

       if( current_x_operator[i+j*3+k*9] )
                            {
                                gradientX[temp]+=current_x_operator[i+j*3+k*9]*volumeData[current_volume];
                            }

       if( current_y_operator[i+j*3+k*9] )
                            {
                                gradientY[temp]+=current_y_operator[i+j*3+k*9]*volumeData[current_volume];
                            }

       if( current_z_operator[i+j*3+k*9] )
                            {
                                gradientZ[temp]+=current_z_operator[i+j*3+k*9]*volumeData[current_volume];
                            }
       
      }
     }
    }
    gradient_Length[temp] = sqrt(gradientX[temp]*gradientX[temp]+gradientY[temp]*gradientY[temp]+gradientZ[temp]*gradientZ[temp]);
    min_g = min_g>gradient_Length[temp] ? gradient_Length[temp]:min_g;
    max_g = max_g<gradient_Length[temp] ? gradient_Length[temp]:max_g;

    /*turn gradient to negative*/
    if (gradient_Length[temp])
    {
     gradientX[temp] = (  ( (float)gradientX[temp]/gradient_Length[temp] )+1 ) / 2.0;
     gradientY[temp] = (  ( (float)gradientY[temp]/gradient_Length[temp] )+1 ) / 2.0;
     gradientZ[temp] = (  ( (float)gradientZ[temp]/gradient_Length[temp] )+1 ) / 2.0;
    }
    else
    {
     gradientX[temp] = 0;
     gradientY[temp] = 0;
     gradientZ[temp] = 0;
    }
//     min_x = min_x>gradient_Length[temp] ? gradient_Length[temp]:min_x;
//     max_x = max_x<gradient_Length[temp] ? gradient_Length[temp]:max_x;
//     min_y = min_y>gradient_Length[temp] ? gradient_Length[temp]:min_y;
//     max_y = max_y<gradient_Length[temp] ? gradient_Length[temp]:max_y;
//     min_z = min_z>gradient_Length[temp] ? gradient_Length[temp]:min_z;
//     max_z = max_z<gradient_Length[temp] ? gradient_Length[temp]:max_z;
    

    grad[temp]  = gradientX[temp];
    grad[temp+1] = gradientY[temp];
    grad[temp+2] = gradientZ[temp];

    /////////////////下一个点梯度开始计算前恢复算子////////////
    for(i=0;i<27;i++) current_z_operator[i]=Z_OPERATOR_MATRIX[i];
    for(i=0;i<27;i++) current_y_operator[i]=Y_OPERATOR_MATRIX[i];
    for(i=0;i<27;i++) current_x_operator[i]=X_OPERATOR_MATRIX[i];
   }   
  }  
 }


 //----------------normalize grad length----------------
 for (i=0; i<totalLength; i++)
 {
  gradient_Length[i] = (float)/*(*/gradient_Length[i]/*-3.4641)*/ / max_g/*1727.77*//*1718.3059*/;
 }

 std::cout<<gradientX[34010]<<std::endl;

  writeFile(gradientX, totalLength, "head256_gradx.raw");
  writeFile(gradientY, totalLength, "head256_grady.raw");
  writeFile(gradientZ, totalLength, "head256_gradz.raw");
 writeFile(gradient_Length, totalLength, "head256_grad.raw");

 delete volumeData;
 delete gradientX ;
 delete gradientY ;
 delete gradientZ ;
 delete gradient_Length ;
 delete grad;
 return 0;
}

 

bool readInFile(char* FileName)
{
 FILE *fd;
 fd=fopen(FileName,"rb");
 int dataLength=width_height*DEPTH;
 volumeType * t=new volumeType [dataLength];
 if(!fd)
 {
  return 0;
 }

 fread(t,sizeof(volumeType),dataLength,fd);

 for(int i=0;i<dataLength;i++)
 {
  volumeData[i]=(float) t[i];///maxScalarData;
 }

 delete t;
 fclose(fd);

 return 1;
}


bool writeFile(float  a[],int leg,char* FileName)
{
 FILE *fd;
 fd=fopen(FileName,"wb");
 if(!fd)
 {
  return 0;
 }
 
 fwrite(a,sizeof(float),leg,fd);
 return 1;
}


bool combine_operator(float destination_array[],float operator_array[])/////////默认是3*3*3矩阵的并操作
{
 int temp;
 for(int i=0;i<3;i++)
 {
  for(int j=0;j<3;j++)
  {
   for(int k=0;k<3;k++)
   {
    temp=i+j*3+k*9;
    if(!operator_array[temp]) destination_array[temp]= -13 ;//////////-13这个特殊值在算子中作为边界判断的值///////
   }
  }
 }

 return 1;
}

zhg2507
关注
Sobel梯度计算过程 - 数字图像处理 边缘检测
GudcSql的博客
09-22 300
Sobel算子是一种常用的边缘检测算子，它通过计算图像中每个像素点的梯度来确定边缘的位置和方向。Sobel算子是一种基于离散差分的边缘检测算子，它利用了图像中像素灰度值的变化来检测边缘。该算子分别计算水平和垂直方向上的梯度，并通过求和得到最终的梯度值。这是使用Sobel算子进行边缘检测的基本过程，你可以根据实际需求对阈值、卷积核等参数进行调整，以获得更好的边缘检测效果。其中，arctan函数返回的是弧度值，需要进行角度转换。即为处理后的图像，其中边缘位置的像素点值为255，非边缘位置的像素点值为0。
图像sobel梯度详细计算过程_OPENCV中的Sobel函数
weixin_39774556的博客
11-17 3197
Sobel算子是一种常用的边缘检测算子，是一阶的梯度算法。对噪声具有平滑作用，提供较为精确的边缘方向信息，边缘定位精度不够高。当对精度要求不是很高时，是一种较为常用的边缘检测方法。它进行处理的模板如下：其中，Gx是横向的算子，Gy是纵向的算子。原图像记为f，则GX = Gx*fGY = Gy*fGx =-1*f(x-1, y-1) + 0*f(x,y-1) + 1*f(x+1,y-1)+(-2)*...
OpenCV学习笔记（十一）——利用Sobel算子计算梯度
最新发布
qq_54186956的博客
03-23 3742
利用Sobel进行求梯度计算
sobel 算子计算图像梯度
03-25
使用sobel 计算图像的梯度,调用torch和CV2实现,可以在pytorch代码中直接使用
SOBEL算子梯度计算.zip
06-05
通过定义sobel算子，对图像的各像素通过选定区域的卷积，得到相应像素点的X方向和Y方向的梯度，再利用梯度得到相应的计算内容，可以计算图像像素点的法线方向。
6.边缘检测：梯度——索贝尔算子（Sobel）、Matlab梯度（Sobel）实战_4
Tom的专栏
11-25 2万+
目录 索贝尔算子（Sobel） Matlab梯度（Sobel）实战 索贝尔算子（Sobel） 人们其实做导数和边的时间已经很长了。最经典的是Sobel运算，它是以一个叫索贝尔的人的名字命名的。 Sobel运算就像我给你们看的上面的图片一样。但不是  和 ，它很奇怪的是它在乘以。 可以看到，它不仅是-2 +2 ，然后除以4得到相同的值。如图： 但它在我上面的行上也有-1  +1...
Sobel算子--Hog-方向梯度直方图（Histogram Of Gradient）
RUN
04-01 3535
写的很好的HOG 方向梯度直方图(HOG)中，梯度的方向分布被用作特征。沿着一张图片X和Y轴的方向上的梯度是很有用的，因为在边缘和角点的梯度值是很大的，我们知道边缘和角点包含了很多物体的形状信息。 怎么计算方向梯度直方图呢？ 我们会先用图像的一个patch来解释。 第一步：预处理 Patch可以是任意的尺寸，但是有一个固定的比例，比如当patch长宽比1:2，那patch大小可以是100200, 128256或者10002000但不可以是101205。 这里有张图是720475的，我们选100200大小的
图像sobel梯度详细计算过程_数字图像处理（第十章）
weixin_39805998的博客
11-21 2913
点、线、边缘检测背景知识。书中主要介绍了图像的一阶导数与二阶导数，这个之前的文章中有过介绍这里在复习一遍。对于函数 ,对于点 在x方向的一阶偏导为： ,二阶偏导为：之后书中总结了一阶导与二阶导对于图像求取边缘的结论：孤立点检测。图像中孤立点检测使用二阶梯度。公式如下：（扩展：用于边缘检测的sobel算子属于一阶梯度。）拓展一下拉普拉斯，包含像素 四个对角，那么可以使用如下模板。线检测线检测同...
11-图像梯度-Sobel算子
beyond谚语的博客
10-12 4073
图像梯度是指图像某像素在x和y两个方向上的变化率（与相邻像素比较），是一个二维向量，由2个分量组成，X轴的变化、Y轴的变化 。 其中X轴的变化是指当前像素右侧（X加1）的像素值减去当前像素左侧（X减1）的像素值。 同理，Y轴的变化是当前像素下方（Y加1）的像素值减去当前像素上方（Y减1）的像素值。 其实Sobel算子求梯度也是分为x轴方向和y轴方向，说白了就是将一个卷积核进行上下左右划分，x轴方向上就是右➖左，y轴方向上就是下➖上 cv2.Sobel(img,cv2.CV_64F,1,0,ksize = .
sobel求取图像梯度
sinat_38998284的博客
09-19 5258
#include "opencv2/imgproc/imgproc.hpp" #include "opencv2/highgui/highgui.hpp" #include &lt;iostream&gt; #include &lt;cmath&gt; using namespace cv; using namespace std; void SobelGradDirction...
Sobel梯度算子的使用与分析
10-08
这个DOC文档详细解释了Sobel梯度算子的使用与分析
图像梯度-Sobel算子
FLR的博客
07-29 693
图像梯度-Sobel算子 img = cv2.imread('pie.png',cv2.IMREAD_GRAYSCALE) cv2.imshow("img",img) cv2.waitKey() cv2.destroyAllWindows() dst = cv2.Sobel(src, ddepth, dx, dy, ksize) ddepth:图像的深度 dx和dy分别表示水平和竖直方向 ksize是Sobel算子的大小 def cv_show(img,name): cv2.imshow(n
利用cv2.Sobel()计算图像梯度的细节讲解
热门推荐
土豆
04-29 4万+
函数cv2.Sobel(src, ddepth, dx, dy[, ksize[, scale[, delta[, borderType]]]]) 概述：利用Sobel算子进行图像梯度计算 参数： src：输入图像 ddepth: 输出图像的深度（可以理解为数据类型），-1表示与原图像相同的深度 dx,dy:当组合为dx=1,dy=0时求x方向的一阶导数，当组合为dx=0,dy=1时求y...
第五章：图像梯度计算 1-Sobel算子
我不是程序员的博客
06-27 605
import cv2 img=cv2.imread('circle.jpg',cv2.IMREAD_GRAYSCALE) cv2.imshow('img',img) cv2.waitKey(0) cv2.destroyAllWindows() ''' dst=cv2.Sobel(src=,ddepth=,dx=,dy=,ksize=) ddepth:图像的深度 dx和dy分别表示水平和竖直方向 ksize是Sobel算子的大小 ''' def cv_show(img,name): cv2.imsh
Sobel边缘检测 - 梯度算子介绍
Henry的专栏
06-03 2590
Sobel是常用的边缘检测Filter,本文主要是介绍一下Sobel的公式的由来。
Sobel求图像梯度(从0实现以及cv2实现)
Hu_Linson的博客
10-15 1535
tensor的像素值特别接近，我们可以简单的设定一个阈值，将无用像素设置为0，并将其他像素归一化到0-255区间，就可以得到近似的结果。二者图像显示不同的原因是因为cv2提取的是灰度图像 numpy像素值在0-255之间，而tensor不同。图像梯度可以把图像看成二维离散函数，图像梯度其实就是这个二维离散函数的求导。图像梯度: G(x,y) = dx(i,j) + dy(i,j);其中，I是图像像素的值(如：RGB值)，(i,j)为像素的坐标。图像就是函数，梯度对应的数值就是像素值的突变情况。
图像梯度算子——Sobel/scharr/Laplacian
Mr_Nobody17的博客
08-30 9642
1.sobel算子 sobel算子可以计算图像梯度，计算图像梯度的作用是提取边界。 （1）X方向的梯度 以3x3的卷积核计算sobel算子为例： 图中左边就是计算水平梯度时的卷积核，简单来说就是右边减左边，权重由卷积核规定。 含义：当目标（P5点）右左两列差别特别大的时候，目标点的值会很大，说明该点为边界。 （2）Y方向的梯度 上图是计算垂直方向梯度的卷积核，如果在垂直方向上存在有较大的差值就说明存在有水平边界。 （3）注意&总结 a.水平梯度运算提取垂直方向的边界
opencv学习笔记15: 梯度运算之sobel算子及其函数使用
总裁余（余登武）博客
07-06 1万+
python+opencv sobel算子理论 从不同方向计算梯度 如图从x轴计算p5的梯度。左边是卷积核系数 如果右边这一列和左边这一列相差很大，则计算出来的P5x很大，可以认为在边界上。否则不在边界上。用于求出图像边界 也可以从y轴计算梯度 如果上下相差很大，则计算出来的值很大，则认为是边界，否则不是。 整个图像梯度 sobel函数使用 dst=cv2.Sobel(src,ddepth,dx,dy,[kszie]) dst:处理结果 src:原始图像 ddpepth:处理图像的深度.-1表示与
opencv基础41-图像梯度-sobel算子详解cv2.Sobel()（边缘检测基础）
小海聊智造
08-07 7402
图像梯度是用于描述图像变化率的概念。在图像处理中，梯度指的是图像中每个像素的灰度值变化速率或方向。它常用于边缘检测和图像特征提取。一维图像的梯度表示为函数 f(x) 的导数，而在二维图像中，梯度是一个向量，包含两个分量：水平方向和垂直方向的灰度变化率。这两个分量的大小和方向可以用来确定图像中的边缘和纹理信息。在图像处理中，常用的算子如Sobel、Prewitt和Scharr等可以用于计算图像的梯度。梯度计算对于计算机视觉任务和图像处理中的特征提取非常有用。
图像识别中的Sobel梯度计算方法解析
标签“sobel 梯度 图像识别”则清晰地指出了这个压缩包可能包含的内容，与Sobel算子、图像识别和梯度计算相关。Sobel算子是一种用于边缘检测的离散微分算子，它结合了高斯平滑和微分求导，通过在水平和垂直方向分别...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值