图像处理之边缘褪化效果

简介: 图像处理之边缘褪化效果   很多图像处理软件都提供边缘褪化效果滤镜,其实原理非常的简单,网上搜索了一把, 实现了基于Java的图像边缘褪化效果。边缘褪化效果取决于以下三个参数: 1.      设定的图像边缘宽度 2.      褪化比率– 其实质是图像融合的百分比数 3.      选择的边框颜色   主要原理是计算图像中的像素点到中心点的距离,对边缘像素根据褪化比率与选择的 边框颜色融合从而产生褪化效果。

图像处理之边缘褪化效果

 

很多图像处理软件都提供边缘褪化效果滤镜,其实原理非常的简单,网上搜索了一把,

实现了基于Java的图像边缘褪化效果。边缘褪化效果取决于以下三个参数:

1.      设定的图像边缘宽度

2.      褪化比率– 其实质是图像融合的百分比数

3.      选择的边框颜色

 

主要原理是计算图像中的像素点到中心点的距离,对边缘像素根据褪化比率与选择的

边框颜色融合从而产生褪化效果。程序效果如下:

原图:


处理以后图像:


滤镜的完全源代码如下:

package com.process.blur.study;

import java.awt.Color;
import java.awt.image.BufferedImage;

/**
 * @author gloomy fish
 * Vignette - a photograph whose edges shade off gradually
 * 
 */
public class VignetteFilter extends AbstractBufferedImageOp {
		
	private int vignetteWidth;
	private int fade;
	private Color vignetteColor;
	
	public VignetteFilter() {
		vignetteWidth = 50;
		fade = 35;
		vignetteColor = Color.BLACK;
	}
	
	@Override
	public BufferedImage filter(BufferedImage src, BufferedImage dest) {
		int width = src.getWidth();
        int height = src.getHeight();

        if ( dest == null )
        	dest = createCompatibleDestImage( src, null );

        int[] inPixels = new int[width*height];
        int[] outPixels = new int[width*height];
        getRGB( src, 0, 0, width, height, inPixels );
        int index = 0;
        for(int row=0; row<height; row++) {
        	int ta = 0, tr = 0, tg = 0, tb = 0;
        	for(int col=0; col<width; col++) {
            	
                int dX = Math.min(col, width - col);
                int dY = Math.min(row, height - row);
                index = row * width + col;
        		ta = (inPixels[index] >> 24) & 0xff;
                tr = (inPixels[index] >> 16) & 0xff;
                tg = (inPixels[index] >> 8) & 0xff;
                tb = inPixels[index] & 0xff;
                if ((dY <= vignetteWidth) & (dX <= vignetteWidth))
                {
                    double k = 1 - (double)(Math.min(dY, dX) - vignetteWidth + fade) / (double)fade;
                    outPixels[index] = superpositionColor(ta, tr, tg, tb, k);
                    continue;
                }

                if ((dX < (vignetteWidth - fade)) | (dY < (vignetteWidth - fade)))
                {
                	outPixels[index] = (ta << 24) | (vignetteColor.getRed() << 16) | (vignetteColor.getGreen() << 8) | vignetteColor.getBlue();
                }
                else
                {
                    if ((dX < vignetteWidth)&(dY>vignetteWidth))
                    {
                        double k = 1 - (double)(dX - vignetteWidth + fade) / (double)fade;
                        outPixels[index] = superpositionColor(ta, tr, tg, tb, k);
                    }
                    else
                    {
                        if ((dY < vignetteWidth)&(dX > vignetteWidth))
                        {
                            double k = 1 - (double)(dY - vignetteWidth + fade) / (double)fade;
                            outPixels[index] = superpositionColor(ta, tr, tg, tb, k);
                        }
                        else
                        {
                        	outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;
                        }
                    }
                }
            }
        }
        
        setRGB( dest, 0, 0, width, height, outPixels );
        return dest;
	}
	
	public int superpositionColor(int ta, int red, int green, int blue, double k) {
		red = (int)(vignetteColor.getRed() * k + red *(1.0-k));
		green = (int)(vignetteColor.getGreen() * k + green *(1.0-k));
		blue = (int)(vignetteColor.getBlue() * k + blue *(1.0-k));
		int color = (ta << 24) | (clamp(red) << 16) | (clamp(green) << 8) | clamp(blue);
		return color;
	}
	
	public int clamp(int value) {
		return value > 255 ? 255 :((value < 0) ? 0 : value);
	}
	
	public int getVignetteWidth() {
		return vignetteWidth;
	}

	public void setVignetteWidth(int vignetteWidth) {
		this.vignetteWidth = vignetteWidth;
	}

	public int getFade() {
		return fade;
	}

	public void setFade(int fade) {
		this.fade = fade;
	}
	
	public Color getVignetteColor() {
		return vignetteColor;
	}

	public void setVignetteColor(Color vignetteColor) {
		this.vignetteColor = vignetteColor;
	}
	
}

转载请务必注明出自本博客
目录
相关文章
|
8月前
|
算法 数据安全/隐私保护 计算机视觉
图像处理基础
图像处理基础
67 0
|
8月前
|
机器学习/深度学习 算法 C语言
FPGA图像处理之边缘检测算法的实现
边缘检测是图像处理和计算机视觉中的基本问题,边缘检测的目的是标识数字图像中亮度变化明显的点。图像属性中的显著变化通常反映了属性的重要事件和变化。这些包括(i)深度上的不连续、(ii)表面方向不连续、(iii)物质属性变化和(iv)场景照明变化。边缘检测是图像处理和计算机视觉中,尤其是特征提取中的一个研究领域。
FPGA图像处理之边缘检测算法的实现
|
12月前
|
机器学习/深度学习 监控 算法
传统图像处理之相机模型
传统图像处理之相机模型
191 0
|
12月前
|
机器学习/深度学习 算法 数据挖掘
传统图像处理之颜色特征
传统图像处理之颜色特征
171 0
传统图像处理之颜色特征
|
算法
基于PSO优化的路径规划避障系统仿真,沿着障碍物边缘平滑的进行转向
基于PSO优化的路径规划避障系统仿真,沿着障碍物边缘平滑的进行转向
127 0
基于PSO优化的路径规划避障系统仿真,沿着障碍物边缘平滑的进行转向
|
传感器 机器学习/深度学习 人工智能
多传感器融合 | CenterFusion:毫米波雷达和相机后融合3D检测算法
本文主要介绍一种基于毫米波雷达和相机后融合的3D目标检测算法——CenterFusion,原本是公司内部的一个技术方案,截取了其中的核心理论部分,所以看起来肯能有些严肃。
多传感器融合 | CenterFusion:毫米波雷达和相机后融合3D检测算法
|
图形学 计算机视觉
GDI+——常用的图像处理技术(二)
GDI+——常用的图像处理技术(二)
140 0
GDI+——常用的图像处理技术(二)
|
图形学 计算机视觉 C++
GDI+——常用的图像处理技术(三)
GDI+——常用的图像处理技术(三)
264 0
GDI+——常用的图像处理技术(三)