src/INTERP_KERNEL/InterpolationOptions.cxx

   1 // Copyright (C) 2007-2013  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (CEA/DEN)
  20
  21 #include "InterpolationOptions.hxx"
  22
  23 #include <sstream>
  24
  25 const double INTERP_KERNEL::InterpolationOptions::DFT_MEDIAN_PLANE=0.5;
  26
  27 const double INTERP_KERNEL::InterpolationOptions::DFT_SURF3D_ADJ_EPS=1.e-4;
  28
  29 const double INTERP_KERNEL::InterpolationOptions::DFT_MAX_DIST_3DSURF_INTERSECT=-1.;
  30
  31 const char INTERP_KERNEL::InterpolationOptions::PRECISION_STR[]="Precision";
  32
  33 const char INTERP_KERNEL::InterpolationOptions::MEDIANE_PLANE_STR[]="MedianPlane";
  34
  35 const char INTERP_KERNEL::InterpolationOptions::BOUNDING_BOX_ADJ_STR[]="BoundingBoxAdjustment";
  36
  37 const char INTERP_KERNEL::InterpolationOptions::BOUNDING_BOX_ADJ_ABS_STR[]="BoundingBoxAdjustmentAbs";
  38
  39 const char INTERP_KERNEL::InterpolationOptions::MAX_DISTANCE_3DSURF_INSECT_STR[]="MaxDistance3DSurfIntersect";
  40
  41 const char INTERP_KERNEL::InterpolationOptions::PRINT_LEV_STR[]="PrintLevel";
  42
  43 const char INTERP_KERNEL::InterpolationOptions::DO_ROTATE_STR[]="DoRotate";
  44
  45 const char INTERP_KERNEL::InterpolationOptions::ORIENTATION_STR[]="Orientation";
  46
  47 const char INTERP_KERNEL::InterpolationOptions::MEASURE_ABS_STR[]="MeasureAbs";
  48
  49 const char INTERP_KERNEL::InterpolationOptions::INTERSEC_TYPE_STR[]="IntersectionType";
  50
  51 const char INTERP_KERNEL::InterpolationOptions::SPLITTING_POLICY_STR[]="SplittingPolicy";
  52
  53 const char INTERP_KERNEL::InterpolationOptions::TRIANGULATION_INTERSECT2D_STR[]="Triangulation";
  54
  55 const char INTERP_KERNEL::InterpolationOptions::CONVEX_INTERSECT2D_STR[]="Convex";
  56
  57 const char INTERP_KERNEL::InterpolationOptions::GEOMETRIC_INTERSECT2D_STR[]="Geometric2D";
  58
  59 const char INTERP_KERNEL::InterpolationOptions::POINTLOCATOR_INTERSECT_STR[]="PointLocator";
  60
  61 const char INTERP_KERNEL::InterpolationOptions::PLANAR_SPLIT_FACE_5_STR[]="PLANAR_FACE_5";
  62
  63 const char INTERP_KERNEL::InterpolationOptions::PLANAR_SPLIT_FACE_6_STR[]="PLANAR_FACE_6";
  64
  65 const char INTERP_KERNEL::InterpolationOptions::GENERAL_SPLIT_24_STR[]="GENERAL_24";
  66
  67 const char INTERP_KERNEL::InterpolationOptions::GENERAL_SPLIT_48_STR[]="GENERAL_48";
  68
  69 void INTERP_KERNEL::InterpolationOptions::init()
  70 {
  71   _print_level=0;
  72   _intersection_type=Triangulation;
  73   _precision=1e-12;
  74   _median_plane=DFT_MEDIAN_PLANE;
  75   _do_rotate=true;
  76   _bounding_box_adjustment=DFT_SURF3D_ADJ_EPS;
  77   _bounding_box_adjustment_abs=0.;
  78   _max_distance_for_3Dsurf_intersect=DFT_MAX_DIST_3DSURF_INTERSECT;
  79   _orientation=0;
  80   _measure_abs=true;
  81   _splitting_policy=PLANAR_FACE_5;
  82   _P1P0_bary_method=false;
  83 }
  84
  85 std::string INTERP_KERNEL::InterpolationOptions::getIntersectionTypeRepr() const
  86 {
  87   if(_intersection_type==INTERP_KERNEL::Triangulation)
  88     return std::string(TRIANGULATION_INTERSECT2D_STR);
  89   else if(_intersection_type==INTERP_KERNEL::Convex)
  90     return std::string(CONVEX_INTERSECT2D_STR);
  91   else if(_intersection_type==INTERP_KERNEL::Geometric2D)
  92     return std::string(GEOMETRIC_INTERSECT2D_STR);
  93   else if(_intersection_type==INTERP_KERNEL::PointLocator)
  94     return std::string(POINTLOCATOR_INTERSECT_STR);
  95   else
  96     return std::string("UNKNOWN_INTERSECT_TYPE");
  97 }
  98
  99 bool INTERP_KERNEL::InterpolationOptions::setOptionDouble(const std::string& key, double value)
 100 {
 101   if(key==PRECISION_STR)
 102     {
 103       setPrecision(value);
 104       return true;
 105     }
 106   else if(key==MEDIANE_PLANE_STR)
 107     {
 108       setMedianPlane(value);
 109       return true;
 110     }
 111   else if(key==BOUNDING_BOX_ADJ_STR)
 112     {
 113       setBoundingBoxAdjustment(value);
 114       return true;
 115     }
 116   else if(key==BOUNDING_BOX_ADJ_ABS_STR)
 117     {
 118       setBoundingBoxAdjustmentAbs(value);
 119       return true;
 120     }
 121   else if(key==MAX_DISTANCE_3DSURF_INSECT_STR)
 122     {
 123       setMaxDistance3DSurfIntersect(value);
 124       return true;
 125     }
 126   else
 127     return false;
 128 }
 129
 130 bool INTERP_KERNEL::InterpolationOptions::setOptionInt(const std::string& key, int value)
 131 {
 132   if(key==PRINT_LEV_STR)
 133     {
 134       setPrintLevel(value);
 135       return true;
 136     }
 137     else if(key==DO_ROTATE_STR)
 138       {
 139         setDoRotate(value != 0);
 140         return true;
 141       }
 142     else if(key==ORIENTATION_STR)
 143       {
 144         setOrientation(value);
 145         return true;
 146       }
 147     else if(key==MEASURE_ABS_STR)
 148       {
 149         bool valBool=(value!=0);
 150         setMeasureAbsStatus(valBool);
 151         return true;
 152       }
 153     else
 154       return false;
 155 }
 156
 157 bool INTERP_KERNEL::InterpolationOptions::setOptionString(const std::string& key, const std::string& value)
 158 {
 159   if(key==INTERSEC_TYPE_STR)
 160     {
 161       if(value==TRIANGULATION_INTERSECT2D_STR)
 162         {
 163           setIntersectionType(INTERP_KERNEL::Triangulation);
 164           return true;
 165         }
 166       else if(value==CONVEX_INTERSECT2D_STR)
 167         {
 168           setIntersectionType(INTERP_KERNEL::Convex);
 169           return true;
 170         }
 171       else if(value==GEOMETRIC_INTERSECT2D_STR)
 172         {
 173           setIntersectionType(INTERP_KERNEL::Geometric2D);
 174           return true;
 175         }
 176       else if(value==POINTLOCATOR_INTERSECT_STR)
 177         {
 178           setIntersectionType(INTERP_KERNEL::PointLocator);
 179           return true;
 180         }
 181     }
 182   else if(key==SPLITTING_POLICY_STR)
 183     {
 184       if(value==PLANAR_SPLIT_FACE_5_STR)
 185         {
 186           setSplittingPolicy(INTERP_KERNEL::PLANAR_FACE_5);
 187           return true;
 188         }
 189       else if(value==PLANAR_SPLIT_FACE_6_STR)
 190         {
 191           setSplittingPolicy(INTERP_KERNEL::PLANAR_FACE_6);
 192           return true;
 193         }
 194       else if(value==GENERAL_SPLIT_24_STR)
 195         {
 196           setSplittingPolicy(INTERP_KERNEL::GENERAL_24);
 197           return true;
 198         }
 199       else if(value==GENERAL_SPLIT_48_STR)
 200         {
 201           setSplittingPolicy(INTERP_KERNEL::GENERAL_48);
 202           return true;
 203         }
 204       else
 205         return false;
 206     }
 207   return false;
 208 }
 209
 210 std::string INTERP_KERNEL::InterpolationOptions::getSplittingPolicyRepr() const
 211 {
 212   if(_splitting_policy==INTERP_KERNEL::PLANAR_FACE_5)
 213     return std::string(PLANAR_SPLIT_FACE_5_STR);
 214   else if(_splitting_policy==INTERP_KERNEL::PLANAR_FACE_6)
 215     return std::string(PLANAR_SPLIT_FACE_6_STR);
 216   else if(_splitting_policy==INTERP_KERNEL::GENERAL_24)
 217     return std::string(GENERAL_SPLIT_24_STR);
 218   else if(_splitting_policy==INTERP_KERNEL::GENERAL_48)
 219     return std::string(GENERAL_SPLIT_48_STR);
 220   else
 221     return std::string("UNKNOWN_SPLITTING_POLICY");
 222 }
 223
 224 std::string INTERP_KERNEL::InterpolationOptions::filterInterpolationMethod(const std::string& meth) const
 225 {
 226   if ( _P1P0_bary_method && meth == "P1P0" )
 227     return "P1P0Bary";
 228   return meth;
 229 }
 230
 231 bool INTERP_KERNEL::InterpolationOptions::setInterpolationOptions(long print_level,
 232                                                                   std::string intersection_type,
 233                                                                   double precision,
 234                                                                   double median_plane,
 235                                                                   bool do_rotate,
 236                                                                   double bounding_box_adjustment,
 237                                                                   double bounding_box_adjustment_abs,
 238                                                                   double max_distance_for_3Dsurf_intersect,
 239                                                                   long orientation,
 240                                                                   bool measure_abs,
 241                                                                   std::string splitting_policy,
 242                                                                   bool P1P0_bary_method )
 243 {
 244   _print_level=print_level;
 245   _precision=precision;
 246   _median_plane=median_plane;
 247   _do_rotate=do_rotate;
 248   _bounding_box_adjustment=bounding_box_adjustment;
 249   _bounding_box_adjustment_abs=bounding_box_adjustment_abs;
 250   _max_distance_for_3Dsurf_intersect=max_distance_for_3Dsurf_intersect;
 251   _orientation=orientation;
 252   _measure_abs=measure_abs;
 253   _P1P0_bary_method=P1P0_bary_method;
 254   return(setOptionString(INTERSEC_TYPE_STR,intersection_type) && setOptionString(SPLITTING_POLICY_STR,splitting_policy));
 255 }
 256
 257 std::string INTERP_KERNEL::InterpolationOptions::printOptions() const
 258 {
 259   std::ostringstream oss; oss.precision(15); oss << "Interpolation Options ******" << std::endl;
 260   oss << "Print level : " << _print_level << std::endl;
 261   oss << "Intersection type : " << getIntersectionTypeRepr() << std::endl;
 262   oss << "Precision : " << _precision << std::endl;
 263   oss << "Median plane : " << _median_plane << std::endl;
 264   oss << "Do Rotate status : " << std::boolalpha << _do_rotate << std::endl;
 265   oss << "Bounding box adj : " << _bounding_box_adjustment << std::endl;
 266   oss << "Bounding box adj abs : " << _bounding_box_adjustment_abs << std::endl;
 267   oss << "Max distance for 3DSurf intersect : " << _max_distance_for_3Dsurf_intersect << std::endl;
 268   oss << "Orientation : " << _orientation << std::endl;
 269   oss << "Measure abs : " << _measure_abs << std::endl;
 270   oss << "Splitting policy : " << getSplittingPolicyRepr() << std::endl;
 271   oss << "P1P0 Barycentric method : " << _P1P0_bary_method << std::endl;
 272   oss << "****************************" << std::endl;
 273   return oss.str();
 274 }