Compression_Valence_Component.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 "arithmetic_codec.hpp"
 
#include <boost/graph/graph_traits.hpp>
#include "FEVV/Wrappings/Geometry_traits.h"
#include "FEVV/Wrappings/properties.h"
 
#include <queue>
#include <list>
 
// struct of integer coordinates
 
 
struct Point_Int
{
 
  int x; 
  int y; 
  int z; 
 
 
  Point_Int() { x = y = z = 0; }
 
 
  const Point_Int operator+(const Point_Int &Pt) const
  {
    Point_Int Res;
    Res.x = x + Pt.x;
    Res.y = y + Pt.y;
    Res.z = z + Pt.z;
 
    return Res;
  }
 
 
  const Point_Int operator-(const Point_Int &Pt) const
  {
    Point_Int Res;
    Res.x = x - Pt.x;
    Res.y = y - Pt.y;
    Res.z = z - Pt.z;
 
    return Res;
  }
 
 
  bool operator==(const Point_Int &Pt) const
  {
    return (x == Pt.x && y == Pt.y && z == Pt.z);
  }
 
 
  bool operator!=(const Point_Int &Pt) const { return !(*this == Pt); }
};
 
 
 
struct Color_Unit
{
  int c0;
  int c1;
  int c2;
 
  Color_Unit() { c0 = c1 = c2 = 0; }
 
  // ELO+ begin
  // constructor to easily store data in property maps
  Color_Unit(int _c0, int _c1, int _c2)
  {
    c0 = _c0;
    c1 = _c1;
    c2 = _c2;
  }
  // ELO+ end
 
 
 
  const Color_Unit operator+(const Color_Unit &m_color) const
  {
    Color_Unit Res;
    Res.c0 = c0 + m_color.c0;
    Res.c1 = c1 + m_color.c1;
    Res.c2 = c2 + m_color.c2;
 
    return Res;
  }
 
 
  const Color_Unit operator-(const Color_Unit &m_color) const
  {
    Color_Unit Res;
    Res.c0 = c0 - m_color.c0;
    Res.c1 = c1 - m_color.c1;
    Res.c2 = c2 - m_color.c2;
 
    return Res;
  }
 
 
  bool operator==(const Color_Unit &m_color) const
  {
    return (c0 == m_color.c0 && c1 == m_color.c1 && c2 == m_color.c2);
  }
 
 
  bool operator!=(const Color_Unit &m_color) const
  {
    return !(*this == m_color);
  }
};
 
 
template< typename HalfedgeGraph, typename PointMap, typename VertexColorMap >
class Compression_Valence_Component
{
public:
  typedef boost::graph_traits< HalfedgeGraph > GraphTraits;
  typedef typename GraphTraits::vertex_descriptor vertex_descriptor;
  typedef typename GraphTraits::vertex_iterator vertex_iterator;
  typedef typename GraphTraits::face_descriptor face_descriptor;
  typedef typename GraphTraits::face_iterator face_iterator;
  typedef typename GraphTraits::halfedge_descriptor halfedge_descriptor;
  typedef typename GraphTraits::halfedge_iterator halfedge_iterator;
  typedef typename FEVV::Geometry_traits< HalfedgeGraph >::Vector Vector;
  typedef typename FEVV::Geometry_traits< HalfedgeGraph >::Point Point3d;
 
 
 
  Compression_Valence_Component(void)
  {
    IsOneColor = false;
    Decompress_count = 0;
 
    Smallest_Alpha = 5000;
    Smallest_Gamma = 5000;
 
    Smallest_C0 = 5000;
    Smallest_C1 = 5000;
    Smallest_C2 = 5000;
 
    /*ColorDiffMinC0 = 5000;
    ColorDiffMinC1 = 5000;
    ColorDiffMinC2 = 5000;*/
 
    IsColored = false;
    GlobalCountOperation = 0;
 
    // from IHM
    IsCompressed = false;
    IsDecompress = false;
    // Afficher = false;
 
    Possible_change_sequence = true;
    // ELO  sequence mode is enabled by default on Mepp1
    // ELO  but disabled by default on Mepp2 because mesh
    // ELO  sequence is not yet supported
    Sequence = false; // ELO- Sequence = true;
    Visu_level = 0;
    Process_level = 0;
    // Writing_level = -1;
 
    N_Inserted_Watermarks = 0;
 
    m_VC[0] = 0.;
    m_VC[1] = 0.;
    m_VC[2] = 0.;
    m_Dist = 0.0005;
 
    Number_non_reversible_vertices = 0;
  }
 
  ~Compression_Valence_Component() {}
 
 
  // Main Function
 
  std::string Main_Function(HalfedgeGraph &pMesh,
                            PointMap *_pm,
                            VertexColorMap *_v_cm,
                            const std::string &Input_File_Name,
                            const std::string &File_Name,
                            const int &Qbit,
                            const int &NVertices,
                            const bool Is_normal_flipping_selected,
                            const bool Is_use_metric_selected,
                            const float &Metric_thread,
                            const bool Is_use_forget_metric_selected,
                            const int &Forget_value,
                            const bool Is_compression_selected,
                            const bool Is_adaptive_quantization_selected,
                            const bool Is_bijection_selected);
 
  // Initialization
 
  void Global_Initialization(HalfedgeGraph &pMesh,
                             const int &Quantization_bit,
                             const char *File_name,
                             const PointMap *pm,
                             VertexColorMap *v_cm);
 
  void Quantization(HalfedgeGraph &pMesh, const PointMap *pm);
 
  void Color_Initialization(HalfedgeGraph &pMesh, VertexColorMap *v_cm);
 
  void Multiple_Components_Initialization(HalfedgeGraph &pMesh,
                                          const PointMap *pm,
                                          const int &Quantization_bit);
 
  void Init(HalfedgeGraph &mesh);
 
#if 0 // TODO-elo-restore-if-needed
 
    void Color_Quantization(HalfedgeGraph &pMesh);
#endif
 
  void Simplification(HalfedgeGraph &pMesh,
                      const PointMap *_pm,
                      const int &NVertices,
                      const bool Is_normal_flipping_selected,
                      const bool Is_use_metric_selected,
                      const float &Metric_thread,
                      const bool Is_use_forget_metric_selected,
                      const int &Forget_value);
 
  int Decimation_Conquest(HalfedgeGraph &pMesh,
                          const PointMap *_pm,
                          const bool Is_normal_flipping_selected,
                          const bool Is_use_metric_selected,
                          const float &Metric_thread,
                          const bool Is_use_forget_metric_selected,
                          const int &Forget_value,
                          const int &Component_ID);
 
  int Regulation(HalfedgeGraph &_pMesh,
                 const bool Normal_flipping,
                 const bool Use_metric,
                 const float &Metric_thread,
                 const bool Use_forget_metric,
                 const int &Forget_value,
                 const int &Component_ID,
                 const PointMap *_pm);
 
 
  // Adaptive Quantization
 
  void Adaptive_Quantization(HalfedgeGraph &pMesh,
                             PointMap *_pm,
                             VertexColorMap *_v_cm,
                             const int &NVertices,
                             const bool Is_normal_flipping_selected,
                             const bool Is_use_metric_selected,
                             const float &Metric_thread,
                             const bool Is_use_forget_metric_selected,
                             const int &Forget_value,
                             const int &Qbit);
 
 
  void Augment_Geometry_Quantization_Precision(HalfedgeGraph &pMesh,
                                               Arithmetic_Codec &Decoder,
                                               const int &Component_ID,
                                               PointMap *_pm);
 
  void Diminush_Geometry_Quantization_Precision(HalfedgeGraph &pMesh,
                                                const int &Component_ID,
                                                PointMap *_pm);
 
  void Calculate_Edge_Color_Difference(HalfedgeGraph &pMesh,
                                       const int &Component_ID,
                                       double &Max_color,
                                       double &Mean_color,
                                       int &Number_of_vertices);
 
  void Diminush_Color_Quantization_Precision(HalfedgeGraph &pMesh,
                                             const int Component_ID,
                                             VertexColorMap *_v_cm);
 
  void Augment_Color_Quantization_Precision(HalfedgeGraph &_pMesh,
                                            Arithmetic_Codec &Decoder,
                                            const int &Component_ID,
                                            VertexColorMap *_v_cm);
 
  // Compression
 
  void Compression(HalfedgeGraph &pMesh,
                   const char *File_Name,
                   const int &Qbit,
                   unsigned &Connectivity_size,
                   unsigned &Color_size,
                   unsigned &Total_size,
                   const PointMap *_pm);
 
#if 0 // TODO-elo-restore-if-needed
 
    int  Calculate_Connectivity_Rate(void);
#endif
 
  void Calculate_Geometry_Color_Offset_Range(void);
 
  void Remove_Last_Phase_Elements(const int &Component_ID);
 
  void Write_Base_Mesh(const HalfedgeGraph &pMesh,
                       Arithmetic_Codec &Enc,
                       unsigned &Connectivity_size,
                       unsigned &Color_size,
                       const int &Num_color_base_mesh,
                       const PointMap *_pm);
 
 
  // Decompression
 
  void Decompress_Init(HalfedgeGraph &pMesh,
                       PointMap *_pm,
                       VertexColorMap *_v_cm,
                       bool &has_color,
                       const std::string &Input_File_Name);
 
#if 0 // TODO-elo-restore-if-needed
 
    void Decompression_From_File(HalfedgeGraph &pMesh);
#endif
 
  void Write_Info(HalfedgeGraph &pMesh);
 
#if 0 // TODO-elo-restore-if-needed
 
    void Decompression_From_Sequence(HalfedgeGraph &pMesh, HalfedgeGraph &New_mesh);
 
 
    void Decompression_Coarser_From_File(HalfedgeGraph &pMesh);
#endif
 
  void write_intermediate_mesh(/*const*/ HalfedgeGraph &_pMesh,
                               const VertexColorMap *_v_cm);
 
  static void copy_mesh(const HalfedgeGraph &_pMesh,
                        const VertexColorMap *_v_cm,
                        HalfedgeGraph &mesh_copy,
                        VertexColorMap *v_cm_copy /* nullptr allowed */);
 
  void keep_intermediate_mesh(
      const HalfedgeGraph &_pMesh,
      const VertexColorMap *_v_cm,
      std::vector< HalfedgeGraph * > *intermediate_meshes,
      std::vector< VertexColorMap * >
          *intermediate_vertexColorMaps /* nullptr allowed */);
 
 
  std::string Decompression_All_From_File(
      HalfedgeGraph &_pMesh,
      PointMap *_pm,
      VertexColorMap *_v_cm,
      bool do_write_info,
      std::vector< HalfedgeGraph * > *intermediate_meshes /* nullptr allowed */,
      std::vector< VertexColorMap * >
          *intermediate_vertexColorMaps /* nullptr allowed */,
      int stop_level = -1 /* decompression level to stop at */,
      bool do_write_intermediate_meshes = false);
 
 
#if 0 // TODO-elo-restore-if-needed
 
    void Decompression_Specific_Level_From_File(HalfedgeGraph &pMesh, const int & WL);
 
    void JCW_Decompression_From_File(HalfedgeGraph &pMesh);
 
 
    void JCW_Decompression_Without_Extraction_From_File(HalfedgeGraph &pMesh);
 
 
    void JCW_Decompression_From_Sequence(HalfedgeGraph &pMesh, HalfedgeGraph &New_mesh);
 
 
    void JCW_Decompression_Without_Extraction_From_Sequence(HalfedgeGraph &pMesh, HalfedgeGraph &New_mesh);
 
    QString Show_Text(void);
#endif
 
 
  int Decompress_Each_Step(HalfedgeGraph &_pMesh,
                           PointMap *_pm,
                           VertexColorMap *_v_cm);
 
  void Un_Decimation_Conquest(HalfedgeGraph &pMesh,
                              Arithmetic_Codec &Decoder,
                              const int &Component_ID,
                              PointMap *_pm,
                              VertexColorMap *_v_cm);
 
  void Un_Regulation(HalfedgeGraph &_pMesh,
                     Arithmetic_Codec &Decoder,
                     const int &Component_ID,
                     PointMap *_pm,
                     VertexColorMap *_v_cm);
 
#if 0 // TODO-elo-restore-if-needed
      // Other functions
      // void   Separate_Components(HalfedgeGraph &pMesh);
 
    double Calculate_Area(HalfedgeGraph & pMesh);
#endif
 
  bool Error_Projected_Surface(const HalfedgeGraph &_pMesh,
                               const PointMap *_pm,
                               const halfedge_descriptor &_h,
                               const int &_Component_ID,
                               const double &Mean_color,
                               const double &Mean_area);
 
  void Recalculate_Component_Area(HalfedgeGraph &pMesh,
                                  const PointMap *_pm,
                                  const int &Component_ID,
                                  int &Number_facets);
 
 
  inline Point_Int Change_Real_Int(const Point3d &pt, const int &Component_ID);
 
  inline Point3d Change_Int_Real(const Point_Int &pt, const int &Component_ID);
 
 
#if 0 // TODO-elo-restore-if-needed
 
    void Attibute_Seed_Gate_Flag(HalfedgeGraph &Original_mesh, HalfedgeGraph &New_mesh);
#endif
 
  unsigned Calculate_Current_File_Size(void)
  {
    // To measure exact quantity of bits used for decompression.
    unsigned Adjust_value;
    if(this->IsColored)
      Adjust_value = 25 + 9 * 4;
    else
      Adjust_value = 25;
 
    return this->Decoder.calculate_current_decoded_size() + Adjust_value;
  }
 
#if 0 // TODO-elo-restore-if-needed
 
    int GetResolutionChange(HalfedgeGraph *pMesh, float Prec);
 
    void Stop_Decoder(void) {this->Decoder.stop_decoder(); }
 
    // Joint Compression Watermarking (JCW) //
 
    QString Joint_Compression_Watermarking(HalfedgeGraph &pMesh,
                        const char * Input_File_Name,
                        const char * Output_File_Name,
                        const int & Number_bins,
                        const int & Number_regions,
                        const int & Embedding_strength,
                        const char * Embedding_message,
                        const bool Is_complete_reversibility_selected,
                        const bool Is_divide_regions_selected,
                        const int & Thres_divide_regions,
                        const int &Qbit,
                        const int  & NVertices,
                        const bool Normal_flipping,
                        const bool Use_metric,
                        const float & Metric_thread,
                        const bool Use_forget_metric,
                        const int &Forget_value);
 
 
    int JCW_Decimation_For_Segmentation(HalfedgeGraph &pMesh,const bool Normal_flipping,const bool Use_metric,const float &Metric_thread, const bool Use_forget_metric,const int &Forget_value, const int & Component_ID);
 
    int JCW_Regulation_For_Segmentation(HalfedgeGraph &pMesh,const bool Normal_flipping,const bool Use_metric,const float &Metric_thread, const bool Use_forget_metric,const int &Forget_value, const int & Component_ID);
 
        void JCW_Un_Regulation_For_Insertion(HalfedgeGraph &pMesh, const int & Component_ID, list<int> & FP_Connectivity, list<Point3d> & SP_Moved_Position, list<Point3d> & SP_Original_Position, list<Point_Int> & SP_Watermarked_Position, list<vector<int> > & JCW_ERROR);
 
    void JCW_Un_Decimation_For_Insertion(HalfedgeGraph &pMesh, const int & Component_ID, list<int> & FP_Connectivity, list<Point3d> & SP_Moved_Position, list<Point3d> & SP_Original_Position, list<Point_Int> & SP_Watermarked_Position, list<vector<int> > & JCW_ERROR);
 
    Point3d JCW_Barycenter_Patch_Before_Removal(const Halfedge_handle & h, const int & Direction);
 
    Point3d JCW_Barycenter_Patch_After_Removal(const Halfedge_handle & h, const int & valence, const int & Direction);
 
    Point3d JCW_Barycenter_Patch_Before_Removal(const Halfedge_handle & h, const int & valence, const int & Direction);
 
    void JCW_Un_Decimation_Conquest(HalfedgeGraph &pMesh,Arithmetic_Codec & Decoder, const int & Component_ID);
 
    void JCW_Un_Regulation(HalfedgeGraph &pMesh, Arithmetic_Codec & Decoder, const int & Component_ID);
 
    void JCW_Un_Regulation_For_Region_Detection(HalfedgeGraph & pMesh, const int & Component_ID, list<int> & FP_connect, list<Point3d> & FP_Geo, list<int> & FP_RN);
 
    void JCW_Un_Decimation_For_Region_Detection(HalfedgeGraph & pMesh, const int & Component_ID, list<int> & FP_connect, list<Point3d> & FP_Geo, list<int> & FP_RN);
 
    vector<double> JCW_Evaluate_Robustness(void);
 
    void Set_Number_Bin(const int & NB)
    {
      this->m_NumberBin = NB;
    }
 
    int Get_Number_Bin(void)
    {
      return this->m_NumberBin;
    }
 
    void Set_Embedding_Level(const int &EL)
    {
      this->m_EmbeddingStrength = EL;
    }
 
    int Get_Embedding_Level(void)
    {
      return this->m_EmbeddingStrength;
    }
 
    void Set_Number_Region(const int &NR)
    {
      this->m_NumberRegion = NR;
    }
 
    int Get_Number_Region(void)
    {
      return this->m_NumberRegion;
    }
 
    void JCW_Calculate_Mesh_Center(HalfedgeGraph &pMesh);
 
    void JCW_Calculate_Radius(HalfedgeGraph &pMesh);
 
    void JCW_Expand_Mesh(HalfedgeGraph &pMesh);
 
    void JCW_Quantization(HalfedgeGraph &pMesh);
 
    void JCW_Generate_Regions_On_Base_Mesh(HalfedgeGraph &pMesh);
 
        void JCW_Region_Mass_Center_Insert_Watermark(HalfedgeGraph & pMesh, list<Point3d> & FP_Geometry, list<int> & FP_Region_Number, list<Point_Int> & SP_Watermarked_Position, list<Point3d> & SP_Moved_Position, list<Point3d> & SP_Original_Position, list<vector<int> > & JCW_ERROR);
 
 
    void JCW_Region_Mass_Center_Extract_Watermark(HalfedgeGraph & pMesh);
 
    void JCW_Code_Difference_Histogram_Shifting(HalfedgeGraph &pMesh,const int & Component_ID);
 
    void JCW_Decode_Difference_Histogram_Shifting(HalfedgeGraph &pMesh, const int & Component_ID);
 
    void Initialize_Spherical_Coordinates(HalfedgeGraph &pMesh);
 
    void Convert_To_Spherical(const Point3d & Pt, double * Spheric);
 
    void Convert_To_Cartesian(const double * Spheric, double * Cartesian);
 
    int  JCW_Decompress_One_Level(HalfedgeGraph &pMesh, const char* File_Name, const int & Noise_mode);
 
    int  JCW_Decompress_One_Level_Without_Extraction(HalfedgeGraph &pMesh, const char* File_Name);
 
 
    int  JCW_Divide_Big_Regions(HalfedgeGraph &pMesh, const int & Thres_divide_regions);
 
    void JCW_Colorify_Regions(HalfedgeGraph & pMesh);
 
    void    Read_Information_To_Hide(const char * Embedding_message);
 
    QString Write_Information_To_Hide();
 
    void Clear_After_Compression();
#endif
 
private:
  std::vector< bool >
      IsClosed; 
 
  bool IsColored;  
  bool IsOneColor; 
 
  float OnlyColor[3]; 
  // Number of connectivity symbol types. Without boundary = 5, with boundary =
  // 7;
  // int NummberConnectivitySymbols;
 
  // To encode each type of operation between decimation and increase of
  // quantization resolution
  std::vector< std::list< int > > ListOperation; 
  std::vector< std::list< int > >
      Connectivity; 
  std::vector< std::list< Point_Int > >
      Geometry; 
  std::vector< std::list< int > >
      NumberSymbol; 
  std::vector< std::list< int > >
      NumberVertices; 
 
  std::list< Point_Int >
      InterGeometry; 
  std::list< int >
      InterConnectivity; 
 
  std::vector< std::list< int > >
      AlphaRange; 
  std::vector< std::list< int > > AlphaOffset; 
  std::vector< std::list< int > >
      GammaRange; 
  std::vector< std::list< int > > GammaOffset; 
 
 
  // Quantization
  std::vector< unsigned > Qbit;           
  std::vector< float > xmin;              
  std::vector< float > ymin;              
  std::vector< float > zmin;              
  std::vector< float > xmax;              
  std::vector< float > ymax;              
  std::vector< float > zmax;              
  std::vector< float > Quantization_Step; 
 
  int Smallest_Alpha; 
  int Smallest_Gamma; 
 
  std::vector< double > HighestLengthBB; 
  std::vector< double > ComponentVolume; 
  std::vector< double > ComponentArea;   
  std::vector< int >
      ComponentNumberVertices; 
 
  // Used for adatative quantization.
  std::vector< std::list< int > >
      QuantizationCorrectVector; 
  std::vector< std::list< int > >
      NumberQuantizationLayer; 
 
  // for color
  std::vector< std::list< int > >
      NumberProcessedVertices; 
  std::vector< std::list< int > >
      ColorChildcellIndex; 
  std::vector< std::list< int > >
      ColorEncoderIndex; 
 
  // Colors
  std::vector< std::list< Color_Unit > >
      VertexColor; 
  std::list< Color_Unit >
      InterVertexColor; 
 
  float C0_Min; 
  float C1_Min; 
  float C2_Min; 
 
  float Color_Quantization_Step;              
  std::vector< int > NumberColorQuantization; 
 
  int Smallest_C0; 
  int Smallest_C1; 
  int Smallest_C2; 
 
  int C0_Range; 
  int C1_Range; 
  int C2_Range; 
 
  /*int ColorDiffMinC0;///< The color difference minimum c0 for restoration of
  colors in Mapping table int ColorDiffMinC1;///< The first color difference
  minimum c1 for restoration of colors in Mapping table int ColorDiffMinC2;///<
  The second color difference minimum c2 for restoration of colors in Mapping
  table
 
  int ColorDiffRangeC0;///< The color difference range c 0 for restoration of
  colors in Mapping table int ColorDiffRangeC1;///< The first color difference
  range c1 for restoration of colors in Mapping table
  int ColorDiffRangeC2;///< The second color difference range c2 for restoration
  of colors in Mapping table*/
 
  // vector<Color_Unit> ColorArray; ///< Color table
  // vector<Color_Unit> PredictedColorArray; ///< Predicted values of colors in
  // color table using prediction based on neighbors. vector<Color_Unit>
  // DifferenceColor; ///< Difference between original and quantized vertex
  // color. need to turn into lossless coding.
  //
  // list<int>       ColorIndex;///< List of color index
  // vector<int>       ReorderingColorIndex;///< Vector of reordering color
  // index list<int>       InterColorIndex;   ///< Vector of
  // inter color index
  // vector<int>       Number_color_index; ///< contain occurence of each
  // initial color vector<int>       IsKnownIndex;///< is known index
 
 
  // Decoder
 
  Arithmetic_Codec Decoder; 
 
  Adaptive_Data_Model Color_0_Model; 
  Adaptive_Data_Model Color_1_Model; 
  Adaptive_Data_Model Color_2_Model; 
 
  Adaptive_Data_Model Index_Model; 
 
  std::vector< int >
      NumberDecimation; 
  std::vector< int > NumberChangeQuantization; 
 
  int DumpSymbolDecimation; 
  int DumpSymbolRegulation; 
 
  int Decompress_count; 
  int NumberComponents; 
 
  int GlobalCountOperation; 
 
  std::vector< int > ComponentOperations; 
 
  // JCW
  int m_NumberBin;         
  int m_EmbeddingStrength; 
  int m_NumberRegion;      
  double m_VC[3];          
  double m_Rmin; 
  double m_Rmax; 
  double m_Dist; 
  std::vector< int >
      m_Number_Vertices_Per_Regions; 
  std::list< int > m_Watermarks;     
 
  int N_Inserted_Watermarks; 
 
  std::vector< int >
      m_N_remained_vertices; 
  std::vector< int >
      m_N_treated_vertices; 
  std::vector< double > m_Rad_decision;
 
  std::list< std::vector< int > >
      m_JCW_Move_Error; 
  std::list< int >
      m_N_Errors; 
 
  Adaptive_Data_Model DM_JCW_MOVE_ERROR;
 
  std::list< int > JCW_Connectivity; 
  std::list< Point_Int > JCW_Geometry; 
 
  // double LUT_CourbureClust[3*256];
  std::vector< std::vector< float > > Region_Color; 
  int Number_non_reversible_vertices; 
  int Number_Save_Over_bins; 
  bool Is_Division_Big_Regions_Enabled;   
  bool Is_Complete_Reversibility_Enabled; 
  bool Is_Bijection_Enabled; 
  int Division_Threshold;    
 
  // from IHM
public:
  bool IsDecompress;             
  bool IsCompressed;             
  int Current_level;             
  int Total_layer;               
  unsigned Initial_file_size;    
  unsigned Compressed_file_size; 
  std::string File_name;         
 
  std::vector< float >
      Prog; 
  std::vector< float >
      Ratio; 
  std::string Message; 
 
public: // private:
  // bool Afficher; ///<
  bool Sequence; 
  bool Possible_change_sequence; 
 
  int Visu_level;    
  int Process_level; 
 
  FILE *Dec_Info; 
  // int Writing_level; ///< Level of
  std::string
      Dec_File_Info; 
 
  // ELO+
  //--------------------------------------------------------------------
  // Property maps that replace ancient vertex/halfedge/face attributes
  //--------------------------------------------------------------------
 
  typename FEVV::Vertex_pmap< HalfedgeGraph, Color_Unit >
      vertex_color_int; // ELO replace pVertex->color_int(...)
  typename FEVV::Vertex_pmap< HalfedgeGraph, int >
      vertex_Seed_Edge; // ELO replace pVertex->Seed_Edge
  typename FEVV::Vertex_pmap< HalfedgeGraph, int >
      vertex_Component_Number; // ELO replace pVertex->Component_Number
  typename FEVV::Vertex_pmap< HalfedgeGraph, int >
      Vertex_Flag; // ELO replace pVert->Vertex_Flag
  typename FEVV::Vertex_pmap< HalfedgeGraph, int >
      Vertex_Number; // ELO replace pVert->Vertex_Number
  typename FEVV::Vertex_pmap< HalfedgeGraph, int >
      Vertex_Sign; // ELO replace pVert->Vertex_Sign
  typename FEVV::Vertex_pmap< HalfedgeGraph, Vector >
      vertex_normal; // ELO replace pVertex->normal()
  typename FEVV::Vertex_pmap< HalfedgeGraph, int >
      vertex_Q_Index; // ELO replace pVertex->Q_Index
  typename FEVV::Vertex_pmap< HalfedgeGraph, int >
      vertex_Region_Number; // ELO replace pVert->Region_Number
  typename FEVV::Vertex_pmap< HalfedgeGraph, int >
      vertex_Removal_Order; // ELO replace pVert->Removal_Order
 
  typename FEVV::Face_pmap< HalfedgeGraph, int >
      facet_tag; // ELO replace pFacet->tag(...)
  typename FEVV::Face_pmap< HalfedgeGraph, int >
      facet_Component_Number; // ELO replace pFacet->Component_Number
  typename FEVV::Face_pmap< HalfedgeGraph, int >
      Facet_Flag; // ELO replace pFacet->Facet_Flag
  typename FEVV::Face_pmap< HalfedgeGraph, Vector >
      facet_normal; // ELO replace pFacet->normal()
 
 
  //-----------------------------------------------------------
  //    Functions moved from Compression_Valence_Common.h
  //-----------------------------------------------------------
 
  bool Is_Border_Vertex(const halfedge_descriptor &h,
                        const HalfedgeGraph &mesh);
 
  int Find_Type(const HalfedgeGraph &_pMesh,
                const halfedge_descriptor &h,
                const int &valence);
 
  bool Is_Manifold_Property_Violated(const HalfedgeGraph &_pMesh,
                                     const halfedge_descriptor &h,
                                     const int &type,
                                     const int &valence);
 
  bool Is_Normal_Flipping_Occured(const HalfedgeGraph &_pMesh,
                                  const PointMap *_pm,
                                  const halfedge_descriptor &h,
                                  const unsigned &valence);
 
  Vector Triangle_Normal(const HalfedgeGraph &_pMesh,
                         const PointMap *_pm,
                         const halfedge_descriptor &h);
 
  Vector Triangle_Normal(const HalfedgeGraph &_pMesh,
                         const Point3d &P,
                         const Point3d &Q,
                         const Point3d &R);
 
  bool Is_Geometric_Metric_Violated(const HalfedgeGraph &_pMesh,
                                    const PointMap *_pm,
                                    const halfedge_descriptor &h,
                                    const int &type,
                                    const unsigned int &valence,
                                    const float &Threshold);
 
 
  // TODO-elo  share this function with Curvature filter that uses its own one
  // TODO-elo  see
  // https://github.com/MEPP-team/MEPP2/blob/master/FEVV/Filters/Generic/Manifold/Curvature/curvature.hpp#L105
  double Area_Facet_Triangle(
      const typename boost::graph_traits< HalfedgeGraph >::halfedge_descriptor
          &h,
      const HalfedgeGraph &mesh,
      const PointMap *pm);
 
  double Area_Facet_Triangle(const Point3d &P,
                             const Point3d &Q,
                             const Point3d &R,
                             const HalfedgeGraph &_pMesh);
 
  double Volume(const Point3d &A,
                const Point3d &B,
                const Point3d &C,
                const Point3d &D,
                const HalfedgeGraph &_pMesh);
 
  Color_Unit Get_Vertex_Color(const halfedge_descriptor &h,
                              const HalfedgeGraph &_pMesh);
 
  Color_Unit Get_Average_Vertex_Color_Lee(const halfedge_descriptor &h,
                                          const int &valence,
                                          const HalfedgeGraph &_pMesh);
 
  Point3d Barycenter_Patch_Before_Removal(const halfedge_descriptor &h,
                                          const HalfedgeGraph &_pMesh,
                                          const PointMap *_pm);
 
  Point3d Barycenter_Patch_After_Removal(const halfedge_descriptor &h,
                                         const int &valence,
                                         const HalfedgeGraph &_pMesh,
                                         const PointMap *_pm);
 
  void Retriangulation(HalfedgeGraph &pMesh,
                       const halfedge_descriptor &ch,
                       const unsigned &valence,
                       const unsigned &Vertex_number,
                       const int &Component_ID,
                       const PointMap *_pm);
 
  Vector Normal_Patch(const halfedge_descriptor &const_h,
                      const unsigned int &valence,
                      const HalfedgeGraph &_pMesh,
                      const PointMap *_pm);
 
  Vector Calculate_T1_T2(const halfedge_descriptor &h,
                         const Vector &normal,
                         Vector &T2,
                         const HalfedgeGraph &_pMesh,
                         const PointMap *_pm);
 
  Point_Int Frenet_Rotation(const Point_Int &Dist,
                            const Vector &T1,
                            const Vector &T2,
                            const Vector &normal);
 
 
  Point_Int Inverse_Frenet_Rotation(const Point_Int &Frenet,
                                    const Vector &T1,
                                    const Vector &T2,
                                    const Vector &normal);
 
  Color_Unit
  Get_Average_Vertex_Color_After_Removal(const halfedge_descriptor &h,
                                         const int &valence,
                                         const HalfedgeGraph &_pMesh);
 
  int Estimate_Geometry_Quantization(double volume,
                                     double area,
                                     int number_vertices);
 
  int Get_Correct_Vector(int i, int j, int k);
 
  bool Remove_Edges(HalfedgeGraph &_pMesh,
                    const halfedge_descriptor &h,
                    const int &type);
 
  void Get_Coefficient_Up_Quantization(const int &Correct_symbol, int coeff[3]);
 
 
  //-----------------------------------------------------------
  //                     Miscellaneous
  //-----------------------------------------------------------
 
 
  void compute_normals(const HalfedgeGraph &_pMesh, const PointMap *_pm);
 
  void compute_normals_per_facet(const HalfedgeGraph &_pMesh,
                                 const PointMap *_pm);
 
  void compute_normals_per_vertex(const HalfedgeGraph &_pMesh);
 
  void compute_facet_normal(const face_descriptor &f,
                            const HalfedgeGraph &_pMesh,
                            const PointMap *_pm);
 
  void compute_vertex_normal(const vertex_descriptor &v,
                             const HalfedgeGraph &_pMesh);
 
  void print_halfedge(const std::string &title,
                      const halfedge_descriptor &h,
                      const HalfedgeGraph &_pMesh,
                      const PointMap *_pm);
 
  void print_vertex(const std::string &title,
                    const vertex_descriptor &v,
                    const PointMap *_pm);
 
  std::string vertex_to_string(const vertex_descriptor &v, const PointMap *_pm);
 
  std::string halfedge_to_string(const halfedge_descriptor &h,
                                 const HalfedgeGraph &_pMesh,
                                 const PointMap *_pm);
 
  std::string edge_to_string(const halfedge_descriptor &h,
                             const HalfedgeGraph &_pMesh,
                             const PointMap *_pm);
 
  void DBG_print_mesh_geometry(const HalfedgeGraph &_pMesh,
                               const PointMap *_pm,
                               const std::string &header = std::string());
 
  void DBG_print_mesh_vertexcolor(const HalfedgeGraph &_pMesh,
                                  const VertexColorMap *_v_cm,
                                  const std::string &header = std::string());
 
  bool v_inf_to_v(const vertex_descriptor &v1,
                  const vertex_descriptor &v2,
                  const PointMap *_pm);
 
  void build_mesh(HalfedgeGraph &_pMesh,
                  PointMap *_pm,
                  VertexColorMap *_v_cm,
                  const std::vector< Point3d > &vlist,
                  const std::vector< int > &flist,
                  const std::vector< float > &clist,
                  const std::vector< int > &Color_index_list);
 
  void init_vertex_attributes(const vertex_descriptor &v);
 
  void truncate_colors(const HalfedgeGraph &_pMesh,
                      VertexColorMap *_v_cm);
};
 
// implementation details
#include "Compression_Valence_Component.inl"
 
 
/*  \page CompressionValencePage  Compression Valence Documentation
 *
 * \section auth Authors
 * H. LEE, C. DIKICI, G. LAVOUE and F. DUPONT \n
 * M2DisCo Team, LIRIS, CNRS, Universite Lyon 1/INSA-Lyon, France. \n
 * \n
 * Please contact the authors \n H. LEE (hosmail@gmail.com), C. DIKICI
 (cagataydikici@yahoo.com),
 * G. LAVOUE (glavoue@liris.cnrs.fr) and F. DUPONT (fdupont@liris.cnrs.fr) \n
 * in case you have any question, comment or a bug to report.
 * \n
 * \n
 *
 * \section paper_reference Related publications
 * Here is the list of related papers if you want to cite our methods. \n
 * It is also strongly recommended that you read these papers
 * in order to know the parameters used in our methods.
 * \n
 *
 * \subsection compression_paper Progressive compression of colored meshes
 * H. LEE, G. LAVOUE, F. DUPONT, \n
 * Rate-distortion optimization for progressive compression of 3D mesh with
 color attributes, \n
 * The Visual Computer, 2011.
 * \n
 *
 * \subsection jcw_paper Joint watermarking and progressive compression of 3D
 meshes
 * H. LEE, C. DIKICI, G. LAVOUE, F. DUPONT, \n
 * Joint reversible watermarking and progressive compression of 3D meshes, \n
 * The Visual Computer 27(6-8):781-792, 2011.
 * \n
 * \n
 *
 * \section overview Overview
 * This Compression Valence component has two main functions:
 * (1) a progressive compresion and (2) a joint progressive compression and
 reversible watermarking for 3D meshes. \n
 * The progressive compression method simplifies iteratively an input mesh to
 generate differents levels of details (LoDs). \n
 * These LoDs are then transmitted progressively in a coarse-to-fine way at the
 decompression. \n
 * In particular, our method adapts the quantization precision (both geometry
 and color) to each LoD in order to optimize the rate-distortion (R-D)
 trade-off. \n \n
 * Our joint progressive compression and reversible watermarking method offers a
 possibility to embed an watermark information
 * in order to protect the ownership of the input mesh. \n
 * Hence, at each decompression step, the inserted message can be extracted also
 progressively. \n
 * The embedded watermarks are reversible, meaning that the deformation caused
 by watermarking embedding step can be removed when extracting the watermark.
 * \n
 * \n
 *
 * \section howto_use How to use this component
 * \subsection howto_progressive_compression Progressive compression
 * First of all you have to load a mesh. \n
 * To compress the input mesh, choose "Compression" and a windows appears. \n
 * (1) File name              : to choose a name for the compressed file. Please
 be aware that the file extension should be ".p3d". \n
 * (2) Mode                   : the mode "Simplification" does not generate a
 compressed file. \n
 * (3) Compression mode       : to enable or disable the use of the adaptation
 of quantization precision. \n
 * (4) Quantization bits      : the number of bits for the geometry
 quantization. \n
 * (5) # Vertices wanted      : the number of vertices of the base (the
 coarsest) mesh. \n
 * (6) Use bijection          : to enable or disable the use of the bijection
 for the geometry encoding. This bijection reduces the coding rates but it needs
 a longer processing time. \n
 * (7) Forbid normal flipping : this option is used to forbid a normal flipping
 when removing a vertex. \n
 * (8) Use Metric             : this option is used to forbid a vertex removal
 if it induces a significant deformation. The threshold value is initially set
 to 0.25. \n The use of this metric can be "forgetted" if the number of vertices
 of the current intermediate mesh is superior to an user-defined threshold. \n
 * \n
 * For the decompression, first you have to load a .p3d file. Then, the base
 mesh is rendered. \n
 * To obtain higher LoDs, you can use : \n
 * (1) "Decompression : all LoDs", to decompress all LoDs and the finest
 intermediate is visualized, \n
 * (2) "Decompression : next LoD", to decompress one level and the next LoD is
 rendered (ALT + left mouse button), \n
 * (3) "Decompression : go to specific LoD", to reach the desired LoD. \n
 * You can also visualize the previous LoDs by selecting "Decompression :
 previous LoD" (ALT + right mouse button). \n \n
 * After loading the .p3d file, you can enable or disable the option of mesh
 sequence generation with the menu "Activate/Desactivate mesh sequence
 generation". \n
 * When this option is enabled, all LoDs are stored in the memory, so that the
 navigation of differents LoDs can be performed quickly. \n
 * You can disable this option in order to save the memory.
 * In this case, when you want to visualize the previous LoD, the decompression
 is performed again until getting the previous LoD.
 * The navigation takes a longer time. \n
 * Note that this option can be modified only after the rendering of the base
 mesh and it cannot be modified when any decompression operation is achieved. \n
 * \n
 * \subsection howto_jcw Joint compression and watermarking
 * First of all you have to load a mesh. \n
 * You can apply our joint method by selecting "JCW - Compression and
 Watermarking embedding". \n
 * (1) File name              : to choose a name for the compressed file (.p3d).
 \n
 * (2) Q bits                 : the number of bits for the geometry
 quantization. \n
 * (3) # vertices             : the number of the base mesh after an iterative
 simplification. \n
 * (4) # Bins         : the number of the histogram bins. \n
 * (5) # Regions              : the number of regions. One watermark bit is
 embedded in each region. \n
 * (6) Embedding Strength     : the number of shifted bins when
 embedding/extracting the watermark. \n
 * (7) Embedding Message      : the message to insert. When this field is empty
 or the length of the message is shorter than necessary, the message is
 generated randomly. \n
 * (8) Divide Regions         : when this option is selected, the big region is
 divided in two in order to insert more watermark bits. \n
 * (9) Complete Reversibility : When this option is checked, the initial
 positions of all vertices are exactly restored. Some extra coding bits are
 necessary.
 * \n
 * For the decompression and the watermark extraction,
 * you have to load a .p3d file. \n
 * To obtain higher LoDs, you can select "JCW - Decompression and Watermark
 extraction : next LoD". \n
 * The extracted message is shown in the status bar of the main window. \n
 * To visualize the results without watermark extraction (non authorized users),
 you can use "JCW - Decompression without extraction : next LoD". \n
 * \n
 *
 * \section last_updated Last updated
 * 18 May, 2011
 *
 */