-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D
//
// This library is free software; 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 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+// Author : Anthony Geay (CEA/DEN)
#include "InterpolationOptions.hxx"
+#include "InterpKernelGeo2DPrecision.hxx"
+#include "InterpKernelException.hxx"
#include <sstream>
const double INTERP_KERNEL::InterpolationOptions::DFT_MAX_DIST_3DSURF_INTERSECT=-1.;
+const double INTERP_KERNEL::InterpolationOptions::DFT_MIN_DOT_BTW_3DSURF_INTERSECT=-1.;
+
const char INTERP_KERNEL::InterpolationOptions::PRECISION_STR[]="Precision";
+const char INTERP_KERNEL::InterpolationOptions::ARC_DETECTION_PRECISION_STR[]="ArcDetectionPrecision";
+
const char INTERP_KERNEL::InterpolationOptions::MEDIANE_PLANE_STR[]="MedianPlane";
const char INTERP_KERNEL::InterpolationOptions::BOUNDING_BOX_ADJ_STR[]="BoundingBoxAdjustment";
const char INTERP_KERNEL::InterpolationOptions::MAX_DISTANCE_3DSURF_INSECT_STR[]="MaxDistance3DSurfIntersect";
+const char INTERP_KERNEL::InterpolationOptions::MIN_DOT_BTW_3DSURF_INSECT_STR[]="MinDotBetween3DSurfIntersect";
+
const char INTERP_KERNEL::InterpolationOptions::PRINT_LEV_STR[]="PrintLevel";
const char INTERP_KERNEL::InterpolationOptions::DO_ROTATE_STR[]="DoRotate";
const char INTERP_KERNEL::InterpolationOptions::POINTLOCATOR_INTERSECT_STR[]="PointLocator";
+const char INTERP_KERNEL::InterpolationOptions::BARYCENTRIC_INTERSECT_STR[]="Barycentric";
+
+const char INTERP_KERNEL::InterpolationOptions::BARYCENTRICGEO2D_INTERSECT_STR[]="BarycentricGeo2D";
+
const char INTERP_KERNEL::InterpolationOptions::PLANAR_SPLIT_FACE_5_STR[]="PLANAR_FACE_5";
const char INTERP_KERNEL::InterpolationOptions::PLANAR_SPLIT_FACE_6_STR[]="PLANAR_FACE_6";
const char INTERP_KERNEL::InterpolationOptions::GENERAL_SPLIT_48_STR[]="GENERAL_48";
+void INTERP_KERNEL::InterpolationOptions::init()
+{
+ _print_level=0;
+ _intersection_type=Triangulation;
+ _precision=1e-12;
+ _median_plane=DFT_MEDIAN_PLANE;
+ _do_rotate=true;
+ _bounding_box_adjustment=DFT_SURF3D_ADJ_EPS;
+ _bounding_box_adjustment_abs=0.;
+ _max_distance_for_3Dsurf_intersect=DFT_MAX_DIST_3DSURF_INTERSECT;
+ _min_dot_btw_3Dsurf_intersect=DFT_MIN_DOT_BTW_3DSURF_INTERSECT;
+ _orientation=0;
+ _measure_abs=true;
+ _splitting_policy=PLANAR_FACE_5;
+}
+
+double INTERP_KERNEL::InterpolationOptions::getArcDetectionPrecision() const
+{
+ return INTERP_KERNEL::QUADRATIC_PLANAR::_arc_detection_precision;
+}
+
+void INTERP_KERNEL::InterpolationOptions::setArcDetectionPrecision(double p)
+{
+ INTERP_KERNEL::QUADRATIC_PLANAR::_arc_detection_precision=p;
+}
+
std::string INTERP_KERNEL::InterpolationOptions::getIntersectionTypeRepr() const
{
if(_intersection_type==INTERP_KERNEL::Triangulation)
return std::string(GEOMETRIC_INTERSECT2D_STR);
else if(_intersection_type==INTERP_KERNEL::PointLocator)
return std::string(POINTLOCATOR_INTERSECT_STR);
+ else if(_intersection_type==INTERP_KERNEL::Barycentric)
+ return std::string(BARYCENTRIC_INTERSECT_STR);
+ else if(_intersection_type==INTERP_KERNEL::BarycentricGeo2D)
+ return std::string(BARYCENTRICGEO2D_INTERSECT_STR);
else
return std::string("UNKNOWN_INTERSECT_TYPE");
}
setPrecision(value);
return true;
}
+ if(key==ARC_DETECTION_PRECISION_STR)
+ {
+ setArcDetectionPrecision(value);
+ return true;
+ }
else if(key==MEDIANE_PLANE_STR)
{
setMedianPlane(value);
setMaxDistance3DSurfIntersect(value);
return true;
}
+ else if(key==MIN_DOT_BTW_3DSURF_INSECT_STR)
+ {
+ setMinDotBtwPlane3DSurfIntersect(value);
+ return true;
+ }
else
return false;
}
setIntersectionType(INTERP_KERNEL::PointLocator);
return true;
}
+ else if(value==BARYCENTRIC_INTERSECT_STR)
+ {
+ setIntersectionType(INTERP_KERNEL::Barycentric);
+ return true;
+ }
+ else if(value==BARYCENTRICGEO2D_INTERSECT_STR)
+ {
+ setIntersectionType(INTERP_KERNEL::BarycentricGeo2D);
+ return true;
+ }
}
else if(key==SPLITTING_POLICY_STR)
{
std::string INTERP_KERNEL::InterpolationOptions::filterInterpolationMethod(const std::string& meth) const
{
- if ( _P1P0_bary_method && meth == "P1P0" )
- return "P1P0Bary";
- return meth;
+ return std::string(meth);
}
bool INTERP_KERNEL::InterpolationOptions::setInterpolationOptions(long print_level,
double max_distance_for_3Dsurf_intersect,
long orientation,
bool measure_abs,
- std::string splitting_policy,
- bool P1P0_bary_method )
+ std::string splitting_policy)
{
_print_level=print_level;
_precision=precision;
_max_distance_for_3Dsurf_intersect=max_distance_for_3Dsurf_intersect;
_orientation=orientation;
_measure_abs=measure_abs;
- _P1P0_bary_method=P1P0_bary_method;
return(setOptionString(INTERSEC_TYPE_STR,intersection_type) && setOptionString(SPLITTING_POLICY_STR,splitting_policy));
}
oss << "Print level : " << _print_level << std::endl;
oss << "Intersection type : " << getIntersectionTypeRepr() << std::endl;
oss << "Precision : " << _precision << std::endl;
+ oss << "Arc Detection Precision : " << getArcDetectionPrecision() << std::endl;
oss << "Median plane : " << _median_plane << std::endl;
oss << "Do Rotate status : " << std::boolalpha << _do_rotate << std::endl;
oss << "Bounding box adj : " << _bounding_box_adjustment << std::endl;
oss << "Bounding box adj abs : " << _bounding_box_adjustment_abs << std::endl;
oss << "Max distance for 3DSurf intersect : " << _max_distance_for_3Dsurf_intersect << std::endl;
+ oss << "Min dot between plane for 3DSurf intersect : " << _min_dot_btw_3Dsurf_intersect << std::endl;
oss << "Orientation : " << _orientation << std::endl;
oss << "Measure abs : " << _measure_abs << std::endl;
oss << "Splitting policy : " << getSplittingPolicyRepr() << std::endl;
- oss << "P1P0 Barycentric method : " << _P1P0_bary_method << std::endl;
oss << "****************************" << std::endl;
return oss.str();
}
+
+void INTERP_KERNEL::InterpolationOptions::CheckAndSplitInterpolationMethod(const std::string& method, std::string& srcMeth, std::string& trgMeth)
+{
+ const int NB_OF_METH_MANAGED=4;
+ const char *METH_MANAGED[NB_OF_METH_MANAGED]={"P0P0","P0P1","P1P0","P1P1"};
+ bool found=false;
+ for(int i=0;i<NB_OF_METH_MANAGED && !found;i++)
+ found=(method==METH_MANAGED[i]);
+ if(!found)
+ {
+ std::string msg("The interpolation method : \'"); msg+=method; msg+="\' not managed by INTERP_KERNEL interpolators ! Supported are \"P0P0\", \"P0P1\", \"P1P0\" and \"P1P1\".";
+ throw INTERP_KERNEL::Exception(msg.c_str());
+ }
+ srcMeth=method.substr(0,2);
+ trgMeth=method.substr(2);
+}
