JAVA数字图像处理常用算法
图像处理算法

图像处理算法随着科技的不断发展,数字图像处理得到了广泛的应用。
图像处理算法是数字图像处理领域中最重要的研究领域之一,它们能够从一幅图像中提取出有用的信息。
本文将会介绍一些常用的图像处理算法。
1. 图像修复算法在许多应用场景中,图像可能受到噪点、瑕疵、损坏、失真等影响,这些影响会严重降低图像的质量和可用性。
图像修复算法的目标是通过复原被噪声、失真等影响破坏的图像,使其恢复到原本的清晰度或者增强其可视化。
常用的图像修复算法有基于滤波的算法、插值算法和卷积神经网络(CNN)等。
其中,基于滤波的算法包括最常见的均值滤波、中值滤波、高斯滤波等;插值算法包括最近邻插值、双线性插值、三次样条插值等。
值得注意的是,卷积神经网络的优点在于它可以通过学习数据的特征,实现自动图像修复的目的。
2. 图像分割算法图像分割是将一幅图像分成若干个部分或区域,以获得图像中物体的轮廓、形状、色彩、纹理等特征,是图像处理领域中的关键技术之一。
图像分割不仅在医学、遥感等领域有很广泛的应用,还可以用于人脸识别、图像分类等领域。
常用的图像分割算法主要包括阈值分割、边缘分割、区域增长算法和基于聚类的分割算法等。
在阈值分割算法中,需要将图像转换为灰度图像,并确定一个灰度值作为分割阈值,通过比较像素与阈值的关系,在图像上进行二值化。
边缘分割算法是根据图像中物体的不同物理特征提取物体的边缘,然后通过边缘将物体进行分割。
在区域增长算法中,将图像上所有像素点作为种子点,通过像素点与种子点之间的相似度来进行某个像素点的区域扩展。
基于聚类的分割算法则是将图像像素进行聚类,归纳出不同的类别,并以此进行图像分割。
3. 图像几何校正算法在实际应用场景中,由于摄像机的位置、角度、校正参数等因素的影响,图像可能会呈现出不同程度的畸变。
为了消除这些影响,需要利用图像几何校正算法对图像进行校正和纠正。
常用的图像几何校正算法包括图像基础变换、透视变换和仿射变换等。
其中,图像基础变换主要包括平移、旋转、缩放和翻转等,通过将图像进行平移、旋转等处理,使图像达到需要的效果。
数字图像处理中常见的滤波算法研究

数字图像处理中常见的滤波算法研究在数字图像处理中,滤波是一种常用的技术,用于改善或修复图像的质量。
滤波算法可以通过降噪、增强边缘、图像平滑等方式来提高图像的视觉效果。
本文将介绍几种常见的滤波算法及其应用。
1. 均值滤波均值滤波是最简单的滤波算法之一。
它通过计算像素周围邻域的平均值来替换该像素的灰度值。
均值滤波可以有效地降低图像中的噪声,但也会导致图像失去细节信息。
因此,适用于对噪声敏感但对图像细节要求不高的应用场景。
2. 中值滤波与均值滤波相比,中值滤波可以更好地去除图像中的噪声同时保留更多的图像细节。
中值滤波算法使用像素邻域的中值来替换该像素的灰度值。
中值滤波对于椒盐噪声的去除效果尤为明显,因此常用于医学图像、科学图像等领域。
3. 高斯滤波高斯滤波是一种常用的线性平滑滤波算法,通过计算像素周围邻域的加权平均值来替换该像素的灰度值。
高斯滤波算法在滤波过程中,使用了一个以该像素为中心的二维高斯函数作为权重,使得距离该像素越近的邻域像素具有更大的权重。
高斯滤波可以有效平滑图像,同时保留边缘信息。
4. Roberts算子Roberts算子是一种边缘检测算法,可以用于提取图像中的边缘信息。
Roberts 算子分为水平和垂直两个方向,通过计算像素与其对角线相邻像素之间的差值来确定边缘的存在。
Roberts算子简单、快速,并且对噪声具有一定的鲁棒性。
5. Sobel算子Sobel算子是一种著名的梯度算子,用于边缘检测和图像增强。
Sobel算子不仅可以检测边缘,还可以确定边缘的方向。
Sobel算子通过计算像素和其周围邻域像素的加权差值来确定边缘的强度,进而提取图像中的边缘信息。
6. Laplacian算子Laplacian算子是一种常见的二阶微分算子,用于图像锐化和边缘检测。
Laplacian算子通过计算像素周围邻域像素的二阶导数来检测边缘。
Laplacian算子可以增强图像中的细节信息,但也容易受到噪声的影响。
java离散点平滑算法

java离散点平滑算法
摘要:
1.Java 离散点平滑算法概述
2.离散点平滑算法的原理
3.离散点平滑算法的实现方法
4.Java 离散点平滑算法的实例
5.离散点平滑算法的应用领域
正文:
【1.Java 离散点平滑算法概述】
离散点平滑算法(Discrete Point Smoothing Algorithm)是一种在计算机图形学和图像处理领域常用的算法,主要用于处理离散数据的平滑处理。
通过该算法,可以有效地减少离散数据点之间的锯齿状,使数据点之间的过渡更加平滑。
在Java 编程语言中,实现离散点平滑算法可以为程序员提供更加美观且自然的图形和图像效果。
【2.离散点平滑算法的原理】
离散点平滑算法的原理是通过对离散点进行加权平均处理,使得离散点之间的过渡更加平滑。
具体来说,就是将离散点周围的其他离散点加入到计算过程中,根据其距离进行加权平均,从而得到一个新的平滑点。
这个过程可以通过迭代进行,直到达到预期的平滑效果。
【3.离散点平滑算法的实现方法】
在Java 中实现离散点平滑算法,可以通过以下步骤:
1.创建一个二维数组,用于存储离散点的坐标。
2.计算离散点周围的其他离散点,并计算它们之间的距离。
3.根据距离对离散点进行加权平均处理,得到新的平滑点。
4.将新的平滑点加入到二维数组中,并更新离散点的坐标。
5.重复步骤3 和4,直到达到预期的平滑效果或达到最大迭代次数。
数字图像处理中的图像压缩算法

数字图像处理中的图像压缩算法随着科技和计算机技术的不断发展,数字图像处理成为了一个非常重要的领域。
数字图像处理技术广泛应用于各个领域,如图像储存、通信、医疗、工业等等。
在大量的图像处理中,图像压缩算法是非常关键的一环。
本文将介绍一些数字图像处理中的图像压缩算法。
一、无损压缩算法1. RLE 算法RLE(Run Length Encoding)算法是常见的图像无损压缩算法之一,它的主要思想是将连续的像素值用一个计数器表示。
比如将连续的“aaaa”压缩成“a4”。
RLE 算法相对比较简单,适用于连续的重复像素值较多的图像,如文字图片等。
2. Huffman 编码算法Huffman 编码算法是一种将可变长编码应用于数据压缩的算法,主要用于图像无损压缩中。
它的主要思想是将频率较高的字符用较短的编码,频率较低的字符用较长的编码。
将编码表储存在压缩文件中,解压时按照编码表进行解码。
Huffman 编码算法是一种效率较高的无损压缩算法。
二、有损压缩算法1. JPEG 压缩算法JPEG(Joint Photographic Experts Group)压缩算法是一种在有损压缩中广泛应用的算法。
该算法主要是针对连续色块和变化缓慢的图像进行处理。
JPEG 压缩算法的主要思想是采用离散余弦变换(DCT)将图像分割成小块,然后对每个小块进行频率分析,去除一些高频信息,再进行量化,最后采用 Huffman 编码进行压缩。
2. MPEG 压缩算法MPEG(Moving Picture Experts Group)压缩算法是一种针对视频压缩的算法,它主要是对视频序列中不同帧之间的冗余信息进行压缩。
该算法采用了空间域和时间域的压缩技术,包括分块变换编码和运动补偿等方法。
在分块变换编码中,采用离散余弦变换或小波变换来对视频序列进行压缩,再通过运动估计和补偿等方法,去除冗余信息。
三、总结数字图像处理中的图像压缩算法有很多种,其中无损压缩算法和有损压缩算法各有特点。
数字图像处理领域的二十四个典型算法

数字图像处理领域的⼆⼗四个典型算法数字图像处理领域的⼆⼗四个典型算法及vc实现、第⼀章⼀、256⾊转灰度图⼆、Walsh变换三、⼆值化变换四、阈值变换五、傅⽴叶变换六、离散余弦变换七、⾼斯平滑⼋、图像平移九、图像缩放⼗、图像旋转数字图像处理领域的⼆⼗四个典型算法及vc实现、第三章图像处理,是对图像进⾏分析、加⼯、和处理,使其满⾜视觉、⼼理以及其他要求的技术。
图像处理是信号处理在图像域上的⼀个应⽤。
⽬前⼤多数的图像是以数字形式存储,因⽽图像处理很多情况下指数字图像处理。
本⽂接下来,简单粗略介绍下数字图像处理领域中的24个经典算法,然后全部算法⽤vc实现。
由于篇幅所限,只给出某⼀算法的主体代码。
ok,请细看。
⼀、256⾊转灰度图算法介绍(百度百科):什么叫灰度图?任何颜⾊都有红、绿、蓝三原⾊组成,假如原来某点的颜⾊为RGB(R,G,B),那么,我们可以通过下⾯⼏种⽅法,将其转换为灰度: 1.浮点算法:Gray=R*0.3+G*0.59+B*0.11 2.整数⽅法:Gray=(R*30+G*59+B*11)/100 3.移位⽅法:Gray =(R*28+G*151+B*77)>>8; 4.平均值法:Gray=(R+G+B)/3; 5.仅取绿⾊:Gray=G; 通过上述任⼀种⽅法求得Gray后,将原来的RGB(R,G,B)中的R,G,B统⼀⽤Gray替换,形成新的颜⾊RGB(Gray,Gray,Gray),⽤它替换原来的RGB(R,G,B)就是灰度图了。
灰度分为256阶。
所以,⽤灰度表⽰的图像称作灰度图。
程序实现: ok,知道了什么叫灰度图,下⾯,咱们就来实现此256⾊灰度图。
这个Convert256toGray(),即是将256⾊位图转化为灰度图:void Convert256toGray(HDIB hDIB) { LPSTR lpDIB; // 由DIB句柄得到DIB指针并锁定DIB lpDIB = (LPSTR) ::GlobalLock((HGLOBAL)hDIB); // 指向DIB象素数据区的指针 LPSTR lpDIBBits; // 指向DIB象素的指针 BYTE * lpSrc; // 图像宽度 LONG lWidth; // 图像⾼度 LONG lHeight; // 图像每⾏的字节数 LONG lLineBytes; // 指向BITMAPINFO结构的指针(Win3.0) LPBITMAPINFO lpbmi; // 指向BITMAPCOREINFO结构的指针 LPBITMAPCOREINFO lpbmc; // 获取指向BITMAPINFO结构的指针(Win3.0) lpbmi = (LPBITMAPINFO)lpDIB; // 获取指向BITMAPCOREINFO结构的指针 lpbmc = (LPBITMAPCOREINFO)lpDIB; // 灰度映射表 BYTE bMap[256]; // 计算灰度映射表(保存各个颜⾊的灰度值),并更新DIB调⾊板 int i,j; for (i = 0; i < 256;i ++) { // 计算该颜⾊对应的灰度值 bMap[i] = (BYTE)(0.299 * lpbmi->bmiColors[i].rgbRed + 0.587 * lpbmi->bmiColors[i].rgbGreen + 0.114 * lpbmi->bmiColors[i].rgbBlue + 0.5); // 更新DIB调⾊板红⾊分量 lpbmi->bmiColors[i].rgbRed = i; // 更新DIB调⾊板绿⾊分量 lpbmi->bmiColors[i].rgbGreen = i; // 更新DIB调⾊板蓝⾊分量 lpbmi->bmiColors[i].rgbBlue = i; // 更新DIB调⾊板保留位 lpbmi->bmiColors[i].rgbReserved = 0; } // 找到DIB图像象素起始位置 lpDIBBits = ::FindDIBBits(lpDIB); // 获取图像宽度 lWidth = ::DIBWidth(lpDIB); // 获取图像⾼度 lHeight = ::DIBHeight(lpDIB); // 计算图像每⾏的字节数 lLineBytes = WIDTHBYTES(lWidth * 8); // 更换每个象素的颜⾊索引(即按照灰度映射表换成灰度值) //逐⾏扫描 for(i = 0; i < lHeight; i++) { //逐列扫描 for(j = 0; j < lWidth; j++) { // 指向DIB第i⾏,第j个象素的指针 lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j; // 变换 *lpSrc = bMap[*lpSrc]; } } //解除锁定 ::GlobalUnlock ((HGLOBAL)hDIB); }变换效果(以下若⽆特别说明,图⽰的右边部分都是为某⼀算法变换之后的效果):程序实现:函数名称:WALSH()参数:double * f - 指向时域值的指针double * F - 指向频域值的指针r -2的幂数返回值:⽆。
javadct_DCT(离散余弦变换)算法原理和源码

javadct_DCT(离散余弦变换)算法原理和源码离散余弦变换(Discrete Cosine Transform,简称DCT)是一种常用的信号处理技术,广泛应用于图像和音频压缩领域。
DCT将输入的离散信号转换为一组系数,这些系数代表了信号的频域特征。
在压缩领域中,DCT可将信号从时域转换为频域,通过舍弃一些高频系数实现信号的压缩。
DCT算法的原理基于傅里叶变换(Fourier Transform)的思想,将时域信号转换为频域信号。
然而,与傅里叶变换相比,DCT更适合处理实数信号,因为它只使用实数运算,而不需要复数运算。
DCT算法的一般步骤如下:1.将输入的离散信号分为若干个块,每个块包含N个采样点。
2.对每个块进行预处理,例如减去均值。
3.对每个块进行DCT变换。
4.根据需要舍弃一些高频系数。
5.对经过舍弃的系数进行逆DCT变换,恢复原始信号。
下面是一个简单的离散余弦变换的Python实现:```pythonimport numpy as npdef dct_transform(signal):N = len(signal)dct_coef = np.zeros(N)for k in range(N):sum = 0for n in range(N):sum += signal[n] * np.cos((np.pi/N)*(n+0.5)*k)dct_coef[k] = sumreturn dct_coefdef idct_transform(dct_coef):N = len(dct_coef)signal = np.zeros(N)for n in range(N):sum = 0for k in range(N):sum += dct_coef[k] * np.cos((np.pi/N)*(n+0.5)*k)signal[n] = sum / Nreturn signal```以上是一个简单的DCT变换和逆变换的实现,其中`dct_transform`函数接受输入信号并返回DCT系数,`idct_transform`函数接受DCT系数并返回恢复的原始信号。
数字图像处理与计算教程

数字图像处理与计算教程当今社会,数字图像处理和计算已经成为了计算机科学中的一门重要学科。
它不仅涉及到日常生活中的摄影、图像编辑等应用,还在医学影像、遥感图像、安防监控等领域发挥着重要作用。
本文将介绍数字图像处理与计算的基本概念、常见算法和应用案例,并通过具体的例子来帮助读者更好地理解和掌握这一领域的知识。
首先,我们来了解一下数字图像处理的基本概念。
数字图像是由一系列像素点组成的二维矩阵,每个像素点表示图像中的一个点,包含了颜色和亮度等信息。
数字图像处理就是对图像进行数字化的操作和处理,以实现增强图像的质量、提取图像的特征、改变图像的内容等目的。
在数字图像处理中,最基本的操作包括图像的采集、预处理、特征提取、图像增强和图像分割等。
其次,我们来介绍一些常见的数字图像处理算法。
其中,最简单的算法是图像的亮度调整。
亮度调整是通过改变图像像素的值来增强或减弱图像的明暗程度。
除了亮度调整,图像的对比度调整也是常见的图像增强算法。
对比度调整可以通过线性拉伸或直方图等方式来改变图像像素值的分布,以增加图像的感知效果。
此外,为了进一步提升图像的质量和清晰度,还有图像滤波算法,它可以用来去除图像中的噪声、模糊图像细节等。
除了基本图像处理算法外,数字图像处理还有很多高级算法和技术。
例如,特征提取算法可以通过寻找图像中的纹理、边缘等特征来帮助我们理解和认识图像。
在医学影像领域,数字图像处理还常用于图像配准算法,它可以将不同时间或不同模态的医学影像进行配准,以帮助医生更准确地诊断疾病。
此外,数字图像处理还有一些应用于图像分析和识别的算法,如目标检测、人脸识别等。
为了帮助读者更好地理解数字图像处理与计算的应用,我们来介绍一些典型的应用案例。
首先是图像去噪。
图像往往会受到采集过程中的噪声的干扰,这些噪声会降低图像的质量和清晰度。
图像去噪算法可以通过滤波等方式去除这些噪声,以改善图像的质量。
其次是图像分割。
图像分割是将图像根据其像素值、纹理、颜色等特征进行划分,以提取图像中感兴趣的目标。
数字图像处理 算法原理

数字图像处理算法原理
数字图像处理是指应用数字计算机对图像进行处理与分析的技术。
其中涉及到的算法原理包括:
1. 灰度变换算法:通过改变图像中像素的灰度级分布,实现对图像亮度、对比度、伽马校正等属性的调整。
常用的灰度变换算法有线性变换、逆变换、非线性自适应直方图均衡化等。
2. 图像滤波算法:用于平滑图像、强调图像细节或检测图像中的边缘。
常用的滤波算法包括均值滤波、中值滤波、高斯滤波、导向滤波等。
3. 图像增强算法:通过改善图像的质量和可视化效果,使图像更适合人眼观察和计算机分析。
常用的图像增强算法有直方图均衡化、局部对比度增强、锐化增强等。
4. 彩色图像处理算法:针对彩色图像的特点,进行颜色空间转换、亮度调整、色彩增强、色彩平衡等操作。
常用的彩色图像处理算法有RGB空间转换为HSV空间、色彩补偿、白平衡调整等。
5. 图像分割与边缘检测算法:将图像划分为不同的区域或提取图像中感兴趣的目标,常用的算法包括阈值分割、基于边缘的分割、基于区域的分割等。
6. 图像压缩与编解码算法:将图像数据经过压缩编码处理,以减少存储空间和传输带宽。
常用的压缩算法有无损压缩算法
(如RLE、Huffman编码)和有损压缩算法(如JPEG)。
除了以上算法原理外,还包括图像配准、图像恢复、形态学处理、基于特征的图像分析等其他算法。
这些算法原理的应用能够有效地处理数字图像,对于图像识别、图像搜索、医学图像分析等领域具有广泛的应用价值。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
nWidth)); /* //调试数据的读取 FileWriter fw = new FileWriter("C:\\Documents and Settings\\Administrator\\My Documents\\nDataRaw.txt");//创建新文件 PrintWriter out = new PrintWriter(fw); for(int j=0;j<nHeight;j++){ for(int i=0;i<nWidth;i++){ out.print((65536*256+nData [nWidth * (nHeight - j - 1) + i])+"_" +nR[nWidth * (nHeight j - 1) + i]+"_" +nG[nWidth * (nHeight j - 1) + i]+"_" +nB[nWidth * (nHeight j - 1) + i]+" "); } out.println(""); } out.close(); */ } } catch (Exception e) { e.printStackTrace(); throw new Exception(e); } finally { if (fs != null) { fs.close(); } } return image;
,nG[]
,
void getBMPImage(String source) throws Exception { clearNData(); //清除数据保存区 FileInputStream fs = null; try { fs = new FileInputStream(source); int bfLen = 14; byte bf[] = new byte[bfLen]; fs.read(bf, 0, bfLen); // 读取 14 字节 BMP
<< 8) | (int) bi[20] & 0xff; // 对 24 位 BMP 进行解析 if (nBitCount == 24){ int nPad = (nSizeImage / nHeight) - nWidth * 3; nData = new int[nHeight * nWidth]; nB=new int[nHeight * nWidth]; nR=new int[nHeight * nWidth]; nG=new int[nHeight * nWidth]; byte bRGB[] = new byte[(nWidth + nPad) * 3 * nHeight]; fs.read(bRGB, 0, (nWidth + nPad) * 3 * nHeight); int nIndex = 0; for (int j = 0; j < nHeight; j++){ for (int i = 0; i < nWidth; i++) { nData[nWidth * (nHeight - j - 1) + i] = (255 & 0xff) << 24 | (((int) bRGB[nIndex + 2] & 0xff) << 16) | (((int) bRGB[nIndex + 1] & 0xff) << 8) | (int) bRGB[nIndex] & 0xff; nB[nWidth * (nHeight - j - 1) + i]=(int) bRGB[nIndex]& 0xff; nG[nWidth * (nHeight - j - 1) + i]=(int) bRGB[nIndex+1]& 0xff; nR[nWidth * (nHeight - j - 1) + i]=(int) bRGB[nIndex+2]& 0xff; nIndex += 3; } nIndex += nPad; } // Toolkit kit = Toolkit.getDefaultToolkit(); // image = kit.createImage(new MemoryImageSource(nWidth, nHeight, // nData, 0,
文件头 int biLen = 40; byte bi[] = new byte[biLen]; fs.read(bi, 0, biLen); // 读取 40 字节 BMP 信息头 // 源图宽度 nWidth = (((int) bi[7] & 0xff) << 24) | (((int) bi[6] & 0xff) << 16) | (((int) bi[5] & 0xff) << 8) | (int) bi[4] & 0xff; // 源图高度 nHeight = (((int) bi[11] & 0xff) << 24) | (((int) bi[10] & 0xff) << 16) | (((int) bi[9] & 0xff) << 8) | (int) bi[8] & 0xff; // 位数 nBitCount = (((int) bi[15] & 0xff) << 8) | (int) bi[14] & 0xff; // 源图大小 int nSizeImage = (((int) bi[23] & 0xff) << 24) | (((int) bi[22] & 0xff) << 16) | (((int) bi[21] & 0xff)
// } 二
由 r g b 获取灰度数组 int[] getBrightnessData(int rData[],int gData[],int
public bData[]){
int brightnessData[]=new int[rData.length]; if(rData.length!=gData.length || rData.length!=bData.length || bData.length!=gData.length){ return brightnessData; } else { for(int i=0;i<bData.length;i++){ double temp=0.3*rData[i]+0.59*gData[i]+0.11*bData[i]; brightnessData[i]=(int)(temp)+((temp-(int)(temp))>0.5 ?1:0); } return brightnessData; } }
四 laplace2 阶滤波,增强边缘,图像锐化
public int[] laplace2DFileter(int []data,int width,int height){
int filterData[]=new int[data.length]; int min=10000; int max=-10000; for(int i=0;i<height;i++){ for(int j=0;j<width;j++){ if(i==0 || i==height-1 || j==0 || j==width-1) filterData[i*width+j]=data[i*width+j]; else filterData[i*width+j]=9*data[i*width+j]-data[i*width+j-1]-data[i*width+j+1] -data[(i-1)*width+j]-data[(i-1)*width+j-1]-da ta[(i-1)*width+j+1] -data[(i+1)*width+j]-data[(i+1)*width+j-1]-da ta[(i+1)*width+j+1]; if(filterData[i*width+j]<min) min=filterData[i*width+j]; if(filterData[i*width+j]>max) max=filterData[i*width+j]; } } // System.out.println("max: "+max); // System.out.println("min: "+min); for(int i=0;i<width*height;i++){ filterData[i]=(filterData[i]-min)*255/(max-min); } return filterData; } 五 laplace2 阶增强滤波,增强边缘,增强系数 delt
public int[] laplaceHigh2DFileter(int []data,int width,int height,double delt){ int filterData[]=new int[data.length]; int min=10000; int max=-10000; for(int i=0;i<height;i++){ for(int j=0;j<width;j++){ if(i==0 || i==height-1 || j==0 || j==width-1) filterData[i*width+j]=(int)((1+delt)*data [i*width+j]); else filterData[i*width+j]=(int)((9+delt)*data[i*width+j]-d ata[i*width+j-1])-data[i*width+j+1] -data[(i-1)*w idth+j]-data[(i-1)*width+j-1]-data[(i-1)*width+j+1] -data[(i+1)*w idth+j]-data[(i+1)*width+j-1]-data[(i+1)*width+j+1]; if(filterData[i*width+j]<min) min=filterData[i*width+j]; if(filterData[i*width+j]>max) max=filterData[i*width+j]; } } for(int i=0;i<width*height;i++){ filterData[i]=(filterData[i]-min)*255/(max-min); } return filterData; }