重新映射

目录

• 目标
• 理论
  • 什么是重新映射？
• 代码
• 说明
• 结果

上一个教程： 使用广义 Ballard 和 Guil Hough 变换进行目标检测
下一个教程： 仿射变换

原作者	Ana Huamán
兼容性	OpenCV >= 3.0

目标

本教程将学习如何

a. 使用 OpenCV 函数 cv::remap 实现简单的重新映射例程。

理论

什么是重新映射？

• 从图像的一个位置获取像素，然后将它们定位在新图像的另一个位置的过程。
• 为了实现映射过程，对于非整数像素位置可能需要执行一些插值，因为源图像和目标图像之间并不总存在一对一像素对应关系。

• 我们可以对每个像素位置 \((x,y)\) 表示重新映射为

  \[g(x,y) = f ( h(x,y) )\]

  其中 \(g()\) 是重新映射的图像，\(f()\) 是源图像，\(h(x,y)\) 是操作 \((x,y)\) 的映射函数。

• 让我们思考一个简单的示例。假设我们有一幅图像 \(I\)，并且我们想要执行重新映射，比如

  \[h(x,y) = (I.cols - x, y )\]

  会发生什么？很容易看出图像将在 \(x\) 方向翻转。例如，考虑输入图像

观察红色圆圈如何相对于 x 改变位置（将 \(x\) 视为水平方向）

• 在 OpenCV 中，函数 cv::remap 提供了简单的重新映射实现。

代码

• 此程序做什么？
  • 加载图像
  • 每秒，将四种不同的重新映射过程中的 1 种应用到图像中，并将它们无限期地显示在一个窗口中。
  • 等待用户退出程序

C++

• 教程代码如下所示。你还可以从 此处 下载它

   
  #include "opencv2/imgcodecs.hpp"
  #include "opencv2/highgui.hpp"
  #include "opencv2/imgproc.hpp"
  #include <iostream>
   
  使用命名空间 cv;
   
  void update_map( int &ind, Mat &map_x, Mat &map_y );
   
  int main(int argc, const char** argv)
  {
      CommandLineParser parser(argc, argv, "{@image |chicky_512.png|input image name}");
  std::string filename = parser.get<std::string>(0);
      Mat src = imread( samples::findFile( filename ), IMREAD_COLOR );
      if (src.empty())
      {
  std::cout << "无法读取图像: " << filename << std::endl;
          return -1;
      }
   
      Mat dst(src.size(), src.type());
      Mat map_x(src.size(), CV_32FC1);
      Mat map_y(src.size(), CV_32FC1);
   
      const char* remap_window = "重新映射演示";
  namedWindow( remap_window, WINDOW_AUTOSIZE );
   
      int ind = 0;
      for(;;)
      {
  update_map(ind, map_x, map_y);
  remap( src, dst, map_x, map_y, INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0) );
   
  imshow( remap_window, dst );
   
          char c = (char)waitKey( 1000 );
          if( c == 27 )
          {
              break;
          }
      }
      return 0;
  }
   
  void update_map( int &ind, Mat &map_x, Mat &map_y )
  {
      for( int i = 0; i < map_x.rows; i++ )
      {
          for( int j = 0; j < map_x.cols; j++ )
          {
              switch( ind )
              {
              case 0:
                  if( j > map_x.cols*0.25 && j < map_x.cols*0.75 && i > map_x.rows*0.25 && i < map_x.rows*0.75 )
                  {
  map_x.at<float>(i, j) = 2*( j - map_x.cols*0.25f ) + 0.5f;
  map_y.在<浮点>(i, j) = 2*( i - map_x.行数*0.25f ) + 0.5f;
                  }
                  其他
                  {
  map_x.在<浮点>(i, j) = 0;
  map_y.在<浮点>(i, j) = 0;
                  }
                  break;
              case 1:
  map_x.在<浮点>(i, j) = (浮点)j;
  map_y.在<浮点>(i, j) = (浮点)(map_x.行数 - i);
                  break;
              case 2:
  map_x.在<浮点>(i, j) = (浮点)(map_x.列数 - j);
  map_y.在<浮点>(i, j) = (浮点)i;
                  break;
              case 3:
  map_x.在<浮点>(i, j) = (浮点)(map_x.列数 - j);
  map_y.在<浮点>(i, j) = (浮点)(map_x.行数 - i);
                  break;
              默认:
                  break;
  } // case结束
          }
      }
  ind = (ind + 1) % 4;
  }

Java

• 教程代码见下方行。您还可以从 此处 下载

  导入 org.opencv.core.核心；
  导入 org.opencv.core.CvType；
  导入 org.opencv.core.垫子；
  导入 org.opencv.highgui.HighGui；
  导入 org.opencv.imgcodecs.Imgcodecs；
  导入 org.opencv.imgproc.Imgproc；
   
  类 Remap {
      私人 Mat mapX = 新 Mat()；
      私人 Mat mapY = 新 Mat()；
      私人 Mat dst = 新 Mat()；
      私人 int ind = 0；
   
      private void updateMap() {
          float buffX[] = new float[(int) (mapX.total() * mapX.channels())];
  mapX.get(0, 0, buffX);
   
          float buffY[] = new float[(int) (mapY.total() * mapY.channels())];
  mapY.get(0, 0, buffY);
   
          for (int i = 0; i < mapX.rows(); i++) {
              for (int j = 0; j < mapX.cols(); j++) {
                  switch (ind) {
                  case 0:
                      if( j > mapX.cols()*0.25 && j < mapX.cols()*0.75 && i > mapX.rows()*0.25 && i < mapX.rows()*0.75 ) {
  buffX[i*mapX.cols() + j] = 2*( j - mapX.cols()*0.25f ) + 0.5f;
  buffY[i*mapY.cols() + j] = 2*( i - mapX.rows()*0.25f ) + 0.5f;
  } else {
  buffX[i*mapX.cols() + j] = 0;
  buffY[i*mapY.cols() + j] = 0;
                      }
                      break;
                  case 1:
  buffX[i*mapX.cols() + j] = j;
  buffY[i*mapY.cols() + j] = mapY.rows() - i;
                      break;
                  case 2:
  buffX[i*mapX.cols() + j] = mapY.cols() - j;
  buffY[i*mapY.cols() + j] = i;
                      break;
                  case 3:
  buffX[i*mapX.cols() + j] = mapY.cols() - j;
  buffY[i*mapY.cols() + j] = mapY.rows() - i;
                      break;
                  默认:
                      break;
                  }
              }
          }
  mapX.put(0, 0, buffX);
  mapY.put(0, 0, buffY);
  ind = (ind + 1) % 4;
      }
   
      public void run(String[] args) {
          String filename = args.length > 0 ? args[0] : "../data/chicky_512.png";
  Mat src = Imgcodecs.imread(filename, Imgcodecs.IMREAD_COLOR);
          if (src.empty()) {
  System.err.println("无法读取图像： " + filename);
  System.exit(0);
          }
   
  mapX = new Mat(src.size(), CvType.CV_32F);
  mapY = new Mat(src.size(), CvType.CV_32F);
   
          final String winname = "重新映射演示";
  HighGui.namedWindow(winname, HighGui.WINDOW_AUTOSIZE);
   
          for (;;) {
  updateMap();
  Imgproc.remap(src, dst, mapX, mapY, Imgproc.INTER_LINEAR);
  HighGui.imshow(winname, dst);
              if (HighGui.waitKey(1000) == 27) {
                  break;
              }
          }
  System.exit(0);
      }
  }
   
  public class RemapDemo {
      public static void main(String[] args) {
          // 加载原生 OpenCV 库
  System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
   
          new Remap().run(args);
      }
  }

Python

• 教程代码如下所示。您也可以从此处下载

  from __future__ import print_function
  import cv2 as cv
  import numpy as np
  import argparse
   
   
  def update_map(ind, map_x, map_y)
      if ind == 0
          for i in range(map_x.shape[0])
              for j in range(map_x.shape[1])
                  if j > map_x.shape[1]*0.25 and j < map_x.shape[1]*0.75 and i > map_x.shape[0]*0.25 and i < map_x.shape[0]*0.75
  map_x[i,j] = 2 * (j-map_x.shape[1]*0.25) + 0.5
  map_y[i,j] = 2 * (i-map_y.shape[0]*0.25) + 0.5
                  其他:
  map_x[i,j] = 0
  map_y[i,j] = 0
      elif ind == 1
          for i in range(map_x.shape[0])
  map_x[i,:] = [x for x in range(map_x.shape[1])]
          for j in range(map_y.shape[1])
  map_y[:,j] = [map_y.shape[0]-y for y in range(map_y.shape[0])]
      elif ind == 2
          for i in range(map_x.shape[0])
  map_x[i,:] = [map_x.shape[1]-x for x in range(map_x.shape[1])]
          for j in range(map_y.shape[1])
  map_y[:,j] = [y for y in range(map_y.shape[0])]
      elif ind == 3
          for i in range(map_x.shape[0])
  map_x[i,:] = [map_x.shape[1]-x for x in range(map_x.shape[1])]
          for j in range(map_y.shape[1])
  map_y[:,j] = [map_y.shape[0]-y for y in range(map_y.shape[0])]
   
   
  parser = argparse.ArgumentParser(description='Remapping tutorial 相关代码。')
  parser.add_argument('--input', help='输入图像路径。', default='chicky_512.png')
  args = parser.parse_args()
   
   
  src = cv.imread(cv.samples.findFile(args.input), cv.IMREAD_COLOR)
  if src is None
  print('不能打开或找到图片: ', args.input)
  exit(0)
   
   
   
  map_x = np.zeros((src.shape[0], src.shape[1]), dtype=np.float32)
  map_y = np.zeros((src.shape[0], src.shape[1]), dtype=np.float32)
   
   
   
  window_name = 'Remap 演示'
  cv.namedWindow(window_name)
   
   
   
  ind = 0
  while True
  update_map(ind, map_x, map_y)
  ind = (ind + 1) % 4
  dst = cv.remap(src, map_x, map_y, cv.INTER_LINEAR)
      cv.imshow(window_name, dst)
  c = cv.waitKey(1000)
      if c == 27
          break
   

解释

• 加载一张图片

  C++

   
      Mat src = imread( samples::findFile( filename ), IMREAD_COLOR );
      if (src.empty())
      {
  std::cout << "无法读取图像: " << filename << std::endl;
          return -1;
      }

  Java

  Mat src = Imgcodecs.imread(filename, Imgcodecs.IMREAD_COLOR);
          if (src.empty()) {
  System.err.println("无法读取图像： " + filename);
  System.exit(0);
          }

  Python

  src = cv.imread(cv.samples.findFile(args.input), cv.IMREAD_COLOR)
  if src is None
  print('不能打开或找到图片: ', args.input)
  exit(0)

• 创建目标图片和两个映射矩阵（用于 x 和 y）

  C++

   
      Mat dst(src.size(), src.type());
      Mat map_x(src.size(), CV_32FC1);
      Mat map_y(src.size(), CV_32FC1);

  Java

  mapX = new Mat(src.size(), CvType.CV_32F);
  mapY = new Mat(src.size(), CvType.CV_32F);

  Python

  map_x = np.zeros((src.shape[0], src.shape[1]), dtype=np.float32)
  map_y = np.zeros((src.shape[0], src.shape[1]), dtype=np.float32)

• 创建窗口来显示结果

  C++

   
      const char* remap_window = "重新映射演示";
  namedWindow( remap_window, WINDOW_AUTOSIZE );

  Java

          final String winname = "Remap demo";
  HighGui.namedWindow(winname, HighGui.WINDOW_AUTOSIZE);

  Python

  window_name = 'Remap 演示'
  cv.namedWindow(window_name)

• 建立循环。每 1000 毫秒我们都会更新映射矩阵（mat_x 和 mat_y）并将它们应用到源图像中

  C++

   
      int ind = 0;
      for(;;)
      {
  update_map(ind, map_x, map_y);
  remap( src, dst, map_x, map_y, INTER_LINEAR, BORDER_CONSTANT, Scalar(0, 0, 0) );
   
  imshow( remap_window, dst );
   
          char c = (char)waitKey( 1000 );
          if( c == 27 )
          {
              break;
          }
      }

  Java

          for (;;) {
  updateMap();
  Imgproc.remap(src, dst, mapX, mapY, Imgproc.INTER_LINEAR);
  HighGui.imshow(winname, dst);
              if (HighGui.waitKey(1000) == 27) {
                  break;
              }
          }

  Python

  ind = 0
  while True
  update_map(ind, map_x, map_y)
  ind = (ind + 1) % 4
  dst = cv.remap(src, map_x, map_y, cv.INTER_LINEAR)
      cv.imshow(window_name, dst)
  c = cv.waitKey(1000)
      if c == 27
          break

• 用于执行重新映射的函数是 cv::remap 。我们给出了以下参数

  • src: 源图像
  • dst: 与 src 大小相同的目标图像
  • map_x: x 方向上的映射函数。它等价于 \(h(i,j)\) 的第一分量
  • map_y: 如上所述，但位于 y 方向。请注意，map_y 和 map_x 都与 src 大小相同
  • INTER_LINEAR: 用于非整数像素的插值类型。这是默认值。
  • BORDER_CONSTANT: 默认

  我们如何更新映射矩阵 mat_x 和 mat_y？继续阅读

• 更新映射矩阵： 我们将执行 4 种不同的映射
  1. 将图片缩小到其大小的一半，并将其显示在中间位置

     \[h(i,j) = ( 2 \times i - src.cols/2 + 0.5, 2 \times j - src.rows/2 + 0.5)\]

     对于所有这样的成对 \((i,j)\) ：\(\dfrac{src.cols}{4}<i<\dfrac{3 \cdot src.cols}{4}\) 并且 \(\dfrac{src.rows}{4}<j<\dfrac{3 \cdot src.rows}{4}\)
  2. 将图像上下颠倒：\(h( i, j ) = (i, src.rows - j)\)
  3. 从左向右反射图像：\(h(i,j) = ( src.cols - i, j )\)
  4. b 和 c 的组合：\(h(i,j) = ( src.cols - i, src.rows - j )\)

这在下面的代码片段中有所体现。在其中，map_x 表示 h(i,j) 的第一个坐标，map_y 表示第二个坐标。

C++

void update_map( int &ind, Mat &map_x, Mat &map_y )
{
    for( int i = 0; i < map_x.rows; i++ )
    {
        for( int j = 0; j < map_x.cols; j++ )
        {
            switch( ind )
            {
            case 0:
                if( j > map_x.cols*0.25 && j < map_x.cols*0.75 && i > map_x.rows*0.25 && i < map_x.rows*0.75 )
                {
map_x.at<float>(i, j) = 2*( j - map_x.cols*0.25f ) + 0.5f;
map_y.在<浮点>(i, j) = 2*( i - map_x.行数*0.25f ) + 0.5f;
                }
                其他
                {
map_x.在<浮点>(i, j) = 0;
map_y.在<浮点>(i, j) = 0;
                }
                break;
            case 1:
map_x.在<浮点>(i, j) = (浮点)j;
map_y.在<浮点>(i, j) = (浮点)(map_x.行数 - i);
                break;
            case 2:
map_x.在<浮点>(i, j) = (浮点)(map_x.列数 - j);
map_y.在<浮点>(i, j) = (浮点)i;
                break;
            case 3:
map_x.在<浮点>(i, j) = (浮点)(map_x.列数 - j);
map_y.在<浮点>(i, j) = (浮点)(map_x.行数 - i);
                break;
            默认:
                break;
} // case结束
        }
    }
ind = (ind + 1) % 4;
}

Java

    private void updateMap() {
        float buffX[] = new float[(int) (mapX.total() * mapX.channels())];
mapX.get(0, 0, buffX);
 
        float buffY[] = new float[(int) (mapY.total() * mapY.channels())];
mapY.get(0, 0, buffY);
 
        for (int i = 0; i < mapX.rows(); i++) {
            for (int j = 0; j < mapX.cols(); j++) {
                switch (ind) {
                case 0:
                    if( j > mapX.cols()*0.25 && j < mapX.cols()*0.75 && i > mapX.rows()*0.25 && i < mapX.rows()*0.75 ) {
buffX[i*mapX.cols() + j] = 2*( j - mapX.cols()*0.25f ) + 0.5f;
buffY[i*mapY.cols() + j] = 2*( i - mapX.rows()*0.25f ) + 0.5f;
} else {
buffX[i*mapX.cols() + j] = 0;
buffY[i*mapY.cols() + j] = 0;
                    }
                    break;
                case 1:
buffX[i*mapX.cols() + j] = j;
buffY[i*mapY.cols() + j] = mapY.rows() - i;
                    break;
                case 2:
buffX[i*mapX.cols() + j] = mapY.cols() - j;
buffY[i*mapY.cols() + j] = i;
                    break;
                case 3:
buffX[i*mapX.cols() + j] = mapY.cols() - j;
buffY[i*mapY.cols() + j] = mapY.rows() - i;
                    break;
                默认:
                    break;
                }
            }
        }
mapX.put(0, 0, buffX);
mapY.put(0, 0, buffY);
ind = (ind + 1) % 4;
    }

Python

def update_map(ind, map_x, map_y)
    if ind == 0
        for i in range(map_x.shape[0])
            for j in range(map_x.shape[1])
                if j > map_x.shape[1]*0.25 and j < map_x.shape[1]*0.75 and i > map_x.shape[0]*0.25 and i < map_x.shape[0]*0.75
map_x[i,j] = 2 * (j-map_x.shape[1]*0.25) + 0.5
map_y[i,j] = 2 * (i-map_y.shape[0]*0.25) + 0.5
                其他:
map_x[i,j] = 0
map_y[i,j] = 0
    elif ind == 1
        for i in range(map_x.shape[0])
map_x[i,:] = [x for x in range(map_x.shape[1])]
        for j in range(map_y.shape[1])
map_y[:,j] = [map_y.shape[0]-y for y in range(map_y.shape[0])]
    elif ind == 2
        for i in range(map_x.shape[0])
map_x[i,:] = [map_x.shape[1]-x for x in range(map_x.shape[1])]
        for j in range(map_y.shape[1])
map_y[:,j] = [y for y in range(map_y.shape[0])]
    elif ind == 3
        for i in range(map_x.shape[0])
map_x[i,:] = [map_x.shape[1]-x for x in range(map_x.shape[1])]
        for j in range(map_y.shape[1])
map_y[:,j] = [map_y.shape[0]-y for y in range(map_y.shape[0])]

结果

1. 在编译完上面的代码后，你可以通过输入一个图像路径来运行它。例如，以下图像

1. 这是将其缩小到一半大小并将其置中的结果

1. 将其上下颠倒

1. 沿 x 方向反射

1. 沿两个方向反射