精华内容
下载资源
问答
  • 创建线程池有哪几种方式

    千次阅读 2019-08-30 10:24:23
    Executors目前提供了5不同的线程池创建配置: 1、newCachedThreadPool(),它是用来处理大量短时间工作任务的线程池,具有个鲜明特点:它会试图缓存线程并重用,当无缓存线程可用时,就会创建新的工作线程;...

    通常开发者都是利用Executors提供的通用线程池创建方法,去创建不同配置的线程池,主要区别在于不同的

    Executors目前提供了5种不同的线程池创建配置:

    1、newCachedThreadPool(),它是用来处理大量短时间工作任务的线程池,具有几个鲜明特点:它会试图缓存线程并重用,当无缓存线程可用时,就会创建新的工作线程;如果线程闲置时间超过60秒,则被终止并移除缓存;长时间闲置时,这种线程池,不会消耗什么资源。其内部使用SynchronousQueue作为工作队列。

    2、newFixedThreadPool(int nThreads),重用指定数目(nThreads)的线程,其背后使用的是无界的工作队列,任何时候最多有nThreads个工作线程是活动的。这意味着,如果任务数量超过了活动线程数目,将在工作队列中等待空闲线程出现;如果工作线程退出,将会有新的工作线程被创建,以补足指定数目nThreads。

    3、newSingleThreadExecutor(),它的特点在于工作线程数目限制为1,操作一个无界的工作队列,所以它保证了所有的任务都是被顺序执行,最多会有一个任务处于活动状态,并且不予许使用者改动线程池实例,因此可以避免改变线程数目。

    4、newSingleThreadScheduledExecutor()和newScheduledThreadPool(int corePoolSize),创建的是个ScheduledExecutorService,可以进行定时或周期性的工作调度,区别在于单一工作线程还是多个工作线程。

    5、newWorkStealingPool(int parallelism),这是一个经常被人忽略的线程池,Java 8 才加入这个创建方法,其内部会构建ForkJoinPool,利用Work-Stealing算法,并行地处理任务,不保证处理顺序。

    Executor框架的基本组成

    各个类型的设计目的

    1、Executor是一个基础的接口,其初衷是将任务提交和任务执行细节解耦,这一点可以天汇其定义的唯一方法。

      void execute(Runnable command);

    2、ExecutorService则更加完善,不仅提供service管理,比如shutdown等方法,也提供了更加全面的提交任务机制,如返回Future而不是 void 的 submit 方法

      <T> Future<T> submit(Callable<T> task);

    注意,这个例子输入的可是Callable,它解决了Runnable无法返回结果的困扰。

    3、Java标准类库提供了几种基础实现,比如 ThreadPoolExecutor、ScheduledThreadPoolExecutor、ForkJoinPool。这些线程池设的设计特点在于其高度的可调节性和灵活性,以尽量满足复杂多变的实际应用场景,我会进一步分析其构建部分的源码,剖析这种灵活性的源头。

    4、Executors则从简化使用的角度,为我们提供了各种方便的静态工长方法。

    阿里发布的 Java开发手册中强制线程池不允许使用 Executors 去创建,而是通过 ThreadPoolExecutor 的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险

    下面从源码角度,分析线程池的设计与实现,将主要围绕最基础的ThreadPoolExecutor源码。ScheduledThreadPoolExecutor是ThreadPoolExecutor的扩展,主要是增加了调度逻辑。而ForkJoinPool则是为了ForkJoinTask定制的线程池,与通常意义的线程池有所不同。

    在现实应用中,理解应用于线程池的交互和线程池内部的工作过程,可以参考下图。

     

     简单理解一下:

    1、工作队列负责存储用户提交的各个任务,这个工作队列,可以是容量为0的 SynchronousQueue(使用newCachedThreadPool),也可以是像固定大小线程池(newFixedThreadPool)那样使用LinkedBlockingQueue。

      private final BlockingQueue<Runnable> workQueue;

    2、内部的“线程池”,这是指保持工作线程的集合,线程池需要在运行过程中管理线程创建、销毁。例如,对于带缓存的线程池,当任务压力较大时,线程池会创建新的工作线程;当业务压力退去,线程池会闲置一段时间(默认60秒)后结束线程。

      private final HashSet<Worker> workers = new HashSet<Worker>();

      线程池的工作线程被抽象为静态内部类Worker,基于AQS实现

    3、ThreadFactory提供上面所需要的创建线程逻辑。

    4、如果任务提交时被拒绝,比如线程池已处于SHUTDOWN状态,需要为其提供处理逻辑,Java 标准库提供了类似 ThreadPoolExecutor.AbortPolicy 等默认实现,也可以按照实际需要自定义。

    从上面的分析,就可以看出线程池的几个基本组成部分,一起都体现在线程池的构造函数中,从字面我们就可以猜测到其用意:

    1、corePoolSize, 稍微的核心线程数,可以大致理解为长期驻留的线程数目(除非设置了allowCoreThreadTimeOut)。对于不同的线程池,这个值可能会有很大区别,比如newFixedThreadPool 会将其设置为 nThreads ,而对于newCachedThreadPool则设为0。

    2、maximumPoolSize,顾名思义,就是线程不够时能够创建的最大线程数。同样进行对比,对于newFixedThreadPool,当然就是nThreads,以为其要求是固定大小,而newCachedThreadPool则是Integer.VALUE。

    3、keepAliveTime和TimeUnit,这两个参数指定了额外的线程能够闲置多久,显然有些线程池不需要它。

    4、workQueue,工作队列,必须是BlockingQueue。

    通过配置不同的参数,我们就可以创建出行为大相径庭的线程池,这就是线程池高度灵活性的基础。

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }
    展开全文
  • JS几种数组遍历方式和性能分析对比

    千次阅读 2017-04-05 17:28:52
    JS数组遍历,基本就是for,forin,foreach,forof,map等等一些方法,以下介绍几种本文分析用到的数组遍历方式以及进行性能分析对比 第一种:普通for循环 代码如下: for(j = 0; j ; j++) { } 简要说明:...


    JS数组遍历的几种方式

    JS数组遍历,基本就是for,forin,foreach,forof,map等等一些方法,以下介绍几种本文分析用到的数组遍历方式以及进行性能分析对比

    第一种:普通for循环

    代码如下:

    for(j = 0; j < arr.length; j++) {
       
    } 
    

    简要说明: 最简单的一种,也是使用频率最高的一种,虽然性能不弱,但仍有优化空间

    第二种:优化版for循环

    代码如下:

    for(j = 0,len=arr.length; j < len; j++) {
       
    }
    

    简要说明: 使用临时变量,将长度缓存起来,避免重复获取数组长度,当数组较大时优化效果才会比较明显。

    这种方法基本上是所有循环遍历方法中性能最高的一种

    第三种:弱化版for循环

    代码如下:

    for(j = 0; arr[j]!=null; j++) {
       
    }
    

    简要说明: 这种方法其实严格上也属于for循环,只不过是没有使用length判断,而使用变量本身判断

    实际上,这种方法的性能要远远小于普通for循环

    第四种:foreach循环

    代码如下:

    arr.forEach(function(e){  
       
    });
    

    简要说明: 数组自带的foreach循环,使用频率较高,实际上性能比普通for循环弱

    第五种:foreach变种

    代码如下:

    Array.prototype.forEach.call(arr,function(el){  
       
    });
    

    简要说明: 由于foreach是Array型自带的,对于一些非这种类型的,无法直接使用(如NodeList),所以才有了这个变种,使用这个变种可以让类似的数组拥有foreach功能。

    实际性能要比普通foreach弱

    第六种:forin循环

    代码如下:

    for(j in arr) {
       
    }
    

    简要说明: 这个循环很多人爱用,但实际上,经分析测试,在众多的循环遍历方式中

    它的效率是最低的

    第七种:map遍历

    代码如下:

    arr.map(function(n){  
       
    });
    

    简要说明: 这种方式也是用的比较广泛的,虽然用起来比较优雅,但实际效率还比不上foreach

    第八种:forof遍历(需要ES6支持)

    代码如下:

    for(let value of arr) {  
       
    });
    

    简要说明: 这种方式是es6里面用到的,性能要好于forin,但仍然比不上普通for循环

    各种遍历方式的性能对比

    上述列举了几种方式都有一一做过对比分析,基本上可以得出的结论是:

    普通for循环才是最优雅的

    (PS:以上所有的代码都只是进行空的循环,没有再循环内部执行代码,仅仅是分析各自循环的时间而已)

    性能对比截图

    分析结果1

    以下截图中的数据是,在chrome (支持es6)中运行了100次后得出的结论(每次运行10次,一共10个循环,得到的分析结果) 

    可以看出,forin循环最慢。优化后的普通for循环最快

    分析结果2

    以下截图数据是,在chrome (支持es6)中运行了1000次后得出的结论(每次运行100次,一共10个循环,得到的分析结果) 

    展开全文
  • PHP变量加1的几种方式对比

    千次阅读 2017-01-24 15:39:11
    PHP 变量加1的几种方式天下武功唯快不破,同一个功能往往都多种实现方式,那么对于强迫症患者,追求完美的程序原来说,那种方式才是最快的呢, 他们的区别又是什么呢?下面会探究下几个典型的例子。$i = $i + 1 ...

    PHP 变量加1的几种方式

    转载请注明出处
    http://blog.csdn.net/fanhengguang_php/article/details/54708270

    天下武功唯快不破,同一个功能往往都有多种实现方式,那么对于强迫症患者,追求完美的程序原来说,那种方式才是最快的呢, 他们的区别又是什么呢?下面会探究下几个典型的例子。

    $i = $i + 1

      <?php
        $i = 0;
        $i = $i + 1;
        echo $i;

    利用vld 扩展打印opcode如下

    这里写图片描述

    所以$i = $i + 1 执行过程是,

    1. 将$i , 1 执行ADD指令 将结果保存到临时变量中,
    2. 将临时变量的值赋给$i;

    $i++

      <?php
        $i = 0;
        $i++
        echo $i;

    利用vld 扩展打印opcode如下

    这里写图片描述

    所以$i++执行过程是,

    1. 先将$i 的值保存到临时变量中,然后对$i 执行POST_INC指令。
    2. free掉临时变量

    此处之所以需要用到临时变量,是因为在表达式中,是先取i+1,i 的原始值

    eg:

    <?php
    echo $i++;

    这里写图片描述

    上图解释了为什么需要一个临时变量,

    1. 先将$i 的值,保存到临时变量中~2中,
    2. 对$i 执行+1 操作,
    3. 对临时变量~2执行ECHO 操作

    $i += 1

      <?php
        $i = 0;
        $i += 1;
        echo $i;

    利用vld 扩展打印opcode如下

    这里写图片描述
    所以$i += 1执行过程如下,仅需一条指令

    1. 对变量$i 与const 值1 执行ASSIGN_ADD 操作

    ++$i

      <?php
        $i = 0;
        ++$i;
        echo $i;

    利用vld 扩展打印opcode如下

    这里写图片描述
    所以++$i执行过程如下,仅需一条指令

    1. 对变量$i 执行PRE_INC操作

    对比

    操作 指令个数 是否生成临时变量
    $i = $i + 1 2
    $i++ 2
    $i += 1; 1
    ++$i 1

    对于以上4中操作各执行1千万次,实验结果:

    $i++最慢, ++$i最快, 剩余两项速度基本一致速度介于两个自增之间, 是不是和大家之前想的不太一样呢 有兴趣的同学可以看下Zend/zend_vm_* 几个源文件,看下每个指令的实现方式。

    展开全文
  • OpenCV进行图像相似度对比几种办法

    万次阅读 多人点赞 2015-02-16 18:40:03
    来自:shiter编写程序的艺术 ...对计算图像相似度的方法,本文做了如下总结,主要办法:1.PSNR峰值信噪比PSNR(Peak Signal to Noise Ratio),一全参考的图像质量评价指标。简介:https://en.wikipedia.

    转载请注明出处:http://blog.csdn.net/wangyaninglm/article/details/43853435,
    来自:shiter编写程序的艺术

    在这里插入图片描述
    对计算图像相似度的方法,本文做了如下总结,主要有三种办法:


    1.PSNR峰值信噪比

    PSNR(Peak Signal to Noise Ratio),一种全参考的图像质量评价指标。

    原理简介

    https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio

    PSNR是最普遍和使用最为广泛的一种图像客观评价指标,然而它是基于对应像素点间的误差,即基于误差敏感的图像质量评价。由于并未考虑到人眼的视觉特性(人眼对空间频率较低的对比差异敏感度较高,人眼对亮度对比差异的敏感度较色度高,人眼对一个区域的感知结果会受到其周围邻近区域的影响等),因而经常出现评价结果与人的主观感觉不一致的情况。

    SSIM(structural similarity)结构相似性,也是一种全参考的图像质量评价指标,它分别从亮度、对比度、结构三方面度量图像相似性。

    在这里插入图片描述

    SSIM取值范围[0,1],值越大,表示图像失真越小.

    在实际应用中,可以利用滑动窗将图像分块,令分块总数为N,考虑到窗口形状对分块的影响,采用高斯加权计算每一窗口的均值、方差以及协方差,然后计算对应块的结构相似度SSIM,最后将平均值作为两图像的结构相似性度量,即平均结构相似性MSSIM:


    参考资料

    [1] 峰值信噪比-维基百科

    [2] 王宇庆,刘维亚,王勇. 一种基于局部方差和结构相似度的图像质量评价方法[J]. 光电子激光,2008。
    [3]http://www.cnblogs.com/vincent2012/archive/2012/10/13/2723152.html

    官方文档的说明,不过是GPU版本的,我们可以修改不用gpu不然还得重新编译

    http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/highgui/video-input-psnr-ssim/video-input-psnr-ssim.html#videoinputpsnrmssim
    http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/gpu/gpu-basics-similarity/gpu-basics-similarity.html?highlight=psnr


    代码

    // PSNR.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    
    #include <iostream>                   // Console I/O
    #include <sstream>                    // String to number conversion
    
    #include <opencv2/core/core.hpp>      // Basic OpenCV structures
    #include <opencv2/imgproc/imgproc.hpp>// Image processing methods for the CPU
    #include <opencv2/highgui/highgui.hpp>// Read images
    #include <opencv2/gpu/gpu.hpp>        // GPU structures and methods
    
    using namespace std;
    using namespace cv;
    
    double getPSNR(const Mat& I1, const Mat& I2);      // CPU versions
    Scalar getMSSIM( const Mat& I1, const Mat& I2);
    
    double getPSNR_GPU(const Mat& I1, const Mat& I2);  // Basic GPU versions
    Scalar getMSSIM_GPU( const Mat& I1, const Mat& I2);
    
    struct BufferPSNR                                     // Optimized GPU versions
    {   // Data allocations are very expensive on GPU. Use a buffer to solve: allocate once reuse later.
    	gpu::GpuMat gI1, gI2, gs, t1,t2;
    
    	gpu::GpuMat buf;
    };
    double getPSNR_GPU_optimized(const Mat& I1, const Mat& I2, BufferPSNR& b);
    
    struct BufferMSSIM                                     // Optimized GPU versions
    {   // Data allocations are very expensive on GPU. Use a buffer to solve: allocate once reuse later.
    	gpu::GpuMat gI1, gI2, gs, t1,t2;
    
    	gpu::GpuMat I1_2, I2_2, I1_I2;
    	vector<gpu::GpuMat> vI1, vI2;
    
    	gpu::GpuMat mu1, mu2; 
    	gpu::GpuMat mu1_2, mu2_2, mu1_mu2; 
    
    	gpu::GpuMat sigma1_2, sigma2_2, sigma12; 
    	gpu::GpuMat t3; 
    
    	gpu::GpuMat ssim_map;
    
    	gpu::GpuMat buf;
    };
    Scalar getMSSIM_GPU_optimized( const Mat& i1, const Mat& i2, BufferMSSIM& b);
    
    void help()
    {
    	cout
    		<< "\n--------------------------------------------------------------------------" << endl
    		<< "This program shows how to port your CPU code to GPU or write that from scratch." << endl
    		<< "You can see the performance improvement for the similarity check methods (PSNR and SSIM)."  << endl
    		<< "Usage:"                                                               << endl
    		<< "./gpu-basics-similarity referenceImage comparedImage numberOfTimesToRunTest(like 10)." << endl
    		<< "--------------------------------------------------------------------------"   << endl
    		<< endl;
    }
    
    int main(int argc, char *argv[])
    {
    	help(); 
    	Mat I1 = imread("swan1.jpg",1);           // Read the two images
    	Mat I2 = imread("swan2.jpg",1);
    
    	if (!I1.data || !I2.data)           // Check for success
    	{
    		cout << "Couldn't read the image";
    		return 0;
    	}
    
    	BufferPSNR bufferPSNR;
    	BufferMSSIM bufferMSSIM;
    
    	int TIMES; 
    	stringstream sstr("500"); 
    	sstr >> TIMES;
    	double time, result;
    
    	//------------------------------- PSNR CPU ----------------------------------------------------
    	time = (double)getTickCount();    
    
    	for (int i = 0; i < TIMES; ++i)
    		result = getPSNR(I1,I2);
    
    	time = 1000*((double)getTickCount() - time)/getTickFrequency();
    	time /= TIMES;
    
    	cout << "Time of PSNR CPU (averaged for " << TIMES << " runs): " << time << " milliseconds."
    		<< " With result of: " <<  result << endl; 
    
    	------------------------------- PSNR GPU ----------------------------------------------------
    	//time = (double)getTickCount();    
    
    	//for (int i = 0; i < TIMES; ++i)
    	//	result = getPSNR_GPU(I1,I2);
    
    	//time = 1000*((double)getTickCount() - time)/getTickFrequency();
    	//time /= TIMES;
    
    	//cout << "Time of PSNR GPU (averaged for " << TIMES << " runs): " << time << " milliseconds."
    	//	<< " With result of: " <<  result << endl; 
    /*
    	//------------------------------- PSNR GPU Optimized--------------------------------------------
    	time = (double)getTickCount();                                  // Initial call
    	result = getPSNR_GPU_optimized(I1, I2, bufferPSNR);
    	time = 1000*((double)getTickCount() - time)/getTickFrequency();
    	cout << "Initial call GPU optimized:              " << time  <<" milliseconds."
    		<< " With result of: " << result << endl;
    
    	time = (double)getTickCount();    
    	for (int i = 0; i < TIMES; ++i)
    		result = getPSNR_GPU_optimized(I1, I2, bufferPSNR);
    
    	time = 1000*((double)getTickCount() - time)/getTickFrequency();
    	time /= TIMES;
    
    	cout << "Time of PSNR GPU OPTIMIZED ( / " << TIMES << " runs): " << time 
    		<< " milliseconds." << " With result of: " <<  result << endl << endl; 
    
    
    	//------------------------------- SSIM CPU -----------------------------------------------------
    	Scalar x;
    	time = (double)getTickCount();    
    
    	for (int i = 0; i < TIMES; ++i)
    		x = getMSSIM(I1,I2);
    
    	time = 1000*((double)getTickCount() - time)/getTickFrequency();
    	time /= TIMES;
    
    	cout << "Time of MSSIM CPU (averaged for " << TIMES << " runs): " << time << " milliseconds."
    		<< " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl; 
    
    	//------------------------------- SSIM GPU -----------------------------------------------------
    	time = (double)getTickCount();    
    
    	for (int i = 0; i < TIMES; ++i)
    		x = getMSSIM_GPU(I1,I2);
    
    	time = 1000*((double)getTickCount() - time)/getTickFrequency();
    	time /= TIMES;
    
    	cout << "Time of MSSIM GPU (averaged for " << TIMES << " runs): " << time << " milliseconds."
    		<< " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl; 
    
    	//------------------------------- SSIM GPU Optimized--------------------------------------------
    	time = (double)getTickCount();    
    	x = getMSSIM_GPU_optimized(I1,I2, bufferMSSIM);
    	time = 1000*((double)getTickCount() - time)/getTickFrequency();
    	cout << "Time of MSSIM GPU Initial Call            " << time << " milliseconds."
    		<< " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl; 
    
    	time = (double)getTickCount();    
    
    	for (int i = 0; i < TIMES; ++i)
    		x = getMSSIM_GPU_optimized(I1,I2, bufferMSSIM);
    
    	time = 1000*((double)getTickCount() - time)/getTickFrequency();
    	time /= TIMES;
    
    	cout << "Time of MSSIM GPU OPTIMIZED ( / " << TIMES << " runs): " << time << " milliseconds."
    		<< " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl << endl; 
    	return 0;
    	*/
    	getchar();
    }
    
    
    double getPSNR(const Mat& I1, const Mat& I2)
    {
    	Mat s1; 
    	absdiff(I1, I2, s1);       // |I1 - I2|
    	s1.convertTo(s1, CV_32F);  // cannot make a square on 8 bits
    	s1 = s1.mul(s1);           // |I1 - I2|^2
    
    	Scalar s = sum(s1);         // sum elements per channel
    
    	double sse = s.val[0] + s.val[1] + s.val[2]; // sum channels
    
    	if( sse <= 1e-10) // for small values return zero
    		return 0;
    	else
    	{
    		double  mse =sse /(double)(I1.channels() * I1.total());
    		double psnr = 10.0*log10((255*255)/mse);
    		return psnr;
    	}
    }
    
    
    
    double getPSNR_GPU_optimized(const Mat& I1, const Mat& I2, BufferPSNR& b)
    {    
    	b.gI1.upload(I1);
    	b.gI2.upload(I2);
    
    	b.gI1.convertTo(b.t1, CV_32F);
    	b.gI2.convertTo(b.t2, CV_32F);
    
    	gpu::absdiff(b.t1.reshape(1), b.t2.reshape(1), b.gs);
    	gpu::multiply(b.gs, b.gs, b.gs);
    
    	double sse = gpu::sum(b.gs, b.buf)[0];
    
    	if( sse <= 1e-10) // for small values return zero
    		return 0;
    	else
    	{
    		double mse = sse /(double)(I1.channels() * I1.total());
    		double psnr = 10.0*log10((255*255)/mse);
    		return psnr;
    	}
    }
    
    double getPSNR_GPU(const Mat& I1, const Mat& I2)
    {
    	gpu::GpuMat gI1, gI2, gs, t1,t2; 
    
    	gI1.upload(I1);
    	gI2.upload(I2);
    
    	gI1.convertTo(t1, CV_32F);
    	gI2.convertTo(t2, CV_32F);
    
    	gpu::absdiff(t1.reshape(1), t2.reshape(1), gs); 
    	gpu::multiply(gs, gs, gs);
    
    	Scalar s = gpu::sum(gs);
    	double sse = s.val[0] + s.val[1] + s.val[2];
    
    	if( sse <= 1e-10) // for small values return zero
    		return 0;
    	else
    	{
    		double  mse =sse /(double)(gI1.channels() * I1.total());
    		double psnr = 10.0*log10((255*255)/mse);
    		return psnr;
    	}
    }
    
    Scalar getMSSIM( const Mat& i1, const Mat& i2)
    { 
    	const double C1 = 6.5025, C2 = 58.5225;
    	/***************************** INITS **********************************/
    	int d     = CV_32F;
    
    	Mat I1, I2; 
    	i1.convertTo(I1, d);           // cannot calculate on one byte large values
    	i2.convertTo(I2, d); 
    
    	Mat I2_2   = I2.mul(I2);        // I2^2
    	Mat I1_2   = I1.mul(I1);        // I1^2
    	Mat I1_I2  = I1.mul(I2);        // I1 * I2
    
    	/*************************** END INITS **********************************/
    
    	Mat mu1, mu2;   // PRELIMINARY COMPUTING
    	GaussianBlur(I1, mu1, Size(11, 11), 1.5);
    	GaussianBlur(I2, mu2, Size(11, 11), 1.5);
    
    	Mat mu1_2   =   mu1.mul(mu1);    
    	Mat mu2_2   =   mu2.mul(mu2); 
    	Mat mu1_mu2 =   mu1.mul(mu2);
    
    	Mat sigma1_2, sigma2_2, sigma12; 
    
    	GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);
    	sigma1_2 -= mu1_2;
    
    	GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);
    	sigma2_2 -= mu2_2;
    
    	GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);
    	sigma12 -= mu1_mu2;
    
    	/ FORMULA 
    	Mat t1, t2, t3; 
    
    	t1 = 2 * mu1_mu2 + C1; 
    	t2 = 2 * sigma12 + C2; 
    	t3 = t1.mul(t2);              // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
    
    	t1 = mu1_2 + mu2_2 + C1; 
    	t2 = sigma1_2 + sigma2_2 + C2;     
    	t1 = t1.mul(t2);               // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
    
    	Mat ssim_map;
    	divide(t3, t1, ssim_map);      // ssim_map =  t3./t1;
    
    	Scalar mssim = mean( ssim_map ); // mssim = average of ssim map
    	return mssim; 
    }
    
    Scalar getMSSIM_GPU( const Mat& i1, const Mat& i2)
    { 
    	const float C1 = 6.5025f, C2 = 58.5225f;
    	/***************************** INITS **********************************/
    	gpu::GpuMat gI1, gI2, gs1, t1,t2; 
    
    	gI1.upload(i1);
    	gI2.upload(i2);
    
    	gI1.convertTo(t1, CV_MAKE_TYPE(CV_32F, gI1.channels()));
    	gI2.convertTo(t2, CV_MAKE_TYPE(CV_32F, gI2.channels()));
    
    	vector<gpu::GpuMat> vI1, vI2; 
    	gpu::split(t1, vI1);
    	gpu::split(t2, vI2);
    	Scalar mssim;
    
    	for( int i = 0; i < gI1.channels(); ++i )
    	{
    		gpu::GpuMat I2_2, I1_2, I1_I2; 
    
    		gpu::multiply(vI2[i], vI2[i], I2_2);        // I2^2
    		gpu::multiply(vI1[i], vI1[i], I1_2);        // I1^2
    		gpu::multiply(vI1[i], vI2[i], I1_I2);       // I1 * I2
    
    		/*************************** END INITS **********************************/
    		gpu::GpuMat mu1, mu2;   // PRELIMINARY COMPUTING
    		gpu::GaussianBlur(vI1[i], mu1, Size(11, 11), 1.5);
    		gpu::GaussianBlur(vI2[i], mu2, Size(11, 11), 1.5);
    
    		gpu::GpuMat mu1_2, mu2_2, mu1_mu2; 
    		gpu::multiply(mu1, mu1, mu1_2);   
    		gpu::multiply(mu2, mu2, mu2_2);   
    		gpu::multiply(mu1, mu2, mu1_mu2);   
    
    		gpu::GpuMat sigma1_2, sigma2_2, sigma12; 
    
    		gpu::GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);
    		//sigma1_2 = sigma1_2 - mu1_2;
    		gpu::subtract(sigma1_2,mu1_2,sigma1_2);
    
    		gpu::GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);
    		//sigma2_2 = sigma2_2 - mu2_2;
    
    		gpu::GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);
    		(Mat)sigma12 =(Mat)sigma12 - (Mat)mu1_mu2;
    		//sigma12 = sigma12 - mu1_mu2
    
    		/ FORMULA 
    		gpu::GpuMat t1, t2, t3; 
    
    // 		t1 = 2 * mu1_mu2 + C1; 
    // 		t2 = 2 * sigma12 + C2; 
    // 		gpu::multiply(t1, t2, t3);     // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
    // 
    // 		t1 = mu1_2 + mu2_2 + C1; 
    // 		t2 = sigma1_2 + sigma2_2 + C2;     
    // 		gpu::multiply(t1, t2, t1);     // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
    
    		gpu::GpuMat ssim_map;
    		gpu::divide(t3, t1, ssim_map);      // ssim_map =  t3./t1;
    
    		Scalar s = gpu::sum(ssim_map);    
    		mssim.val[i] = s.val[0] / (ssim_map.rows * ssim_map.cols);
    
    	}
    	return mssim; 
    }
    
    Scalar getMSSIM_GPU_optimized( const Mat& i1, const Mat& i2, BufferMSSIM& b)
    { 
    	int cn = i1.channels();
    
    	const float C1 = 6.5025f, C2 = 58.5225f;
    	/***************************** INITS **********************************/
    
    	b.gI1.upload(i1);
    	b.gI2.upload(i2);
    
    	gpu::Stream stream;
    
    	stream.enqueueConvert(b.gI1, b.t1, CV_32F);
    	stream.enqueueConvert(b.gI2, b.t2, CV_32F);      
    
    	gpu::split(b.t1, b.vI1, stream);
    	gpu::split(b.t2, b.vI2, stream);
    	Scalar mssim;
    
    	for( int i = 0; i < b.gI1.channels(); ++i )
    	{        
    		gpu::multiply(b.vI2[i], b.vI2[i], b.I2_2, stream);        // I2^2
    		gpu::multiply(b.vI1[i], b.vI1[i], b.I1_2, stream);        // I1^2
    		gpu::multiply(b.vI1[i], b.vI2[i], b.I1_I2, stream);       // I1 * I2
    
    		//gpu::GaussianBlur(b.vI1[i], b.mu1, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);
    		//gpu::GaussianBlur(b.vI2[i], b.mu2, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);
    
    		gpu::multiply(b.mu1, b.mu1, b.mu1_2, stream);   
    		gpu::multiply(b.mu2, b.mu2, b.mu2_2, stream);   
    		gpu::multiply(b.mu1, b.mu2, b.mu1_mu2, stream);   
    
    		//gpu::GaussianBlur(b.I1_2, b.sigma1_2, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);
    		//gpu::subtract(b.sigma1_2, b.mu1_2, b.sigma1_2, stream);
    		//b.sigma1_2 -= b.mu1_2;  - This would result in an extra data transfer operation
    
    		//gpu::GaussianBlur(b.I2_2, b.sigma2_2, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);
    		//gpu::subtract(b.sigma2_2, b.mu2_2, b.sigma2_2, stream);
    		//b.sigma2_2 -= b.mu2_2;
    
    		//gpu::GaussianBlur(b.I1_I2, b.sigma12, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);
    		//gpu::subtract(b.sigma12, b.mu1_mu2, b.sigma12, stream);
    		//b.sigma12 -= b.mu1_mu2;
    
    		//here too it would be an extra data transfer due to call of operator*(Scalar, Mat)
    		gpu::multiply(b.mu1_mu2, 2, b.t1, stream); //b.t1 = 2 * b.mu1_mu2 + C1; 
    		//gpu::add(b.t1, C1, b.t1, stream);
    		gpu::multiply(b.sigma12, 2, b.t2, stream); //b.t2 = 2 * b.sigma12 + C2; 
    		//gpu::add(b.t2, C2, b.t2, stream);     
    
    		gpu::multiply(b.t1, b.t2, b.t3, stream);     // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
    
    		//gpu::add(b.mu1_2, b.mu2_2, b.t1, stream);
    		//gpu::add(b.t1, C1, b.t1, stream);
    
    		//gpu::add(b.sigma1_2, b.sigma2_2, b.t2, stream);
    		//gpu::add(b.t2, C2, b.t2, stream);
    
    
    		gpu::multiply(b.t1, b.t2, b.t1, stream);     // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))        
    		gpu::divide(b.t3, b.t1, b.ssim_map, stream);      // ssim_map =  t3./t1;
    
    		stream.waitForCompletion();
    
    		Scalar s = gpu::sum(b.ssim_map, b.buf);    
    		mssim.val[i] = s.val[0] / (b.ssim_map.rows * b.ssim_map.cols);
    
    	}
    	return mssim; 
    }
    

    效果

    两幅一样的图片,对比结果:

    在这里插入图片描述

    在这里插入图片描述


    2.感知哈希算法

    (perceptual hash algorithm)

    http://blog.csdn.net/fengbingchun/article/details/42153261

    感知哈希算法(perceptual hash algorithm),它的作用是对每张图像生成一个“指纹”(fingerprint)字符串,然后比较不同图像的指纹。结果越接近,就说明图像越相似。

    实现步骤

    1. 缩小尺寸:将图像缩小到8*8的尺寸,总共64个像素。

    2. 这一步的作用是去除图像的细节,只保留结构/明暗等基本信息,摒弃不同尺寸/比例带来的图像差异;这一步的作用是去除图像的细节,只保留结构/明暗等基本信息,摒弃不同尺寸/比例带来的图像差异;

    3. 简化色彩:将缩小后的图像,转为64级灰度,即所有像素点总共只有64种颜色;

    4. 计算平均值:计算所有64个像素的灰度平均值;

    5. 比较像素的灰度:将每个像素的灰度,与平均值进行比较,大于或等于平均值记为1,小于平均值记为0;

    6. 计算哈希值:将上一步的比较结果,组合在一起,就构成了一个64位的整数,这就是这张图像的指纹。组合的次序并不重要,只要保证所有图像都采用同样次序就行了;

    7. 得到指纹以后,就可以对比不同的图像,看看64位中有多少位是不一样的。在理论上,这等同于”汉明距离”(Hamming distance,在信息论中,两个等长字符串之间的汉明距离是两个字符串对应位置的不同字符的个数)。

    如果不相同的数据位数不超过5,就说明两张图像很相似;
    如果大于10,就说明这是两张不同的图像。

    以上内容摘自:http://www.ruanyifeng.com/blog/2011/07/principle_of_similar_image_search.html

    代码

    // similarity.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <iostream>
    #include <opencv2/core/core.hpp>
    #include <opencv2/highgui/highgui.hpp>
    #include <opencv2/imgproc/imgproc.hpp>
    
    #pragma comment(lib,"opencv_core2410d.lib")          
    #pragma comment(lib,"opencv_highgui2410d.lib")          
    #pragma comment(lib,"opencv_imgproc2410d.lib")    
    
    
    using namespace std;
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    
    	string strSrcImageName = "swan.jpg";
    
    	cv::Mat matSrc, matSrc1, matSrc2;
    
    	matSrc = cv::imread(strSrcImageName, CV_LOAD_IMAGE_COLOR);
    	CV_Assert(matSrc.channels() == 3);
    
    	cv::resize(matSrc, matSrc1, cv::Size(357, 419), 0, 0, cv::INTER_NEAREST);
    	//cv::flip(matSrc1, matSrc1, 1);
    	cv::resize(matSrc, matSrc2, cv::Size(2177, 3233), 0, 0, cv::INTER_LANCZOS4);
    
    	cv::Mat matDst1, matDst2;
    
    	cv::resize(matSrc1, matDst1, cv::Size(8, 8), 0, 0, cv::INTER_CUBIC);
    	cv::resize(matSrc2, matDst2, cv::Size(8, 8), 0, 0, cv::INTER_CUBIC);
    	//update 20181206 for the bug cvtColor
    	cv::Mat temp1 = matDst1;
    	cv::Mat temp2 = matDst2;
    	cv::cvtColor(temp1 , matDst1, CV_BGR2GRAY);
    	cv::cvtColor(temp2 , matDst2, CV_BGR2GRAY);
    
    	int iAvg1 = 0, iAvg2 = 0;
    	int arr1[64], arr2[64];
    
    	for (int i = 0; i < 8; i++)
    	{
    		uchar* data1 = matDst1.ptr<uchar>(i);
    		uchar* data2 = matDst2.ptr<uchar>(i);
    
    		int tmp = i * 8;
    
    		for (int j = 0; j < 8; j++) 
    		{
    			int tmp1 = tmp + j;
    
    			arr1[tmp1] = data1[j] / 4 * 4;
    			arr2[tmp1] = data2[j] / 4 * 4;
    
    			iAvg1 += arr1[tmp1];
    			iAvg2 += arr2[tmp1];
    		}
    	}
    
    	iAvg1 /= 64;
    	iAvg2 /= 64;
    
    	for (int i = 0; i < 64; i++) 
    	{
    		arr1[i] = (arr1[i] >= iAvg1) ? 1 : 0;
    		arr2[i] = (arr2[i] >= iAvg2) ? 1 : 0;
    	}
    
    	int iDiffNum = 0;
    
    	for (int i = 0; i < 64; i++)
    		if (arr1[i] != arr2[i])
    			++iDiffNum;
    
    	cout<<"iDiffNum = "<<iDiffNum<<endl;
    
    	if (iDiffNum <= 5)
    		cout<<"two images are very similar!"<<endl;
    	else if (iDiffNum > 10)
    		cout<<"they are two different images!"<<endl;
    	else
    		cout<<"two image are somewhat similar!"<<endl;
    
    	getchar();
    	return 0;
    }
    
    
    

    效果

    一幅图片自己对比:

    在这里插入图片描述

    结果:

    在这里插入图片描述


    3.计算特征点

    OpenCV的feature2d module中提供了从局部图像特征(Local image feature)的检测、特征向量(feature vector)的提取,到特征匹配的实现。其中的局部图像特征包括了常用的几种局部图像特征检测与描述算子,如FAST、SURF、SIFT、以及ORB。对于高维特征向量之间的匹配,OpenCV主要有两种方式:

    1)BruteForce穷举法;
    2)FLANN近似K近邻算法(包含了多种高维特征向量匹配的算法,例如随机森林等)。

    feature2d module: http://docs.opencv.org/modules/features2d/doc/features2d.html

    OpenCV FLANN: http://docs.opencv.org/modules/flann/doc/flann.html

    FLANN: http://www.cs.ubc.ca/~mariusm/index.php/FLANN/FLANN

    原文:

    http://blog.csdn.net/icvpr/article/details/8491369

    代码

    //localfeature.h
    #ifndef _FEATURE_H_ 
    #define _FEATURE_H_
    
    #include <iostream>
    #include <vector>
    #include <string>
    
    #include <opencv2/opencv.hpp>
    #include <opencv2/core/core.hpp>
    #include <opencv2/highgui/highgui.hpp>
    #include <opencv2/imgproc/imgproc.hpp>
    #include <opencv2/nonfree/nonfree.hpp>  
    #include <opencv2/nonfree/features2d.hpp>  
    using namespace cv;
    using namespace std;
    
    class Feature
    {
    public:
    	Feature();
    	~Feature();
    
    	Feature(const string& detectType, const string& extractType, const string& matchType);
    
    public:
    
    	void detectKeypoints(const Mat& image, vector<KeyPoint>& keypoints);  // 检测特征点
    	void extractDescriptors(const Mat& image, vector<KeyPoint>& keypoints, Mat& descriptor);  // 提取特征向量
    	void bestMatch(const Mat& queryDescriptor, Mat& trainDescriptor, vector<DMatch>& matches);  // 最近邻匹配
    	void knnMatch(const Mat& queryDescriptor, Mat& trainDescriptor, vector<vector<DMatch>>& matches, int k);  // K近邻匹配
    
    	void saveKeypoints(const Mat& image, const vector<KeyPoint>& keypoints, const string& saveFileName = "");  // 保存特征点
    	void saveMatches(const Mat& queryImage,
    		const vector<KeyPoint>& queryKeypoints,
    		const Mat& trainImage,
    		const vector<KeyPoint>& trainKeypoints,
    		const vector<DMatch>& matches,
    		const string& saveFileName = "");  // 保存匹配结果到图片中
    
    private:
    	Ptr<FeatureDetector> m_detector;
    	Ptr<DescriptorExtractor> m_extractor;
    	Ptr<DescriptorMatcher> m_matcher;
    
    	string m_detectType;
    	string m_extractType;
    	string m_matchType;
    
    };
    
    
    #endif
    
    //localfeature.cpp
    
    #include "stdafx.h"
    #include "localfeature.h"
    
    
    Feature::Feature()
    {
    	m_detectType = "SIFT";
    	m_extractType = "SIFT";
    	m_matchType = "BruteForce";
    }
    
    Feature::~Feature()
    {
    
    }
    
    
    Feature::Feature(const string& detectType, const string& extractType, const string& matchType)
    {
    	assert(!detectType.empty());
    	assert(!extractType.empty());
    	assert(!matchType.empty());
    
    	m_detectType = detectType;
    	m_extractType = extractType;
    	m_matchType = matchType;
    }
    
    
    void Feature::detectKeypoints(const Mat& image, std::vector<KeyPoint>& keypoints) 
    {
    	assert(image.type() == CV_8UC1);
    	assert(!m_detectType.empty());
    
    	keypoints.clear();
    
    	initModule_nonfree();
    
    	m_detector = FeatureDetector::create(m_detectType);
    	m_detector->detect(image, keypoints);
    
    }
    
    
    
    void Feature::extractDescriptors(const Mat& image, std::vector<KeyPoint>& keypoints, Mat& descriptor)
    {
    	assert(image.type() == CV_8UC1);
    	assert(!m_extractType.empty());
    
    	initModule_nonfree(); 
    	m_extractor = DescriptorExtractor::create(m_extractType);
    	m_extractor->compute(image, keypoints, descriptor);
    
    }
    
    
    void Feature::bestMatch(const Mat& queryDescriptor, Mat& trainDescriptor, std::vector<DMatch>& matches) 
    {
    	assert(!queryDescriptor.empty());
    	assert(!trainDescriptor.empty());
    	assert(!m_matchType.empty());
    
    	matches.clear();
    
    	m_matcher = DescriptorMatcher::create(m_matchType);
    	m_matcher->add(std::vector<Mat>(1, trainDescriptor));
    	m_matcher->train();
    	m_matcher->match(queryDescriptor, matches);
    
    }
    
    
    void Feature::knnMatch(const Mat& queryDescriptor, Mat& trainDescriptor, std::vector<std::vector<DMatch>>& matches, int k)
    {
    	assert(k > 0);
    	assert(!queryDescriptor.empty());
    	assert(!trainDescriptor.empty());
    	assert(!m_matchType.empty());
    
    	matches.clear();
    
    	m_matcher = DescriptorMatcher::create(m_matchType);
    	m_matcher->add(std::vector<Mat>(1, trainDescriptor));
    	m_matcher->train();
    	m_matcher->knnMatch(queryDescriptor, matches, k);
    
    }
    
    
    
    void Feature::saveKeypoints(const Mat& image, const vector<KeyPoint>& keypoints, const string& saveFileName)
    {
    	assert(!saveFileName.empty());
    
    	Mat outImage;
    	cv::drawKeypoints(image, keypoints, outImage, Scalar(255,255,0), DrawMatchesFlags::DRAW_RICH_KEYPOINTS );
    
    	//
    	string saveKeypointsImgName = saveFileName + "_" + m_detectType + ".jpg";
    	imwrite(saveKeypointsImgName, outImage);
    
    }
    
    
    
    void Feature::saveMatches(const Mat& queryImage,
    	const vector<KeyPoint>& queryKeypoints,
    	const Mat& trainImage,
    	const vector<KeyPoint>& trainKeypoints,
    	const vector<DMatch>& matches,
    	const string& saveFileName)
    {
    	assert(!saveFileName.empty());
    
    	Mat outImage;
    	cv::drawMatches(queryImage, queryKeypoints, trainImage, trainKeypoints, matches, outImage, 
    		Scalar(255, 0, 0), Scalar(0, 255, 255), vector<char>(),  DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
    
    	//
    	string saveMatchImgName = saveFileName + "_" + m_detectType + "_" + m_extractType + "_" + m_matchType + ".jpg";
    	imwrite(saveMatchImgName, outImage);
    }
    
    
    
    // main.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <iostream>
    #include <opencv2/core/core.hpp>
    #include <opencv2/highgui/highgui.hpp>
    #include <opencv2/imgproc/imgproc.hpp>
    #include <opencv2/nonfree/nonfree.hpp>  
    #include <opencv2/nonfree/features2d.hpp>  
    
    #include "localfeature.h"
    
    #pragma comment(lib,"opencv_core2410d.lib")          
    #pragma comment(lib,"opencv_highgui2410d.lib")          
    #pragma comment(lib,"opencv_imgproc2410d.lib") 
    #pragma comment(lib,"opencv_nonfree2410d.lib")    
    #pragma comment(lib,"opencv_features2d2410d.lib")    
    
    
    using namespace std;
    
    
    
    
    
    int main(int argc, char** argv)
    {
    	/*if (argc != 6)
    	{
    		cout << "wrong usage!" << endl;
    		cout << "usage: .exe FAST SIFT BruteForce queryImage trainImage" << endl;
    		return -1;
    	}*/
    
    	string detectorType = "SIFT";
    	string extractorType = "SIFT";
    	string matchType = "BruteForce";
    	string queryImagePath = "swan.jpg";
    	string trainImagePath = "swan.jpg";
    
    
    	Mat queryImage = imread(queryImagePath, CV_LOAD_IMAGE_GRAYSCALE);
    	if (queryImage.empty())
    	{
    		cout<<"read failed"<< endl;
    		return -1;
    	}
    
    	Mat trainImage = imread(trainImagePath, CV_LOAD_IMAGE_GRAYSCALE);
    	if (trainImage.empty())
    	{
    		cout<<"read failed"<< endl;
    		return -1;
    	}
    
    
    	Feature feature(detectorType, extractorType, matchType);
    
    	vector<KeyPoint> queryKeypoints, trainKeypoints; 
    	feature.detectKeypoints(queryImage, queryKeypoints);
    	feature.detectKeypoints(trainImage, trainKeypoints);
    
    
    	Mat queryDescriptor, trainDescriptor;
    
    
    	feature.extractDescriptors(queryImage, queryKeypoints, queryDescriptor);
    	feature.extractDescriptors(trainImage, trainKeypoints, trainDescriptor);
    
    
    	vector<DMatch> matches;
    	feature.bestMatch(queryDescriptor, trainDescriptor, matches);
    
    	vector<vector<DMatch>> knnmatches;
    	feature.knnMatch(queryDescriptor, trainDescriptor, knnmatches, 2);
    
    	Mat outImage;
    	feature.saveMatches(queryImage, queryKeypoints, trainImage, trainKeypoints, matches, "../");
    
    
    	return 0;
    }
    
    
    

    效果

    两幅同样图片结果:

    在这里插入图片描述

    几年前上学时候写了这个文章,没想到现在居然是博客访问最高的一篇文章,现在我又收集了一些论文文档资料,当然衡量图像相似度的方法有很多不止上述的三种方法,具体我们再看看论文和外围资料,下载链接:

    http://download.csdn.net/detail/wangyaninglm/9764301


    更新

    参照大牛@yuanwenmao,大家可能得对部分代码做出修改

    cv::cvtColor(matDst1, matDst1, CV_BGR2GRAY);
    cv::cvtColor(matDst2, matDst2, CV_BGR2GRAY);
    

    感知哈希算法,的这里有个bug,入参与出参不能是同一个变量,内部应该在计算时被自己修改了,造成判断结果都是很相似。由于博主采用了同一个图片进行比较,所以没发现问题。

    void cv::cvtColor(
    cv::InputArray src, // 输入序列
    cv::OutputArray dst, // 输出序列
    int code, // 颜色映射码
    int dstCn = 0 // 输出的通道数 (0='automatic')
    );
    

    你src、dst都传同一个array,内部计算的同时又在修改array的值,自然有问题。可以看看cvtColor的实现。dst换用另外的变量即可,后面的计算也以更换的变量来。


    转载请注明出处:http://blog.csdn.net/wangyaninglm/article/details/51533549,
    来自:
    shiter编写程序的艺术

    展开全文
  • mysql中删除数据的几种方式对比

    千次阅读 2019-05-22 11:53:29
    我们对Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下点新功能,帮助你用它写博客: 全新的界面设计 ,将会带来全新的写作体验; 在创作中心设置你喜爱的代码...
  • 基于Oracle访问数据不同方法:包含全表扫描和采样表扫描,介绍三随机取样方式,并分别从随机性和性能(读取时间)作比较。
  • 从今年的九月份到现在,接触机器学习、深度学习再到现在的深度强化学习已经三个月的时间了。从java web开发到人工智能的领域转变的过程中,学到了很多很杂的东西,感觉这才是我以后要研究的东西。然而,在这个转变...
  • Qt 定时器的几种方式 摘要: Qt中定时器的使用两种方法,一种是使用QObject类提供的定时器startTimer,还有一种就是使用QTimer类。 方法介绍: 共有方法:   QTimer(QObject *parent = Q_NULLPTR) ...
  • 几种流行Webservice框架性能对比

    万次阅读 2016-08-31 21:12:37
    几种流行Webservice框架性能对比(转载、拼接)   分类: WebService(1)  Dubbo(1)  目录(?)[+] 1摘要   开发webservice应用程序中离不开框架的支持,当open-open网站...
  • JS几种数组遍历方式总结

    万次阅读 多人点赞 2018-03-14 15:25:41
    JS数组遍历的几种方式JS数组遍历,基本就是for,forin,foreach,forof,map等等一些方法,以下介绍几种本文分析用到的数组遍历方式以及进行性能分析对比第一种:普通for循环代码如下:for(j = 0; j &lt; arr.length; ...
  • 因为天气、拍摄技术等原因,我们拍出来的照片对比度经常不够,看上去像在照片上蒙了一层细纱,整张照片看起来... 今天,我们就向大家介绍用Photoshop提高照片对比度的几种常见的方法,让你的照片告别灰蒙蒙的模样。在
  • 几种运维工具的对比

    万次阅读 多人点赞 2018-11-09 15:15:38
    运维行业句话:“无监控、不运维”,是的,一点也不夸张,监控俗称“第三只眼”。没了监控,什么基础运维,业务运维都是“瞎子”。 所以说监控是运维这个职业的根本。尤其是在现在DevOps这么火的时候,用监控...
  • 几种常见的MQ总结对比

    万次阅读 多人点赞 2020-06-27 12:12:08
    Kafka、ActiveMQ、RabbitMQ、RocketMQ 都什么区别,以及适合哪些场景? 面试官心理分析 其实面试官主要是想看看: 第一,你知不知道你们系统里为什么要用消息队列这个东西? 不少候选人,说自己项目里用了 ...
  • 最近在制作一个安卓上的...但是关于亮与暗的解释很多,在RGB模式中,要使图片变亮的方法是提高R,G,B三个通道的值,从而使图片看起来更亮。   网上最常用的调整对比度的算法是根据图像的灰度进行调整 下
  • OpenCV 学习(几种基本的低通滤波)

    万次阅读 2015-09-25 13:57:19
    OpenCV 学习(几种基本的低通滤波)对图像进行滤波处理是图像处理中最常见的一种操作类型。而这其中低通滤波(也可以叫做平滑)有事各种滤波处理中最常用的。这里就简单写写 OpenCV 中提供的几种低通滤波方法。均值...
  • 上一篇主要介绍了硬件平台的基本情况,并没有详细的分析和对比每种硬件平台的优劣,这里我选取几种常见的硬件平台,从输入、硬件架构、输出等几个方面进行详细对比,以便深入了解各种平台。 这里我主要对比:恩智...
  • 进行图像相似度对比几种办法

    万次阅读 2018-08-23 14:31:09
    方法描述:两幅图像patch(当然也可是整幅图像),分别计算两幅图像的直方图,并将直方图进行归一化,然后按照某种距离度量的标准进行相似度的测量。 方法的思想:基于简单的向量相似度来对图像相似度进行度量。 ...
  • 几种大数据框架的对比

    千次阅读 2016-01-06 22:08:14
    hadoop(批量,离线,非实时) ...HDFS高容错性的特点,并且设计用来部署在低廉的(low-cost)硬件上;而且它提供高吞吐量(high throughput)来访问应用程序的数据,适合那些有着超大数据集(large data set)的
  • SVM几种核函数的对比分析以及SVM算法的优缺点

    万次阅读 多人点赞 2019-04-25 14:54:00
    SVM核函数的作用 SVM核函数是用来解决数据线性不可分而提出的,把数据从源空间映射到目标空间(线性可分空间)。...基本原理:依靠升维使得原本线性不可分的数据线性可分; 升维的意义:使得原本线性不可分的数...
  • 摄影构图的几种基本方法

    万次阅读 2016-01-23 20:02:35
    对于摄影,构图是基本的技巧之一。同样的事物,不同的角度就不同的... 但摄影构图的几种基本方法决不是要把摄影框死。只是让初学考以最简单的方法突破固有的思维。我们知道,武侠里真正厉害的是招似无招。摄影也一
  • 对比几种无线技术在智能家居的应用 2015/12/21 9:10:00 afzhan.com 关键字:无线技术,智能家居 浏览量:357 近年来,近距离无线通信技术获得了迅猛的发展,包括红外、蓝牙(Blue-tooth)、Zigbee、Insteon、...
  • 开发webservice应用程序中离不开框架的支持,当open-open网站列举的就很多,这对于开发者如何选择带来一定的疑惑。性能Webservice的关键要素,不同的框架性能上存在较大差异,而当前在官方网站、网络资料中可以...
  • 几种开源SIP协议栈对比

    千次阅读 2006-12-05 15:49:00
    基于SIP的开发的话,基本还是使用开源的协议栈的,当然也...现在开发会议系统,清华那边要求用RESIPROCATE,郁闷,没太多文档…… 几种开源SIP协议栈对比 随着VoIP和NGN技术的发展,H.323时代即将过渡到SIP时代,在
  • JAVA中几种文件操作流的效率对比

    千次阅读 2017-01-14 18:25:28
    以下案例说明了分别采用字节流方式、字节缓冲流方式读写文件的效率对比
  • 几种机器学习框架的对比和选择

    万次阅读 2017-03-22 20:35:42
    随着近年AI的火热,越来越多的出现有关各个机器学习框架的对比文章,且随着 Python 逐渐成为机器学习社区最受欢迎的语言,支持 Python 的深度学习框架的性能也在持续的被关注。 本文是我根据诸多文献给予此,将...
  • 可以通过多种方式将Pandas对象联合到一起 pandas.merge: 根据一个或多个键进行连接。类似SQL的连接操作 pandas.concat:使对象在...Pandas.DataFrame操作表连接种方式:merge, join, concat。下面就来说一说这...
  • 几种主流bi工具的对比

    千次阅读 2012-03-17 02:32:57
    最近在替公司选型,查了些主流bi的资料,因为以前用了一年多的cognos,所以其他的工具也主要看和cognos的对比.拿些报告里的摘要放下面: 虽然IBM、Microsoft、Oracle和SAP公司不能算是纯粹的商业智能厂商,但他们的确...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 294,547
精华内容 117,818
关键字:

对比有哪几种基本方式