Mostrar imágenes múltiples (2,3,4, ...) en la misma ventana en OpenCV

Question

Quiero mostrar 2, 3 o más imágenes en la misma ventana.

Mi problema es cómo colocar la segunda y tercera imagen justo en el lado derecho (arriba, izquierda o arriba) de la imagen principal.

Quiero crear algo como esto, usando OpenCV.

--------------- 
|  |  | 
|  |  | 
--------------- 
| |  | 
| |  | 
--------------- 

Gracias de antemano Jorge

Answer 1

usted puede encontrar la respuesta en el OpenCV Wiki:

https://github.com/opencv/opencv/wiki/DisplayManyImages

:-)

Answer 2

La respuesta depende de qué interfaz que está utilizando (C o C++). Flujo de trabajo general es

• crear una imagen (cv::Mat para C++, IplImage* para C) lo suficientemente grande como para acomodar su imagen compuesta
• Copie sus imágenes en la imagen grande
  • C++: Utilice el constructor Mat::Mat(const Mat& m, const Range& rowRange, const Range& colRange) llegar a cv::Mat apuntando a una subimagen de su ventana original, luego use el método copyTo para copiar su imagen pequeña en la grande
  • C: establezca un ROI en la imagen grande y copie su imagen pequeña en él
• Mostrar su imagen grande

Answer 3

La interfaz gráfica de usuario incluido con OpenCV es bastante limitada, si es que tiene que hacer nada complicado, que realmente debe utilizar un marco GUI tales como QT o VC++ en ventanas

Answer 4

Implementé esto muy recientemente. Así que pensé en compartirlo. Utiliza la API C++. El código es autoexplicativo (con suerte).

/** 
    * @brief makeCanvas Makes composite image from the given images 
    * @param vecMat Vector of Images. 
    * @param windowHeight The height of the new composite image to be formed. 
    * @param nRows Number of rows of images. (Number of columns will be calculated 
    *    depending on the value of total number of images). 
    * @return new composite image. 
    */ 
    cv::Mat makeCanvas(std::vector<cv::Mat>& vecMat, int windowHeight, int nRows) { 
      int N = vecMat.size(); 
      nRows = nRows > N ? N : nRows; 
      int edgeThickness = 10; 
      int imagesPerRow = ceil(double(N)/nRows); 
      int resizeHeight = floor(2.0 * ((floor(double(windowHeight - edgeThickness)/nRows))/2.0)) - edgeThickness; 
      int maxRowLength = 0; 

      std::vector<int> resizeWidth; 
      for (int i = 0; i < N;) { 
        int thisRowLen = 0; 
        for (int k = 0; k < imagesPerRow; k++) { 
          double aspectRatio = double(vecMat[i].cols)/vecMat[i].rows; 
          int temp = int(ceil(resizeHeight * aspectRatio)); 
          resizeWidth.push_back(temp); 
          thisRowLen += temp; 
          if (++i == N) break; 
        } 
        if ((thisRowLen + edgeThickness * (imagesPerRow + 1)) > maxRowLength) { 
          maxRowLength = thisRowLen + edgeThickness * (imagesPerRow + 1); 
        } 
      } 
      int windowWidth = maxRowLength; 
      cv::Mat canvasImage(windowHeight, windowWidth, CV_8UC3, Scalar(0, 0, 0)); 

      for (int k = 0, i = 0; i < nRows; i++) { 
        int y = i * resizeHeight + (i + 1) * edgeThickness; 
        int x_end = edgeThickness; 
        for (int j = 0; j < imagesPerRow && k < N; k++, j++) { 
          int x = x_end; 
          cv::Rect roi(x, y, resizeWidth[k], resizeHeight); 
          cv::Size s = canvasImage(roi).size(); 
          // change the number of channels to three 
          cv::Mat target_ROI(s, CV_8UC3); 
          if (vecMat[k].channels() != canvasImage.channels()) { 
           if (vecMat[k].channels() == 1) { 
            cv::cvtColor(vecMat[k], target_ROI, CV_GRAY2BGR); 
           } 
          } else {    
           vecMat[k].copyTo(target_ROI); 
          } 
          cv::resize(target_ROI, target_ROI, s); 
          if (target_ROI.type() != canvasImage.type()) { 
           target_ROI.convertTo(target_ROI, canvasImage.type()); 
          } 
          target_ROI.copyTo(canvasImage(roi)); 
          x_end += resizeWidth[k] + edgeThickness; 
        } 
      } 
      return canvasImage; 
    } 

Aquí es resultado de ejemplo.

Answer 5

o simplemente utilizar:

Mat a, Mat b, Mat dst // a,b loaded 

cv::hconcat(a, b, dst) // horizontal 
cv::vconcat(a, b, dst) // vertical 

DST Mat -> | a | b |

o lo hacen con vectores:

std::vector<cv::Mat> matrices = { 
      a, b 
    }; 
hconcat(matrices, dst);