Android NDK图片模糊处理之高斯模糊算法

最新推荐文章于 2024-04-01 02:14:47 发布
最新推荐文章于 2024-04-01 02:14:47 发布
阅读量456 收藏
点赞数
分类专栏： android 文章标签： ndk 高斯模糊
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014389362/article/details/111619335
版权

效果图：

在这里插入图片描述
参考了c++的高斯模糊的算法 高斯模糊的C++实现（Gaussian Blur），改成了Java版本的和ndk版本的，对比了下效果，Java的效率比较低，用时几十秒，ndk才不到1秒，毕竟安卓是Linux内核，c++跟接近底层。

原理

图像是颜色矩阵组成的，通过改变每个像素点的rgb的颜色值，可以改变图像。
图片模糊就是把像素点的rgb的值取周围像素点的加权平均值，使像素点失去其特性。
高斯模糊（英语：Gaussian Blur），也叫高斯平滑。
正态分布一维表达式：
在这里插入图片描述
二维是2个一维函数的积分：
在这里插入图片描述
这种计算方式时间复杂度大，这里试了下另一种高效的方法，对一维高斯函数分别在水平和垂直方向上继续2次计算。

下面分别贴出Java和dnk2个版本的核心代码。

  • GsUtil.java工具类
/**
 * @author DaQiang
 * @time 2020/12/18 14:25
 * @desc 高斯函数工具类
 */
public class GsUtil {
    public static final float sigma = 1F;
    public static final int r = 5;

    /**
     * 边界处理函数
     * 之所以引入这个函数，是因为在高斯模糊中，每个点的新值都是由临近的矩形区域的平均值得出，
     * 但是若矩形区域超出图像范围，则会产生黑边。为了消除这一影响，我们采用对称的方法，
     * 将矩形的超出部分用内部的对应点代替。
     *
     * @param x
     * @param i
     * @param w
     * @return
     */
    private static int edge(int x, int i, int w) {
        // x为中心位置, i为偏移量,w为宽度
        int inx = x + i;
        if (inx < 0 || inx >= w)
            return x - i;
        return inx;
    }


    // 一维高斯函数
    private static double gaussFunc1D(int x) {
        double A = 1 / (sigma * Math.sqrt(2 * 3.141592653));
        double index = -1.0 * (x * x) / (2 * sigma * sigma);
        return A * Math.exp(index);
    }

    // 获取线性的权值空间
    private static double[] getKernal() {
        double[] weight = new double[2 * r + 1];
        double sum = 0;

        // 获取权值空间weight[]
        for (int i = 0; i < 2 * r + 1; i++) {
            weight[i] = gaussFunc1D(i - r);
            sum += weight[i];
        }
        // 归一化
        for (int i = 0; i < 2 * r + 1; i++) {
            weight[i] /= sum;
        }

        return weight;
    }

    //进行两个方向的高斯模糊获
    // 获取最终的模糊图像
    public static Bitmap getBlurImage(Bitmap originImg) {
        int width = originImg.getWidth();
        int height = originImg.getHeight();
        // 原图为 originImg
        // 第一个方向处理的图像为tmpImg
        Bitmap tmpImg = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
        // 经过第二次处理的最终结果newImg
        Bitmap newImg = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);

        double[] weight = getKernal();

        // 在横向进行一次相加
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                double red = 0, green = 0, blue = 0;
                for (int i = -r; i <= r; i++) {
                    // 边界处理后的对应的权值矩阵实际值
                    int inx = edge(x, i, width);
                    int color = originImg.getPixel(inx, y);
                    red += Color.red(color) * weight[r + i];
                    green += Color.green(color) * weight[r + i];
                    blue += Color.blue(color) * weight[r + i];
                }
                int color = Color.rgb(Integer.parseInt(Math.round(red)+""), Integer.parseInt(Math.round(green)+""), Integer.parseInt(Math.round(blue)+""));
                int srcColor = originImg.getPixel(x,y);
                Log.d("GsUtil", "color:" + color+" srcColor: "+srcColor);
                tmpImg.setPixel(x, y, color);
            }
        }
        // 在纵方向对第一次的结果重新进行一次
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                double red = 0, green = 0, blue = 0;
                for (int i = -r; i <= r; i++) {
                    int iny = edge(y, i, height);
                    int color = tmpImg.getPixel(x, iny);

                    red += Color.red(color) * weight[r + i];
                    green += Color.green(color) * weight[r + i];
                    blue += Color.blue(color) * weight[r + i];

                }
                int color = Color.rgb(Integer.parseInt(Math.round(red)+""), Integer.parseInt(Math.round(green)+""), Integer.parseInt(Math.round(blue)+""));
                newImg.setPixel(x, y, color);
            }
        }
        return newImg;
    }

}
  • native-lib.cpp
#include <jni.h>
#include <string>
#include<math.h>
#include <android/bitmap.h>
#include <stdlib.h>
#include <android/log.h>

#define TAG "native-lib" // 这个是自定义的LOG的标识
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,TAG ,__VA_ARGS__) // 定义LOGE类型

float sigma = 3;
int r = 9;

int edge(int x, int i, int w) {
    // x为中心位置, i为偏移量,w为宽度
    int inx = x + i;
    if (inx < 0 || inx >= w)
        return x - i;
    return inx;
}


double gaussFunc1D(int x) {
    double A = 1 / (sigma * sqrt(2 * 3.141592653));
    double index = -1.0 * (x * x) / (2 * sigma * sigma);
    return A * exp(index);
}

void getKernal(double *weight) {
//    double *weight = new double[2 * r + 1];

    double sum = 0;

    // 获取权值空间weight[]
    for (int i = 0; i < 2 * r + 1; i++) {
        weight[i] = gaussFunc1D(i - r);
        sum += weight[i];
    }
    // 归一化
    for (int i = 0; i < 2 * r + 1; i++) {
        weight[i] /= sum;
    }
}

extern "C"
JNIEXPORT jintArray JNICALL
Java_com_example_imagendk_ImageUtil_getImageGaoSiMohu(JNIEnv *env, jclass clazz, jintArray arr,
                                                      jint width, jint height) {

    jint *source = (*env).GetIntArrayElements(arr, NULL);
    int newSize = width * height;
    double *weight = new double[2 * r + 1];
    getKernal(weight);
    int *temp = new int[newSize];
    int *re = new int[newSize];


    // 在横向进行一次相加
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            double red = 0, green = 0, blue = 0;
            for (int i = -r; i <= r; i++) {
                // 边界处理后的对应的权值矩阵实际值
                int inx = edge(x, i, width);
                int color = source[y * width + inx];
                int tmpRed = (color >> 16) & 0xFF;
                int g = (color >> 8) & 0xFF;
                int b = color & 0xFF;

                red += tmpRed * weight[r + i];
                green += g * weight[r + i];
                blue += b * weight[r + i];
            }
            int color = 0xff000000 | (int(red) << 16) | (int(green) << 8) | int(blue);
            temp[y * width + x] = color;
        }
    }


    // 在纵方向对第一次的结果重新进行一次
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            double red = 0, green = 0, blue = 0;
            for (int i = -r; i <= r; i++) {
                int iny = edge(y, i, height);
                int color = temp[iny * width + x];

                int tmpRed = (color >> 16) & 0xFF;
                int g = (color >> 8) & 0xFF;
                int b = color & 0xFF;

                red += tmpRed * weight[r + i];
                green += g * weight[r + i];
                blue += b * weight[r + i];

            }
            int color = 0xff000000 | (int(red) << 16) | (int(green) << 8) | int(blue);
            re[y * width + x] = color;
        }
    }


    jintArray result = (*env).NewIntArray(newSize);
    (*env).SetIntArrayRegion(result, 0, newSize, re);
    (*env).ReleaseIntArrayElements(arr, source, 0);
    (*env).ReleaseIntArrayElements(arr, temp, 0);
    (*env).ReleaseIntArrayElements(arr, re, 0);
    return result;
}
小强_程序猿_
关注
专栏目录
Android NDK之旅——图片高斯模糊，Android架构组件Room功能详解
m0_63737792的博客
11-07 646
在Customize C++ Support界面默认即可,意为CMake/C++11环境 3 认识CMakeLists.txt 工程创建完毕之后Android Studio会在app目录下生成CMakeLists.txt文件。CMakeLists.txt是CMake的配置文件，用于表明版本、依赖、等信息，以下为Android Studio生成的CMakeLists（过滤注释） cmake_minimum_required(VERSION 3.4.1) add_library(native-lib SHARE
Android NDK之旅——图片高斯模糊，android开发者网站
m0_64382868的博客
11-29 196
如何使用CMake做JNI/NDK开发 1 新建工程 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5qeS2J4V-1638155002522)(https://user-gold-cdn.xitu.io/2017/10/7/030ba32094de32b2c2dadb7a416c4535?imageView2/0/w/1280/h/960/ignore-error/1)] 选中Include C++ Support，意为引入C++支持。 2 配置C++支持 [外链图片转存
Android NDK 高斯模糊的实践
BLOG
12-04 209
Android 高斯模糊的实践（DEMO级别） 掌握Android JNI的创建 JNI创建，这个可以参考我之前的文章地址 Android JNI创建 掌握什么是高斯模糊 高斯模糊介绍链接 学习掌握高斯模糊算法 高斯模糊算法介绍 利用代码进行实际操作实现 来粘贴下主要的代码实现： #include <jni.h> #include <string> #include &...
Android 实现图片高斯模糊算法，真正有效的工具类
chakeshe的博客
01-14 1282
import android.graphics.Bitmap; import android.graphics.Color; public class FastBlur {     /***      * 高斯模糊算法      * @param bmp 要处理的图像      * @param radius 处理的半径      * @return      */    
图形算法 - 模糊函数比较，Blur Function Compare
凌风探梅的专栏
10-19 2166
-5
图像处理算法--高斯模糊
AcceptedLin的博客
12-05 3069
                         图像处理算法--高斯模糊 高斯模糊（英语：Gaussian Blur），也叫高斯平滑，是在Adobe Photoshop、GIMP以及Paint.NET等图像处理软件中广泛使用的处理效果，通常用它来减少图像噪声以及降低细节层次。 高斯模糊相信很多学习p图的人并不陌生,它能够让一张图片产生需要的模糊效果. 提起高斯模糊,我们应该联想到正态分布，所...
Android实现图片的高斯模糊效果
11-12
Android使用RenderScript实现图片的高斯模糊效果。通过在网上资料查找，有以下4种方法可以实现： - RenderScript - Java算法 - NDK算法 - openGL 最终考虑，使用RenderScript 应该是最适合的。
Android NDK之旅——图片高斯模糊，【2024Android最新学习路线
最新发布
m0_61331491的博客
04-01 1060
由于文章篇幅原因，我只把面试题列了出来，详细的答案，我整理成了一份PDF文档，这份文档还包括了还有高级架构技术进阶脑图、Android开发面试专题资料，高级进阶架构资料 ，帮助大家学习提升进阶，也节省大家在网上搜索资料的时间来学习。新**如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）[外链图片转存中…(img-OOJ4VBje-1711908875949)]由于文章篇幅原因，我只把面试题列了出来，详细的答案，我整理成了一份PDF文档，这份文档还包括了还有。
图片高斯模糊处理应用-涉及libjpeg的使用,NDK对SurfaceView的操作,图像模糊处理
01-05
在本文中，我们将深入探讨如何在Android开发中利用C/C++的NDK进行图片的高斯模糊处理，特别是在涉及到libjpeg库的使用以及对SurfaceView的处理时。高斯模糊是一种常见的图像处理技术，用于创建柔和、朦胧的效果，...
图片模糊算法
热门推荐
不一样的博客
08-02 1万+
有很多App对背景进行高斯图模糊设计，比如网易云音乐、QQ、微信、随手记等等。在Adnroid中，现在常用的图片高斯模糊技术有三种：RenderScript 、fastBlur、对RenderScript和fastBlur的优化，下面分析这三种方法的优缺点。 RenderScript RenderScript是在Android上的高性能运行密集型运算的框架，主要用于数据并行计算，尤其对图像处理...
图片高斯模糊处理应用-涉及libjpeg的使用,NDK对SurfaceView的操作,图像模糊处理的APK文件
01-05
博客原文地址在http://write.blog.csdn.net/postedit/42400825 欢迎大家留言,交流讨论
android高斯模糊
狂奔的乌牛的博客
06-02 544
高斯模糊算法介绍
Android 中比较“高效”的图像模糊处理算法
积累人生
07-14 1231
转自：http://www.littledai.com/tag/blurmaskfilter本文假设读者拥有基础的图像处理概念。这是今天刚刚完成的一个方法，之前不停地在网上找有关 Android 的图像模糊处理代码。期间找到了倒影、缩放等参考代码，却无一帖子对模糊处理有过提及。最
android模糊背景算法
Mr_li13的博客
03-29 495
提供一个最简单的Java高斯模糊实现，我网上找来的，方便大家也是方便自己。 /** * 位图处理类 * @author HalfmanG2 */ public class BitmapUtil { /** * 创建一个虚化的位图 * @param sentBitmap 原位图 * @param radius 虚化半径
Android JNI编译SO库完整demo实现高斯模糊效果
zhuxingchong的博客
04-11 376
很久没用玩jni ndk编译so库了，为了防止手生就用最近需要实现的一个高斯模糊算法类练手。当然这个算法不是我实现的，我只是把这个算法C代码编译成了一个so库，因为C执行效率比java更高，作为这个吃CPU的算法很适合做成SO文件。 这里不再介绍JNI和NDK了，我要说的重点是一个SO库从编译到使用的这个过程。 上面图片可以清除看到这个SO库的生成和java层代码通过KJNI环境调用C/C...
图像处理中的模糊算法
I good vegetable a!
06-27 4031
平滑 在数字图像上进行平滑操作，就是需要用模板(高斯模板，均值模板)在图像上做卷积，得到新值，这就是模糊的原理。卷积核中的每个元素叫做卷积系数，卷积核中卷积系数的大小、方向及排列次序决定图像卷积后处理的最终效果。改变卷积核中的加权系数，会影响到综合的数值与符号，从而影响到所求像素的新值。常用卷积核有3×3、5×5、7×7等，所有卷积核的行、列都是奇数。均值滤波、高斯滤波以及各种自定义的滤波都可以通...
图像模糊算法实现
gaobohello1987的专栏
11-26 685
将一幅图像看成是由像素组成的矩形，每个像素由R(Red),G(Green), B(Blue)三个值组成，图像模糊的原理就是算出每个像素相对于它相邻的多个元素的平均R,G,B值（每个R,G,B值分别处理), 其中边界点有六个相邻元素，内部点有9个相邻元素，顶点有4个相邻元素。可以对图像进行多次模糊。下面是核心算法实现： public PixImage boxBlur(int numIterati
最快速的“高斯”模糊算法（附Android源码）
zxg19的专栏
07-15 1449
这是一个外国人的算法，本人是搬运工。参考：http://blog.ivank.net/fastest-gaussian-blur.html   1：高斯模糊算法（参考：http://www.ruanyifeng.com/blog/2012/11/gaussian_blur.html） 所谓的模糊算法就是当前像素点和周围像素点进行加权均值之后的结果替换当前像素值。因此均值模糊是最简
图像处理算法之模糊检测
kkae8643150的专栏
12-16 6019
1）拉普拉斯算子边缘模糊程度值 def getImageVar( image ): img2gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) imageVar = cv2.Laplacian(img2gray, cv2.CV_64F).var() return imageVar
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值