2019-04-03 20:11:14 ziyonghong 阅读数 88
  • 学习OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频教程

    OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频培训课程概况:教程中会讲解到基于opencv视频和摄像机录制、播放和播放进度控制,多视频图像合并、多视频图像融合、剪切、视频亮度、对比度、尺寸(近邻插值(手动实现),双线性插值,图像金字塔)、颜色格式(灰度图,二值化(阈值)),旋转镜像,视频裁剪(ROI),视频水印(ROI+weight),导出处理后的视频(包含音频,使用ffmpeg工具对音频进行抽取、剪切和终于opencv处理的视频合并)。

    19504 人正在学习 去看看 夏曹俊

        图像金字塔就是用来做图像缩放,pyrUp( )、pyrDown( )函数分别对图像进行向上采样(放大),向下采样(缩小)的操作。

  也可以使用resize函数。 

一、高斯金字塔:

  用于下采样。原理:首先将原图像作为最底层图像G0(高斯金字塔的第0层),利用高斯核(5*5)对其进行卷积,然后对卷积后的图像进行下采样(去除偶数行和列)得到上一层图像G1,将此图像作为输入,重复卷积和下采样操作得到更上一层图像,反复迭代多次,形成一个金字塔形的图像数据结构,即高斯金字塔。

  • 对图像向下采样:pyrDown函数

获取层级为 G_i+1 的金字塔图像(每一层都按从下到上的次序编号):

1.对图像G_i进行高斯内核卷积

2.将所有偶数行和列去除 (所以图像向下取样会丢失信息)

 

  • 对图像向上采样:pyrUp函数

放大图像做法:

1.将图像在每个方向扩大为原来的两倍,新增的行和列以0填充

2.使用先前同样的内核与放大后的图像卷积,获得 “新增像素”的近似值

    上、下采样都存在图像信息丢失的问题(导致图像会变模糊)。要解决这个问题,就得用拉普拉斯金字塔。

 

二、拉普拉斯金字塔

用于重建图像,也就是预测残差,对图像进行最大程度的还原。比如一幅小图像重建为一幅大图,原理:用高斯金字塔的每一层图像减去其上一层图像上采样并高斯卷积之后的预测图像,得到一系列的差值图像即为 LP 分解图像。

拉普拉斯金字塔第i层的数学定义:

表示第i层的图像。而PyrUp()操作是将源图像中位置为(x,y)的像素映射到目标图像的(2x+1,2y+1)位置,即在进行向上取样。表示卷积,为5x5的高斯内核。

 

OpenCV进行拉普拉斯运算:

import cv2 as cv
#高斯金字塔
def pyramid_demo(image):
    level = 3      #设置金字塔的层数为3
    temp = image.copy()  #拷贝图像
    pyramid_images = []  #建立一个空列表
    for i in range(level):
        dst = cv.pyrDown(temp)   #先对图像进行高斯平滑,然后再进行降采样(将图像尺寸行和列方向缩减一半)
        pyramid_images.append(dst)  #在列表末尾添加新的对象
        cv.imshow("pyramid"+str(i), dst)
        temp = dst.copy()
    return pyramid_images
#拉普拉斯金字塔
def lapalian_demo(image):
    pyramid_images = pyramid_demo(image)    #做拉普拉斯金字塔必须用到高斯金字塔的结果
    level = len(pyramid_images)
    for i in range(level-1, -1, -1):
        if (i-1) < 0:
            expand = cv.pyrUp(pyramid_images[i], dstsize = image.shape[:2])
            lpls = cv.subtract(image, expand)
            cv.imshow("lapalian_down_"+str(i), lpls)
        else:
            expand = cv.pyrUp(pyramid_images[i], dstsize = pyramid_images[i-1].shape[:2])
            lpls = cv.subtract(pyramid_images[i-1], expand)
            cv.imshow("lapalian_down_"+str(i), lpls)


src = cv.imread('F:/Desktop/image/a.JPG')
cv.namedWindow('input_image', cv.WINDOW_AUTOSIZE) #设置为WINDOW_NORMAL可以任意缩放
cv.imshow('input_image', src)
lapalian_demo(src)
cv.waitKey(0)
cv.destroyAllWindows()

pyrDown(src[, dst[, dstsize[, borderType]]]) -> dst 函数原型:

src:输入图像。

dst:输出图像,它与src类型、大小相同。

dstsize:向下采样之后的目标图像的大小。默认按照 Size((src.cols+1)/2, (src.rows+1)/2) 计算的,其实就是把图像的尺寸缩减一半,行和列同时缩减一半。

borderType:图像边界的处理方式。

 

注意:拉普拉斯金字塔时,图像大小必须是2的n次方*2的n次方,不然会报错。

2016-10-06 16:48:16 SoaringLee_fighting 阅读数 6892
  • 学习OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频教程

    OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频培训课程概况:教程中会讲解到基于opencv视频和摄像机录制、播放和播放进度控制,多视频图像合并、多视频图像融合、剪切、视频亮度、对比度、尺寸(近邻插值(手动实现),双线性插值,图像金字塔)、颜色格式(灰度图,二值化(阈值)),旋转镜像,视频裁剪(ROI),视频水印(ROI+weight),导出处理后的视频(包含音频,使用ffmpeg工具对音频进行抽取、剪切和终于opencv处理的视频合并)。

    19504 人正在学习 去看看 夏曹俊
一、基本原理   
   图像金字塔常用作多分辨率模型。视频图像的多分辨率模型是视频图像处理的重要方法。
图像金字塔包括高斯金字塔和拉普拉斯金字塔两种实现形式。
1、高斯金字塔:
  高斯金字塔的实现包括两步:高斯低通滤波和下采样。首先利用高斯核对图像进行卷积;然后进行下采样,得到不同尺度下的目标图像。

2、拉普拉斯金字塔:
拉普拉斯金字塔是建立在高斯金字塔的基础上的,就是高斯金字塔在不同层之间的差分。

二、算法实现
OpenCV实现:
#include <iostream>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
using namespace std;
using namespace cv;
int main(int argv, char* argc[])
{
       int levels = 2;
       Mat img = imread("E:\\OpenCV\\Picture\\airplane.jpg",1);
       namedWindow("original");
       imshow("original", img);
    Mat currentImg = img;
       Mat lap = currentImg;
       for (int l = 0; l<levels; l++) {
         Mat down, up;
      pyrDown(currentImg, down);
         pyrUp(down, up, currentImg.size());
         lap = currentImg - up;
         currentImg = down;
       }
       namedWindow("Laplace Pyramid");
       imshow("Laplace Pyramid", lap);
       waitKey(0);
       return 0;
}

实验效果:



从原图和拉普拉斯金字塔图像可以看出,通过建立拉普拉斯金字塔,可以对特定尺度下的细节进行平滑和增强。
2019-04-25 20:19:26 lyd1995 阅读数 170
  • 学习OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频教程

    OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频培训课程概况:教程中会讲解到基于opencv视频和摄像机录制、播放和播放进度控制,多视频图像合并、多视频图像融合、剪切、视频亮度、对比度、尺寸(近邻插值(手动实现),双线性插值,图像金字塔)、颜色格式(灰度图,二值化(阈值)),旋转镜像,视频裁剪(ROI),视频水印(ROI+weight),导出处理后的视频(包含音频,使用ffmpeg工具对音频进行抽取、剪切和终于opencv处理的视频合并)。

    19504 人正在学习 去看看 夏曹俊

一、实验内容与原理

图像金字塔常用作多分辨率模型。视频图像的多分辨率模型是视频图像处理的重要方法。图像金字塔包括高斯金字塔和拉普拉斯金字塔两种实现形式。

1、高斯金字塔:(向下取样,缩小图像)

高斯金字塔的实现包括两步:高斯低通滤波和下采样。首先利用高斯核对图像进行卷积;然后进行下采样,得到不同尺度下的目标图像。
高斯金字塔工作原理,为了获取层级为i+1层的高斯金字塔图像:
(1)对图像i进行高斯内核卷积
(2)将所有偶数行和列去除
得到的图像即为 i+1层的图像,显而易见,结果图像只有原图的四分之一。通过对输入图像i层(原始图像)不停迭代以上步骤就会得到整个金字塔。同时我们也可以看到,向下取样会逐渐丢失图像的信息。
以上就是对图像的向下取样操作,即缩小图像。

2、拉普拉斯金字塔:(向上取样,放大图像)

拉普拉斯金字塔是建立在高斯金字塔的基础上的,就是高斯金字塔在不同层之间的差分。
拉普拉斯金字塔工作原理:
如果想放大图像,则需要通过向上取样操作得到,具体做法如下:
(1)将图像在每个方向扩大为原来的两倍,新增的行和列以0填充
(2)使用先前同样的内核(乘以4)与放大后的图像卷积,获得 “新增像素”的近似值
得到的图像即为放大后的图像,但是与原来的图像相比会发觉比较模糊,因为在缩放的过程中已经丢失了一些信息,如果想在缩小和放大整个过程中减少信息的丢失,这些数据形成了拉普拉斯金字塔。
也就是说,拉普拉斯金字塔是通过源图像减去先缩小后再放大的图像的一系列图像构成的。

二、实验代码

实验环境:
(1)OpenCV3.4.3
(2)Ubuntu16.04
(3)VS Code
(4)C++

#include <iostream>
#include <opencv2/opencv.hpp>
#include <string>
#include <vector>
#include <math.h>
#include <cmath>
#include <algorithm>

class Exp8{
public:
    Exp8(std::vector<std::string> path){
        for(int i = 0; i < path.size(); i++){
            original_color_image.push_back(cv::imread(path[i]));
            original_gray_image.push_back(color2Gray(original_color_image[i]));
        }
        std::cout<< "初始化结束" << "\n";
        for(int i = 5; i < 10; i = i + 2){
            makeGaussTemplate(i);
            filter_size.push_back(i);
        }
        computerGaussTemplateSum();
        zerosPadding(0);
    }
    // 0 彩色图像转灰度图像
    cv::Mat color2Gray(cv::Mat& src){
        //创建与原图同类型和同大小的矩阵
	    cv::Mat gray_image = cv::Mat::zeros(src.rows, src.cols, CV_8UC1);
        if(src.channels()!=1){
            for(int i = 0; i < src.rows; i++)
                for(int j = 0; j < src.cols; j++)
                    gray_image.at<uchar>(i, j) = (src.at<cv::Vec3b>(i, j)[0] + src.at<cv::Vec3b>(i, j)[1] + src.at<cv::Vec3b>(i, j)[2]) / 3;
        }
        else
            gray_image = src.clone();
        return gray_image;
    }
    // 1 生成高斯滤波模板
    void makeGaussTemplate(int size=5, int sigma=1){
        cv::Mat gaussTemplate = cv::Mat::zeros(size, size, CV_32F);
        int center=size/2;
        double min = g(center,center);
        for(int i=0; i < size; i++)
            for(int j=0; j < size; j++)
                gaussTemplate.at<float>(i, j) = g(i-center,j-center)/min; 
        gaussTemplate.convertTo(gaussTemplate, CV_8U);
        gauss_template.push_back(gaussTemplate);
    }
    // 1.1 计算正态分布
    double g(double x, double y, double sigma=1){
        return exp(-(x*x + y*y)/(2*sigma*sigma));
    }
    // 1.2 计算高斯模板之和
    void computerGaussTemplateSum(){
        for(int k=0; k < gauss_template.size(); k++){
            int sum = 0;
            for(int i=0; i < gauss_template[k].rows; i++)
                for(int j=0; j < gauss_template[k].cols; j++)
                    sum += gauss_template[k].at<uchar>(i, j);
            gauss_template_sum.push_back(sum);
        }
    }
    // 1.3 预处理零填充
    void zerosPadding(int id, int kernel_size=5){
        int m = kernel_size/2;
        cv::Mat gray_dst = cv::Mat::zeros(2*m + original_gray_image[id].rows, 2*m + original_gray_image[id].cols, original_gray_image[id].type());
        cv::Mat color_dst = cv::Mat::zeros(2*m + original_color_image[id].rows, 2*m + original_color_image[id].cols, original_color_image[id].type());
        // 相加,填充零
        gray_dst(cv::Rect(m, m, original_gray_image[id].cols, original_gray_image[id].rows)) += original_gray_image[id];
        color_dst(cv::Rect(m, m, original_color_image[id].cols, original_color_image[id].rows)) += original_color_image[id];
        color_image_padding.push_back(color_dst);
        gray_image_padding.push_back(gray_dst);
    }
    // 1.4 计算高斯滤波
    int computerGaussResult(cv::Mat& image_block, int size_id=0){
        int sum = gauss_template_sum[size_id];
        return image_block.dot(gauss_template[size_id])/sum;
    }
    // 2 向下采样,缩小图像
    void grayDownSampling(int pic_id, int level=1, int size_id=0){
        int size = filter_size[size_id];
        int m = size/2;
        int rate=2*level;
        
        cv::Mat image_shrink = cv::Mat::zeros(original_gray_image[pic_id].rows/rate, original_gray_image[pic_id].cols/rate, original_gray_image[pic_id].type());
        cv::Mat image_process = cv::Mat::zeros(original_gray_image[pic_id].size(), original_gray_image[pic_id].type());
        // 1 高斯滤波
        for(int i = m; i < gray_image_padding[pic_id].rows - m; i++)
            for(int j = m; j < gray_image_padding[pic_id].cols - m; j++){ 
                cv::Mat sub_matrix = gray_image_padding[pic_id](cv::Rect(j - m, i - m, size, size));
                image_process.at<uchar>(i - m, j - m) = computerGaussResult(sub_matrix, size_id);
            }
        cv::imshow("高斯滤波", image_process);
        cv::waitKey(0);
        // 2 缩小图像
        for(int i = 0; i < image_shrink.rows - m; i++)
            for(int j = 0; j < image_shrink.cols - m; j++)
                image_shrink.at<uchar>(i, j) = image_process.at<uchar>(rate*i + 1, rate*j + 1);
        
        gray_image_downsampling.push_back(image_shrink);
    }
    // 3 向上采样,放大图像
    void grayUpSampling(int pic_id, int level=1, int size_id=0){
        int size = filter_size[size_id];
        int m = size/2;
        int rate=2*level;
        // 1 放大图像
        cv::Mat image_amplify = cv::Mat::zeros(gray_image_downsampling[pic_id].rows*rate, gray_image_downsampling[pic_id].cols*rate, gray_image_downsampling[pic_id].type());
        for(int i = 0; i < gray_image_downsampling[pic_id].rows - m; i++)
            for(int j = 0; j < gray_image_downsampling[pic_id].cols - m; j++)
                image_amplify.at<uchar>(rate*i + 1, rate*j + 1) = gray_image_downsampling[pic_id].at<uchar>(i, j);
        cv::imshow("直接放大", image_amplify);
        cv::waitKey(0);
        // 2 高斯滤波
        //int rows=image_amplify.rows, cols = image_amplify.cols;
        cv::Mat image_process = image_amplify.clone();
        imageZerosPadding(image_amplify, image_amplify);
        //cv::Mat image_process = image_amplify.clone();
        for(int i = m; i < image_amplify.rows - m; i++)
            for(int j = m; j < image_amplify.cols - m; j++){ 
                cv::Mat sub_matrix = image_amplify(cv::Rect(j - m, i - m, size, size));
                //image_process.at<uchar>(i, j) = 4*computerGaussResult(sub_matrix, size_id);
                if((i-m) == 0 || (j-m) == 0 || (i-m) == (image_process.rows-1) || (j-m) == (image_process.cols-1))
                    image_process.at<uchar>(i-m, j-m) = 8*computerGaussResult(sub_matrix, size_id);
                else
                    image_process.at<uchar>(i-m, j-m) = 4*computerGaussResult(sub_matrix, size_id);
                //std::cout<<"j-m:"<<j-m<<"\n";
            }
        gray_image_upsampling.push_back(image_process);
        //gray_image_upsampling.push_back(image_process( cv::Rect(0, 0, original_gray_image[pic_id].cols, original_gray_image[pic_id].rows) ));
    }
    // 3.1 零填充图像
    void imageZerosPadding(cv::Mat& src, cv::Mat& dst, int kernel_size=5){
        int m = kernel_size/2;
        cv::Mat gray_dst = cv::Mat::zeros(2*m + src.rows, 2*m + src.cols, src.type());
        gray_dst(cv::Rect(m, m, src.cols, src.rows)) += src;
        dst = gray_dst;
    }
    // 4 测试上面的采样效果
    void test_sampling(){
        cv::imshow("原始图像", original_gray_image[0]);
        cv::waitKey(0);

        grayDownSampling(0);
        cv::imshow("DownSampling", gray_image_downsampling[0]);
        cv::waitKey(0);

        grayUpSampling(0);
        cv::imshow("UpSampling", gray_image_upsampling[0]);
        cv::waitKey(0);
    }
    void run(int pic_id=0){
        int levels = 1;
        cv::Mat currentImg = original_gray_image[pic_id];
        cv::imshow("原始图像", currentImg);
        cv::waitKey(0);
        cv::Mat lap = currentImg;

        grayDownSampling(pic_id, levels);
        cv::imshow("DownSampling", gray_image_downsampling[pic_id]);
        cv::waitKey(0);

        grayUpSampling(pic_id, levels);
        cv::imshow("UpSampling", gray_image_upsampling[pic_id]);
        cv::waitKey(0);
        //std::cout << "lap:"<<lap.size()<<"\n";
        //std::cout << "gray_image_upsampling[pic_id]:"<<gray_image_upsampling[pic_id].size()<<"\n";

        lap = currentImg - gray_image_upsampling[pic_id];
        cv::imshow("金字塔方法进行图像分割 ", lap(cv::Rect(0, 0,lap.cols - 5, lap.rows - 5)));
        cv::waitKey(0);
    }
   

private:
    // 原始图像
    std::vector<cv::Mat> original_color_image;
    std::vector<cv::Mat> original_gray_image;
    // 零填充图像
    std::vector<cv::Mat> color_image_padding;
    std::vector<cv::Mat> gray_image_padding;
    // 高斯滤波模板
    std::vector<cv::Mat> gauss_template;
    std::vector<int> gauss_template_sum;
    // 降采样后的图像
    std::vector<cv::Mat> color_image_downsampling;
    std::vector<cv::Mat> gray_image_downsampling;
    // 向上采样后的图像
    std::vector<cv::Mat> color_image_upsampling;
    std::vector<cv::Mat> gray_image_upsampling;
    // 高斯模板尺寸
    std::vector<int> filter_size;
};

int main(){
    std::vector<std::string> path;
    path.push_back("/home/lyd/image_process/pic/lena.jpg");
    Exp8 a(path);
    a.run();

    return 0;
}

三、实验结果

在这里插入图片描述

2019-10-30 11:48:12 Python_Matlab 阅读数 16
  • 学习OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频教程

    OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频培训课程概况:教程中会讲解到基于opencv视频和摄像机录制、播放和播放进度控制,多视频图像合并、多视频图像融合、剪切、视频亮度、对比度、尺寸(近邻插值(手动实现),双线性插值,图像金字塔)、颜色格式(灰度图,二值化(阈值)),旋转镜像,视频裁剪(ROI),视频水印(ROI+weight),导出处理后的视频(包含音频,使用ffmpeg工具对音频进行抽取、剪切和终于opencv处理的视频合并)。

    19504 人正在学习 去看看 夏曹俊

图像金字塔原理
高斯金字塔与拉普拉斯金字塔
reduce = 高斯模糊+降采样
expand = 扩大 + 卷积
PyrDown:降采样
PyrUp:还原

from matplotlib import pyplot as plt 
from cv2 import cv2 as cv
import numpy as np 

# 高斯金字塔
def pyramid_demo(image):
    level = 3   #层数
    temp = image.copy()
    pyramid_images = []
    for i in range(level):
        dst = cv.pyrDown(temp)
        pyramid_images.append(dst)
        cv.imshow('pyramid_down_'+str(i),dst)
        temp = dst.copy()
    return pyramid_images

# 拉普拉斯金字塔
# 通过高斯金字塔可以构建拉普拉斯金字塔
def lapalian_demo(image):
    pyramid_images = pyramid_demo(image)
    level = len(pyramid_images)     #求层数
    for i in range(level-1,-1,-1): # 每次递减
        if (i-1) < 0:
            expand = cv.pyrUp(pyramid_images[i], dstsize = image.shape[:2])
            lpls = cv.subtract(image, expand)
            cv.imshow("lapalian_down_" + str(i), lpls)
        else:
            expand = cv.pyrUp(pyramid_images[i], dstsize = pyramid_images[i-1].shape[:2])
            lpls = cv. subtract(pyramid_images[i-1], expand)
            cv. imshow("lapalian_down_"+str(i), lpls)

if __name__ == '__main__':
	filepath = "C:\\pictures\\cat.jpg"  # 对于这样 图片必须是2^n 格式如(512*512)
	img = cv.imread(filepath)       # blue green red
	# cv.namedWindow("input image",cv.WINDOW_AUTOSIZE)
	cv.imshow("input image",img)
	
	lapalian_demo(img)
	
	cv.waitKey(0)
	cv.destroyAllWindows()

拉普拉斯:
在这里插入图片描述
高斯:
在这里插入图片描述

2018-04-09 10:13:20 zcg1942 阅读数 342
  • 学习OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频教程

    OpenCV3.2+QT5+ffmpeg实战开发视频编辑器视频培训课程概况:教程中会讲解到基于opencv视频和摄像机录制、播放和播放进度控制,多视频图像合并、多视频图像融合、剪切、视频亮度、对比度、尺寸(近邻插值(手动实现),双线性插值,图像金字塔)、颜色格式(灰度图,二值化(阈值)),旋转镜像,视频裁剪(ROI),视频水印(ROI+weight),导出处理后的视频(包含音频,使用ffmpeg工具对音频进行抽取、剪切和终于opencv处理的视频合并)。

    19504 人正在学习 去看看 夏曹俊

美重建要求使用无限求和来内插,实践中,不得不寻求某种近似。在图像处理中,二维内插最普通的应用就是调整图像的大小。放大可看成是过取样,缩小是欠取样。无论是过取样还是欠取样,都需要内插,内插有最近邻、双线性、双三次。在图像配准构建图像金字塔的过程中,和图像配准的最后一步图像透视变换,都需要内插,内插的好坏直接影响最终的效果。

当我们想要整数倍得地增加一幅图像的尺寸时,与过取样相联系的最近邻内插的一个特殊情况是采用像素复制的放大操作,例如,将一幅图像放大两倍,我们可以先复制每一列,这时水平尺寸放大一倍,再复制每一行,垂直尺寸也放大了一倍。欠取样可以通过行-列删除来实现,如缩小为一半时,每隔一行和一列来删除,当收缩为非整数时,用网格模拟的方法,因为内插的本质是用已知的数据来估计未知位置的数值的处理。在缩小图像前频率域模糊,可以减小混淆。在图像的边缘内容很强时,混淆的影响看起来就是块状图像分量,称为锯齿。

另外一种人为缺陷是莫尔波纹模式,是使用周期或者近似周期分量对场景取样产生的。在光学中,莫尔模式指的是在两个近似等间隔的光栅之间产生的差拍模式。在数字图像处理中,当扫描介质印刷物如报纸和杂志时,或者在具有周期分量的图像中,如果它的间隔与取样间隔可比的时候,通常会出现这个问题。与取样造成的人为缺陷相比,莫尔模式更加常见。将一个模式叠加在另外一个模式在数学上等价于两个模式相乘。

刚才提到的报纸等印刷物使用的是半色调diao点。

知乎作者:Monster Matt:连续调(continuous-tone)指的是图像的基本元素(像素)自身含有颜色的深浅、明亮的连续变化,而半色调(half-tone)的图像自身的基本元素(这里指的是比网点还小的曝光点)只有有色、无色两种状态,印刷物的由浅变深,由淡到浓是由曝光点的大小来实现的。“利用曝光点的均匀排列组成网点(调幅加网)”、“利用曝光点不均匀排列形成图像(调频加网)”或者以上两种方式的混合体(二阶调频加网)实现图像的复制。网点面积大,颜色就深,称为深调;网点面积小,颜色就浅,称为亮调。由于网点在空间上是有一定距离的,呈离散发布,并且由于加网的级数总有一定的限制,在图像的层次上不能像连续图像一样实现无极变化,故称加网图像为半色调图像。




图像金字塔

阅读数 6

没有更多推荐了,返回首页