src/INTERP_KERNEL/InterpolationOptions.cxx

   1 // Copyright (C) 2007-2012  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 std::string INTERP_KERNEL::InterpolationOptions::getIntersectionTypeRepr() const
  70 {
  71   if(_intersection_type==INTERP_KERNEL::Triangulation)
  72     return std::string(TRIANGULATION_INTERSECT2D_STR);
  73   else if(_intersection_type==INTERP_KERNEL::Convex)
  74     return std::string(CONVEX_INTERSECT2D_STR);
  75   else if(_intersection_type==INTERP_KERNEL::Geometric2D)
  76     return std::string(GEOMETRIC_INTERSECT2D_STR);
  77   else if(_intersection_type==INTERP_KERNEL::PointLocator)
  78     return std::string(POINTLOCATOR_INTERSECT_STR);
  79   else
  80     return std::string("UNKNOWN_INTERSECT_TYPE");
  81 }
  82
  83 bool INTERP_KERNEL::InterpolationOptions::setOptionDouble(const std::string& key, double value)
  84 {
  85   if(key==PRECISION_STR)
  86     {
  87       setPrecision(value);
  88       return true;
  89     }
  90   else if(key==MEDIANE_PLANE_STR)
  91     {
  92       setMedianPlane(value);
  93       return true;
  94     }
  95   else if(key==BOUNDING_BOX_ADJ_STR)
  96     {
  97       setBoundingBoxAdjustment(value);
  98       return true;
  99     }
 100   else if(key==BOUNDING_BOX_ADJ_ABS_STR)
 101     {
 102       setBoundingBoxAdjustmentAbs(value);
 103       return true;
 104     }
 105   else if(key==MAX_DISTANCE_3DSURF_INSECT_STR)
 106     {
 107       setMaxDistance3DSurfIntersect(value);
 108       return true;
 109     }
 110   else
 111     return false;
 112 }
 113
 114 bool INTERP_KERNEL::InterpolationOptions::setOptionInt(const std::string& key, int value)
 115 {
 116   if(key==PRINT_LEV_STR)
 117     {
 118       setPrintLevel(value);
 119       return true;
 120     }
 121     else if(key==DO_ROTATE_STR)
 122       {
 123         setDoRotate(value != 0);
 124         return true;
 125       }
 126     else if(key==ORIENTATION_STR)
 127       {
 128         setOrientation(value);
 129         return true;
 130       }
 131     else if(key==MEASURE_ABS_STR)
 132       {
 133         bool valBool=(value!=0);
 134         setMeasureAbsStatus(valBool);
 135         return true;
 136       }
 137     else
 138       return false;
 139 }
 140
 141 bool INTERP_KERNEL::InterpolationOptions::setOptionString(const std::string& key, const std::string& value)
 142 {
 143   if(key==INTERSEC_TYPE_STR)
 144     {
 145       if(value==TRIANGULATION_INTERSECT2D_STR)
 146         {
 147           setIntersectionType(INTERP_KERNEL::Triangulation);
 148           return true;
 149         }
 150       else if(value==CONVEX_INTERSECT2D_STR)
 151         {
 152           setIntersectionType(INTERP_KERNEL::Convex);
 153           return true;
 154         }
 155       else if(value==GEOMETRIC_INTERSECT2D_STR)
 156         {
 157           setIntersectionType(INTERP_KERNEL::Geometric2D);
 158           return true;
 159         }
 160       else if(value==POINTLOCATOR_INTERSECT_STR)
 161         {
 162           setIntersectionType(INTERP_KERNEL::PointLocator);
 163           return true;
 164         }
 165     }
 166   else if(key==SPLITTING_POLICY_STR)
 167     {
 168       if(value==PLANAR_SPLIT_FACE_5_STR)
 169         {
 170           setSplittingPolicy(INTERP_KERNEL::PLANAR_FACE_5);
 171           return true;
 172         }
 173       else if(value==PLANAR_SPLIT_FACE_6_STR)
 174         {
 175           setSplittingPolicy(INTERP_KERNEL::PLANAR_FACE_6);
 176           return true;
 177         }
 178       else if(value==GENERAL_SPLIT_24_STR)
 179         {
 180           setSplittingPolicy(INTERP_KERNEL::GENERAL_24);
 181           return true;
 182         }
 183       else if(value==GENERAL_SPLIT_48_STR)
 184         {
 185           setSplittingPolicy(INTERP_KERNEL::GENERAL_48);
 186           return true;
 187         }
 188       else
 189         return false;
 190     }
 191   return false;
 192 }
 193
 194 std::string INTERP_KERNEL::InterpolationOptions::getSplittingPolicyRepr() const
 195 {
 196   if(_splitting_policy==INTERP_KERNEL::PLANAR_FACE_5)
 197     return std::string(PLANAR_SPLIT_FACE_5_STR);
 198   else if(_splitting_policy==INTERP_KERNEL::PLANAR_FACE_6)
 199     return std::string(PLANAR_SPLIT_FACE_6_STR);
 200   else if(_splitting_policy==INTERP_KERNEL::GENERAL_24)
 201     return std::string(GENERAL_SPLIT_24_STR);
 202   else if(_splitting_policy==INTERP_KERNEL::GENERAL_48)
 203     return std::string(GENERAL_SPLIT_48_STR);
 204   else
 205     return std::string("UNKNOWN_SPLITTING_POLICY");
 206 }
 207
 208 std::string INTERP_KERNEL::InterpolationOptions::filterInterpolationMethod(const std::string& meth) const
 209 {
 210   if ( _P1P0_bary_method && meth == "P1P0" )
 211     return "P1P0Bary";
 212   return meth;
 213 }
 214
 215 bool INTERP_KERNEL::InterpolationOptions::setInterpolationOptions(long print_level,
 216                                                                   std::string intersection_type,
 217                                                                   double precision,
 218                                                                   double median_plane,
 219                                                                   bool do_rotate,
 220                                                                   double bounding_box_adjustment,
 221                                                                   double bounding_box_adjustment_abs,
 222                                                                   double max_distance_for_3Dsurf_intersect,
 223                                                                   long orientation,
 224                                                                   bool measure_abs,
 225                                                                   std::string splitting_policy,
 226                                                                   bool P1P0_bary_method )
 227 {
 228   _print_level=print_level;
 229   _precision=precision;
 230   _median_plane=median_plane;
 231   _do_rotate=do_rotate;
 232   _bounding_box_adjustment=bounding_box_adjustment;
 233   _bounding_box_adjustment_abs=bounding_box_adjustment_abs;
 234   _max_distance_for_3Dsurf_intersect=max_distance_for_3Dsurf_intersect;
 235   _orientation=orientation;
 236   _measure_abs=measure_abs;
 237   _P1P0_bary_method=P1P0_bary_method;
 238   return(setOptionString(INTERSEC_TYPE_STR,intersection_type) && setOptionString(SPLITTING_POLICY_STR,splitting_policy));
 239 }
 240
 241 std::string INTERP_KERNEL::InterpolationOptions::printOptions() const
 242 {
 243   std::ostringstream oss; oss.precision(15); oss << "Interpolation Options ******" << std::endl;
 244   oss << "Print level : " << _print_level << std::endl;
 245   oss << "Intersection type : " << getIntersectionTypeRepr() << std::endl;
 246   oss << "Precision : " << _precision << std::endl;
 247   oss << "Median plane : " << _median_plane << std::endl;
 248   oss << "Do Rotate status : " << std::boolalpha << _do_rotate << std::endl;
 249   oss << "Bounding box adj : " << _bounding_box_adjustment << std::endl;
 250   oss << "Bounding box adj abs : " << _bounding_box_adjustment_abs << std::endl;
 251   oss << "Max distance for 3DSurf intersect : " << _max_distance_for_3Dsurf_intersect << std::endl;
 252   oss << "Orientation : " << _orientation << std::endl;
 253   oss << "Measure abs : " << _measure_abs << std::endl;
 254   oss << "Splitting policy : " << getSplittingPolicyRepr() << std::endl;
 255   oss << "P1P0 Barycentric method : " << _P1P0_bary_method << std::endl;
 256   oss << "****************************" << std::endl;
 257   return oss.str();
 258 }