精华内容
下载资源
问答
  • 拉普拉斯金字塔

    2013-04-23 15:41:01
    拉普拉斯金字塔
  • 拉普拉斯金字塔融合

    2015-05-02 21:39:30
    好用的拉普拉斯金字塔融合程序,直接可以运行使用,融合效果很好.matlab
  • 11.5 拉普拉斯金字塔

    2020-08-19 14:53:46
    本次介绍拉普拉斯金字塔。 一、拉普拉斯金字塔 我们前面学的金字塔是高斯金字塔。这里学拉普拉斯金字塔。 首先对原始图像Gi进行向下取样,然后向上采用,最后与原始图像相减,...

                                                                                                                点击此处返回总目录

     

    本次介绍拉普拉斯金字塔。

     

    一、拉普拉斯金字塔

     

     

    我们前面学的金字塔是高斯金字塔。这里学拉普拉斯金字塔。

    首先对原始图像Gi进行向下取样,然后向上采用,最后与原始图像相减,得到拉普拉斯金字塔图像。

     

    虽然说他的原理很简单,但是很多人对整个过程进行了不同的描述。

    我们在看很多教材或官网上面,会有各种各样的图。我们来解释一下。

     

     

    下面这张图也是比较常见的:

     

     

     

    其实就是上面的公式。

    使用原始图像 套入公式得到拉普拉斯金字塔第0层。

    使用原始图像向下采样Od 代入公式 得到 拉普拉色金字塔第1层。

     

     

    这张图在看一些资料的时候也经常看到:

     

     

    也是一样的。

     

    这个图也很常见。

     

     

    下面这个图也是一样的。

     

     

     

    二、代码实现

     

    例1:得到拉普拉斯金字塔第0层

     

     

    结果:

     

     

     

     

    例2:得到两层拉普拉斯金字塔

     

     

    结果:

     

     

     

     

     

     

     

     

     

     

    展开全文
  • matlab高斯金字塔代码拉普拉斯金字塔 过滤器的GPU实现 该库包括过滤器和拉普拉斯金字塔的GPU实现。 还在openCV中实现了本地拉普拉斯金字塔和混合示例。 与此处给出的原始MATLAB代码相比,GPU代码可以非常快速地运行...
  • matlab开发-高斯金字塔和拉普拉斯金字塔。视为原始图像
  • 简单图像融合(加权平均、像素选大、像素选小)算法,拉普拉斯金字塔算法的Matlab实现 GUI界面 简单图像融合(加权平均、像素选大、像素选小)算法,拉普拉斯金字塔算法的Matlab实现 GUI界面
  • 提出了基于CUDA的并行拉普拉斯金字塔算法。算法采用的并行拉普拉斯算法很好地解决了共享存储器的bank冲突和全局存储器的合并访问的问题,为了最大化并行效率,计算了SM占用率,并通过公式进行了论证。在GTX480平台下...
  • 拉普拉斯金字塔和对比度金字塔

    千次阅读 2019-05-10 17:23:18
    拉普拉斯金字塔和对比度金字塔 对比度方法具有特别突出红外特征明显的目标的特点,从整幅图像的视角效果看并不优于用拉普拉斯金字塔融合的图像,从图像平滑、视角不失真的角度看拉普拉斯金字塔的融合方法可能还优于...

    拉普拉斯金字塔和对比度金字塔

    对比度方法具有特别突出红外特征明显的目标的特点,从整幅图像的视角效果看并不优于用拉普拉斯金字塔融合的图像,从图像平滑、视角不失真的角度看拉普拉斯金字塔的融合方法可能还优于对比度金字塔的方法

    两个图像融合时,拉普拉斯金字塔中得到两幅残差图后取最大再融合清晰度高于掩码来计算(个人图片比较),

    展开全文
  • 拉普拉斯金字塔变换

    2012-12-16 17:59:22
    拉普拉斯金字塔变换程序的代码,可直接进行出结果。
  • 高斯金字塔 拉普拉斯金字塔Recursion is beautiful, and when applied in combination it is truly a form of art. In this story, we are going to implement an interesting algorithm to create pyramids with ...

    高斯金字塔 拉普拉斯金字塔

    Recursion is beautiful, and when applied in combination it is truly a form of art. In this story, we are going to implement an interesting algorithm to create pyramids with recursion.

    递归是美丽的,结合使用它确实是一种艺术形式。 在这个故事中,我们将实现一个有趣的算法来创建具有递归的金字塔。

    Ancient civilizations around the world have built giant pyramids for worship and other holy purposes. The most famous, perhaps, are the pyramids built by the Egyptians. These huge structures are built with white, limestone surfaces so that they appear to be shining when seen from a distance. They are so magnificent, in fact, that many people today still believe that they were built by the aliens. So, today we are going to build them in code with recursion. It is very fitting.

    世界各地的古代文明都建造了巨型金字塔,以供崇拜和其他神圣用途。 也许最著名的是埃及人建造的金字塔。 这些巨大的建筑物是用白色石灰石表面建造的,因此从远处看时它们看起来像是在发光。 实际上,它们是如此的宏伟,以至于当今许多人仍然相信它们是由外星人建造的。 因此,今天我们将使用递归代码构建它们。 非常合适。

    问题: (Problem:)

    Suppose I am given a base like this:

    假设给我这样的基础:

    [a, b, c ]

    [a,b,c]

    and that the following triangles are allowed:

    并且允许以下三角形:

    [aab, bdc, bad]

    [AAB,BDC,坏]

    what kind of pyramids can I create?

    我可以创建哪种金字塔?

    Image for post
    Base = abc, Allows = [abb, bdc, bad]
    基本= abc,允许= [abb,bdc,坏]

    Shown above is a valid pyramid that can be built with the specifications given. The base is [a, b, c], and there are 3 triangles in this pyramid:

    上面显示的是可以使用给定规格构建的有效金字塔。 底数为[a,b,c],此金字塔中有3个三角形:

    from bottom to top: [abb, bdc, bad]

    从下到上:[abb,bdc,坏]

    They are all in the allowed triangles.

    它们都在允许的三角形中。

    What if I add one more allowed triangle: acb?

    如果我再添加一个允许的三角形:acb怎么办?

    Well, if you did that you could get into this situation:

    好吧,如果您这样做,可能会遇到这种情况:

    Image for post
    Unfinished Pyramid
    未完成的金字塔

    But there’s no way for you to complete the pyramid, because there is no allowed triangle that satisfies: c*d.

    但是您无法完成金字塔,因为没有允许的三角形满足:c * d。

    But if you add yet one more allowed triangle: cad

    但是,如果再添​​加一个允许的三角形:cad

    Image for post
    Base = abc, Allows = [abb, bdc, bad, acb, cad]
    基本= abc,允许= [abb,bdc,坏,acb,cad]

    Then you can complete a new pyramid!

    然后,您可以完成一个新的金字塔!

    解决: (Solve:)

    行制造商: (Row Maker:)

    How do we go about creating all of the possible pyramids from a base, [a, b, c], and a set of allowed triangles, [abb, bdc, bad, acb, cad]?

    我们如何从一个底数[a,b,c]和一组允许的三角形[abb,bdc,bad,acb,cad]创建所有可能的金字塔?

    I think it’s clear that you’ll have to loop through each pair of base nodes, [ab, bc], and create the next rows of the pyramids (that would be [b, d] and [c, d]). So let’s do that.

    我认为很明显,您必须遍历每对基本节点[ab,bc],并创建金字塔的下一行(即[b,d]和[c,d])。 因此,让我们这样做。

    Starting with ab, we check what are the allowed triangles with base ab. That would be: [abb, acb], at this point it’s clear that there are at least two possible combinations of next row, so how do you proceed to find all of them? Well, what we could do is recursively find the next row for the remaining base: [b, c], and then append the solutions to that to each of the possible first triangle. In this case the solutions to [b, c] is simple, there is only one: [bdc], so we append this solution to the two possible solutions to the first triangle ([abb, acb]), and contruct the two possible next row: ([b, d], [c, d])

    从ab开始,我们检查以ab为基础的三角形是什么。 那应该是:[abb,acb],这时很显然下一行至少有两种可能的组合,那么如何继续查找所有这些呢? 好吧,我们可以做的是递归地找到剩余基数的下一行:[b,c],然后将解决方案附加到每个可能的第一个三角形上。 在这种情况下,[b,c]的解很简单,只有一个:[bdc],因此我们将此解附加到第一个三角形的两个可能解中([abb,acb]),并构造两个可能的解下一行:([b,d],[c,d])

    def row_maker(bottom, allows):

    if len(bottom) <= 1:
    return [bottom]

    def get_allowed(pair):

    allowed = []
    for allow in allows:
    if allow[0] == pair[0] and allow[-1] == pair[-1]:
    allowed.append(allow[1])

    return allowed

    allowed = get_allowed(bottom[:2])
    if len(bottom) == 2:
    return allowed

    substrings = row_maker(bottom[1:], allows)
    res = []
    for allow in allowed:
    for substring in substrings:
    res.append(allow + substring)

    return resbase = 'abc'
    allows = ['abb', 'bdc', 'bad', 'acb', 'cad']

    row_maker(base, allows)
    # ['bd', 'cd']

    Now that we have the next row maker function, we still need to construct the pyramid.

    现在我们有了下一个行生成器功能,我们仍然需要构造金字塔。

    金字塔制作器: (Pyramid Maker:)

    In order to do that, again we start with the base [a, b, c], find the next rows: [b,d], [c, d], then for each of the next rows we again recursively find their respective next rows: [a], [a], and combine them into the final solutions:

    为此,我们再次从基础[a,b,c]开始,找到下一行:[b,d],[c,d],然后对于接下来的每一行,我们再次递归地找到它们各自的接下来的行:[a],[a],并将它们合并为最终解决方案:

    Image for post
    Solutions for Base = abc, Allows = [abb, bdc, bad, acb, cad]
    Base = abc,Allows = [abb,bdc,bad,acb,cad]的解决方案
    def pyramid_maker(bottom, allows):

    if len(bottom) <= 1:
    return [[bottom]]

    rows = row_maker(bottom, allows)

    res = []
    for row in rows:
    res = res + pyramid_maker(row, allows)

    res = [[bottom] + s for s in res]

    return resbase = 'abc'
    allows = ['abb', 'bdc', 'bad', 'acb', 'cad']

    res = pyramid_maker(base, allows)
    # [['abc', 'bd', 'a'], ['abc', 'cd', 'a']]

    Isn’t it wonderful?

    这不是很好吗?

    复杂: (Complexity:)

    Before we go for dinner, what is the complexity of this algorithm?

    在我们共进晚餐之前,该算法的复杂性是什么?

    Let’s start with row_maker, in order to make the next row you are looping through every character of the current row, so that’s O(n) where n is the length of base.

    让我们从row_maker开始,为了制作下一行,您正在遍历当前行的每个字符,因此为O(n),其中n是基数的长度。

    Moving onto the pyramid_maker. In it, you first call row_maker to get all of the possible rows, if allows is size m, the maximum number of possible rows returned are m^(n-1) and for each of those rows you call pyramid_maker again, until the returned rows are length 1. so the total number of operations are m^(n-1) * m^(n-2) * … * m¹ = m^(n(n-1)/2)

    移动到pyramid_maker。 在其中,您首先调用row_maker以获取所有可能的行,如果允许的大小为m,则返回的最大可能行数为m ^(n-1),对于这些行中的每一行,您再次调用pyramid_maker,直到返回行的长度为1。因此操作总数为m ^(n-1)* m ^(n-2)*…*m¹= m ^(n(n-1)/ 2)

    The maximum complexity is actually:

    实际上,最大复杂度是:

    O(m^(n²))

    O(m ^(n²))

    That’s a pretty large number… but it’s really only for special cases where all the characters in the pyramid and allows are identical, so don’t worry too much about it!

    这是一个相当大的数字……但实际上仅适用于特殊情况下,金字塔和允许的所有字符都相同,因此不必为此担心太多!

    艺术时间! (Art Time!)

    Image for post
    Base = faye, Allows = [fya, afy, fay, ayf, yfa, yaf, yae, yea, eay, eya, aye, aey]
    基数= faye,允许= [fya,afy,fay,ayf,yfa,yaf,yae,是,eay,eya,aye,aey]

    翻译自: https://medium.com/swlh/pyramid-maker-1d5b13ab9b67

    高斯金字塔 拉普拉斯金字塔

    展开全文
  • Opencv-拉普拉斯金字塔

    千次阅读 2019-09-17 09:15:26
    拉普拉斯金字塔知识点python代码c++代码 知识点 拉普拉斯金字塔 对输入图像实现金字塔的reduce操作就会生成不同分辨率的图像、对这些图像进行金字塔expand操作,然后使用reduce减去expand之后的结果就会得到图像...

    拉普拉斯金字塔

    知识点

    拉普拉斯金字塔
    对输入图像实现金字塔的reduce操作就会生成不同分辨率的图像、对这些图像进行金字塔expand操作,然后使用reduce减去expand之后的结果就会得到图像拉普拉斯金字塔图像。
    举例如下:
    输入图像G(0)
    金字塔reduce操作生成 G(1), G(2), G(3)
    拉普拉斯金字塔:
    L0 = G(0)-expand(G(1))
    L1 = G(1)-expand(G(2))
    L2 = G(2)–expand(G(3))
    G(0)减去expand(G(1))得到的结果就是两次高斯模糊输出的不同,所以L0称为DOG(高斯不同)、它约等于LOG所以又称为拉普拉斯金字塔。所以要求的图像的拉普拉斯金字塔,首先要进行金字塔的reduce操作,然后在通过expand操作,最后相减得到拉普拉斯金字塔图像。
    在这里插入图片描述

    python代码

    import cv2 as cv
    import numpy as np
    
    
    def laplaian_demo(pyramid_images):
        level = len(pyramid_images)
        for i in range(level-1, -1, -1):
            if (i-1) < 0:
                h, w = src.shape[:2]
                expand = cv.pyrUp(pyramid_images[i], dstsize=(w, h))
                lpls = cv.subtract(src, expand) + 127
                cv.imshow("lpls_" + str(i), lpls)
            else:
                h, w = pyramid_images[i-1].shape[:2]
                expand = cv.pyrUp(pyramid_images[i], dstsize=(w, h))
                lpls = cv.subtract(pyramid_images[i-1], expand) + 127
                cv.imshow("lpls_"+str(i), lpls)
    
    
    def pyramid_up(image, level=3):
        temp = image.copy()
        # cv.imshow("input", image)
        pyramid_images = []
        for i in range(level):
            dst = cv.pyrDown(temp)
            pyramid_images.append(dst)
            # cv.imshow("pyramid_up_" + str(i), dst)
            temp = dst.copy()
        return pyramid_images
    
    
    src = cv.imread("C:/Users/qqxd/Desktop/opencvcode/images/master.jpg")
    cv.namedWindow("input", cv.WINDOW_AUTOSIZE)
    cv.imshow("input", src)
    # pyramid_up(src)
    laplaian_demo(pyramid_up(src))
    
    cv.waitKey(0)
    cv.destroyAllWindows()
    
    

    c++代码

    #include <opencv2/opencv.hpp>
    #include <iostream>
    
    using namespace cv;
    using namespace std;
    
    void pyramid_up(Mat &image, vector<Mat> &pyramid_images, int level);
    void laplaian_demo(vector<Mat> &pyramid_images, Mat &image);
    int main(int artc, char** argv) {
    	Mat src = imread("C:/Users/qqxd/Desktop/opencvcode/images/master.jpg");
    	if (src.empty()) {
    		printf("could not load image...\n");
    		return -1;
    	}
    	namedWindow("input", WINDOW_AUTOSIZE);
    	imshow("input", src);
    
    	vector<Mat> p_images;
    	pyramid_up(src, p_images, 3);
    	laplaian_demo(p_images, src);
    
    	waitKey(0);
    	return 0;
    }
    
    void pyramid_up(Mat &image, vector<Mat> &pyramid_images, int level) {
    	Mat temp = image.clone();
    	Mat dst;
    	for (int i = 0; i < level; i++) {
    		pyrDown(temp, dst);
    		//imshow(format("pyramid_up_%d", i), dst);
    		temp = dst.clone();
    		pyramid_images.push_back(temp);
    	}
    }
    
    void laplaian_demo(vector<Mat> &pyramid_images, Mat &image) {
    	for (int t = pyramid_images.size() - 1; t > -1; t--) {
    		Mat dst;
    		if (t - 1 < 0) {
    			pyrUp(pyramid_images[t], dst, image.size());
    			subtract(image, dst, dst);
    			dst = dst + Scalar(127, 127, 127);
    			imshow(format("laplaian_layer_%d", t), dst);
    		}
    		else {
    			pyrUp(pyramid_images[t], dst, pyramid_images[t - 1].size());
    			subtract(pyramid_images[t - 1], dst, dst);
    			dst = dst + Scalar(127, 127, 127);
    			imshow(format("laplaian_layer_%d", t), dst);
    		}
    	}
    }
    

    运行结果如下:
    在这里插入图片描述

    展开全文
  • 拉普拉斯金字塔与dog金字塔与log金字塔的区别...............
  • 高斯金字塔和拉普拉斯金字塔

    千次阅读 2019-05-21 21:23:57
    高斯金字塔和拉普拉斯金字塔 高斯金字塔算法流程: (1)对图像进行高斯卷积(高斯滤波) (2)删除偶数行和偶数列(下采样) 拉普拉斯金字塔算法流程:(用于低分辨率恢复高分辨率图像时计算残差) 对于高斯金字塔...
  • 高斯金字塔 拉普拉斯金字塔 当我看到开发团队时,我期望看到的程序员比需求人员(BA,产品经理等)更多,并且期望看到更少的管理类型。 可以认为它就像一个人员配置金字塔结构: 程序员(通常是测试人员)应该...
  • 高斯金字塔 拉普拉斯金字塔The topic for today is on data validation and settings management using Python type hinting. We are going to use a Python package called pydantic which enforces type hints at ...
  • 是个重复迭代的过程 求拉普拉斯前两层 第零层,第一层… ...第0层拉普拉斯金字塔 o1 第1层的处理图像 od1 第1层的向下采样图像 odu1 第1层的向下采样再向上采样图像 lappyr1 第1层拉普拉斯金字塔 im...
  • 高斯金字塔 拉普拉斯金字塔 For the first time in 10 years, http://aclark.net is not powered by Plone. 这是10年来的第一次,Plone不再支持http://aclark.net。 Nothing against Plone: it’s still one of ...
  • 拉普拉斯金字塔图像融合

    千次阅读 2019-06-20 14:43:33
      关于拉普拉斯金字塔分解和融合的文章很多了,本文不阐述原理。简单记录一下遥感图像的融合效果和融合规则,遥感图为可见光和NIR图。 融合规则   由拉普拉斯金字塔分解可以得张两组待融合图像的金字塔,对...
  • 高斯金字塔 ( ...拉普拉斯金字塔拉普拉斯金字塔的第i层为高斯金字塔的第i层减去先经过上采样(每个方向扩大两倍,即新增的行和列用0填充)再经过卷积操作的第i+1层高斯金字塔。从而获得由降采样操作丢失的信息
  • 目录前言原理高斯金字塔拉普拉斯金字塔正文PyrDown降采样pyrUp函数升采样参考文献 前言 这篇文章主要讲的是图像金字塔,拉普拉斯金字塔。在说明什么是图像金字塔的过程之前,我们需要需要了解一个概念:尺度 尺度,...
  • 拉普拉斯金字塔重构 一、概述         拉普拉斯金字塔的重构主要是包括三部分,第一部分是高斯金字塔的构造,第二部分是构造拉普拉斯金字塔,第三部分是利用高斯—拉普拉斯...
  • 高斯金字塔: repeat{ 1.对图像进行高斯滤波(平滑化); 2.抛除偶数行和列,依次缩小图片尺寸。 // 每进行一轮循环,得到一层金字塔,每层金字塔图像大小都是上一层的一半。...// 拉普拉斯金字塔的顶层(即图
  • 文章目录一、图像金字塔的定义二、高斯金字塔的计算三、拉普拉斯金字塔的计算 一、图像金字塔的定义 图像金字塔是图像中多尺度表达的一种,用多分辨率来解释图像。 金字塔的底部是待处理图像的高分辨率表示,而顶部...
  • 目录 一、图像金字塔 二、高斯金字塔 三、拉普拉斯金字塔 ...拉普拉斯金字塔:本层图像减去先缩小(pyrDown)后再放大(pyrUp)的图像的一系列图像构成的,得到的其实是原始像素值减去估计值得到的差值 一...
  • 使用高斯金字塔和拉普拉斯金字塔重构的主要思想就是:高斯金字塔中的内容在高斯模糊并且下采样的过程中会丢失信息,而为了重构出和原图像相差不大的图像,我们则希望能够用某种方式将建立高斯金字塔过程中丢失的信息...
  • OpenCV图像金字塔:高斯金字塔、拉普拉斯金字塔总结

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,659
精华内容 1,463
关键字:

拉普拉斯金字塔