vpDisplayFactory.h

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2024 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:
 * Display Factory
 */
 
#ifndef VP_DISPLAY_FACTORY_H
#define VP_DISPLAY_FACTORY_H
 
#include <visp3/core/vpConfig.h>
#include <visp3/core/vpDisplay.h>
#include <visp3/gui/vpDisplayD3D.h>
#include <visp3/gui/vpDisplayGDI.h>
#include <visp3/gui/vpDisplayGTK.h>
#include <visp3/gui/vpDisplayOpenCV.h>
#include <visp3/gui/vpDisplayX.h>
 
#if (VISP_CXX_STANDARD >= VISP_CXX_STANDARD_11)
#include <memory>
#endif
 
BEGIN_VISP_NAMESPACE
namespace vpDisplayFactory
{
inline vpDisplay *allocateDisplay()
{
#if defined(VISP_HAVE_DISPLAY)
#ifdef VISP_HAVE_X11
  return new vpDisplayX();
#elif defined(VISP_HAVE_D3D9)
  return new vpDisplayD3D();
#elif defined(VISP_HAVE_GDI)
  return new vpDisplayGDI();
#elif defined(VISP_HAVE_GTK)
  return new vpDisplayGTK();
#elif defined(HAVE_OPENCV_HIGHGUI)
  return new vpDisplayOpenCV();
#endif
#else
  return nullptr;
#endif
}
 
template<typename T>
vpDisplay *allocateDisplay(vpImage<T> &I, const int winx = -1, const int winy = -1, const std::string &title = "",
                           const vpDisplay::vpScaleType &scaleType = vpDisplay::SCALE_DEFAULT)
{
#if defined(VISP_HAVE_DISPLAY)
#ifdef VISP_HAVE_X11
  return new vpDisplayX(I, winx, winy, title, scaleType);
#elif defined(VISP_HAVE_GDI)
  return new vpDisplayGDI(I, winx, winy, title, scaleType);
#elif defined(HAVE_OPENCV_HIGHGUI)
  return new vpDisplayOpenCV(I, winx, winy, title, scaleType);
#elif defined(VISP_HAVE_GTK)
  return new vpDisplayGTK(I, winx, winy, title, scaleType);
#elif defined(VISP_HAVE_D3D9)
  return new vpDisplayD3D(I, winx, winy, title, scaleType);
#endif
#else
  (void)I;
  (void)winx;
  (void)winy;
  (void)title;
  (void)scaleType;
  return nullptr;
#endif
}
 
#if (VISP_CXX_STANDARD >= VISP_CXX_STANDARD_11)
inline std::shared_ptr<vpDisplay> createDisplay()
{
#if defined(VISP_HAVE_DISPLAY)
#ifdef VISP_HAVE_X11
  return std::make_shared<vpDisplayX>();
#elif defined(VISP_HAVE_GDI)
  return std::make_shared<vpDisplayGDI>();
#elif defined(HAVE_OPENCV_HIGHGUI)
  return std::make_shared<vpDisplayOpenCV>();
#elif defined(VISP_HAVE_GTK)
  return std::make_shared<vpDisplayGTK>();
#elif defined(VISP_HAVE_D3D9)
  return std::make_shared<vpDisplayD3D>();
#endif
#else
  return std::shared_ptr<vpDisplay>(nullptr);
#endif
}
 
template<typename T>
std::shared_ptr<vpDisplay> createDisplay(vpImage<T> &I, const int winx = -1, const int winy = -1,
                                         const std::string &title = "",
                                         const vpDisplay::vpScaleType &scaleType = vpDisplay::SCALE_DEFAULT)
{
#if defined(VISP_HAVE_DISPLAY)
#ifdef VISP_HAVE_X11
  return std::make_shared<vpDisplayX>(I, winx, winy, title, scaleType);
#elif defined(VISP_HAVE_GDI)
  return std::make_shared<vpDisplayGDI>(I, winx, winy, title, scaleType);
#elif defined(HAVE_OPENCV_HIGHGUI)
  return std::make_shared<vpDisplayOpenCV>(I, winx, winy, title, scaleType);
#elif defined(VISP_HAVE_GTK)
  return std::make_shared<vpDisplayGTK>(I, winx, winy, title, scaleType);
#elif defined(VISP_HAVE_D3D9)
  return std::make_shared<vpDisplayD3D>(I, winx, winy, title, scaleType);
#endif
#else
  (void)I;
  (void)winx;
  (void)winy;
  (void)title;
  (void)scaleType;
  return nullptr;
  return std::shared_ptr<vpDisplay>(nullptr);
#endif
}
 
namespace impl
{
struct GridSettings
{
  unsigned int rows;
  unsigned int cols;
  unsigned int startY;
  unsigned int startX;
  unsigned int paddingX;
  unsigned int paddingY;
};
 
inline void makeDisplayGridHelper(std::vector<std::shared_ptr<vpDisplay>> &res, const GridSettings &settings,
                                  unsigned int currRow, unsigned int currCol,
                                  unsigned int currentPixelX, unsigned int currentPixelY,
                                  unsigned int maxRowHeightPixel)
{
  if (currRow != (settings.rows - 1)  && (currCol != settings.cols - 1)) {
    throw vpException(vpException::dimensionError, "Too few images for the grid size");
  }
  (void)res;
  (void)settings;
  (void)currRow;
  (void)currCol;
  (void)currentPixelX;
  (void)currentPixelY;
  (void)maxRowHeightPixel;
}
 
template <typename T, typename... Args>
void makeDisplayGridHelper(std::vector<std::shared_ptr<vpDisplay>> &res, const GridSettings &settings,
                           unsigned int currRow, unsigned int currCol,
                           unsigned int currentPixelX, unsigned int currentPixelY,
                           const unsigned int maxRowHeightPixel,
                           const std::string &name, vpImage<T> &I, Args&... args)
{
  if (currRow >= settings.rows) {
    throw vpException(vpException::dimensionError, "Too many images for the grid size");
  }
  if (currCol == settings.cols) {
    makeDisplayGridHelper(res, settings, currRow + 1, 0, settings.startX,
                          currentPixelY + maxRowHeightPixel  + settings.paddingY, 0, name, I, args...);
  }
  else {
    std::shared_ptr<vpDisplay> display = vpDisplayFactory::createDisplay(I, currentPixelX, currentPixelY, name);
    vpDisplay::display(I);
    vpDisplay::flush(I);
    res.push_back(display);
    makeDisplayGridHelper(res, settings, currRow, currCol + 1, currentPixelX + I.getWidth() + settings.paddingX,
                          currentPixelY, std::max(maxRowHeightPixel, I.getHeight()), args...);
  }
}
}
 
template <typename... Args>
std::vector<std::shared_ptr<vpDisplay>> makeDisplayGrid(unsigned int rows, unsigned int cols,
                                                        unsigned int startX, unsigned int startY,
                                                        unsigned int paddingX, unsigned int paddingY,
                                                        Args&... args)
{
  std::vector<std::shared_ptr<vpDisplay>> res;
  impl::GridSettings settings;
  settings.rows = rows;
  settings.cols = cols;
  settings.paddingX = paddingX;
  settings.paddingY = paddingY;
  settings.startX = startX;
  settings.startY = startY;
  makeDisplayGridHelper(res, settings, 0, 0, settings.startX, settings.startY, 0, args...);
  return res;
}
#endif
}
 
END_VISP_NAMESPACE
#endif