songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update basic viewer to avoid conflict with another external function.

This commit is contained in:
Guillaume Damiand 2019-10-15 11:16:02 +02:00
parent 8fac29bda2
commit 0707d80d63
5 changed files with 86 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
GraphicsView/include/CGAL/Buffer_for_vao.h
View File

@ -39,9 +39,6 @@
namespace CGAL namespace CGAL
{ {
typedef CGAL::Exact_predicates_inexact_constructions_kernel Local_kernel;
typedef Local_kernel::Point_3 Local_point;
typedef Local_kernel::Vector_3 Local_vector;
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
namespace internal namespace internal
@ -58,90 +55,77 @@ namespace internal
n.z()+((p.x()-q.x())*(p.y()+q.y()))); n.z()+((p.x()-q.x())*(p.y()+q.y())));
} }
inline template <class Point, class Vector>
Local_vector compute_normal_of_face(const std::vector<Local_point>& points) Vector compute_normal_of_face(const std::vector<Point>& points)
{ {
Local_vector normal(CGAL::NULL_VECTOR); Vector normal(CGAL::NULL_VECTOR);
unsigned int nb = 0; unsigned int nb = 0;
for (std::size_t i=0; i<points.size(); ++i) for (std::size_t i=0; i<points.size(); ++i)
{ {
newell_single_step_3(points[i], points[(i+1)%points.size()], normal); internal::newell_single_step_3(points[i], points[(i+1)%points.size()],
normal);
++nb; ++nb;
} }
assert(nb>0); assert(nb>0);
return (Local_kernel::Construct_scaled_vector_3()(normal, 1.0/nb)); return (typename Kernel_traits<Vector>::Kernel::Construct_scaled_vector_3()
(normal, 1.0/nb));
} }
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
// Structs to transform any CGAL point/vector into a Local_point/Local_vector // Structs to transform any CGAL point/vector into a Local_point/Local_vector
template<typename K> template<typename K, typename Local_kernel>
struct Geom_utils struct Geom_utils
{ {
static Local_point get_local_point(const typename K::Point_2& p) static typename Local_kernel::Point_3 get_local_point(const typename K::Point_2& p)
{ {
CGAL::Cartesian_converter<K, Local_kernel> converter; CGAL::Cartesian_converter<K, Local_kernel> converter;
return Local_point(converter(p.x()), 0, converter(p.y())); return Local_point(converter(p.x()), 0, converter(p.y()));
} }
static Local_point get_local_point(const typename K::Weighted_point_2& p) static typename Local_kernel::Point_3 get_local_point(const typename K::Weighted_point_2& p)
{ {
typename K::Point_2 lp(p); typename K::Point_2 lp(p);
return Geom_utils<K>::get_local_point(lp); return Geom_utils<K, Local_kernel>::get_local_point(lp);
} }
static Local_point get_local_point(const typename K::Point_3& p) static typename Local_kernel::Point_3 get_local_point(const typename K::Point_3& p)
{ {
CGAL::Cartesian_converter<K, Local_kernel> converter; CGAL::Cartesian_converter<K, Local_kernel> converter;
return converter(p); return converter(p);
} }
static Local_point get_local_point(const typename K::Weighted_point_3& p) static typename Local_kernel::Point_3 get_local_point(const typename K::Weighted_point_3& p)
{ {
typename K::Point_3 lp(p); typename K::Point_3 lp(p);
return Geom_utils<K>::get_local_point(lp); return Geom_utils<K, Local_kernel>::get_local_point(lp);
} }
static Local_vector get_local_vector(const typename K::Vector_2& v) static typename Local_kernel::Vector_3 get_local_vector(const typename K::Vector_2& v)
{ {
CGAL::Cartesian_converter<K, Local_kernel> converter; CGAL::Cartesian_converter<K, Local_kernel> converter;
return Local_vector(converter(v.x()), 0, converter(v.y())); return Local_vector(converter(v.x()), 0, converter(v.y()));
} }
static Local_vector get_local_vector(const typename K::Vector_3& v) static typename Local_kernel::Vector_3 get_local_vector(const typename K::Vector_3& v)
{ {
CGAL::Cartesian_converter<K, Local_kernel> converter; CGAL::Cartesian_converter<K, Local_kernel> converter;
return converter(v); return converter(v);
} }
}; };
// Specialization for Local_kernel, because there is no need of convertion here. // Specialization when K==Local_kernel, because there is no need of convertion here.
template<> template<typename Local_kernel>
struct Geom_utils<Local_kernel> struct Geom_utils<Local_kernel, Local_kernel>
{ {
static Local_point get_local_point(const Local_kernel::Point_2& p) static typename Local_kernel::Point_3 get_local_point(const typename Local_kernel::Point_2& p)
{ return Local_point(p.x(), 0, p.y()); } { return typename Local_kernel::Point_3(p.x(), 0, p.y()); }
static Local_point get_local_point(const Local_kernel::Weighted_point_2& p) static typename Local_kernel::Point_3 get_local_point(const typename Local_kernel::Weighted_point_2& p)
{ return Local_point(p.point().x(), 0, p.point().y());} { return typename Local_kernel::Point_3(p.point().x(), 0, p.point().y());}
static const Local_point & get_local_point(const Local_kernel::Point_3& p) static const typename Local_kernel::Point_3 & get_local_point(const typename Local_kernel::Point_3& p)
{ return p; } { return p; }
static Local_point get_local_point(const Local_kernel::Weighted_point_3& p) static typename Local_kernel::Point_3 get_local_point(const typename Local_kernel::Weighted_point_3& p)
{ return Local_point(p);} { return typename Local_kernel::Point_3(p);}
static Local_vector get_local_vector(const Local_kernel::Vector_2& v) static typename Local_kernel::Vector_3 get_local_vector(const typename Local_kernel::Vector_2& v)
{ return Local_vector(v.x(), 0, v.y()); } { return typename Local_kernel::Vector_3(v.x(), 0, v.y()); }
static const Local_vector& get_local_vector(const Local_kernel::Vector_3& v) static const typename Local_kernel::Vector_3& get_local_vector(const typename Local_kernel::Vector_3& v)
{ return v; } { return v; }
}; };
////////////////////////////////////////////////////////////////
// Global function to simplify function calls.
template<typename KPoint>
Local_point get_local_point(const KPoint& p)
{
return Geom_utils<typename CGAL::Kernel_traits<KPoint>::Kernel>::
get_local_point(p);
}
template<typename KVector>
Local_vector get_local_vector(const KVector& v)
{
return Geom_utils<typename CGAL::Kernel_traits<KVector>::Kernel>::
get_local_vector(v);
}
} // End namespace internal } // End namespace internal
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@ -149,6 +133,10 @@ template<typename BufferType=float, typename IndexType=std::size_t>
class Buffer_for_vao class Buffer_for_vao
{ {
public: public:
typedef CGAL::Exact_predicates_inexact_constructions_kernel Local_kernel;
typedef Local_kernel::Point_3 Local_point;
typedef Local_kernel::Vector_3 Local_vector;
Buffer_for_vao(std::vector<BufferType>* pos=nullptr, Buffer_for_vao(std::vector<BufferType>* pos=nullptr,
std::vector<IndexType>* indices=nullptr, std::vector<IndexType>* indices=nullptr,
CGAL::Bbox_3* bbox=nullptr, CGAL::Bbox_3* bbox=nullptr,
@ -220,7 +208,7 @@ public:
{ {
if (!has_position()) return (std::size_t)-1; if (!has_position()) return (std::size_t)-1;
Local_point p=internal::get_local_point(kp); Local_point p=get_local_point(kp);
add_point_in_buffer(p, *m_pos_buffer); add_point_in_buffer(p, *m_pos_buffer);
if (m_bb!=nullptr) if (m_bb!=nullptr)
@ -293,7 +281,7 @@ public:
template<typename KNormal> template<typename KNormal>
void face_begin(const KNormal& kv) void face_begin(const KNormal& kv)
{ {
m_normal_of_face=internal::get_local_vector(kv); m_normal_of_face=get_local_vector(kv);
face_begin_internal(false, true); face_begin_internal(false, true);
} }
@ -302,7 +290,7 @@ public:
void face_begin(const CGAL::Color& c, const KNormal& kv) void face_begin(const CGAL::Color& c, const KNormal& kv)
{ {
m_color_of_face=c; m_color_of_face=c;
m_normal_of_face=internal::get_local_vector(kv); m_normal_of_face=get_local_vector(kv);
face_begin_internal(true, true); face_begin_internal(true, true);
} }
@ -314,7 +302,7 @@ public:
{ {
if (!is_a_face_started()) return false; if (!is_a_face_started()) return false;
Local_point p=internal::get_local_point(kp); Local_point p=get_local_point(kp);
if (m_points_of_face.empty() || m_points_of_face.back()!=p) // TODO test if the distance between prev point and kp is smaller than an epsilon (?? not sure ??) if (m_points_of_face.empty() || m_points_of_face.back()!=p) // TODO test if the distance between prev point and kp is smaller than an epsilon (?? not sure ??)
{ {
m_points_of_face.push_back(p); m_points_of_face.push_back(p);
@ -331,7 +319,7 @@ public:
{ {
if (add_point_in_face(kp)) if (add_point_in_face(kp))
{ {
m_vertex_normals_for_face.push_back(internal::get_local_vector(p_normal)); m_vertex_normals_for_face.push_back(get_local_vector(p_normal));
return true; return true;
} }
return false; return false;
@ -388,7 +376,8 @@ public:
} }
Local_vector normal=(m_started_face_has_normal?m_normal_of_face: Local_vector normal=(m_started_face_has_normal?m_normal_of_face:
internal::compute_normal_of_face(m_points_of_face)); internal::compute_normal_of_face
<Local_point, Local_vector>(m_points_of_face));
if (m_points_of_face.size()==3) if (m_points_of_face.size()==3)
{ triangular_face_end_internal(normal); } // Triangle: no need to triangulate { triangular_face_end_internal(normal); } // Triangle: no need to triangulate
@ -411,7 +400,7 @@ public:
template<typename KPoint> template<typename KPoint>
static void add_point_in_buffer(const KPoint& kp, std::vector<float>& buffer) static void add_point_in_buffer(const KPoint& kp, std::vector<float>& buffer)
{ {
Local_point p=internal::get_local_point(kp); Local_point p=get_local_point(kp);
buffer.push_back(p.x()); buffer.push_back(p.x());
buffer.push_back(p.y()); buffer.push_back(p.y());
buffer.push_back(p.z()); buffer.push_back(p.z());
@ -421,7 +410,7 @@ public:
template<typename KVector> template<typename KVector>
static void add_normal_in_buffer(const KVector& kv, std::vector<float>& buffer) static void add_normal_in_buffer(const KVector& kv, std::vector<float>& buffer)
{ {
Local_vector n=internal::get_local_vector(kv); Local_vector n=get_local_vector(kv);
buffer.push_back(n.x()); buffer.push_back(n.x());
buffer.push_back(n.y()); buffer.push_back(n.y());
buffer.push_back(n.z()); buffer.push_back(n.z());
@ -796,6 +785,21 @@ protected:
{ add_normal_in_buffer(kv, *m_gouraud_normal_buffer); } { add_normal_in_buffer(kv, *m_gouraud_normal_buffer); }
} }
protected:
// Shortcuts to simplify function calls.
template<typename KPoint>
static Local_point get_local_point(const KPoint& p)
{
return internal::Geom_utils<typename CGAL::Kernel_traits<KPoint>::Kernel, Local_kernel>::
get_local_point(p);
}
template<typename KVector>
static Local_vector get_local_vector(const KVector& v)
{
return internal::Geom_utils<typename CGAL::Kernel_traits<KVector>::Kernel, Local_kernel>::
get_local_vector(v);
}
protected: protected:
// Types usefull for triangulation // Types usefull for triangulation
struct Vertex_info struct Vertex_info

14
GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
View File

@ -446,6 +446,20 @@ public:
} }
protected: protected:
// Shortcuts to simplify function calls.
template<typename KPoint>
static Local_point get_local_point(const KPoint& p)
{
return internal::Geom_utils<typename CGAL::Kernel_traits<KPoint>::Kernel, Local_kernel>::
get_local_point(p);
}
template<typename KVector>
static Local_vector get_local_vector(const KVector& v)
{
return internal::Geom_utils<typename CGAL::Kernel_traits<KVector>::Kernel, Local_kernel>::
get_local_vector(v);
}
void compile_shaders() void compile_shaders()
{ {
rendering_program_face.removeAllShaders(); rendering_program_face.removeAllShaders();

19
Linear_cell_complex/include/CGAL/draw_linear_cell_complex.h
View File

@ -127,29 +127,30 @@ struct DefaultDrawingFunctorLCC
} }
}; };
template<class LCC, class Kernel, int dim=LCC::ambient_dimension> template<class LCC, class Local_kernel, int dim=LCC::ambient_dimension>
struct LCC_geom_utils; struct LCC_geom_utils;
template<class LCC, class Kernel> template<class LCC, class Local_kernel>
struct LCC_geom_utils<LCC, Kernel, 3> struct LCC_geom_utils<LCC, Local_kernel, 3>
{ {
static typename Kernel::Vector_3 static typename Local_kernel::Vector_3
get_vertex_normal(const LCC& lcc, typename LCC::Dart_const_handle dh) get_vertex_normal(const LCC& lcc, typename LCC::Dart_const_handle dh)
{ {
typename Kernel::Vector_3 n = internal::Geom_utils<typename LCC::Traits>:: typename Local_kernel::Vector_3 n = internal::Geom_utils
<typename LCC::Traits, Local_kernel>::
get_local_vector(CGAL::compute_normal_of_cell_0<LCC>(lcc,dh)); get_local_vector(CGAL::compute_normal_of_cell_0<LCC>(lcc,dh));
n = n/(CGAL::sqrt(n*n)); n = n/(CGAL::sqrt(n*n));
return n; return n;
} }
}; };
template<class LCC, class Kernel> template<class LCC, class Local_kernel>
struct LCC_geom_utils<LCC, Kernel, 2> struct LCC_geom_utils<LCC, Local_kernel, 2>
{ {
static typename Kernel::Vector_3 static typename Local_kernel::Vector_3
get_vertex_normal(const LCC&, typename LCC::Dart_const_handle) get_vertex_normal(const LCC&, typename LCC::Dart_const_handle)
{ {
typename Kernel::Vector_3 n=CGAL::NULL_VECTOR; typename Local_kernel::Vector_3 n=CGAL::NULL_VECTOR;
return n; return n;
} }
}; };

4
Polyhedron/include/CGAL/draw_polyhedron.h
View File

@ -157,8 +157,8 @@ protected:
do do
{ {
internal::newell_single_step_3 internal::newell_single_step_3
(internal::Geom_utils<Kernel>::get_local_point(he->vertex()->point()), (this->get_local_point(he->vertex()->point()),
internal::Geom_utils<Kernel>::get_local_point(he->next()->vertex()->point()), this->get_local_point(he->next()->vertex()->point()),
normal); normal);
++nb; ++nb;
he=he->next(); he=he->next();

4
Surface_mesh/include/CGAL/draw_surface_mesh.h
View File

@ -165,8 +165,8 @@ protected:
do do
{ {
internal::newell_single_step_3 internal::newell_single_step_3
(internal::Geom_utils<Kernel>::get_local_point(sm.point(sm.source(he))), (this->get_local_point(sm.point(sm.source(he))),
internal::Geom_utils<Kernel>::get_local_point(sm.point(sm.target(he))), normal); this->get_local_point(sm.point(sm.target(he))), normal);
++nb; ++nb;
he=sm.next(he); he=sm.next(he);
} }