vpImageConvert_opencv.cpp

/*
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2025 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See https://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Convert image types.
 */

 
#include <visp3/core/vpConfig.h>
#include <visp3/core/vpImageConvert.h>
 
#if defined(VISP_HAVE_SIMDLIB)
#include <Simd/SimdLib.h>
#endif
 
#if defined(VISP_HAVE_OPENCV) && defined(HAVE_OPENCV_IMGPROC)
 
BEGIN_VISP_NAMESPACE
void vpImageConvert::convert(const cv::Mat &src, vpImage<vpRGBa> &dest, bool flip)
{
  dest.resize(static_cast<unsigned int>(src.rows), static_cast<unsigned int>(src.cols));
  unsigned int destRows = dest.getRows();
  unsigned int destCols = dest.getCols();
  const unsigned int index_0 = 0;
  const unsigned int index_1 = 1;
  const unsigned int index_2 = 2;
  const unsigned int index_3 = 3;
  if (src.type() == CV_8UC4) {
    vpRGBa rgbaVal;
    for (unsigned int i = 0; i < destRows; ++i)
      for (unsigned int j = 0; j < destCols; ++j) {
        cv::Vec4b tmp = src.at<cv::Vec4b>(static_cast<int>(i), static_cast<int>(j));
        rgbaVal.R = tmp[index_2];
        rgbaVal.G = tmp[index_1];
        rgbaVal.B = tmp[index_0];
        rgbaVal.A = tmp[index_3];
        if (flip) {
          dest[destRows - i - 1][j] = rgbaVal;
        }
        else {
          dest[i][j] = rgbaVal;
        }
      }
  }
  else if (src.type() == CV_8UC3) {
#if defined(VISP_HAVE_SIMDLIB)
    if (src.isContinuous() && (!flip)) {
      SimdRgbToBgra(src.data, src.cols, src.rows, src.step[0], reinterpret_cast<uint8_t *>(dest.bitmap),
                    dest.getWidth() * sizeof(vpRGBa), vpRGBa::alpha_default);
    }
    else {
#endif
      vpRGBa rgbaVal;
      rgbaVal.A = vpRGBa::alpha_default;
      for (unsigned int i = 0; i < destRows; ++i) {
        for (unsigned int j = 0; j < destCols; ++j) {
          cv::Vec3b tmp = src.at<cv::Vec3b>(static_cast<int>(i), static_cast<int>(j));
          rgbaVal.R = tmp[index_2];
          rgbaVal.G = tmp[index_1];
          rgbaVal.B = tmp[index_0];
          if (flip) {
            dest[destRows - i - 1][j] = rgbaVal;
          }
          else {
            dest[i][j] = rgbaVal;
          }
        }
      }
#if defined(VISP_HAVE_SIMDLIB)
    }
#endif
  }
  else if (src.type() == CV_8UC1) {
#if defined(VISP_HAVE_SIMDLIB)
    if (src.isContinuous() && (!flip)) {
      SimdGrayToBgra(src.data, src.cols, src.rows, src.step[0], reinterpret_cast<uint8_t *>(dest.bitmap),
                     dest.getWidth() * sizeof(vpRGBa), vpRGBa::alpha_default);
    }
    else {
#endif
      vpRGBa rgbaVal;
      for (unsigned int i = 0; i < destRows; ++i) {
        for (unsigned int j = 0; j < destCols; ++j) {
          rgbaVal = src.at<unsigned char>(static_cast<int>(i), static_cast<int>(j));
          rgbaVal.A = vpRGBa::alpha_default;
          if (flip) {
            dest[destRows - i - 1][j] = rgbaVal;
          }
          else {
            dest[i][j] = rgbaVal;
          }
        }
      }
#if defined(VISP_HAVE_SIMDLIB)
    }
#endif
  }
}

void vpImageConvert::convert(const cv::Mat &src, vpImage<unsigned char> &dest, bool flip, unsigned int nThreads)
{
  if (src.type() == CV_8UC1) {
    dest.resize(static_cast<unsigned int>(src.rows), static_cast<unsigned int>(src.cols));
    unsigned int destRows = dest.getRows();
    unsigned int destCols = dest.getCols();
    if (src.isContinuous() && (!flip)) {
      memcpy(dest.bitmap, src.data, static_cast<size_t>(src.rows * src.cols));
    }
    else {
      if (flip) {
        for (unsigned int i = 0; i < destRows; ++i) {
          memcpy(dest.bitmap + (i * destCols), src.data + ((destRows - i - 1) * src.step1()), static_cast<size_t>(destCols * sizeof(unsigned char)));
        }
      }
      else {
        for (unsigned int i = 0; i < destRows; ++i) {
          memcpy(dest.bitmap + (i * destCols), src.data + (i * src.step1()), static_cast<size_t>(destCols * sizeof(unsigned char)));
        }
      }
    }
  }
  else if (src.type() == CV_8UC3) {
    dest.resize(static_cast<unsigned int>(src.rows), static_cast<unsigned int>(src.cols));
    unsigned int destRows = dest.getRows();
    unsigned int destCols = dest.getCols();
    if (src.isContinuous()) {
      BGRToGrey((unsigned char *)src.data, (unsigned char *)dest.bitmap, static_cast<unsigned int>(src.cols), static_cast<unsigned int>(src.rows),
                flip, nThreads);
    }
    else {
      if (flip) {
        for (unsigned int i = 0; i < destRows; ++i) {
          BGRToGrey((unsigned char *)src.data + (i * src.step1()),
                    (unsigned char *)dest.bitmap + ((destRows - i - 1) * destCols),
                    static_cast<unsigned int>(destCols), 1, false);
        }
      }
      else {
        for (unsigned int i = 0; i < destRows; ++i) {
          BGRToGrey((unsigned char *)src.data + (i * src.step1()), (unsigned char *)dest.bitmap + (i * destCols),
                    static_cast<unsigned int>(destCols), 1, false);
        }
      }
    }
  }
  else if (src.type() == CV_8UC4) {
    dest.resize(static_cast<unsigned int>(src.rows), static_cast<unsigned int>(src.cols));
    unsigned int destRows = dest.getRows();
    unsigned int destCols = dest.getCols();
    if (src.isContinuous()) {
      BGRaToGrey((unsigned char *)src.data, (unsigned char *)dest.bitmap, static_cast<unsigned int>(src.cols),
                 static_cast<unsigned int>(src.rows), flip, nThreads);
    }
    else {
      if (flip) {
        for (unsigned int i = 0; i < destRows; ++i) {
          BGRaToGrey((unsigned char *)src.data + (i * src.step1()),
                     (unsigned char *)dest.bitmap + ((destRows - i - 1) * destCols),
                     static_cast<unsigned int>(destCols), 1, false);
        }
      }
      else {
        for (unsigned int i = 0; i < destRows; ++i) {
          BGRaToGrey((unsigned char *)src.data + (i * src.step1()), (unsigned char *)dest.bitmap + (i * destCols),
                     static_cast<unsigned int>(destCols), 1, false);
        }
      }
    }
  }
}

void vpImageConvert::convert(const cv::Mat &src, vpImage<float> &dest, bool flip)
{
  dest.resize(static_cast<unsigned int>(src.rows), static_cast<unsigned int>(src.cols));
  unsigned int destRows = dest.getRows();
  unsigned int destCols = dest.getCols();
 
  if (src.type() == CV_32FC1) {
    for (unsigned int i = 0; i < destRows; ++i) {
      for (unsigned int j = 0; j < destCols; ++j) {
        if (flip) {
          dest[dest.getRows() - i - 1][j] = src.at<float>(static_cast<int>(i), static_cast<int>(j));
        }
        else {
          dest[i][j] = src.at<float>(static_cast<int>(i), static_cast<int>(j));
        }
      }
    }
  }
  else if (src.type() == CV_16SC1) {
    for (unsigned int i = 0; i < destRows; ++i) {
      for (unsigned int j = 0; j < destCols; ++j) {
        if (flip) {
          dest[dest.getRows() - i - 1][j] = src.at<short>(static_cast<int>(i), static_cast<int>(j));
        }
        else {
          dest[i][j] = src.at<short>(static_cast<int>(i), static_cast<int>(j));
        }
      }
    }
  }
  else {
    throw vpException(vpException::badValue, "cv::Mat type is not supported!");
  }
}

void vpImageConvert::convert(const cv::Mat &src, vpImage<double> &dest, bool flip)
{
  vpImage<float> I_float;
  convert(src, I_float, flip);
  unsigned int nbRows = static_cast<unsigned int>(src.rows);
  unsigned int nbCols = static_cast<unsigned int>(src.cols);
  dest.resize(nbRows, nbCols);
  for (unsigned int i = 0; i < nbRows; ++i) {
    for (unsigned int j = 0; j < nbCols; ++j) {
      dest[i][j] = I_float[i][j];
    }
  }
}

void vpImageConvert::convert(const cv::Mat &src, vpImage<uint16_t> &dest, bool flip)
{
  dest.resize(static_cast<unsigned int>(src.rows), static_cast<unsigned int>(src.cols));
  unsigned int destRows = dest.getRows();
  unsigned int destCols = dest.getCols();
 
  if (src.type() == CV_16UC1) {
    if (src.isContinuous()) {
      memcpy(dest.bitmap, src.data, static_cast<size_t>(src.rows * src.cols) * sizeof(uint16_t));
    }
    else {
      if (flip) {
        for (unsigned int i = 0; i < destRows; ++i) {
          memcpy(dest.bitmap + (i * destCols), src.data + ((destRows - i - 1) * src.step1() * sizeof(uint16_t)), static_cast<size_t>(destCols * sizeof(uint16_t)));
        }
      }
      else {
        for (unsigned int i = 0; i < destRows; ++i) {
          memcpy(dest.bitmap + (i * destCols), src.data + (i * src.step1() * sizeof(uint16_t)), static_cast<size_t>(destCols * sizeof(uint16_t)));
        }
      }
    }
  }
  else {
    throw(vpException(vpException::fatalError, "cv:Mat format not supported for conversion into vpImage<uint16_t>"));
  }
}

void vpImageConvert::convert(const cv::Mat &src, vpImage<vpRGBf> &dest, bool flip)
{
  dest.resize(static_cast<unsigned int>(src.rows), static_cast<unsigned int>(src.cols));
  unsigned int destRows = dest.getRows();
  unsigned int destCols = dest.getCols();
  const unsigned int index_0 = 0;
  const unsigned int index_1 = 1;
  const unsigned int index_2 = 2;
 
  if (src.type() == CV_32FC3) {
    vpRGBf rgbVal;
    for (unsigned int i = 0; i < destRows; ++i)
      for (unsigned int j = 0; j < destCols; ++j) {
        cv::Vec3f tmp = src.at<cv::Vec3f>(static_cast<int>(i), static_cast<int>(j));
        rgbVal.R = tmp[index_2];
        rgbVal.G = tmp[index_1];
        rgbVal.B = tmp[index_0];
        if (flip) {
          dest[destRows - i - 1][j] = rgbVal;
        }
        else {
          dest[i][j] = rgbVal;
        }
      }
  }
  else {
    throw vpException(vpException::badValue, "cv::Mat type is not supported!");
  }
}

void vpImageConvert::convert(const vpImage<vpRGBa> &src, cv::Mat &dest)
{
  cv::Mat vpToMat(static_cast<int>(src.getRows()), static_cast<int>(src.getCols()), CV_8UC4, (void *)src.bitmap);
  cv::cvtColor(vpToMat, dest, cv::COLOR_RGBA2BGR);
}

void vpImageConvert::convert(const vpImage<unsigned char> &src, cv::Mat &dest, bool copyData)
{
  if (copyData) {
    cv::Mat tmpMap(static_cast<int>(src.getRows()), static_cast<int>(src.getCols()), CV_8UC1, (void *)src.bitmap);
    dest = tmpMap.clone();
  }
  else {
    dest = cv::Mat(static_cast<int>(src.getRows()), static_cast<int>(src.getCols()), CV_8UC1, (void *)src.bitmap);
  }
}

void vpImageConvert::convert(const vpImage<float> &src, cv::Mat &dest, bool copyData)
{
  if (copyData) {
    cv::Mat tmpMap(static_cast<int>(src.getRows()), static_cast<int>(src.getCols()), CV_32FC1, (void *)src.bitmap);
    dest = tmpMap.clone();
  }
  else {
    dest = cv::Mat(static_cast<int>(src.getRows()), static_cast<int>(src.getCols()), CV_32FC1, (void *)src.bitmap);
  }
}

void vpImageConvert::convert(const vpImage<double> &src, cv::Mat &dest, bool copyData)
{
  unsigned int nbRows = src.getRows();
  unsigned int nbCols = src.getCols();
  vpImage<float> I_float(nbRows, nbCols);
  for (unsigned int i = 0; i < nbRows; ++i) {
    for (unsigned int j = 0; j < nbCols; ++j) {
      I_float[i][j] = static_cast<float>(src[i][j]);
    }
  }
  convert(I_float, dest, copyData);
}

void vpImageConvert::convert(const vpImage<vpRGBf> &src, cv::Mat &dest)
{
  cv::Mat vpToMat(static_cast<int>(src.getRows()), static_cast<int>(src.getCols()), CV_32FC3, (void *)src.bitmap);
  cv::cvtColor(vpToMat, dest, cv::COLOR_RGB2BGR);
}
 
END_VISP_NAMESPACE
 
#endif