mapping.cpp

#include "mapping.h"
#include "unwrapping.h"
#include "meshhelper.h"
#include "omp.h"

//*****************************************************************************/
//* Mapping                                                                   */
//*****************************************************************************/
Mapping::Mapping(const base::Mesh &original_mesh, const base::Mesh &flat_mesh, const cv::Size2i &flat_surface_image_size) :
  flat_surface_image_size_(flat_surface_image_size),
  flat_mesh_bb_(flat_mesh.bBox()),
  elevation_limits_({INFINITY, -INFINITY}),
  flat_to_original_face_map_(std::map<const base::he::Face*, base::he::Face*>())
{
  const base::Mesh::Faces flat_faces = flat_mesh.faces();
  const base::Mesh::Faces original_faces = original_mesh.faces();
  const std::size_t num_flat_faces = flat_faces.size();
  for(std::size_t f_idx = 0; f_idx < num_flat_faces; f_idx++)
  {
    flat_to_original_face_map_.insert({
      flat_faces[f_idx],
      original_faces[uint(flat_faces[f_idx]->property(PROPERTY_LABEL_ORIGINAL_FACE_ID))]
    });
  }

  const base::Mesh::Vertices original_vertices = original_mesh.vertices();
  const std::size_t num_original_vertices = original_vertices.size();
  Axes ax1;
  Axes ax2;
  std::tie(ax1, ax2) = base::MeshHelper::getAxesPair(ROTATION_AXIS);
  omp_lock_t lock;
  omp_init_lock(&lock);
  #pragma omp parallel for
  for(std::size_t v_idx = 0; v_idx < num_original_vertices; v_idx++)
  {
    const cv::Vec3f &pos = original_vertices[v_idx]->pos();
    const float elevation = -atan2f(sqrtf(pos[ax1]*pos[ax1] + pos[ax2]*pos[ax2]), pos[ROTATION_AXIS]) + float(M_PI_2);
    omp_set_lock(&lock);
    if(elevation < elevation_limits_.first) elevation_limits_.first = elevation;
    if(elevation > elevation_limits_.second) elevation_limits_.second = elevation;
    omp_unset_lock(&lock);
  }
}

// -----------------------------------------------------------------------------
PolygonPoints Mapping::mapImagePolygonToFlattenedSurfaceSpace(const PolygonPoints &image_polygon_pts) const
{
  const float bb_width = flat_mesh_bb_.max().x - flat_mesh_bb_.min().x;
  const float bb_height = flat_mesh_bb_.max().y - flat_mesh_bb_.min().y;
  assert(bb_width > 0 && bb_height > 0);

  const std::size_t num_polygon_pts = image_polygon_pts.size();
  PolygonPoints mapped_polygon = PolygonPoints(num_polygon_pts);
  for(std::size_t pt_idx = 0; pt_idx < num_polygon_pts; pt_idx++)
  {
    mapped_polygon[pt_idx] = cv::Point2f(-(image_polygon_pts[pt_idx].x/flat_surface_image_size_.width*bb_width + flat_mesh_bb_.min().x),
                                         (1-image_polygon_pts[pt_idx].y/flat_surface_image_size_.height)*bb_height + flat_mesh_bb_.min().y);
  }
  return mapped_polygon;
}

// -----------------------------------------------------------------------------
std::set<base::he::Face*> Mapping::mapFlatSurfaceMeshToOriginal(const std::set<base::he::Face*> &flat_faces) const
{
  std::set<base::he::Face*> mapped_faces = {};
  for(std::set<base::he::Face*>::const_iterator flat_face_it = flat_faces.begin();
      flat_face_it != flat_faces.end();
      flat_face_it++)
  {
    mapped_faces.insert(flat_to_original_face_map_.at(*flat_face_it));
  }
  return mapped_faces;
}

// -----------------------------------------------------------------------------
cv::Vec2f Mapping::cartesianImagePosToSpherical(const cv::Point2f &image_pos) const
{
  const float delta_azimuth = 2*TWO_PIf;
  const float delta_elevation = elevation_limits_.second - elevation_limits_.first;
  assert(delta_azimuth > 0 & delta_elevation > 0);

  /// clip elevation to min/max elevation
  return {
    delta_azimuth*image_pos.x - float(M_PI) + float(M_PI_2), /// todo: why this offset?
    std::min(std::max(delta_elevation*image_pos.y + elevation_limits_.first, elevation_limits_.first), elevation_limits_.second)
  };
}