2. 程式人生 > >雙線性插值原理及其實現--基於OpenCV實現

雙線性插值原理及其實現--基於OpenCV實現

阿新 • • 發佈：2019-01-30

這是我第一個部落格，一方面我把部落格看作筆記，記錄我在學習的過程中遇到的問題，寫部落格的過程也是加深理解的過程；另一方面也是為了與大家分享，共同進步。

雙線性插值分為兩步：1. 先做影象尺寸縮放；2. 求縮放後的影象畫素灰度值。

  • 影象尺度縮放變換的公式
x'=ax
y'=bx

其中，(x, y)是原圖座標，(x’, y’)是變換後的座標，a，b分別是水平和垂直方向的縮放因子。這是前向變換，即從原圖變換到目標影象。在雙線性插值處理中，我們往往已知原圖大小和縮放因子，求得縮放後的影象灰度值。目標影象灰度值就是根據目標畫素在原圖中的位置的灰度值雙線性插值得到的。根據目標影象的畫素求得對應於原圖中的位置就是後向變換，公式如下：

x=x'/a
y=y'/b
根據公式，後向變換計算出來的座標一般不是整數。最鄰近插值就是把後向變換的座標取整，獲得原圖座標處的畫素值作為目標影象的畫素值。

上述變換公式都假定原圖和目標影象的座標原點在左上角，前向變換沒有任何問題，但是後向變換就存在問題了。如下圖所示，假設把5x5的影象縮小為3x3的，那麼原圖與目標影象之間的座標對應關係如下圖所示：這裡只畫出第一行!
這裡寫圖片描述

其中，黑色的原圖，紅色的框是目標影象。變換後的影象的3個畫素平均佔據在原圖的5個畫素的前3個位置上，但是由於目標影象的3個畫素起始點選在了原圖的左上角，導致原圖最後一個畫素座標沒有以及最後一行的畫素座標都沒有使用到。為了充分利用原圖每一個畫素座標，應該保持兩個影象的幾何中心重合，並且目標影象的每個畫素之間都是等間隔的，並且都和兩邊有一定的邊距，如下圖所示。
這裡寫圖片描述


所以，最終的後向變換公式為

x=(x'+0.5)/a−0.5
y=(y'+0.5)/b−0.5
  • 雙線性插值

在求得影象縮放後的座標只之後，就需要對目標影象的每一個畫素計算其畫素值了。
雙線性變換其實就是在水平和垂直方向分別作一次線性變換，如下圖所示
這裡寫圖片描述
假設目標影象P點座標為P(x, y)，現在利用P點在原圖的位置的最鄰近的4個點的畫素值擬合P點的畫素值。P點座標在原圖上最鄰近的4點分別為左上、右上、左下、右下。
(1). 先對x方向插值
Q12，R2，Q22； Q11，R1，Q21三點共線，所以

這裡寫圖片描述
(2). 再對y方向進行插值
R2，P，R1三點共線，有
這裡寫圖片描述
其中，與P點最鄰近的4點座標分別為
Q11 = (x’, y’), Q21 = (x’+1, y’)
Q21 = (x’, y’+1), Q22 = (x’+1, y’ + 1)
其中，(x’, y’)是P點座標在原圖的整數部分。
所以，上述公式可以進一步變化為

f(x,y)=(1−u)f(R1)+uf(R2)=(1−u)(1−v)f(Q11)+(1−u)vf(Q21)+u(1−v)f(Q12)+uvf(Q22)=(1−u)(1−v)f(x',y')+(1−u)vf(x'+1,y')+u(1−v)f(x',y'+1)+uvf(x'+1,y'+1)
其中，u，v分別是P點y,x座標取整後的小數部分。

至此，雙線性插值的原理部分講完了。其實這個原理也不完全是我自己寫的，我也是參考了很多網上的別人的播客，待會我會在下面把那些部落格貼上來。

下面附上我的雙線性插值程式碼實現：

這裡寫程式碼片

void Geometry_Transform::Interpolate(Mat src, Mat& mask)
{
int Rows = mask.rows;
int Cols = mask.cols;

uchar* mask_data = mask.data;
uchar* src_data = _src.data;
if (3 == src.channels())
{
    for (int i = 0; i < Rows; ++i)
    {
        double r = (i + 0.5 ) * 1.0 / _sy - 0.5;//浮點行
        for (int j = 0; j < Cols; ++j)
        {
            double c = (j + 0.5 ) * 1.0 / _sx - 0.5;//浮點列

            //獲得四個頂點
            int lRow = static_cast<int>(r);//最鄰近行，取整
            int nRow = lRow + 1;

            int lCol = static_cast<int>(c);//最鄰近列
            int nCol = lCol + 1;

            double u = r - lRow;
            double v = c - lCol;

            if (lRow >= _src.rows - 1 && lCol >= _src.cols - 1)//右下角
            {
                mask_data[i * mask.step[0] + j * mask.step[1]] =
                    saturate_cast<uchar>((1 - u) * (1 - v) *
                    src_data[lRow * _src.step[0] + lCol * _src.step[1]]);//B通道

                mask_data[i * mask.step[0] + j * mask.step[1] + 1] =
                    saturate_cast<uchar>((1 - u) * (1 - v) *
                    src_data[lRow * _src.step[0] + lCol * _src.step[1]] + 1);//G通道

                mask_data[i * mask.step[0] + j * mask.step[1] + 2] =
                    saturate_cast<uchar>((1 - u) * (1 - v) *
                    src_data[lRow * _src.step[0] + lCol * _src.step[1] + 2]);//R通道
            }
            else if (lRow >= _src.rows - 1)//最後一行
            {
                mask_data[i * mask.step[0] + j * mask.step[1]] =
                    saturate_cast<uchar>((1 - u) * (1 - v) *
                    src_data[lRow * _src.step[0] + lCol * _src.step[1]] +
                    (1 - u) * v * src_data[lRow * _src.step[0] + nCol * _src.step[1]]);

                mask_data[i * mask.step[0] + j * mask.step[1] + 1] =
                    saturate_cast<uchar>((1 - u) * (1 - v) *
                    src_data[lRow * _src.step[0] + lCol * _src.step[1] + 1] +
                    (1 - u) * v * src_data[lRow * _src.step[0] + nCol * _src.step[1] + 1]);

                mask_data[i * mask.step[0] + j * mask.step[1] + 2] =
                    saturate_cast<uchar>((1 - u) * (1 - v) *
                    src_data[lRow * _src.step[0] + lCol * _src.step[1] + 2] +
                    (1 - u) * v * src_data[lRow * _src.step[0] + nCol * _src.step[1] + 2]);
            }
            else if (lCol >= _src.cols /** _src.channels()*/ - 1)//最後一列
            {
                mask_data[i * mask.step[0] + j * mask.step[1]] =
                    saturate_cast<uchar>(
                    (1 - u) * (1 - v) * src_data[lRow * _src.step[0] + lCol * _src.step[1]] +
                    u * (1 - v) * src_data[nRow * _src.step[0] + lCol * _src.step[1]]);

                mask_data[i * mask.step[0] + j * mask.step[1] + 1] =
                    saturate_cast<uchar>(
                    (1 - u) * (1 - v) * src_data[lRow * _src.step[0] + lCol * _src.step[1] + 1] +
                    u * (1 - v) * src_data[nRow * _src.step[0] + lCol * _src.step[1] + 1]);

                mask_data[i * mask.step[0] + j * mask.step[1] + 2] =
                    saturate_cast<uchar>(
                    (1 - u) * (1 - v) * src_data[lRow * _src.step[0] + lCol * _src.step[1] + 2] +
                    u * (1 - v) * src_data[nRow * _src.step[0] + lCol * _src.step[1] + 2]);
            }
            else
            {
                mask_data[i * mask.step[0] + j * mask.step[1]] = saturate_cast<uchar>(
                    (1 - u) * (1 - v) * src_data[lRow * _src.step[0] + lCol * _src.step[1]] +
                    (1 - u) * v * src_data[lRow * _src.step[0] + nCol * _src.step[1]] +
                    u * (1 - v) * src_data[nRow * _src.step[0] + lCol * _src.step[1]] +
                    u * v * src_data[nRow * _src.step[0] + nCol * _src.step[1]]);

                mask_data[i * mask.step[0] + j * mask.step[1] + 1] = saturate_cast<uchar>(
                    (1 - u) * (1 - v) * src_data[lRow * _src.step[0] + lCol * _src.step[1] + 1] +
                    (1 - u) * v * src_data[lRow * _src.step[0] + nCol * _src.step[1] + 1] +
                    u * (1 - v) * src_data[nRow * _src.step[0] + lCol * _src.step[1] + 1] +
                    u * v * src_data[nRow * _src.step[0] + nCol * _src.step[1] + 1]);

                mask_data[i * mask.step[0] + j * mask.step[1] + 2] = saturate_cast<uchar>(
                    (1 - u) * (1 - v) * src_data[lRow * _src.step[0] + lCol * _src.step[1] + 2] +
                    (1 - u) * v * src_data[lRow * _src.step[0] + nCol * _src.step[1] + 2] +
                    u * (1 - v) * src_data[nRow * _src.step[0] + lCol * _src.step[1] + 2] +
                    u * v * src_data[nRow * _src.step[0] + nCol * _src.step[1] + 2]);
            }

        }//end inner for
    }//end outer for
}//end color
else
{
    for (int i = 0; i < Rows; ++i)
    {
        double r = i * 1.0 / _sy;//浮點行
        //uchar* mask_p = mask.ptr<uchar>(i);//當前行指標
        for (int j = 0; j < Cols; ++j)
        {
            double c = j * 1.0 / _sx;//浮點列

            //獲得四個頂點
            int lRow = static_cast<int>(r);//最鄰近行，取整
            int nRow = lRow + 1;

            int lCol = static_cast<int>(c);//最鄰近列
            int nCol = lCol + 1;

            double u = r - lRow;
            double v = c - lCol;

            if (lRow >= _src.rows - 1 && lCol >= _src.cols - 1)//右下角
            {
                mask_data[i * mask.step[0] + j * mask.step[1]] =
                    saturate_cast<uchar>((1 - u) * (1 - v) *
                    src_data[lRow * _src.step[0] + lCol * _src.step[1]]);
            }
            else if (lRow >= _src.rows - 1)//最後一行
            {

                mask_data[i * mask.step[0] + j * mask.step[1]] =
                    saturate_cast<uchar>((1 - u) * (1 - v) *
                    src_data[lRow * _src.step[0] + lCol * _src.step[1]] +
                    (1 - u) * v * src_data[lRow * _src.step[0] + nCol * _src.step[1]]);
            }
            else if (lCol >= _src.cols - 1)//最後一列
            {
                mask_data[i * mask.step[0] + j * mask.step[1]] =
                    saturate_cast<uchar>((1 - u) * (1 - v) * src_data[lRow * _src.step[0] + lCol * _src.step[1]] +
                    u * (1 - v) * src_data[nRow * _src.step[0] + lCol * _src.step[1]]);
            }
            else
            {
                mask_data[i * mask.step[0] + j * mask.step[1]] = saturate_cast<uchar>(
                    (1 - u) * (1 - v) * src_data[lRow * _src.step[0] + lCol * _src.step[1]] +
                    (1 - u) * v * src_data[lRow * _src.step[0] + nCol * _src.step[1]] +
                    u * (1 - v) * src_data[nRow * _src.step[0] + lCol * _src.step[1]] +
                    u * v * src_data[nRow * _src.step[0] + nCol * _src.step[1]]);
            }

        }//end inner for
    }//end outer for
}//end else

}

這裡寫程式碼片

Mat Geometry_Transform::Up_Down(const double sx, const double sy)
{
int sw = static_cast<int>(_src.rows * sy);
int sh = static_cast<int>(_src.cols * sx);
Mat mask = Mat::zeros(sw, sh, _src.type());

_sx = sx;
_sy = sy;
if (sx == 1 && sy == 1)//不做縮放運算，直接返回原圖
    return _src;
else
{
    Interpolate(_src, mask);
    return mask;
}

}

這裡寫程式碼片
int main()
{
    const string impath = "D:/opera.png";
    Mat src = imread(impath);
    if (!src.data)
    {
        cerr << "讀取圖片失敗..." << endl;
        return 0;
    } 

    Mat gray;
    cvtColor(src, gray, CV_BGR2GRAY);
    const double sx = 3;
    const double sy = 3;
    Geometry_Transform Geo_obj(src, sx, sy);
    Mat mask = Geo_obj.Up_Down();

    //呼叫OpenCV自帶的縮放函式測試
    Mat res;
    resize(src, res, Size(0, 0), sx, sy, INTER_LINEAR);
    Mat ss;
    subtract(mask, rs, ss);//做差比較
    return 0;
    }

PS：
- 啊，我的第一個部落格終於寫完了。第一次寫部落格發現好難，文筆向來不好，不知道怎麼寫。對於數學公式插入進來不知道怎麼編輯，不會latex語法，後面我會學一點latex語法，儘量把公式編輯的漂亮一點吧。

相關推薦

雙線性插值原理及其實現--基於OpenCV實現

這是我第一個部落格，一方面我把部落格看作筆記，記錄我在學習的過程中遇到的問題，寫部落格的過程也是加深理解的過程；另一方面也是為了與大家分享，共同進步。 雙線性插值分為兩步：1. 先做影象尺寸縮放；2. 求縮放後的影象畫素灰度值。 影象尺度縮放變換的公式

雙線性插值演算法詳解並用matlab實現

雙線性插值演算法 介紹 雙線性插值法又稱為二次線性插值法。在傳統的插值演算法中，它的插值效果比nearest插值法要好的多，但是速度上也必然會慢很多，比bicubic（二次立方法）效果要差， 但速度上要優於bicubic。 它主要思想就是利用某

基於opencv的雙線性插值的實現(一)

#include <cv.h> #include <highgui.h> #include <iostream> using namespace std; float Abs(float f); void zoom(IplImage

最近鄰插值和雙線性插值的基本原理 以及OpenCV中resize函式的用法改變影象的大小

最近鄰插值和雙線性插值的基本原理 影象的縮放很好理解,就是影象的放大和縮小。傳統的繪畫工具中,有一種叫做“放大尺”的繪畫工具，畫家常用它來放大圖畫。當然，在計算機上，我們不再需要用放大尺去放大或縮小影象了，把這個工作交給程式來完成就可以了。下面就來講講計算機怎麼來放大縮小圖象；在本文中，

雙線性插值 - c#實現

1.雙線性插值  線性插值是遊戲Unity開發過程中非常常用的演算法，在Unity中直接使用 lerp函式就可以實現。但對於雙線性插值，Unity並沒有給出可以直接使用了API，下面會給出一個利用C#對二維陣列進行雙線性插值的演算法。 下圖是雙線性插值的示意圖（圖片取自維

影象放縮中最近鄰插值和雙線性插值的基本原理

影象的縮放很好理解,就是影象的放大和縮小。傳統的繪畫工具中,有一種叫做“放大尺”的繪畫工具，畫家常用它來放大圖畫。當然，在計算機上，我們不再需要用放大尺去放大或縮小影象了，把這個工作交給程式來完成就可以了。下面就來講講計算機怎麼來放大縮小圖象；在本文中，我們所說的影象都是指

雙線性插值的實現

影象在進行仿射變換後由於變換後的某些畫素點在原影象中並不存在，因此需採用灰度內插為新位置賦灰度值，常用的內插方法包括：最近鄰內插法、雙線性內插法以及雙三次內插技術，綜合插值效果及效率，雙線性內插法得到了更廣泛的應用。 雙線性插值的演算法實現是這樣的：首先對源影象與目標影象做對比，比如源影象大小為

雙線性插值（Matlab實現）

三、實現 1.  實驗平臺與資料 本演算法使用Matlab語言實現，實驗平臺為Windows 8 32位作業系統、4GB記憶體（可用為2.31GB）、Matlab2013b。 資料1： 大小為：256*256 的lena灰度影象，將使用實現的演算法對其進行2倍放大操作，如下圖1所示： 圖1

opencv 學習--- 雙線性插值演算法原理簡述

***好記性不如爛筆頭*** 轉自： https://www.cnblogs.com/yssongest/p/5303151.html 1，原理 　　在影象的仿射變換中，很多地方需要用到插值運算，常見的插值運算包括最鄰近插值，雙線性插值，雙三次插值，蘭索思插值等方法，Op

OpenCV-最近鄰插值及雙線性插值實現

最近鄰插值及雙線性插值的基本原理舉個簡單的影象：3X3 的256級灰度圖，也就是高為3個象素，寬也是3個象素的影象，每個象素的取值可以是 0－255，代表該畫素的亮度，255代表最亮，也就是白色，0代表最暗，即黑色。假如影象的象素矩陣如下圖所示（這個原始圖把它叫做源圖，Sou

雙線性插值的影象縮放演算法的研究與實現

Opencv學堂 http://mp.weixin.qq.com/s?__biz=MzA4MDExMDEyMw==&mid=100000109&idx=1&sn=7540b49e869c3e27f87c84f6f3dfe9a8&chksm

【短道速滑一】OpenCV中cvResize函式使用雙線性插值縮小影象到長寬大小一半時速度飛快（比最近鄰還快）之異象解析和自我實現。

　　今天，一個朋友想使用我的SSE優化Demo裡的雙線性插值演算法，他已經在專案裡使用了OpenCV，因此，我就建議他直接使用OpenCV，朋友的程式非常注意效率和實時性（因為是處理視訊），因此希望我能測試下我的速度和OpenCV相比到底那一個更有速度優勢，恰好前一段時間也有朋友有這方面的需求，因此我就隨意編

幾何角度理解線性插值和雙線性插值

表示 兩種 容易 灰度 圖片 技術分享 方塊 描述 浮點 已知兩個點的坐標為\((x0,y0)\)和\((x1,y1)\)，他們呈簡單的線性關系（或者近似）。帶求坐標x落在\((x0,x1)\)之間，求y。 如上圖白色的線。 從幾何角度有兩種方法，一是相似三角形，二是斜率

圖像縮放——雙線性插值算法

val 位置 單位 sso 數學 圖像 取值 利用 等待 　　在數學上，雙線性插值是有兩個變量的插值函數的線性插值擴展，其核心思想是在兩個方向分別進行一次線性插值。如果選擇一個坐標系統使得 的四個已知點坐標分別為 (0, 0)、(0, 1)、(1, 0) 和 (1, 1)

影象演算法的基礎知識(雙線性插值，協方差矩陣，矩陣的特徵值、特徵向量）

0. 前言 MATLAB或者OpenCV裡有很多封裝好的函式，我們可以使用一行程式碼直接呼叫並得到處理結果。然而當問到具體是怎麼實現的時候，卻總是一臉懵逼，答不上來。前兩天參加一個演算法工程師的筆試題，其中就考到了這幾點，感到非常汗顏！趕緊補習！ 1. 雙線性插值 在影象處

雙線性插值的影象縮放問題

       初次開始寫部落格，想記錄下自己在公司實習所做過的事情以及學習到的東西，雖然還是有很多東西不瞭解也還沒做出來，但是也希望這是一種體驗。        我於2018.9.3入職進行實習，到現在也快過去兩個月了，我在公司

線性插值，雙線性插值Bilinear Interpolation演算法

線性插值 先講一下線性插值：已知資料 (x0, y0) 與 (x1, y1)，要計算 [x0, x1] 區間內某一位置 x 在直線上的y值（反過來也是一樣，略）： y−y0x−x0=y1−y0x1−x0y−y0

OpenCV---如何對影象進行雙線性插值運算（7）

附程式碼如下： import cv2 as cv import numpy as np def resize(): src = cv.imread("D:/matplotlib/0.jpg") cv.imshow("input",src) h, w = src.shape

影象演算法-最近鄰插值 雙線性插值

影象插值演算法包括向上插值和向下插值，向上插值就是對影象進行放大，向下插值就是對影象進行縮小，插值演算法在影象預處理過程中經常被使用，通過插值演算法，可以將影象尺寸變換為任意尺寸，下面以舉例子的方式來說明兩種常見的插值演算法： 假設影象原始尺寸為wi,hi，縮

影象演算法（一）：最近鄰插值，雙線性插值，三次插值

最近在複習影象演算法，對於一些簡單的影象演算法進行一個程式碼實現，由於找工作比較忙，具體原理後期補上，先上程式碼。今天先給出最近鄰插值，雙線性插值，三次插值。 1.最近鄰插值 原始圖中影響點數為1 （1）程式碼 # include<iostream>