图像处理的采样

2019-05-21 22:43:40 qq_32790593 阅读数 825
  • 图像金字塔

    学完本课程,可以牢固掌握人工智能计算机视觉的基础知识与常见算法,对图像处理、图像分析可以理解与应用 掌握python opencv框架编程与相关算法原理与函数使用,可以完成基础的图像处理与图像分析项目任务 为进一步...

    165人学习 贾志刚
    免费试看

图像处理——上采样和下采样

最近看一篇图像去雾的论文,看到算法中使用了图像的下采样和上采样,就去了解了一下。

上下采样的评判标准为看重(chong)采样时的采样频率与第一次采样将连续信号变为离散信号时的采样频率相比的大小,若小于第一次的采样频率则为下采样,若大于第一次的采样频率则为上采样。

下采样

在图像处理中,在图像超分辨重建的时候经常涉及对图像进行下采样。关于下采样,我看到一个很好的描述:对于一幅图像I尺寸为M*N,对其进行s倍下采样,即得到(M/s)*(N/s)尺寸的分辨率图像,当然s应该是M和N的公约数才行,如果考虑的是矩阵形式的图像,就是把原始图像s*s窗口内的图像变成一个像素,这个像素点的值就是窗口内所有像素的均值,这种情况下像素个数缩减为原先的S的平方倍。

上采样

上采样可以用来进行图像放大,多采用内插方法,即在原有图像像素的基础上在像素点之间采用合适的插值算法插入新的元素。插值算法有很多种,例如基于边缘的图像插值算法和基于区域的图像插值算法。下面介绍一下插值滤波器。

它的思路分为两步:

1.在原先已经经过第一次差值的数字信号之间插0值
2.将插0值后的数字信号通过一个合适的低通滤波器进行滤波(低通滤波器的通带要大于原信号带宽×插值倍数)


最后说一下我在论文中看到的一个小点,在使用导向滤波器进行图像滤波时,先将输入图像和导向图像进行下采样,经过滤波后,再将滤波器的输出图像进行上采样得到重建后的图像。通过此方法,选取适当的采样率s就可以将运行时间从O(N)减小为O(s2N)。(0<s<1)是一个很好用的方法。


我们下期见!

2017-12-22 11:11:47 zqhwando 阅读数 12226
  • 图像金字塔

    学完本课程,可以牢固掌握人工智能计算机视觉的基础知识与常见算法,对图像处理、图像分析可以理解与应用 掌握python opencv框架编程与相关算法原理与函数使用,可以完成基础的图像处理与图像分析项目任务 为进一步...

    165人学习 贾志刚
    免费试看

因为自己是一枚图像处理领域的研究生菜鸟,即将从事的方向是图像处理下的图像融合方向,故,把我自己学习中遇到的不太明白的知识列下来,留作纪念,加深印象与理解。
从广义上说,图像是自然界景物的客观反映。以照片形式或视频记录介质保存的图像是连续的,计算机无法接收和
处理这种空间分布和亮度取值均连续分布的图像。图像数字化就是将连续图像离散化,其工作包括两个方面:
取样和量化。
那么,究竟什么是采样,什么又是量化呢?
所谓采样,就是把一幅连续图像在空间上分割成M×N个网格,每个网格用一亮度值来表示。一个网格称为一个像素。M×N的取值满足采样定理。
采样示意图
而量化就是把采样点上对应的亮度连续变化区间转换为单个特定数码的过程。量化后,图像就被表示成一个整数矩阵。每个像素具有两个属性:位置和灰度。位置由行、列表示。灰度表示该像素位置上亮暗程度的整数。此数字矩阵M×N就作为计算机处理的对象了。灰度级一般为0-255(8bit量化)。
量化示意图(a)为量化过程(b)为量化为8bit
在现实生活中,采集到的图像都需要经过离散化变成数字图像后才能被计算机识别和处理。
二维图像的成像过程
采样又可分为均匀采样和非均匀采样。
图像均匀采样量化——像素灰度值在黑白范围较均匀分布的图像。
图像非均匀采样量化——对图像中像素灰度值频繁出现的灰度值范围,量化间隔取小一些,而对那些像素灰度值极少出现的范围,则量化间隔取大一些。
不同分辨率下图像的显示情况
通过自己查资料整理,终于对图像的采样与量化过程有了最基本的了解,不像刚开始写之前,懵懵懂懂的,就感觉听了好多遍这两个词,但就是不知道他两是干啥用的。谨以此文,纪念之。

2018-07-24 10:01:29 DL960722 阅读数 3025
  • 图像金字塔

    学完本课程,可以牢固掌握人工智能计算机视觉的基础知识与常见算法,对图像处理、图像分析可以理解与应用 掌握python opencv框架编程与相关算法原理与函数使用,可以完成基础的图像处理与图像分析项目任务 为进一步...

    165人学习 贾志刚
    免费试看

      图像是由像素点组成的矩阵,矩阵的每个点记录着图像的RGB值。数字图像处理即根据用户需求,使用计算机技术对图像进行处理得到所需效果。

1.采样

      我们获取到的图像一般为模拟图像,要让计算机进行处理需将其数字化,采样的作用就是将模拟图像转变为数字图像。一般来说,采样间隔越大,所得图像像素数越少,空间分辨率越低,质量差,严重时出现马赛克效应;采样间隔越小,所得图像像素数越多,空间分辨率越高,图像质量好,但数据量大。

2.量化

       模拟图像经过采样后,在时间和空间上离散化为像素,但采样所得的像素值(即灰度值)仍是连续量,把采样后所得的各像素的灰度值从模拟量到离散量的转换称为图像灰度的量化。量化等级越多,所得图像层次越丰富,灰度分辨率高,图像质量好,但数据量大;量化等级越少,图像层次欠丰富,灰度分辨率低,会出现假轮廓现象,图像质量变差,但数据量小。

一般,当限定数字图像的大小时, 为了得到质量较好的图像可采用如下原则:

   (1) 对缓变的图像, 应该细量化, 粗采样, 以避免假轮廓。

   (2) 对细节丰富的图像,应细采样,粗量化, 以避免模糊(混叠)。

3.邻域

图像邻域即相邻像素关系,有4-邻域、8-邻域、D邻域

(1)4-邻域

4-邻域即像素点的上下左右四个点构成的邻域。设p(i,j),则p(i-1,j)、p(i+1,j)、p(i,j+1)、p(i,j-1)为其4-领域点。

(2)8-邻域

8-邻域即像素点周围一圈的八个点构成的邻域。设p(i,j),则p(i-1,j)、p(i+1,j)、p(i,j+1)、p(i,j-1)、p(i+1,j+1)、p(i-1,j+1),p(i-1,j-1),p(i-1,j-1)为其8-邻域点。

(3)D邻域

D邻域及像素点对角上的点。设p(i,j),则p(i+1,j+1)、p(i-1,j+1),p(i-1,j-1),p(i-1,j-1)为其D邻域点。

4.连通性

两像素连通的必要条件:1)两像素位置是否相邻;2)两像素灰度值是否满足特定的相似性准则

(1)4连通:两个像素p和q,如果p在q的4邻域中,称这两个像素是4连通

(2)8连通:两个像素p和q,如果p在q的8邻域中,称这两个像素是8连通

(3)m连通:1)两个像素p和q,p在q的4邻域内,或者p在q的D邻域内   2)且p和q的4邻域的交集为空,即m连通是4连通和D连通的混合(mixture)连通,(特别注意第二个条件!)

 

2014-02-23 10:47:20 u012627502 阅读数 4598
  • 图像金字塔

    学完本课程,可以牢固掌握人工智能计算机视觉的基础知识与常见算法,对图像处理、图像分析可以理解与应用 掌握python opencv框架编程与相关算法原理与函数使用,可以完成基础的图像处理与图像分析项目任务 为进一步...

    165人学习 贾志刚
    免费试看

灰度:用黑色为基准色,不同的饱和度的黑色来显示图像。


空间采样:空间坐标的离散化。

灰度量化:灰度的离散化。


采样:... ...

量化:对象素赋予G个级别灰度值的过程。(对灰度级离散)


图像空间分辨率(采样)N:随着空间分辨率的下降图像会出现马赛克效果。

图像幅度分辨率(灰度级)k:随着幅度分辨率的下降会出现“虚假轮廓效应”。一般出现在过渡比较平滑的区域。


1、图像质量一般随N和k的增加而增加。在极少情况下对固定的N,减少k能改进质量。最有可能是减少k常可增加图像看起来的反差(对比度增加 )——二值化处理。

2、对具有大量细节的图像常只需很少的灰度级数就可较好地表示——人眼分辨率能力有限。

3、 b(存储一幅图像所需的位数bit:b = M x N x k)为常数的一系列图像主观看起来可以有较大的差异——采样和灰度级之间存在某种合理的分配。


非均匀量化

非均匀量化

锥形量化

2012-10-06 21:38:04 luoweifu 阅读数 22947
  • 图像金字塔

    学完本课程,可以牢固掌握人工智能计算机视觉的基础知识与常见算法,对图像处理、图像分析可以理解与应用 掌握python opencv框架编程与相关算法原理与函数使用,可以完成基础的图像处理与图像分析项目任务 为进一步...

    165人学习 贾志刚
    免费试看

图像的采样

采样是把空域上或时域上连续的图像(模拟图像)转换成离散采样点(像素)集合(数字图像)的操作。

 采样越细,像素越小,越能精细地表现图像。不同采样间距的效果如下:

      

a.采样间隔16                                                                     b.采样间隔32                                                                     c.采样间隔64

图1

算法源代码1(java):

/**
	 * 对图像进行采样
	 * 
	 * @param pix
	 *            保存图片像素
	 * @param iw
	 *            二维像素矩阵的宽
	 * @param ih
	 *            二维像素矩阵的高
	 * @param grey
	 *            采样间距
	 * @return
	 */
	private static int[] sample(int[] pix, int iw, int ih, int grey) {
		// 对图像进行采样
		ColorModel cm = ColorModel.getRGBdefault();

		int d = (int) (256 / grey); // 采样间隔
		int dd = d * d;
		for (int i = 0; i < ih; i = i + d) {
			for (int j = 0; j < iw; j = j + d) {
				int r = 0, g = 0, b = 0;
				for (int k = 0; k < d; k++)
					for (int l = 0; l < d; l++) {
						r = r + cm.getRed(pix[(i + k) * iw + (j + l)]);
						g = g + cm.getGreen(pix[(i + k) * iw + (j + l)]);
						b = b + cm.getBlue(pix[(i + k) * iw + (j + l)]);
					}
				r = (int) (r / dd);
				g = (int) (g / dd);
				b = (int) (b / dd);
				for (int k = 0; k < d; k++)
					for (int l = 0; l < d; l++)
						// pix[(i+k)*iw+(j+l)] = 255<<24|r<<16|g<<8|b;
						pix[(i + k) * iw + (j + l)] = new Color(r, g, b)
								.getRGB();
			}
		}
		return pix;
	}

图像的量化

量化是把像素的灰度(浓淡)变换成离散的整数值的操作。最简单的量化是用黑(0)白(255)两个数值(即2级)来表示,成为二值图像。

量化越细致,灰度级数(浓淡层次)表现越丰富。计算机中一般用8bit(256级)来量化,这意味着像素的灰度(浓淡)是0—255之间的数值。化级数的效果图如下:

      

a.量化级数2                                                                    b.量化级数8                                                                 c.量化级数64

图2

算法源代码2(java): 

/**
	 * 对图像进行量化
	 * @param srcPath 原图像文件路径
	 * @param distPath 目标图像文件路径
	 * @param grey 量化的级数
	 */
	public static void quantize(String srcPath, String distPath, int grey) {
		OutputStream out = null;
		try {
			BufferedImage img = ImageIO.read(new File(srcPath));
			int imgType = img.getType();
			int w = img.getWidth();
			int h = img.getHeight();
			int pix[] = new int[w*h];
			img.getRGB(0, 0, w, h, pix, 0, w);
			int greyScope = 256/grey;
			int r,g,b,temp;
			r=b=g=temp=0;
			ColorModel cm=ColorModel.getRGBdefault();
			for(int i=0; i<w*h; i++) {
				r = cm.getRed(pix[i]);
				temp = r/greyScope;
				r = temp*greyScope;
				g = cm.getGreen(pix[i]);
				temp = g/greyScope;
				g = temp*greyScope;
				b = cm.getBlue(pix[i]);
				temp = b/greyScope;
				b = temp*greyScope;
				pix[i] = new Color(r, g, b).getRGB();
			}
			out = new FileOutputStream(distPath);
			BufferedImage imgOut = new BufferedImage(w, h, imgType); 
			imgOut.setRGB(0, 0, w, h, pix, 0, w);
			ImageIO.write(imgOut, "jpg", out);
			System.out.println("test");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			try {
				out.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

图像直方图

直方图的定义

灰度直方图(histogram)是灰度级分布的函数,它表示图象中具有每种灰度级的象素的个数,反映图象中每种灰度出现的频率。灰度直方图的横坐标是灰度级,纵坐标是该灰度级出现的频率,是图象的最基本的统计特征。

生成图像灰度直方图的一般步骤:

1、统计各个灰度值的像素个数;

2、根据统计表画出直方图

如下图

 

图3


图4

算法源代码3:见下面算法源代码4中的drawHistogram()方法

灰度直方图的性质

1、只反映该图像中不同灰度值出现的次数(或频率),而不能反映某一灰度值像素所在的位置;

2、任何一张图像能唯一地确定一个与它对应的直方图,而一个直方图可以有多个不同的图像;

3、如果一张图片被剪裁成多张图片,各个子图的直方图之和就是这个全图的直方图。

直方图的用途

直方图有很多的用途,比如阀值分割,图像增强,还常常用于医疗影像。

 

图像的阀值(二值)处理

阀值处理的定义


图像的阀值处理是将图像的像素灰度值在某个定值(设为t)以上的点赋值为白色(或黑色),在这个定值t以下的点赋值为黑色(或白色)的处理过程。用公式表示成:


由于图像的阀值处理得到的是只有两个灰度值的二值图像,所以也将阀值处理称作二值化处理,得到的图像叫二值图像。如下图

图像阀值处理的步骤

1、 画出图像的灰度直方图;

2、 根据图像的灰度直方图确定阀值t,如图5的阀值为65;

3、 将像素灰度值小于等于t的点赋值为白色(或黑色),大于t的点赋值为黑色(或白色);效果如图6:

图5


图6

算法源代码4(java):

package cn.edu.jxau.luoweifu;

import java.awt.BorderLayout;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FileDialog;
import java.awt.FlowLayout;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.io.File;
import java.io.IOException;
import java.util.Date;

import javax.imageio.ImageIO;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.border.LineBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;


/**
 * 设置头像
 * @author 罗伟富
 *
 */
public class Histogram extends JFrame implements ChangeListener, ActionListener{
	/**
	 * 头像界面的宽度
	 */
	public static final int WIDTH = 680;
	/**
	 * 头像界面的高度
	 */
	public static final int HEIGHT = 400;
	/**
	 * 显示图片版面的宽度
	 */
	public static final int PWIDTH = 350;
	/**
	 * 显示图片版面的高度
	 */
	public static final int PHEIGHT = 300;
	/**
	 * 直方图版面的宽度
	 */
	public static final int H_WIDTH = 350;
	/**
	 * 直方图片版面的高度
	 */
	public static final int H_HEIGHT = 300;
	/**
	 * 滑块的最大值
	 */
	public static final int JS_MAXIMUM = 100;
	
	public static final String FRAMTITLE = "图像的灰度直方图";
	private String imgSrc;
	Image img;
	JSlider jsliderH, jsliderV;	//水平和垂直滑块
	JPanel uP, picP, uplodP, histP;
	JButton openFile, histogram, threshold; 
	MyCanvas canvas;
	Canvas histCanvas;
	int imgW = PWIDTH, imgH = PHEIGHT;
	int xcentre = PWIDTH/2, ycentre = PHEIGHT/2;
	private int dx1 = xcentre-imgW/2, dy1 = ycentre-imgH/2, dx2 = xcentre + imgW/2, dy2 = ycentre + imgH/2;
	private int sx1 = 0, sy1 = 0, sx2, sy2;
	private float shx = 0, shy = 0;
	/**
	 * 构造函数
	 */
	public Histogram() {
		setTitle(FRAMTITLE);
		launchDialog();
	}
	
	/**
	 * 返回canvas
	 * @return
	 */
	public Canvas getCanvas() {
		return canvas;
	}
	/**
	 * 界面设计
	 */
	private void launchDialog() {
		//初始化图片对象
		imgSrc = "F:\\image processing\\baboom2_gray.jpg";
		img = Toolkit.getDefaultToolkit().getImage(imgSrc);
		//初始化组件
		canvas = new MyCanvas();
		jsliderH = new JSlider();
		jsliderH.setMaximum(JS_MAXIMUM);
		jsliderH.setValue(JS_MAXIMUM/2);
		jsliderH.setMinimum(1);
		jsliderH.setOrientation(JSlider.HORIZONTAL);
		jsliderH.addChangeListener(this);
		jsliderV = new JSlider();
		jsliderV.setMaximum(JS_MAXIMUM);
		jsliderV.setValue(JS_MAXIMUM/2);
		jsliderV.setMinimum(1);
		jsliderV.setOrientation(JSlider.VERTICAL);
		jsliderV.addChangeListener(this);
		picP = new JPanel();
		picP.setPreferredSize(new Dimension(PWIDTH, PHEIGHT));
		//picP.setBackground(Color.green);
		uP = new JPanel();
		uplodP = new JPanel();
		openFile = new JButton("打开图片");
		histogram = new JButton("显示直方图");
		threshold = new JButton("显示二值图像");
		openFile.addActionListener(this);
		histogram.addActionListener(this);	
		threshold.addActionListener(this);
		//添加组件
		picP.setLayout(new BorderLayout());
		picP.add(canvas, BorderLayout.CENTER);
		uP.setLayout(new BorderLayout());
		uP.add(picP, BorderLayout.CENTER);
		uP.add(jsliderH, BorderLayout.SOUTH);
		uP.add(jsliderV, BorderLayout.EAST);
		
		histCanvas = new Canvas();
		histP = new JPanel(new BorderLayout());
		histP.add(histCanvas);
		histP.setPreferredSize(new Dimension(H_WIDTH, H_HEIGHT));
		histP.setBorder(new LineBorder(Color.blue));
		//System.out.println("w:" + histP.getWidth() + "  h:" + histP.getHeight() + " " + histP.HEIGHT);
		
		uplodP.setLayout(new FlowLayout());		
		uplodP.add(openFile);		
		uplodP.add(histogram);
		uplodP.add(threshold);
		Container c = getContentPane();
		c.setLayout(new BoxLayout(c, BoxLayout.Y_AXIS));
		//c.add(uP);
		JPanel p = new JPanel();
		p.setLayout(new BoxLayout(p, BoxLayout.X_AXIS));
		p.add(uP);
		p.add(histP);
		c.add(p);
		c.add(uplodP);
		setSize(WIDTH, HEIGHT);
		setResizable(false);
		setLocationRelativeTo(null);
		setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
		setVisible(true);		
	}
	
	public void drawHistogram() {
		try {
			BufferedImage bfImg = ImageIO.read(new File(imgSrc));
			int w = bfImg.getWidth();
			int h = bfImg.getHeight();
			int pix[] = new int[w*h];
			int hist[] = new int[256];
			/*for(int i=0; i<hist.length; i++) {
				hist[i] = 0;
			}*/
			int imgType = bfImg.getType();
			int temp;
			bfImg.getRGB(0, 0, w, h, pix, 0, w);
			ColorModel cm = ColorModel.getRGBdefault();
			for(int i=0; i<pix.length; i++) {
				/*for(int j=0; j<hist.length; j++) {
					if(j ==  cm.getRed(pix[i])) {
						hist[j] ++;
					}
				}*/				
				temp = cm.getRed(pix[i]);
				hist[temp] ++;
			}
			//System.out.println(hist.length);
			
			int max = 0;
			for(int i=0; i<hist.length; i++) {
				if(hist[i] > max) {
					max = hist[i];
				}				
				
			}
			for(int i=0; i<hist.length; i++) {
				hist[i] = (int)(hist[i]/(float)max * 250);
				/*System.out.print(hist[i] + "\t");
				if(i%10 == 0) {
					System.out.println();
				}*/
			}		
			//histCanvas.setHistPix(hist);
			//histCanvas.repaint();
			
			Graphics g = histCanvas.getGraphics();
			Color c = g.getColor();
			g.setColor(Color.red);
			g.drawLine(10, H_HEIGHT-10, H_WIDTH-30, H_HEIGHT-10);
			g.drawLine(H_WIDTH-35, H_HEIGHT-15, H_WIDTH-30, H_HEIGHT-10);
			g.drawLine(H_WIDTH-35, H_HEIGHT-5, H_WIDTH-30, H_HEIGHT-10);
			g.drawString("灰度级", H_WIDTH-80, H_HEIGHT);
			g.drawLine(10,  H_HEIGHT-10, 10, 10);
			g.drawLine(5, 15, 10, 10);
			g.drawLine(15, 15, 10, 10);
			g.drawString("像素个数", 15, 15);
			g.setColor(Color.black);
			for(int i=0; i<hist.length; i++) {
				g.drawLine(10+i, H_HEIGHT-10, 10+i, H_HEIGHT-10-hist[i]);
				if(i%30 == 0) {
					g.drawString(i+"", 10+i, H_HEIGHT);
				}
			}
			g.setColor(c);
		} catch (IOException e) {
			e.printStackTrace();
		} 
	}
	
	public void threshold(int threshold) {
		try {
			BufferedImage bfImg = ImageIO.read(new File(imgSrc));
			int w = bfImg.getWidth();
			int h = bfImg.getHeight();
			int pix[] = new int[w*h];
			
			int imgType = bfImg.getType();
			bfImg.getRGB(0, 0, w, h, pix, 0, w);
			int max = 0;
			ColorModel cm = ColorModel.getRGBdefault();
			for(int i=0; i<pix.length; i++) {
				if(cm.getRed(pix[i]) <= threshold) {
					pix[i] = new Color(255,255,255).getRGB();					
				} else {
					pix[i] = new Color(0, 0, 0).getRGB();
				}				
			}			
			bfImg.setRGB(0, 0, w, h, pix, 0, w);
				
			//histCanvas.setHistPix(hist);
			//histCanvas.repaint();
			
			Graphics g = histCanvas.getGraphics();
			g.clearRect(0, 0, H_WIDTH, H_HEIGHT);
			Color c = g.getColor();
			g.drawImage(bfImg, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, this);
			g.setColor(c);
		} catch (IOException e) {
			e.printStackTrace();
		} 
	}
	
	/**
	 * 事件监听响应
	 */
	public void actionPerformed(ActionEvent e) {
		if(e.getSource() == openFile) {
			FileDialog openFileDialog = new FileDialog(this, "打开图片");
			openFileDialog.setMode(FileDialog.LOAD);	//设置此对话框为从文件加载内容
			openFileDialog.setFile("*.jpg;*.jpeg;*.gif;*.png;*.bmp;*.tif;");		//设置可打开文件的类型为:.txt,.java
			
			openFileDialog.setVisible(true);
			String fileName = openFileDialog.getFile();
			String directory = openFileDialog.getDirectory();
			if(null != fileName) {
				imgSrc = directory + fileName;
				img = Toolkit.getDefaultToolkit().getImage(imgSrc);	
				histCanvas.repaint();
			} else {
				JOptionPane.showMessageDialog(this, "您已经取消选择了,请重新选择!");
			}
		} else if(e.getSource() == histogram) {
			System.out.println(new Date());
			drawHistogram();
			System.out.println(new Date());
		} else if(e.getSource() == threshold) {
			threshold(65);
		}
	}
	/**
	 * 滑动条滑动响应事件
	 */
	public void stateChanged(ChangeEvent e) {
		if(e.getSource() == jsliderH) {
			float valueH = jsliderH.getValue();
			imgW = (int)(2*PWIDTH*(valueH/JS_MAXIMUM));	
			if(imgW < PWIDTH/4) {
				imgW = PWIDTH/4;
			}
			dx1 = xcentre-imgW/2;
			dy1 = ycentre-imgH/2;
			dx2 = xcentre + imgW/2;
			dy2 = ycentre + imgH/2;
			canvas.repaint();
		} else if(e.getSource() == jsliderV) {
			float valueV = jsliderV.getValue();
			imgH = (int)(2*PHEIGHT*(valueV/JS_MAXIMUM));
			if(imgH < PHEIGHT/4) {
				imgH = PHEIGHT/4;
			}
			dx1 = xcentre-imgW/2;
			dy1 = ycentre-imgH/2;
			dx2 = xcentre + imgW/2;
			dy2 = ycentre + imgH/2;
			canvas.repaint();
		}
	}
	
	public static void main(String[] args) {
		new Histogram();
	}
	
	/**
	 * 用于画图像的Canvas
	 */
	class MyCanvas extends Canvas {		
		public MyCanvas() {
			
		}
		public void paint(Graphics g) {
			Graphics2D g2 = (Graphics2D) g;
			//g.drawImage(img, xcentre-imgW/2, ycentre-imgH/2, imgW, imgH, this);
			sx2  = img.getWidth(this);
			sy2  = img.getHeight(this);
			g2.shear(shx, shy);
			g2.drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, this);//Color.green, 
		}
	}
			
}

/*class HistCanvas extends Canvas {
int histPix[] = new int[0];
public void setHistPix(int[] pix) {
	histPix = pix;
}
public void paint(Graphics g) {
	Color c = g.getColor();
	g.setColor(Color.red);
	g.drawLine(10, H_HEIGHT-10, H_WIDTH-30, H_HEIGHT-10);
	g.drawLine(H_WIDTH-35, H_HEIGHT-15, H_WIDTH-30, H_HEIGHT-10);
	g.drawLine(H_WIDTH-35, H_HEIGHT-5, H_WIDTH-30, H_HEIGHT-10);
	g.drawString("灰度级", H_WIDTH-80, H_HEIGHT);
	g.drawLine(10,  H_HEIGHT-10, 10, 10);
	g.drawLine(5, 15, 10, 10);
	g.drawLine(15, 15, 10, 10);
	g.drawString("像素个数", 15, 15);
	g.setColor(Color.black);
	for(int i=0; i<histPix.length; i++) {
		g.drawLine(10+i, H_HEIGHT-10, 10+i, H_HEIGHT-10-histPix[i]);
		if(i%30 == 0) {
			g.drawString(i+"", 10+i, H_HEIGHT);
		}
	}
	g.setColor(c);
}
}*/







                                    

图像处理 重采样

阅读数 3204

5.3.7 图像重采样

阅读数 2404