vpMeterPixelConversion.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:
 * Meter to pixel conversion.
 */

 
#include <visp3/core/vpCameraParameters.h>
#include <visp3/core/vpException.h>
#include <visp3/core/vpMath.h>
#include <visp3/core/vpMeterPixelConversion.h>
 
#if defined(VISP_HAVE_OPENCV) && (VISP_HAVE_OPENCV_VERSION < 0x050000) && defined(HAVE_OPENCV_CALIB3D)
#include <opencv2/calib3d/calib3d.hpp>
#endif
#if defined(VISP_HAVE_OPENCV) && (VISP_HAVE_OPENCV_VERSION >= 0x050000) && defined(HAVE_OPENCV_CALIB) && defined(HAVE_OPENCV_3D)
#include <opencv2/calib.hpp>
#include <opencv2/3d.hpp>
#endif
 
BEGIN_VISP_NAMESPACE
void vpMeterPixelConversion::convertLine(const vpCameraParameters &cam, const double &rho_m, const double &theta_m,
                                         double &rho_p, double &theta_p)
{
  double co = cos(theta_m);
  double si = sin(theta_m);
  double d = sqrt(vpMath::sqr(cam.m_py * co) + vpMath::sqr(cam.m_px * si));
 
  if (fabs(d) < 1e-6) {
    throw(vpException(vpException::divideByZeroError, "division by zero"));
  }
 
  theta_p = atan2(cam.m_px * si, cam.m_py * co);
  rho_p = ((cam.m_px * cam.m_py * rho_m) + (cam.m_u0 * cam.m_py * co) + (cam.m_v0 * cam.m_px * si));
  rho_p /= d;
}

void vpMeterPixelConversion::convertEllipse(const vpCameraParameters &cam, const vpCircle &circle,
                                            vpImagePoint &center_p, double &n20_p, double &n11_p, double &n02_p)
{
  // Get the parameters of the ellipse in the image plane
  const unsigned int index_0 = 0;
  const unsigned int index_1 = 1;
  const unsigned int index_2 = 2;
  const unsigned int index_3 = 3;
  const unsigned int index_4 = 4;
  double xc_m = circle.p[index_0];
  double yc_m = circle.p[index_1];
  double n20_m = circle.p[index_2];
  double n11_m = circle.p[index_3];
  double n02_m = circle.p[index_4];
 
  // Convert from meter to pixels
  vpMeterPixelConversion::convertPoint(cam, xc_m, yc_m, center_p);
  n20_p = n20_m * vpMath::sqr(cam.get_px());
  n11_p = n11_m * cam.get_px() * cam.get_py();
  n02_p = n02_m * vpMath::sqr(cam.get_py());
}

void vpMeterPixelConversion::convertEllipse(const vpCameraParameters &cam, const vpSphere &sphere,
                                            vpImagePoint &center_p, double &n20_p, double &n11_p, double &n02_p)
{
  // Get the parameters of the ellipse in the image plane
  const unsigned int index_0 = 0;
  const unsigned int index_1 = 1;
  const unsigned int index_2 = 2;
  const unsigned int index_3 = 3;
  const unsigned int index_4 = 4;
  double xc_m = sphere.p[index_0];
  double yc_m = sphere.p[index_1];
  double n20_m = sphere.p[index_2];
  double n11_m = sphere.p[index_3];
  double n02_m = sphere.p[index_4];
 
  // Convert from meter to pixels
  vpMeterPixelConversion::convertPoint(cam, xc_m, yc_m, center_p);
  n20_p = n20_m * vpMath::sqr(cam.get_px());
  n11_p = n11_m * cam.get_px() * cam.get_py();
  n02_p = n02_m * vpMath::sqr(cam.get_py());
}

void vpMeterPixelConversion::convertEllipse(const vpCameraParameters &cam, double xc_m, double yc_m, double n20_m,
                                            double n11_m, double n02_m, vpImagePoint &center_p, double &n20_p,
                                            double &n11_p, double &n02_p)
{
  // Convert from meter to pixels
  vpMeterPixelConversion::convertPoint(cam, xc_m, yc_m, center_p);
  n20_p = n20_m * vpMath::sqr(cam.get_px());
  n11_p = n11_m * cam.get_px() * cam.get_py();
  n02_p = n02_m * vpMath::sqr(cam.get_py());
}
 
#if defined(VISP_HAVE_OPENCV) && \
    (((VISP_HAVE_OPENCV_VERSION < 0x050000) && defined(HAVE_OPENCV_CALIB3D)) || \
    ((VISP_HAVE_OPENCV_VERSION >= 0x050000) && defined(HAVE_OPENCV_CALIB) && defined(HAVE_OPENCV_3D)))
void vpMeterPixelConversion::convertLine(const cv::Mat &cameraMatrix, const double &rho_m, const double &theta_m,
                                         double &rho_p, double &theta_p)
{
  double co = cos(theta_m);
  double si = sin(theta_m);
  double px = cameraMatrix.at<double>(0, 0);
  double py = cameraMatrix.at<double>(1, 1);
  double u0 = cameraMatrix.at<double>(0, 2);
  double v0 = cameraMatrix.at<double>(1, 2);
  double d = sqrt(vpMath::sqr(py * co) + vpMath::sqr(px * si));
 
  if (fabs(d) < 1e-6) {
    throw(vpException(vpException::divideByZeroError, "division by zero"));
  }
 
  theta_p = atan2(px * si, py * co);
  rho_p = (px * py * rho_m + u0 * py * co + v0 * px * si);
  rho_p /= d;
}

void vpMeterPixelConversion::convertEllipse(const cv::Mat &cameraMatrix, const vpCircle &circle, vpImagePoint &center,
                                            double &n20_p, double &n11_p, double &n02_p)
{
  const unsigned int index_0 = 0;
  const unsigned int index_1 = 1;
  const unsigned int index_2 = 2;
  const unsigned int index_3 = 3;
  const unsigned int index_4 = 4;
  const unsigned int index_5 = 5;
  double px = cameraMatrix.at<double>(index_0, index_0);
  double py = cameraMatrix.at<double>(index_1, index_1);
  cv::Mat distCoeffs = cv::Mat::zeros(index_5, index_1, CV_64FC1);
  // Get the parameters of the ellipse in the image plane
  double xc_m = circle.p[index_0];
  double yc_m = circle.p[index_1];
  double n20_m = circle.p[index_2];
  double n11_m = circle.p[index_3];
  double n02_m = circle.p[index_4];
 
  // Convert from meter to pixels
  vpMeterPixelConversion::convertPoint(cameraMatrix, distCoeffs, xc_m, yc_m, center);
  n20_p = n20_m * vpMath::sqr(px);
  n11_p = n11_m * px * py;
  n02_p = n02_m * vpMath::sqr(py);
}

void vpMeterPixelConversion::convertEllipse(const cv::Mat &cameraMatrix, const vpSphere &sphere, vpImagePoint &center,
                                            double &n20_p, double &n11_p, double &n02_p)
{
  const unsigned int index_0 = 0;
  const unsigned int index_1 = 1;
  const unsigned int index_2 = 2;
  const unsigned int index_3 = 3;
  const unsigned int index_4 = 4;
  const unsigned int index_5 = 5;
  double px = cameraMatrix.at<double>(index_0, index_0);
  double py = cameraMatrix.at<double>(index_1, index_1);
  cv::Mat distCoeffs = cv::Mat::zeros(index_5, index_1, CV_64FC1);
  // Get the parameters of the ellipse in the image plane
  double xc_m = sphere.p[index_0];
  double yc_m = sphere.p[index_1];
  double n20_m = sphere.p[index_2];
  double n11_m = sphere.p[index_3];
  double n02_m = sphere.p[index_4];
 
  // Convert from meter to pixels
  vpMeterPixelConversion::convertPoint(cameraMatrix, distCoeffs, xc_m, yc_m, center);
  n20_p = n20_m * vpMath::sqr(px);
  n11_p = n11_m * px * py;
  n02_p = n02_m * vpMath::sqr(py);
}

void vpMeterPixelConversion::convertEllipse(const cv::Mat &cameraMatrix, double xc_m, double yc_m, double n20_m,
                                            double n11_m, double n02_m, vpImagePoint &center_p, double &n20_p,
                                            double &n11_p, double &n02_p)
{
  double px = cameraMatrix.at<double>(0, 0);
  double py = cameraMatrix.at<double>(1, 1);
  cv::Mat distCoeffs = cv::Mat::zeros(5, 1, CV_64FC1);
 
  // Convert from meter to pixels
  vpMeterPixelConversion::convertPoint(cameraMatrix, distCoeffs, xc_m, yc_m, center_p);
  n20_p = n20_m * vpMath::sqr(px);
  n11_p = n11_m * px * py;
  n02_p = n02_m * vpMath::sqr(py);
}

void vpMeterPixelConversion::convertPoint(const cv::Mat &cameraMatrix, const cv::Mat &distCoeffs, const double &x,
                                          const double &y, double &u, double &v)
{
  std::vector<cv::Point3d> objectPoints_vec;
  objectPoints_vec.push_back(cv::Point3d(x, y, 1.0));
  std::vector<cv::Point2d> imagePoints_vec;
  cv::projectPoints(objectPoints_vec, cv::Mat::eye(3, 3, CV_64FC1), cv::Mat::zeros(3, 1, CV_64FC1), cameraMatrix,
                    distCoeffs, imagePoints_vec);
  u = imagePoints_vec[0].x;
  v = imagePoints_vec[0].y;
}

void vpMeterPixelConversion::convertPoint(const cv::Mat &cameraMatrix, const cv::Mat &distCoeffs, const double &x,
                                          const double &y, vpImagePoint &iP)
{
  std::vector<cv::Point3d> objectPoints_vec;
  objectPoints_vec.push_back(cv::Point3d(x, y, 1.0));
  std::vector<cv::Point2d> imagePoints_vec;
  cv::projectPoints(objectPoints_vec, cv::Mat::eye(3, 3, CV_64FC1), cv::Mat::zeros(3, 1, CV_64FC1), cameraMatrix,
                    distCoeffs, imagePoints_vec);
  iP.set_u(imagePoints_vec[0].x);
  iP.set_v(imagePoints_vec[0].y);
}
#endif
END_VISP_NAMESPACE