计算机视觉度量指标教程（四）

于 2024-08-22 15:31:46 发布
阅读量732 收藏 30
点赞数 22
分类专栏： VKDoc 文章标签： VKDoc
License CC BY-NC-SA 4.0 / 自豪地采用谷歌翻译
本文链接：https://blog.csdn.net/wizardforcel/article/details/141429580
版权

原文：Computer Vision Metrics

协议：CC BY-NC-SA 4.0

十一、附录 C：图像处理和计算机视觉资源

本附录包含计算机视觉和成像的一些资源列表，包括商业产品、开源项目、组织和标准机构。

商业产品

|

名字

|

矩阵实验室

|
| — | — |
| 描述 | 行业标准数学软件包，包含许多科学软件包选项，适用于包括成像和计算机视觉在内的各个领域。包括一个不错的软件开发环境，为计算机视觉、图像处理、可视化等提供附加库。非常适合代码开发。 |
| 库 API | SDE 内部丰富的 API 库。 |
| 同时蒸馏萃取 | 包括用于编码的软件开发环境。 |
| 开放源码 | 不是针对产品，可能是针对用户开发的一些代码。 |
| 环 | http://www.mathworks.com/products/matlab/ |

|

名字

|

数学软件

|
| — | — |
| 描述 | 行业标准数学软件包，包含许多科学软件包选项，适用于各种领域，包括图像处理和计算机视觉。非常适合创建出版就绪的可视化和数学笔记本。用于计算机视觉、图像处理、可视化等的附加库。 |
| 库 API | SDE 内部丰富的 API 库。 |
| 同时蒸馏萃取 | 包括一个默认的基于函数的脚本开发环境，以及一些代码开发插件。 |
| 开放源码 | 不针对产品，但可能针对用户开发的代码。 |
| 环 | http://www.wolfram.com/mathematica/ |

|

名字

|

英特尔 TBB、英特尔 IPP、英特尔 CILK++软件

|
| — | — |
| 描述 | 英特尔提供针对 IA 指令集优化的库、语言和编译器。英特尔 TBB 是面向单核和多核处理器的多线程库，英特尔 IPP 提供针对 IA 和 SIMD 指令以及某些情况下的 GPGPU 优化的图像和计算机视觉性能原语，英特尔 CILK++是用于编写 SIMD/SIMT 并行代码的语言。 |
| 库 API | 丰富的 API 库。 |
| 同时蒸馏萃取 | 不，但英特尔 CILK++是一种编程语言。 |
| 开放源码 | 号码 |
| 环 | http://software.intel.com/en-us/intel-tbb
|

开源

|

名字

|

开放计算机视觉

|
| — | — |
| 描述 | 工业标准计算机视觉和图像处理库，被世界各地的大公司和其他公司使用。 |
| 库 API | 丰富的 API 库。 |
| 同时蒸馏萃取 | 号码 |
| 开放源码 | BSD 许可证。 |
| 环 | http://opencv.org/ |

|

名字

|

影像-斐济

|
| — | — |
| 描述 | 图像处理、可视化和计算机视觉的应用。由美国政府国立卫生研究院[502]开发，可供公众使用。广泛。FIJI 是 ImageJ 的一个发行版，有许多用户社区提交的插件。 |
| 库 API | 号码 |
| 同时蒸馏萃取 | 号码 |
| 开放源码 | 公共领域使用。 |
| 环 | http://rsbweb.nih.gov/ij/index.html
http://rsb.info.nih.gov/ij/plugins/
|

|

名字

|

VLFEAT

|
| — | — |
| 描述 | 包含一系列用于特征描述、模式匹配和图像处理的通用计算机视觉算法的 c 库。 |
| 库 API | 丰富的 API 库。 |
| 同时蒸馏萃取 | 号码 |
| 开放源码 | BSD 许可证。 |
| 环 | http://vlfeat.org |

|

名字

|

VTK

|
| — | — |
| 描述 | C++库，包含一系列常见的图像处理、图形和数据可视化功能。包括 GUI 小部件。VTL 也提供咨询服务。 |
| 库 API | 丰富的 API 库。 |
| 同时蒸馏萃取 | 号码 |
| 开放源码 | BSD 许可证。 |
| 环 | http://vtk.org/ |

|

名字

|

网格实验室

|
| — | — |
| 描述 | 用于可视化、渲染、注释和转换 3D 数据网格(如点云和 CAD 设计)的应用。广泛。使用 ISTI 的 VCG 图书馆。 |
| 库 API | 号码 |
| 同时蒸馏萃取 | 号码 |
| 开放源码 | BSD 许可证。 |
| 环 | http://meshlab.sourceforge.net/ |

|

名字

|

pdflib

|
| — | — |
| 描述 | 图像处理和计算机视觉加速库。 |
| 库 API | 是的。 |
| 同时蒸馏萃取 | 号码 |
| 开放源码 | 号码 |
| 环 | 参见参考文献[495]。 |

|

名字

|

点云库(PCL)

|
| — | — |
| 描述 | 广泛的开源库，主要用于处理 3D 点云，包括来自最新学术研究和可视化方法的许多尖端 3D 描述符的实现。 |
| 库 API | 是的。 |
| 同时蒸馏萃取 | 号码 |
| 开放源码 | 是的。 |
| 环 | http://pointclouds.org/downloads/
http://pointclouds.org/documentation/
|

|

名字

|

幕府机器学习工具箱

|
| — | — |
| 描述 | 机器学习和模式匹配库。广泛。 |
| 库 API | 是的。 |
| 同时蒸馏萃取 | 号码 |
| 开放源码 | GPL。 |
| 环 | http://shogun-toolbox.org/page/features/ |

|

名字

|

卤化物高性能图像处理语言

|
| — | — |
| 描述 | 针对 SIMD、SIMT 和 GPGPU 优化的 C++语言类。 |
| 库 API | 是的。 |
| 同时蒸馏萃取 | 号码 |
| 开放源码 | 开源 MIT 许可。 |
| 环 | http://halide-lang.org/ |

|

名字

|

REIN(识别基础设施)视觉算法框架

|
| — | — |
| 描述 | 机器人学中的计算机视觉框架:使用 ROS 操作系统。参见参考文献[397，503]。 |
| 库 API | 是的。 |
| 同时蒸馏萃取 | 号码 |
| 开放源码 | 麻省理工学院开源许可证。 |
| 环 | http://wiki.ros.org/rein |

|

名字

|

ECTO——计算机视觉的图形网络构建

|
| — | — |
| 描述 | 用于为计算机视觉流水线创建函数的有向非循环图的库，支持线程。用 C++/Python 框架写的。可以和 OpenCV，PCL，ROS 集成。 |
| 库 API | 是的。 |
| 同时蒸馏萃取 | 号码 |
| 开放源码 | 很显然。 |
| 环 | http://plasmodic.github.io/ecto/ |

组织、机构和标准

| 微软研究院
http://academic.research.microsoft.com/ | 微软研究院拥有世界上最大的计算机视觉专家团队之一，并积极推动会议和研究。提供了几个好的在线资源。 |
| CIE
http://www.cie.co.at/ | 国际照明委员会(在法语名称后缩写为 CIE)提供了与颜色科学相关的一系列光源的标准照明数据，以及众所周知的颜色空间 CIE XYZ、CIE Lab 和 CIE Luv 的标准。 |
| ICC
http://www.color.org/index.xalter | 国际色彩联盟为成像设备提供 ICC 标准色彩描述文件，以及许多其他行业标准，包括彩色显示器的 sRGB 色彩空间。 |
| 洞穴计算机视觉实验室
http://www.cs.columbia.edu/CAVE/ | 由 Shree Nayar 博士领导的哥伦比亚大学计算机视觉实验室提供世界一流的成像和视觉研究。 |
| RIT Munsel 颜色科学实验室
http://www.rit.edu/cos/colorscience/ | 罗切斯特理工学院 Munsel 色彩科学实验室是色彩科学和成像领域的领先研究机构，提供广泛的资源，并与柯达、施乐等行业成像巨头有着密切的联系。 |
| 开 VX KHRONOS
http://www.khronos.org/openvx | OPENVX 是针对低级视觉图元加速的建议标准，由 KHRONOS 标准组执行。 |
| SPIE 光学和光子学会
医学成像杂志
电子成像杂志
应用遥感杂志
| 光科学的跨学科方法，包括光子学、传感器和成像；推广会议，出版杂志。 |
| IEEE CVPR，计算机视觉与模式识别
PAMI，模式分析与机器智能
ICCV，计算机视觉国际会议
IP，Trans。图像处理http://ieee.org | 期刊和会议出版协会，包括各种计算机视觉和成像主题。 |
| CVF 计算机视觉基础
http://www.cv-foundation.org/ | 促进计算机视觉，提供论文传播。 |
| NIST-图像集团
国家标准研究院
http://www.nist.gov/itl/iad/ig/ | 促进计算机视觉和成像大挑战；涵盖生物识别标准、指纹测试、人脸、虹膜、多模态测试、下一代测试平台。 |
| I20 - Darpa 信息创新办公室
http://www.darpa.mil/Our_Work/I2O/Programs/
http://www.darpa.mil/OpenCatalog/index.html | 用于军事应用的大量计算机视觉和相关程序研究。一些作品通过 OpenCatalog 向公众发布。 |

日记账及其缩写

  • 图形模型/图形模型和图像处理/计算机视觉、图形和图像处理
  • CVIU 计算机视觉和图像理解
  • IJCV 国际计算机视觉杂志
  • IVC 图像和视觉计算
  • 数学成像和视觉杂志
  • MVA 机器视觉及应用
  • TMI - IEEE 医学成像汇刊

会议 及其缩写

  • 3DIM 国际三维成像和建模会议
  • 三维数据处理可视化和传输
  • ACCV 亚洲计算机视觉会议
  • 人脸和手势的 AMFG 分析和建模
  • 生物驱动的计算机视觉
  • BMVC 英国机器视觉会议
  • CRV 加拿大计算机和机器人视觉会议
  • CVPR 计算机视觉和模式识别
  • 医学中的计算机视觉、虚拟现实和机器人技术
  • 计算机图像的 DGCI 离散几何
  • ECCV 欧洲计算机视觉会议
  • 计算机视觉和模式识别中的 EMMCVPR 能量最小化方法
  • FGR IEEE 自动人脸和手势识别国际会议
  • ICARCV 控制、自动化、机器人和视觉国际会议
  • ICCV 计算机视觉国际会议
  • ICCV 工作室
  • ICVS 计算机视觉系统国际会议
  • 网络日志和社交媒体国际会议
  • ISVC 视觉计算国际研讨会
  • 神经信息处理系统
  • 计算机视觉中的尺度空间理论
  • 计算机视觉中的 VLSM 变分、几何和水平集方法
  • 计算机视觉应用研讨会

在线资源

|

名字

|

csonline

|
| — | — |
| 描述 | 计算机视觉软件和项目的巨大列表，索引到维基百科 |
| 环 | http://homepages.inf.ed.ac.uk/rbf/CVonline/environ.htm |

|

名字

|

注释计算机视觉书目

|
| — | — |
| 描述 | 链接到计算机视觉主题、参考资料、软件等的巨大索引 |
| 环 | http://www.visionbib.com/bibliography/contents.html |

|

名字

|

NIST 在线工程统计手册(USG)

|
| — | — |
| 描述 | 统计手册，包括例子和软件 |
| 环 | http://www.itl.nist.gov/div898/handbook/ |

|

名字

|

计算机工业(大卫·洛)

|
| — | — |
| 描述 | 包括主要计算机视觉和成像产品公司的链接 |
| 环 | http://www.cs.ubc.ca/~lowe/vision.html |

十二、附录 D：扩展的 SDM 度量

图 D-1 提供了使用 SDM 的图像纹理的可视化。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

图 D-1 。SDM 扩展指标

清单 D-1 展示了来自第三章的扩展 SDM 指标。该准则可在网站上获得

http://www.apress.com/source-code/ComputerVisionMetrics

清单 D-1。 延伸 SDM 度量从第三章

/*
**        CREATED 1991 (C) KRIG RESEARCH, SCOTT KRIG - UNPUBLISHED SOFTWARE
**        PORTED TO MAC 2014
**
**                        ALL RIGHTS RESERVED
**
**        THIS SOFTWARE MAY BE USED FREELY FOR ACADEMIC AND RESEARCH PURPOSES.
**        REFERENCE THIS BOOK AND PROVIDE THIS NOTICE WHEN USING THE SOFTWARE.
*/

using namespace std;

#include <math.h>
#include <stdio.h>
#include <opencv2/opencv.hpp>
#include "/usr/local/include/opencv/cv.h"
#include "/usr/local/include/opencv2/core/core.hpp"
#include "/usr/local/include/opencv2/highgui/highgui.hpp"
#include <iostream>

using namespace cv;

#define TINY       0.0000000001
#define F6U        "%6f.3"
#define F6F        "%.6f"
#define F3F        "%.3f"
#define FXF        "%.0f"
#define FALSE 0
#define TRUE 1

typedef struct area {
        int x;
        int y;
        int dx;
        int dy;
} area_t;

typedef struct {
        double        t0;
        double        t90;
        double        t135;
        double        t45;
        double        tave;
        } ctab;

typedef struct {
        double        median;
        double        ave;
        double        adev;
        double        sdev;
        double        svar;
        double        skew;
        double        curt;
        int           min;
        int           max;
        ctab          xcentroid;
        ctab          ycentroid;
        ctab          _asm;
        ctab          low_frequency_coverage;
        ctab          total_coverage;
        ctab          corrected_coverage;
        ctab          total_power;
        ctab          relative_power;
        ctab          locus_length;
        ctab          locus_mean_density;
        ctab          bin_mean_density;
        ctab          containment;
ctab          linearity;
        ctab          linearity_strength;
        ctab          autocorrelation;
        ctab          covariance;
        ctab          inertia; /* haralick contrast */
        ctab          absolute_value;
        ctab          inverse_difference; /* haralick /* ctab          entropy; /* haralick /* ctab          correlation; /* haralick /* } glob_t;

glob_t        gt;

/* FUNCTIONS */

int i_sort (
int        *x,
int        n,
int        parm)
{
int        k,i,ii;
int        y,found;
int        xi;
int        n2, n2p;

x--;
for (k=1; k<n+1; k++) {
y = x[k];
for (i=k-1, found = FALSE; i>=0 && !found; ) {
xi = x[i];
ii = i+1;
if (y < xi) {
x[ii] = xi;
i--;
} else {
found = TRUE;
}
}
x[ii] = y;
}
if (parm == 0) return 0;
n2p = (n2=(n>>1))+1;
return ( n % 2 ? x[n2p] : (x[n2] + x[n2p]) >>1 );
}

int lmoment(
int        *data,
int        n,
double     *median,
double     *ave,
double     *adev,
double     *sdev,
double     *svar,
double     *skew,
double     *curt)
{
int        j;
double     s,p,ep=0.0;

if (n <= 1) return 0;

s=0.0;
for (j=1; j<=n;j++) s += (double)data[j];
*ave=s/n;
*adev=(*svar)=(*skew)=(*curt)=0.0;
for (j=1;j<=n;j++) {
*adev += abs(s=(double)data[j]-(*ave));
*svar += (p=s*s);
*skew += (p *= s);
*curt += (p *= s);
}

*adev /=n;
*svar = (*svar - ep*ep / n) / (n-1);
*sdev=sqrt (*svar);
if (*svar) {
s = (n*(*svar)*(*sdev));
if (s != 0) *skew /=s;
else *skew = 0;
s = (n*(*svar)*(*svar))-3.0;
if (s != 0) *curt = (*curt) / s;
else *curt = 0;
} else {
*skew = *curt = 0.0;
}
*median = 0;
if (n > 20000) return 0;

*median = (double)i_sort(data, n, 1);

return 0;

}

int        mean_sdev (
int        xp,
int        yp,
int        *xdata,
double     *xmean,
double     *xsdev,
double     *ymean,
double     *ysdev)
{
double     u_x1, a_x1;
int        mx, my,v,t,x,y,z, offset;
int        dif[256];

/* first calculate mean */
offset = 256 * yp;
x = y = 0;
for (z=0; z < 256; x += xdata[offset+z], z++);
for (z=0; z < 256; y += xdata[xp + (z*256)], z++);

mx = x / 256.;
*xmean = (double)mx;
my = y / 256.;
*ymean = (double)my;

/* now calculate standard deviation */
x = y = 0;
z=0;
while (z < 256) {
v = mx - xdata[offset+z];
x += v*v;
v = my - xdata[xp + (z*256)];
y += v*v;
z++;
}
*xsdev = x / 256;
*ysdev = y / 256;

return 0;
}

int lohi(
int     n,
int     *cv,
int     *lo,
int     *hi)
{
int        x;
int        lv, hv;

lv = 0x1fffff;
hv =0;
x=0;
while (x < n) {
if (cv[x] < lv) lv = cv[x];
if (cv[x] > hv) hv = cv[x];
x++;
}

*lo = lv;
*hi = hv;

return 0;
}

int        savegt (
ctab       *ctp,
double     dv1,
double dv2,
double dv3,
double dv4)
{

ctp->t0 = dv1;
ctp->t90 = dv2;
ctp->t135 = dv3;
ctp->t45 = dv4;
ctp->tave = (dv1 + dv2 + dv3 + dv4) / 4;

return 0;
}

int     gtput (
char    *prompt,
char    *fs,
ctab    *ctp,
FILE    *fstream)
{
char        str[256];
char        form[256];

fputs(prompt, fstream);
sprintf(form, "%s       %s    %s    %s    %s \n", fs, fs, fs, fs, fs);
sprintf(str, form, ctp->t0, ctp->t90, ctp->t135, ctp->t45, ctp->tave);
fputs(str, fstream);

return 0;

}

int     put_txfile(
FILE    *fstream)
{
char        str[256];

sprintf(str, "gray value moments:min:%u max:%u mean:%u\n",gt.min,gt.max, (int )gt.ave);
fputs(str, fstream);
sprintf(str, "moments:  adev:%.4f  sdev:%.4f  svar:%.4f  skew:%.6f  curt:%.6f \n",
gt.adev, gt.sdev, gt.svar, gt.skew, gt.curt);
fputs(str, fstream);

fputs("\n", fstream);
fputs("         --------------------------------------\n", fstream);
fputs("            0deg   90deg   135deg   45deg   ave\n", fstream);
fputs("         --------------------------------------\n", fstream);
gtput("xcentroid               ", FXF, &gt.xcentroid, fstream);
gtput("ycentroid               ", FXF, &gt.ycentroid, fstream);
gtput("low_frequency_coverage  ", F3F, &gt.low_frequency_coverage, fstream);
gtput("total_coverage          ", F3F, &gt.total_coverage, fstream);
gtput("corrected_coverage      ", F3F, &gt.corrected_coverage, fstream);
gtput("total_power             ", F3F, &gt.total_power, fstream);
gtput("relative_power          ", F3F, &gt.relative_power, fstream);
gtput("locus_length            ", FXF, &gt.locus_length, fstream);
gtput("locus_mean_density      ", FXF, &gt.locus_mean_density, fstream);
gtput("bin_mean_density        ", FXF, &gt.bin_mean_density, fstream);
gtput("containment             ", F3F, &gt.containment, fstream);
gtput("linearity               ", F3F, &gt.linearity, fstream);
gtput("linearity_strength      ", F3F, &gt.linearity_strength, fstream);

return 0;

}

int     texture(
char    *filename)
{
char        str[256];
int        pmx[256], pmy[256];
int        x,y,z,dx,dy,dz,sz,bpp;
int        accum, tmin, tmax;
int        tmin2, tmax2, yc;
int        *data;
int        mval0, mval90, mval135, mval45;
double  median, ave, adev, sdev, svar, skew, curt;
double  median2, ave2, adev2, sdev2, svar2, skew2, curt2;
int        *dm0, *dm90, *dm135, *dm45;
FILE       *fstream;
int        i0, i90, i135, i45, iave, n;
int        c0, c90, c135, c45, cave;
int        p0, p90, p135, p45, pave;
double     d0, d90, d135, d45, dave;
double     f0, f90, f135, f45;

/**************************************************************/
/* READ THE INPUT IMAGE, EXPECT IT TO BE 8-bit UNSIGNED INT   */
/* Mat type conversion is simple in openCV, try it later      */

Mat imageIn = cv::imread(filename);
dx = imageIn.rows;
dy = imageIn.cols;
unsigned char *pixels = imageIn.data;

cout << "dx" << dx << "dy" << dy << " elemSize() " << imageIn.elemSize() <<endl ;
data = (int *)malloc(dx * dy * 4);
if(data == 0)
{
cout << "mallocerror in texture()" <<endl ;
}
for(y=0; y < dy; y++) {
for(x=0; x < dx; x++) {
int pixel = (int )*(imageIn.ptr(x,y));
if(pixel > 255) { pixel = 255; }
data[(y * dx) + x] = pixel;
}
}

/**********************************************************/
/* PART 1 - get normal types of statistics from pixel data */

lmoment(data, sz, &median, &ave, &adev, &sdev, &svar, &skew, &curt);
lohi(sz, data, &tmin, &tmax);

gt.median = median;
gt.ave = ave;
gt.adev = adev;
gt.sdev = sdev;
gt.svar = svar;
gt.skew = skew;
gt.curt = curt;
gt.min = tmin;
gt.max = tmax;

fstream = fopen("SDMExtended.txt", "w");
if (fstream <= 0) {
cout << "#cannot create file" <<endl ;
return 0;
}

sprintf(str, "texture for object:     %s\n", filename);
fputs(str, fstream);
sprintf(str, "area:                   %u, %u \n", dx, dy);
fputs(str, fstream);

/**********************************************************/
/* PART 2 - calculate the 4 spatial dependencymatricies/* dm0   = (int *)malloc( 256*256*4 );
dm90  = (int *)malloc( 256*256*4 );
dm135 = (int *)malloc( 256*256*4 );
dm45  = (int *)malloc( 256*256*4 );
if ((dm0==0) || (dm90==0) || (dm135==0) || (dm45==0)) {
cout << "mallocerror in texture2" <<endl ;
return 0;
}

x=0;
while (x < 256*256) {
dm0[x] = dm90[x] = dm135[x] = dm45[x] = 0;
x++;
}

y=0;
while (y < dy-1) {
yc = dx * y;

x=0;
while (x < dx-1) {

dm0[ (data[yc + x]&0xff) + ((( data[yc + x + 1]  )<< 8)&0xff00) ]++;
dm0[ (data[yc + x + 1]&0xff) + ((( data[yc + x]  )<< 8)&0xff00) ]++;
dm90[ (data[yc + x]&0xff) + ((( data[yc + x + dx]  )<< 8)&0xff00) ]++;
dm90[ (data[yc + x + dx]&0xff) + ((( data[yc + x]  )<< 8)&0xff00) ]++;
dm135[ (data[yc + x]&0xff) + ((( data[yc + x + dx + 1]  )<< 8)&0xff00) ]++;
dm135[ (data[yc + x + dx + 1]&0xff) + ((( data[yc + x]  )<< 8)&0xff00) ]++;
dm45[ (data[yc + x + 1]&0xff) + ((( data[yc + x + dx]  )<< 8)&0xff00) ]++;
dm45[ (data[yc + x + dx]&0xff) + ((( data[yc + x + 1]  )<< 8)&0xff00) ]++;

x++;
}
y++;
}

/***************** CALCULATE TEXTURE METRICS ******************/

/* centroid/* pmx[0] = pmx[1] = pmx[2] = pmx[3] = 0;
pmy[0] = pmy[1] = pmy[2] = pmy[3] = 0;
i0 = i90 = i135 = i45 = 0;
y=0;
while (y < 256) {
x=0;
while (x < 256) {
z = x + (256 * y);
pmx[0] += (x * dm0[z]);
pmy[0] += (y * dm0[z]); i0 += dm0[z];
pmx[1] += (x * dm90[z]);
pmy[1] += (y * dm90[z]); i90 += dm90[z];
pmx[2] += (x * dm135[z]);
pmy[2] += (y * dm135[z]); i135 += dm135[z];
pmx[3] += (x * dm45[z]);
pmy[3] += (y * dm45[z]); i45 += dm45[z];
x++;
}
y++;
}
pmx[0] = pmx[0] / i0;
pmy[0] = pmy[0] / i0;
pmx[1] = pmx[1] / i90;
pmy[1] = pmy[1] / i90;
pmx[2] = pmx[2] / i135;
pmy[2] = pmy[2] / i135;
pmx[3] = pmx[3] / i45;
pmy[3] = pmy[3] / i45;
x = (pmx[0] + pmx[1] + pmx[2] + pmx[3]) / 4;
y = (pmy[0] + pmy[1] + pmy[2] + pmy[3]) / 4;

gt.xcentroid.t0 = pmx[0];
gt.ycentroid.t0 = pmy[0];
gt.xcentroid.t90 = pmx[1];
gt.ycentroid.t90 = pmy[1];
gt.xcentroid.t135 = pmx[2];
gt.ycentroid.t135 = pmy[2];
gt.xcentroid.t45 = pmx[3];
gt.ycentroid.t45 = pmy[3];
gt.xcentroid.tave = x;
gt.ycentroid.tave = y;

/* low frequency coverage */
i0 = i90 = i135 = i45 = 0;
c0 = c90 = c135 = c45 = 0;
x=0;
while (x < 256*256) {
if((dm0[x] != 0) && (dm0[x] < 3)) i0++;
if((dm90[x] != 0) && (dm90[x] < 3)) i90++;
if((dm135[x] != 0) && (dm135[x] < 3)) i135++;
if((dm45[x] != 0) && (dm45[x] < 3)) i45++;
if(!dm0[x]) c0++;
if(!dm90[x]) c90++;
if(!dm135[x]) c135++;
if(!dm45[x]) c45++;
x++;
}
d0 = (double)i0 / 0x10000;
d90 = (double)i90 / 0x10000;
d135 = (double)i135 / 0x10000;
d45 = (double)i45 / 0x10000;

savegt(&gt.low_frequency_coverage, d0, d90, d135, d45);

d0 = (double)c0 / 0x10000;
d90 = (double)c90 / 0x10000;
d135 = (double)c135 / 0x10000;
d45 = (double)c45 / 0x10000;

savegt(&gt.total_coverage, d0, d90, d135, d45);

d0 = (c0-i0) / (double)0x10000;
d90 = (c90-i90) / (double)0x10000;
d135 = (c135-i135) / (double)0x10000;
d45 = (c45-i45) / (double)0x10000;

savegt(&gt.corrected_coverage, d0, d90, d135, d45);

/* power */
i0 = i90 = i135 = i45 = 0;
c0 = c90 = c135 = c45 = 0;
p0 = p90 = p135 = p45 = 0;
y=0;
while (y < 256) {
z = y * 256;
x=0;
while (x < 256) {
n = x-y;
if(n < 0) n = -n;
if(dm0[x+z] != 0) { i0 += n; c0++;  }
if(dm90[x+z] != 0) { i90 += n; c90++; }
if(dm135[x+z] != 0) { i135 += n; c135++; }
if(dm45[x+z] != 0) { i45 += n; c45++; }
x++;
}
y++;
}
d0 =  (i0 / 0x10000);
d90 =  (i90 / 0x10000);
d135 =  (i135 / 0x10000);
d45 =  (i45 / 0x10000);

savegt(&gt.total_power, d0, d90, d135, d45);

d0 =  (i0 / c0);
d90 =  (i90 / c90);
d135 =  (i135 / c135);
d45 =  (i45 / c45);

savegt(&gt.relative_power, d0, d90, d135, d45);

/* locus density */
d0 = d90 = d135 = d45 = 0.0;
c0 = c90 = c135 = c45 = 0;
p0 = p90 = p135 = p45 = 0;
y=0;
while (y < 256) {
z = y * 256;
i0 = i90 = i135 = i45 = 0;
x=0;
while (x < 256) {
n = x-y;
if(n < 0) n = -n;
if((dm0[x+z] != 0) && (n < 7)) { c0++; p0 += dm0[x+z]; }
if((dm90[x+z] != 0) && (n < 7)) { c90++; p90 += dm90[x+z]; }
if((dm135[x+z] != 0) && (n < 7)) { c135++; p135 += dm135[x+z]; }
if((dm45[x+z] != 0) && (n < 7)) { c45++; p45 += dm45[x+z]; }

if((dm0[x+z] == 0) && (n < 7)) { i0++; }
if((dm90[x+z] == 0) && (n < 7)) { i90++; }
if((dm135[x+z] == 0) && (n < 7)) { i135++; }
if((dm45[x+z] == 0) && (n < 7)) { i45++; }

x++;
}
if(!i0) d0 += 1;
if(!i90) d90 += 1;
if(!i135) d135 += 1;
if(!i45) d45 += 1;
y++;
}

savegt(&gt.locus_length, d0, d90, d135, d45);

d0 = (p0/c0);
d90 = (p90/c90);
d135 = (p135/c135);
d45 = (p45/c45);

savegt(&gt.locus_mean_density, d0, d90, d135, d45);

/* density */
c0 = c90 = c135 = c45 = 0;
p0 = p90 = p135 = p45 = 0;
x=0;
while ( x < 256*256) {
if(dm0[x] != 0) { c0 += dm0[x]; p0++; }
if(dm90[x] != 0) { c90 += dm90[x]; p90++; }
if(dm135[x] != 0) { c135 += dm135[x]; p135++; }
if(dm45[x] != 0) { c45 += dm45[x]; p45++; }
x++;
}
d0 = c0 / p0;
d90 = c90 / p90;
d135 = c135 / p135;
d45 = c45 / p45;

savegt(&gt.bin_mean_density, d0, d90, d135, d45);

/* containment */
i0 = i90 = i135 = i45 = 0;
x=0;
while (x < 256) {
if(dm0[x]) i0++; if(dm0[256*256 - x - 1]) i0++;
if(dm90[x]) i90++; if(dm90[256*256 - x - 1]) i90++;
if(dm135[x]) i135++; if(dm135[256*256 - x - 1]) i135++;
if(dm45[x]) i45++; if(dm45[256*256 - x - 1]) i45++;

if(dm0[x*256]) i0++; if(dm0[(x*256)+255]) i0++;
if(dm90[x*256]) i90++; if(dm90[(x*256)+255]) i90++;
if(dm135[x*256]) i135++; if(dm135[(x*256)+255]) i135++;
if(dm45[x*256]) i45++; if(dm45[(x*256)+255]) i45++;

x++;
}

d0 = 1.0 - ((double)i0 / 1024.0);
d90 = 1.0 - ((double)i90 / 1024.0);
d135 = 1.0 - ((double)i135 / 1024.0);
d45 = 1.0 - ((double)i45 / 1024.0);

savegt(&gt.containment, d0, d90, d135, d45);

/* linearity */
i0 = i90 = i135 = i45 = 0;
c0 = c90 = c135 = c45 = 0;
y=0;
while (y < 256) {
z = y * 256;
if(dm0[z + y] > 1) { i0++; c0 += dm0[z+y]; }
if(dm90[z + y] > 1) { i90++; c90 += dm90[z+y]; }
if(dm135[z + y] > 1) { i135++; c135 += dm135[z+y]; }
if(dm45[z + y] > 1) { i45++; c45 += dm45[z+y]; }
y++;
}
d0 = (double)i0 / 256.;
d90 = (double)i90 / 256.;
d135 = (double)i135 / 256.;
d45 = (double)i45 / 256.;

savegt(&gt.linearity, d0, d90, d135, d45);

/* linearity strength */
d0 = (c0/(i0+.00001)) / 256.;
d90 = (c90/(i90+.00001)) / 256.;
d135 = (c135/(i135+.00001)) / 256.;
d45 = (c45/(i45+.00001)) / 256.;

savegt(&gt.linearity_strength, d0, d90, d135, d45);

/* WRITE ALL STATISTICS INgt. STRUCTURE TO OUTPUT FILE */
put_txfile(fstream);

/*  clip to max value 255 */
mval0 = mval90 = mval135 = mval45 = 0;
x=0;
while (x < 256*256) {
if(dm0[x] > 255)  dm0[x] = 255;
if(dm90[x] > 255)  dm90[x] = 255;
if(dm135[x] > 255)  dm135[x] = 255;
if(dm45[x] > 255)  dm45[x] = 255;
x++;
}

/******************************************************/
/* Convert data to unsigned char to write intopng/* unsigned char *dm0b   = (unsigned char *)malloc( 256*256);
unsigned char *dm90b  = (unsigned char *)malloc( 256*256);
unsigned char *dm135b = (unsigned char *)malloc( 256*256);
unsigned char *dm45b  = (unsigned char *)malloc( 256*256);
if((dm0b==0) || (dm90b==0) || (dm135b==0) || (dm45b==0)) {
cout << "mallocerror in texture3" <<endl ;
return 0;
}

x=0;
while (x < 256*256) {
dm0b[x] = (unsigned char ) (dm0[x] & 0xff);
dm90b[x] = (unsigned char ) (dm90[x] & 0xff);
dm135b[x] = (unsigned char ) (dm135[x] & 0xff);
dm45b[x] = (unsigned char ) (dm45[x] & 0xff);
x++;
}

/*
* write output to 4 quadrants:        0=0, 1=90, 2=135, 3=145
/* char outfile[256];

sprintf(outfile, "%s_SDMQUadrant_0deg_8UC1.png", filename);
Mat SDMQuadrant0(256, 256, CV_8UC1, dm0b);
imwrite(outfile, SDMQuadrant0);
sprintf(outfile, "%s_SDMQUadrant_90deg_8UC1.png", filename);
Mat SDMQuadrant90(256, 256, CV_8UC1, dm90b);
imwrite(outfile, SDMQuadrant90);
sprintf(outfile, "%s_SDMQUadrant_135deg_8UC1.png", filename);
Mat SDMQuadrant135(256, 256, CV_8UC1, dm135b);
imwrite(outfile, SDMQuadrant135);
sprintf(outfile, "%s_SDMQUadrant_45deg_8UC1.png", filename);
Mat SDMQuadrant45(256, 256, CV_8UC1, dm45b);
imwrite(outfile, SDMQuadrant45);

free(dm0);
free(dm90);
free(dm135);
free(dm45);
free(data);
free(dm0b);
free(dm90b);
free(dm135b);
free(dm45b);
fclose(fstream);

return 0;

}

int main (int argc, char **argv)
{
cout << "8-bit unsigned image expected as input" <<endl ;
texture (argv[1]);
return 0;
}
绝不原创的飞龙
关注
专栏目录
计算机视觉相关的评价指标
h1yupyp的专栏
06-28 5536
目录：一：准确率 （Accuracy） 、错误率 （Error rate）二：混淆矩阵 （Confusion Matrix）三：召回率（Recall）、精确率（Precision）四： P-R曲线、平均精度（Average-Precision，AP）、F指标五：受试者工作特征曲线（Receiver OperatingCharacteristic，ROC）、AUC（Area Under Curve）...
计算机视觉基础考查试卷1
08-08
1. **性能度量指标**：Precision（精确率）、Recall（召回率）、BEP（Break-Even Point）、F1分数、ROC曲线和AUC（Area Under the Curve）都是评估机器学习模型性能的重要指标。Precision衡量的是预测为正例的样本中...
计算机视觉度量指标教程（一）
龙哥盟
08-22 1357
污垢。这是一罐泥土。是的。。。。这瓶泥土有用吗？如果你不想要，就还给我。*——加勒比海盗，*杰克斯派洛和蒂亚·达尔玛这项工作侧重于计算机视觉度量领域的一个部分，从特征描述度量的角度，或者如何描述、计算和设计构成图像中较大对象的宏观特征和微观特征。重点是视觉流水线的像素端，而不是后端训练、分类、机器学习和匹配阶段。这本书适合参考，更高层次的课程，以及计算机视觉的自我导向学习。这本书的目标读者是已经熟悉计算机视觉和图像处理的人；
计算机视觉模型常用评价指标
Mike_honor的博客
08-04 4337
分类任务常用准确率、精确率、召回率、F1_scores、ROC曲线等指标来评价模型的优劣，当然这些基础指标也可以用来评价分割模型或检测模型，它们基本上是可以通用的。混淆矩阵是对分类问题预测结果的总结，也是衡量分类型模型准确度中最基本，最直观，计算最简单的方法。混淆矩阵中含有4个分类问题的基础指标，如下表所示。.........
计算机视觉领域常见的度量指标
weixin_34344677的博客
10-28 1048
一：Precision, Recall, F-score信息检索、分类、识别、翻译等领域两个最基本指标是召回率(Recall Rate)和准确率(Precision Rate------注意统计学习方法中precesion称为精确率，而准确率为accuracy 是分类正确的样本除以总样本的个数。)，召回率也叫查全率，准确率也叫查准率，概念公式:            召回率(Recall)=  系...
图像特征Vol.1：计算机视觉特征度量|第一弹：【纹理区域特征】
Yaoyao2024的博客
10-27 1921
🍊什么是计算机视觉特征？简单来说就是图像特征，对于我们来说，看到一张图片，能很自然的说出和描述图像中的一些特征，但是同样的图片，丢给计算机，只是一个二维矩阵，计算机需要从这个图像中提取计算得到一些数值表示，来描述这个图像所具有的特征：颜色、形状、纹理等。🍊什么是计算机视觉特征度量？（如颜色直方图、梯度直方图、形状描述符），（如图像检索、目标跟踪、人脸识别、物体识别等）的。根据，可以将特征度量分为这三类：🍊特征度量的方法。
计算机视觉(AI)面试大全
sazass的博客
06-04 7239
面试题
计算机视觉 目标分割
mengxianglong123的博客
07-17 2624
一、目标分割简介 1.1 图像分割的定义 1.2 任务类型 1.2.1 任务描述 1.2.2 任务类型 1.3 常用的开源数据集 1.3.1 VOC数据集 1.3.2 城市风光Cityscapes数据集 1.4 评价指标 1.4.1 像素精度 1.4.2 平均像素精度 1.4.3 平均交并比 二、语义分割：FCN和UNet 1. FCN网络 1.1 网络结构 1.1.1 全卷积部分 1.1.2 上采样部分 1.2 跳层连接 1.3 总结 2. Unet网络 三、UNet案例 1.1 任务及数据集简介 1.2
CV：计算机视觉技最强学习路线之CV简介(传统视觉技术/相关概念)、早期/中期/近期应用领域(偏具体应用)、经典CNN架构(偏具体算法)概述、常用工具/库/框架/产品、环境安装、常用数据集、编程技巧
热门推荐
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
10-18 7万+
​ CV：计算机视觉技最强学习路线之CV简介(传统视觉技术/相关概念)、早期/中期/近期应用领域(偏具体应用)、经典CNN架构(偏具体算法)概述、常用工具/库/框架/产品、环境安装、常用数据集、编程技巧 目录 最新文章 计算机视觉技最强学习路线 ☆☆一、计算机视觉的简介 ☆☆二、计算机视觉相关概念简介 ☆☆三、传统的计算机视觉技术之机器视觉/计算机图形学
计算机视觉实验：人脸识别系统设计
weixin_51735061的博客
07-31 5032
实验内容设计计算机视觉目标识别系统，与实际应用有关（建议：最终展示形式为带界面可运行的系统），以下内容选择其中一个做。1.人脸识别系统设计(1)人脸识别系统设计（必做）：根据课堂上学习的理论知识（包括特征提取、分类器设计），设计一个人脸识别系统，该系统具有较好的识别率。可在提供的AR人脸图片数据集（120人）、Feret人脸图片数据集（175人）、人脸视频数据集（10人）、真实采集的人脸视频或其他公开数据集上展开实验。(2)人脸识别系统提升（至少选择其中1。
视觉分割的定义与性能度量
ChuanhuaYu的博客
06-26 1072
整理了图像与视频中的一些分割任务的定义和任务需求，同时给出了对这类任务的模型性能的度量方法。
人脸识别人工智能计算机视觉课设
06-25
人脸识别人工智能计算机视觉课程设计是一门深入探讨如何利用计算机技术模拟人类视觉感知的实践课程。在这个项目中，我们将重点关注人工智能（AI）在计算机视觉领域中的应用，特别是人脸识别技术。计算机视觉是AI的一...
计算机视觉深度学习入门五讲：优化篇.pdf
01-22
而对于无监督学习，则可能需要优化类内方差、类间距离度量或信息压缩率等指标。在强化学习场景下，目标则是最大化时间轴上的综合收益。 #### 基本优化方法 文档中提到了几种常见的优化方法： - **梯度下降...
正态分布（高斯分布）及Python实现——计算机视觉修炼之路（三） 计算机视觉.pdf
04-21
在计算机视觉中，高斯函数是一个极为重要的函数。使用核方法，高斯核函数可以把低维数据映射到高维，我们在这个高维的非线性流程上处理数据；高斯噪声、高斯滤波器等方法经常在图像加噪去噪过程中使用。在信息论中，...
测表自动组装机_三维3D设计图纸.zip
09-29
测表自动组装机_三维3D设计图纸.zip
美萍民宿客栈收银管理系统标准版2021v1
09-29
美萍民宿客栈收银管理系统标准版2021v1官方正式版，要有加密狗才可以安装使用。
基于ThinkPHP6的ChatGPT接口接入与调用设计源码
最新发布
09-29
该项目是一款基于ThinkPHP6框架开发的ChatGPT接口接入与调用设计源码，包含51个文件，其中包括33个PHP源代码文件、4个HTML文件、4个Git忽略文件、2个文本文件、2个Markdown文件、1个htaccess文件、1个JSON文件、1个锁定文件和1个ICO文件。该系统实现了对ChatGPT接口的调用与集成，适用于需要集成智能聊天功能的Web应用开发。
基于C#的教师授课系统设计与实现.docx
09-29
基于C#的教师授课系统设计与实现.docx
基于asp.net的房产公司综合信息管理系统设计与实现.docx
09-29
基于asp.net的房产公司综合信息管理系统设计与实现.docx
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值