图像处理：图像金字塔

#include <vector>
#include <string>
#include <iostream>
#include <opencv2/opencv.hpp>

int patch_size=32;
const float scale_stride = sqrt(2);
int scale_num = 8;

void InitPry(const cv::Mat& frame, std::vector<float>& scales, std::vector<cv::Size>& sizes);
void BuildPry(const std::vector<cv::Size>& sizes, const int type, std::vector<cv::Mat>& grey_pyr);
int main(int,char*[])
{
    std::string imgDir="/home/wang/imagesAndVideos/lena.jpeg";
    cv::Mat img=cv::imread(imgDir);
    if(!img.data){
        printf("img can't load!!!!\n");
        return -1;
    }
//    cv::resize(img,img,cv::Size(320,320),cv::INTER_LINEAR);
    cv::imshow("raw img",img);
    cv::cvtColor(img,img,cv::COLOR_BGR2GRAY);
    std::vector<cv::Mat> prev_gray_pyr(0);
    std::vector<float> fscales(0);
    std::vector<cv::Size> sizes(0);
   InitPry(img,fscales,sizes);
   BuildPry(sizes,CV_8UC1,prev_gray_pyr);
    for(int iScale=0;iScale<scale_num;iScale++)
    {
        if(iScale==0)
        {
            img.copyTo(prev_gray_pyr[0]);
            std::string winName="prev_gray_pyr-"+std::to_string(iScale);
            cv::imshow(winName,prev_gray_pyr[0]);
        }
        else
        {
            cv::resize(prev_gray_pyr[iScale-1],prev_gray_pyr[iScale],prev_gray_pyr[iScale].size(),0,0,cv::INTER_LINEAR);
            std::string winName="prev_gray_pyr-"+std::to_string(iScale);
            cv::imshow(winName,prev_gray_pyr[iScale]);
        }
    }

    cv::waitKey(0);
    return 0;
}

void InitPry(const cv::Mat& frame, std::vector<float>& scales, std::vector<cv::Size>& sizes)
{
    int rows = frame.rows, cols = frame.cols;
    float min_size = std::min<int>(rows, cols);

    int nlayers = 0;
    while(min_size >= patch_size) {
        min_size /= scale_stride;
        nlayers++;
    }

    if(nlayers == 0) nlayers = 1; // at least 1 scale

    scale_num = std::min<int>(scale_num, nlayers);

    scales.resize(scale_num);
    sizes.resize(scale_num);

    scales[0] = 1.;
    sizes[0] = cv::Size(cols, rows);
    printf("sizes[0].size:(%d,%d)\n",cols,rows);

    for(int i = 1; i < scale_num; i++) {
        scales[i] = scales[i-1] * scale_stride;
        sizes[i] = cv::Size(cvRound(cols/scales[i]), cvRound(rows/scales[i]));
        printf("sizes[%d].size(%d,%d)\n",i,cvRound(cols/scales[i]),cvRound(rows/scales[i]));
    }
}

void BuildPry(const std::vector<cv::Size>& sizes, const int type, std::vector<cv::Mat>& grey_pyr)
{
    int nlayers = sizes.size();
    grey_pyr.resize(nlayers);

    for(int i = 0; i < nlayers; i++)
        grey_pyr[i].create(sizes[i], type);
}

运行结果：

对应的图像尺寸：

参考：

https://www.cnblogs.com/tianyalu/p/5467813.html SIFT简介

https://www.cnblogs.com/tianyalu/p/5467834.html   尺度空间理论