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

Start to implement infinite line in basic viewer.

This commit is contained in:
Jasmeet Singh 2019-06-12 23:05:10 -07:00
parent d2eaef16d0
commit 608ba3eee8
3 changed files with 196 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -42,6 +42,7 @@ 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;
typedef Local_kernel::Ray_2 Local_ray;
//------------------------------------------------------------------------------
namespace internal
@ -108,6 +109,11 @@ namespace internal
CGAL::Cartesian_converter<K, Local_kernel> converter;
return converter(v);
}
static Local_ray get_local_ray(const typename K::Ray_2& r)
{
CGAL::Cartesian_converter<K, Local_kernel> converter;
return converter(r);
}
};
// Specialization for Local_kernel, because there is no need of convertion here.
@ -246,6 +252,14 @@ public:
add_color(c);
}
// 2.2+) Add a line, without color. TODO: Modify comment numbering
template<typename KPoint>
void add_line(const KPoint& kp1, const KPoint& kp2)
{
add_point(kp1);
add_point(kp2);
}
// 2.3) Add an indexed segment, without color.
template<typename T>
void add_indexed_segment(T index1, T index2)

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

@ -178,9 +178,11 @@ public:
m_use_mono_color(use_mono_color),
m_inverse_normal(inverse_normal),
m_size_points(7.),
m_size_edges(3.1),
m_size_edges(3.1),
m_size_lines(3.1),
m_vertices_mono_color(200, 60, 60),
m_edges_mono_color(0, 0, 0),
m_lines_mono_color(0,100,0),
m_faces_mono_color(60, 60, 200),
m_ambient_color(0.6f, 0.5f, 0.5f, 0.5f),
m_are_buffers_initialized(false),
@ -202,6 +204,15 @@ public:
&m_bounding_box,
&arrays[COLOR_SEGMENTS],
NULL, NULL),
m_buffer_for_mono_lines(&arrays[POS_MONO_LINES],
NULL,
&m_bounding_box,
NULL, NULL),
m_buffer_for_colored_lines(&arrays[POS_COLORED_LINES],
NULL,
&m_bounding_box,
&arrays[COLOR_LINES],
NULL, NULL),
m_buffer_for_mono_faces(&arrays[POS_MONO_FACES],
NULL,
&m_bounding_box,
@ -268,7 +279,11 @@ public:
template<typename KPoint>
void add_segment(const KPoint& p1, const KPoint& p2,
const CGAL::Color& acolor)
{ m_buffer_for_colored_segments.add_segment(p1, p2, acolor); }
{ m_buffer_for_colored_segments.add_segment(p1, p2, acolor); }
template<typename KPoint>
void add_line(const KPoint& p1, const KPoint& p2)
{ m_buffer_for_mono_lines.add_line(p1, p2); }
bool is_a_face_started() const
{
@ -467,6 +482,52 @@ protected:
rendering_program_p_l.release();
// 3) LINE SHADER
// 3.1) Mono lines
vao[VAO_MONO_LINES].bind();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_MONO_LINES].data(),
static_cast<int>(arrays[POS_MONO_LINES].size()*sizeof(float)));
rendering_program_p_l.enableAttributeArray("vertex");
rendering_program_p_l.setAttributeArray("vertex",GL_FLOAT,0,3);
buffers[bufn].release();
rendering_program_p_l.disableAttributeArray("color");
vao[VAO_MONO_LINES].release();
// 3.2) Color lines
vao[VAO_COLORED_LINES].bind();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[POS_COLORED_LINES].data(),
static_cast<int>(arrays[POS_COLORED_LINES].size()*sizeof(float)));
rendering_program_p_l.enableAttributeArray("vertex");
rendering_program_p_l.setAttributeBuffer("vertex",GL_FLOAT,0,3);
buffers[bufn].release();
++bufn;
assert(bufn<NB_VBO_BUFFERS);
buffers[bufn].bind();
buffers[bufn].allocate(arrays[COLOR_LINES].data(),
static_cast<int>(arrays[COLOR_LINES].size()*sizeof(float)));
rendering_program_p_l.enableAttributeArray("color");
rendering_program_p_l.setAttributeBuffer("color",GL_FLOAT,0,3);
buffers[bufn].release();
vao[VAO_COLORED_LINES].release();
rendering_program_p_l.release();
// 3) FACE SHADER
rendering_program_face.bind();
@ -702,6 +763,39 @@ protected:
rendering_program_p_l.release();
}
if(m_draw_lines)
{
rendering_program_p_l.bind();
vao[VAO_MONO_LINES].bind();
color.setRgbF((double)m_lines_mono_color.red()/(double)255,
(double)m_lines_mono_color.green()/(double)255,
(double)m_lines_mono_color.blue()/(double)255);
rendering_program_p_l.setAttributeValue("color",color);
glLineWidth(m_size_lines);
glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(arrays[POS_MONO_LINES].size()/3));
vao[VAO_MONO_SEGMENTS].release();
vao[VAO_COLORED_SEGMENTS].bind();
if (m_use_mono_color)
{
color.setRgbF((double)m_lines_mono_color.red()/(double)255,
(double)m_lines_mono_color.green()/(double)255,
(double)m_lines_mono_color.blue()/(double)255);
rendering_program_p_l.disableAttributeArray("color");
rendering_program_p_l.setAttributeValue("color",color);
}
else
{
rendering_program_p_l.enableAttributeArray("color");
}
glLineWidth(m_size_lines);
glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(arrays[POS_COLORED_LINES].size()/3));
vao[VAO_COLORED_LINES].release();
rendering_program_p_l.release();
}
if (m_draw_faces)
{
rendering_program_face.bind();
@ -985,6 +1079,7 @@ protected:
protected:
bool m_draw_vertices;
bool m_draw_edges;
bool m_draw_lines;
bool m_draw_faces;
bool m_flatShading;
bool m_use_mono_color;
@ -992,9 +1087,11 @@ protected:
double m_size_points;
double m_size_edges;
double m_size_lines;
CGAL::Color m_vertices_mono_color;
CGAL::Color m_edges_mono_color;
CGAL::Color m_lines_mono_color;
CGAL::Color m_faces_mono_color;
QVector4D m_ambient_color;
@ -1009,12 +1106,15 @@ protected:
POS_COLORED_POINTS,
POS_MONO_SEGMENTS,
POS_COLORED_SEGMENTS,
POS_MONO_LINES,
POS_COLORED_LINES,
POS_MONO_FACES,
POS_COLORED_FACES,
END_POS,
BEGIN_COLOR=END_POS,
COLOR_POINTS=BEGIN_COLOR,
COLOR_SEGMENTS,
COLOR_LINES,
COLOR_FACES,
END_COLOR,
BEGIN_NORMAL=END_COLOR,
@ -1031,6 +1131,8 @@ protected:
Buffer_for_vao<float> m_buffer_for_colored_points;
Buffer_for_vao<float> m_buffer_for_mono_segments;
Buffer_for_vao<float> m_buffer_for_colored_segments;
Buffer_for_vao<float> m_buffer_for_mono_lines;
Buffer_for_vao<float> m_buffer_for_colored_lines;
Buffer_for_vao<float> m_buffer_for_mono_faces;
Buffer_for_vao<float> m_buffer_for_colored_faces;
@ -1045,6 +1147,8 @@ protected:
VAO_COLORED_POINTS,
VAO_MONO_SEGMENTS,
VAO_COLORED_SEGMENTS,
VAO_MONO_LINES,
VAO_COLORED_LINES,
VAO_MONO_FACES,
VAO_COLORED_FACES,
NB_VAO_BUFFERS

97
Voronoi_diagram_2/include/CGAL/draw_voronoi_diagram_2.h
View File

@ -26,10 +26,17 @@
#ifdef CGAL_USE_BASIC_VIEWER
#include <CGAL/Voronoi_diagram_2/basic.h>
#include <CGAL/Voronoi_diagram_2/Handle_adaptor.h>
#include <CGAL/Voronoi_diagram_2/Face.h>
#include <CGAL/Voronoi_diagram_2/Vertex.h>
#include <CGAL/Triangulation_utils_2.h>
#include <CGAL/Qt/Converter.h>
#include <CGAL/Random.h>
namespace CGAL
{
// Default color functor; user can change it to have its own face color
struct DefaultColorFunctorV2
{
@ -46,11 +53,21 @@ struct DefaultColorFunctorV2
template<class V2, class ColorFunctor>
class SimpleVoronoiDiagram2ViewerQt : public Basic_viewer_qt
{
typedef Basic_viewer_qt Base;
typedef typename V2::Halfedge_iterator Halfedge_const_handle;
typedef typename V2::Face_iterator Face_const_handle;
typedef typename V2::Vertex_iterator Vertex_const_handle;
typedef typename V2::Point_2 Point;
typedef Basic_viewer_qt Base;
typedef typename V2::Halfedge_iterator Halfedge_const_handle;
typedef typename V2::Face_iterator Face_const_handle;
typedef typename V2::Vertex_iterator Vertex_const_handle;
typedef typename V2::Point_2 Point;
typedef typename V2::Delaunay_vertex_handle Delaunay_vertex_const_handle;
typedef typename V2::Ccb_halfedge_circulator Ccb_halfedge_circulator;
typedef typename V2::Delaunay_geom_traits Delaunay_geom_traits;
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef CGAL_VORONOI_DIAGRAM_2_INS::Face<V2> Face;
typedef CGAL_VORONOI_DIAGRAM_2_INS::Handle_adaptor<Face> Face_handle;
typedef CGAL_VORONOI_DIAGRAM_2_INS::Vertex<V2> Vertex;
typedef CGAL_VORONOI_DIAGRAM_2_INS::Handle_adaptor<Vertex> Vertex_handle;
typedef Triangulation_cw_ccw_2 CW_CCW_2;
public:
/// Construct the viewer.
@ -72,22 +89,56 @@ public:
}
protected:
// void compute_face(Face_const_handle fh)
// {
void compute_face(Face_const_handle fh)
{
// CGAL::Color c=m_fcolor.run(v2, fh);
// face_begin(c);
// add_point_in_face(fh->halfedge()->source()->point());
// add_point_in_face(fh->halfedge()->source()->point());
// add_point_in_face(fh->halfedge()->source()->point());
// Ccb_halfedge_circulator ec_start = fh->ccb();
// Ccb_halfedge_circulator ec = ec_start;
// do{
// if( ec->has_source() )
// add_point_in_face(ec->source()->point());
// else if(ec->has_target())
// add_point_in_face(ec->target()->point());
// } while(++ec != ec_start);
// face_end();
// }
}
void compute_edge(Halfedge_const_handle he)
{
if(he->is_segment())
add_segment(he->source()->point(),
he->target()->point());
if(he->is_segment()){
add_segment(he->source()->point(),
he->target()->point());
} else if(he->is_ray()){
Delaunay_vertex_const_handle v1 = he->up();
Delaunay_vertex_const_handle v2 = he->down();
Kernel::Vector_2 direction(v1->point().y()-v2->point().y(),
v2->point().x()-v1->point().x());
Kernel::Point_2 end_point;
if(he->has_source()){
end_point = he->source()->point();
} else {
end_point = he->target()->point();
}
Kernel::Ray_2 ray(end_point, direction);
CGAL::Bbox_3 bb;
if (bb==bounding_box()) // Case of "empty" bounding box
{ bb=Local_point(CGAL::ORIGIN).bbox();
bb=bb + Local_point(500,500,500).bbox(); // To avoid a warning from Qglviewer
}
else
{ bb=bounding_box(); }
Kernel::Iso_rectangle_2 clipping_rect(bb.xmin(), bb.ymin(),
bb.xmax(), bb.ymax());
Object o = CGAL::intersection(ray, clipping_rect);
typedef Kernel::Segment_2 Segment_2;
typedef Kernel::Point_2 Point_2;
if(const Segment_2 *s = CGAL::object_cast<Segment_2>(&o)){
add_segment(s->source(), s->target());
}
}
}
void compute_vertex(Vertex_const_handle vh)
@ -97,13 +148,16 @@ protected:
{
clear();
// if (!m_nofaces)
// {
// for (typename V2::Face_iterator it=v2.faces_begin();
// it!=v2.faces_end(); ++it)
// { compute_face(it); }
// }
if (!m_nofaces)
{
for (typename V2::Face_iterator it=v2.faces_begin();
it!=v2.faces_end(); ++it)
{ compute_face(it); }
}
// for(Delaunay_vertex_const_handle it = v2.dual().finite_vertices_begin();
// it!=v2.dual().finite_vertices_end(); ++it)
// { compute_vertex(it);}
for (typename V2::Halfedge_iterator it=v2.halfedges_begin();
it!=v2.halfedges_end(); ++it)
{ compute_edge(it); }
@ -130,6 +184,7 @@ protected:
}
protected:
CGAL::Qt::Converter<Delaunay_geom_traits> convert;
const V2& v2;
bool m_nofaces;
const ColorFunctor& m_fcolor;