color_mesh.h

Go to the documentation of this file.

// Copyright (c) 2012-2019 University of Lyon and CNRS (France).
// All rights reserved.
//
// This file is part of MEPP2; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 3 of
// the License, or (at your option) any later version.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
#pragma once
 
#include <CGAL/boost/graph/properties.h>
#include <boost/foreach.hpp>
#include <limits>
#include <stdexcept> // for std::invalid_argument
#include <cmath>     // for std::fmod
#include <vector>
 
namespace FEVV {
namespace Filters {
 
// Numeric maps
 
typedef  std::vector< float >   ColorMeshLUT;
 
inline
ColorMeshLUT
make_LUT(bool color_in_0_255 = true,
         unsigned int colors_nbr = 256,
         float h1 = 240,
         float h2 = 0)
{
  // check parameters
  if(h1 == h2)
    throw std::invalid_argument("make_LUT: h1 and h2 must be different.");
  if(colors_nbr == 0)
    throw std::invalid_argument("make_LUT: colors_nbr must not be zero.");
 
  // create LUT
  ColorMeshLUT rgb_LUT(3*colors_nbr);
 
  // initializations
  float max_color_value = 1;
  if(color_in_0_255)
    max_color_value = 255;
  float step = (h2 - h1)/colors_nbr;
  float H = h1;
  const float S = 1;
  const float V = 1;
 
  // helper lambda function to convert HSV to RGB
  // see https://en.wikipedia.org/wiki/HSL_and_HSV#HSV_to_RGB
  // section "HSV to RGB alternative"
  auto f = [](float h, float s, float v, int n) -> float
  {
    float k = std::fmod(n + h/60.0f, 6.0f);
    return v - v*s*std::max(std::min({k, 4-k, 1.0f}), 0.0f);
  };
 
  // populate LUT
  for(unsigned int i = 0; i < colors_nbr; i++)
  {
 
    rgb_LUT[3 * i]     = max_color_value * f(H, S, V, 5); // R
    rgb_LUT[3 * i + 1] = max_color_value * f(H, S, V, 3); // G
    rgb_LUT[3 * i + 2] = max_color_value * f(H, S, V, 1); // B
 
    H += step;
  }
 
  return rgb_LUT;
}
 
 
template< typename Descriptor,
          typename PropertyMap,
          typename ColorMap,
          typename MapType = typename PropertyMap::value_type >
void
color_descriptor_from_map(const Descriptor &d,
                          const PropertyMap &prop_map,
                          ColorMap &color_pmap,
                          const MapType min_metric,
                          const MapType max_metric,
                          const ColorMeshLUT &colors)
{
  typedef typename boost::property_traits< ColorMap >::value_type  Color;
  // this is a work-around to retrieve the color component type (aka float
  // with meshes and uchar with point clouds)
  Color dummy;
  typedef  typename std::remove_reference< decltype(dummy[0]) >::type
                                                                ColorComponent;
  // note: std::remove_reference< > is needed because dummy[0] is a reference
  //       with some datastructure (PCL).
  // TODO-elo: fix this work-around by something like
  //             typedef  color_traits< Color >::component_type  ColorComponent
  //           when a 'Color traits' is implemented
 
  size_t number_of_colors = colors.size() / 3;
 
  if(min_metric != max_metric)
  {
    // retrieve value from property map
    MapType val_metric = get(prop_map, d);
 
    // ensure value is between min and max to avoid LUT overflow
    val_metric = std::min(val_metric, max_metric);
    val_metric = std::max(val_metric, min_metric);
 
    // convert value to LUT id
    MapType id = (val_metric - min_metric) / (max_metric - min_metric);
    int indice_lut = static_cast< int >(std::floor((number_of_colors - 1) * id));
 
    // convert value to color
    Color newcolor(static_cast< ColorComponent >(colors[3 * indice_lut]),
                   static_cast< ColorComponent >(colors[3 * indice_lut + 1]),
                   static_cast< ColorComponent >(colors[3 * indice_lut + 2]));
    put(color_pmap, d, newcolor);
  }
  else
  {
    // use first color of the color map for all values
    put(color_pmap, d, Color(static_cast< ColorComponent >(colors[0]),
                             static_cast< ColorComponent >(colors[1]),
                             static_cast< ColorComponent >(colors[2])));
  }
}
 
 
template< typename HalfedgeGraph,
          typename PropertyMap,
          typename ColorMap,
          typename MapType = typename PropertyMap::value_type >
void
color_faces_from_map(const HalfedgeGraph &g,
                     const PropertyMap &prop_map,
                     ColorMap &color_pmap,
                     const MapType min_metric,
                     const MapType max_metric,
                     const ColorMeshLUT &colors = make_LUT())
{
  typedef typename boost::graph_traits< HalfedgeGraph >::face_descriptor
      Face_Descriptor;
 
  BOOST_FOREACH(Face_Descriptor f, faces(g))
  {
    color_descriptor_from_map(f,
                              prop_map,
                              color_pmap,
                              min_metric,
                              max_metric,
                              colors);
  }
}
 
 
template< typename HalfedgeGraph,
          typename PropertyMap,
          typename ColorMap,
          typename MapType = typename PropertyMap::value_type >
void
color_vertices_from_map(const HalfedgeGraph &g,
                        const PropertyMap &prop_map,
                        ColorMap &color_pmap,
                        const MapType min_metric,
                        const MapType max_metric,
                        const ColorMeshLUT &colors = make_LUT())
{
  typedef typename boost::graph_traits< HalfedgeGraph >::vertex_descriptor
      Vertex_Descriptor;
 
  BOOST_FOREACH(Vertex_Descriptor v, vertices(g))
  {
    color_descriptor_from_map(v,
                              prop_map,
                              color_pmap,
                              min_metric,
                              max_metric,
                              colors);
  }
}
 
 
template< typename HalfedgeGraph,
          typename PropertyMap,
          typename ColorMap,
          typename MapType = typename PropertyMap::value_type >
void
color_halfedges_from_map(const HalfedgeGraph &g,
                         const PropertyMap &prop_map,
                         ColorMap &color_pmap,
                         const MapType min_metric,
                         const MapType max_metric,
                         const ColorMeshLUT &colors = make_LUT())
{
  typedef typename boost::graph_traits< HalfedgeGraph >::halfedge_descriptor
      Halfedge_Descriptor;
 
  BOOST_FOREACH(Halfedge_Descriptor h, halfedges(g))
  {
    color_descriptor_from_map(h,
                              prop_map,
                              color_pmap,
                              min_metric,
                              max_metric,
                              colors);
  }
}
 
// Boolean map
 
template<
    typename Descriptor,
    typename BooleanMap,
    typename ColorMap,
    typename Color = typename boost::property_traits< ColorMap >::value_type >
void
color_descriptor_from_bool(const Descriptor &d,
                           const BooleanMap &prop_map,
                           ColorMap &color_pmap,
                           const Color &color1,
                           const Color &color2)
{
  if(get(prop_map, d))
  {
    put(color_pmap, d, color1);
  }
  else
  {
    put(color_pmap, d, color2);
  }
}
 
 
template<
    typename HalfedgeGraph,
    typename BooleanMap,
    typename ColorMap,
    typename Color = typename boost::property_traits< ColorMap >::value_type >
void
color_faces_from_bool_map(const HalfedgeGraph &g,
                          const BooleanMap &prop_map,
                          ColorMap &color_pmap,
                          const Color &color1,
                          const Color &color2)
{
  typedef typename boost::graph_traits< HalfedgeGraph >::face_descriptor
      Face_Descriptor;
 
  BOOST_FOREACH(Face_Descriptor f, faces(g))
  {
    color_descriptor_from_bool(f, prop_map, color_pmap, color1, color2);
  }
}
 
template<
    typename HalfedgeGraph,
    typename BooleanMap,
    typename ColorMap,
    typename Color = typename boost::property_traits< ColorMap >::value_type >
void
color_vertices_from_bool_map(const HalfedgeGraph &g,
                             const BooleanMap &prop_map,
                             ColorMap &color_pmap,
                             const Color &color1,
                             const Color &color2)
{
  typedef typename boost::graph_traits< HalfedgeGraph >::vertex_descriptor
      Vertex_Descriptor;
 
  BOOST_FOREACH(Vertex_Descriptor v, vertices(g))
  {
    color_descriptor_from_bool(v, prop_map, color_pmap, color1, color2);
  }
}
 
template<
    typename HalfedgeGraph,
    typename BooleanMap,
    typename ColorMap,
    typename Color = typename boost::property_traits< ColorMap >::value_type >
void
color_halfedge_from_bool_map(const HalfedgeGraph &g,
                             const BooleanMap &prop_map,
                             ColorMap &color_pmap,
                             const Color &color1,
                             const Color &color2)
{
  typedef typename boost::graph_traits< HalfedgeGraph >::halfedge_descriptor
      Halfedge_Descriptor;
 
  BOOST_FOREACH(Halfedge_Descriptor h, halfedges(g))
  {
    color_descriptor_from_bool(h, prop_map, color_pmap, color1, color2);
  }
}
} // namespace Filters
} // namespace FEVV