CGAL users discussion list

["jasmeet.singh" <>]

Thanks, everyone for the answers. I really appreciate it.

I do not think that I truly understand what exactly has to be done to solve
the root of the issue here. Getting the Kernel from the point type is not
the right way as pointed out earlier
(CGAL::Kernel_traits<Arr_circle_segment_traits_2&lt;K>::Point_2>::Kernel).
However, the Basic viewer currently imports everything into the buffer by
first converting the points into the Kernel -
CGAL::Exact_predicates_exact_constructions_kernel.

//
-------------------------------------------------------------------------------------
  // Structs to transform any CGAL point/vector into a
Local_point/Local_vector
  template<typename K>
  struct Geom_utils
  {
    static Local_point get_local_point(const typename K::Point_2& p)
    {
      CGAL::Cartesian_converter<K, Local_kernel> converter;
      return Local_point(converter(p.x()), 0, converter(p.y()));
    }
    static Local_point get_local_point(const typename K::Weighted_point_2&
p)
    {
      typename K::Point_2 lp(p);
      return Geom_utils<K>::get_local_point(lp);
    }
    static Local_point get_local_point(const typename K::Point_3& p)
    {
      CGAL::Cartesian_converter<K, Local_kernel> converter;
      return converter(p);
    }
    static Local_point get_local_point(const typename K::Weighted_point_3&
p)
    {
      typename K::Point_3 lp(p);
      return Geom_utils<K>::get_local_point(lp);
    }
    static Local_vector get_local_vector(const typename K::Vector_2& v)
    {
      CGAL::Cartesian_converter<K, Local_kernel> converter;
      return Local_vector(converter(v.x()), 0, converter(v.y()));
    }
    static Local_vector get_local_vector(const typename K::Vector_3& v)
    {
      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 conversion
here.
  template<>
  struct Geom_utils<Local_kernel>
  {
    static Local_point get_local_point(const Local_kernel::Point_2& p)
    { return Local_point(p.x(), 0, p.y()); }
    static Local_point get_local_point(const Local_kernel::Weighted_point_2&
p)
    { return Local_point(p.point().x(), 0, p.point().y());}
    static const Local_point & get_local_point(const Local_kernel::Point_3&
p)
    { return p; }
    static Local_point get_local_point(const Local_kernel::Weighted_point_3&
p)
    { return Local_point(p);}
    static Local_vector get_local_vector(const Local_kernel::Vector_2& v)
    { return Local_vector(v.x(), 0, v.y()); }
    static const Local_vector& get_local_vector(const
Local_kernel::Vector_3& 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);
  }
//
-------------------------------------------------------------------------------------

After trying several methods, I found a method to bypass the conversion of
the point type. I make a call to the add_point() method in circular segment
viewer after converting the point to the kernel used in the buffer of the
basic viewer.

//
-------------------------------------------------------------------------------------
typedef CGAL::Exact_predicates_exact_constructions_kernel Viewer_kernel;
Viewer_kernel::Point_3 p(to_double(vit->point().x()), 0,
                               to_double(vit->point().y()));
this->add_point(p);
//
-------------------------------------------------------------------------------------

This way the code compiles just fine and the points can be viewed in the
viewer window. I know this is probably not the best method to deal with the
problem at hand but it works for the viewer's purposes. Kindly let me know
if you can suggest doing something better.

Also, can you comment on the second part of my doubt:

2. To draw the various curves, the demo uses Qt5's various function defined 
in qpainter.h, eg. drawArc, drawEllipse. However, the basic viewer doesn't 
have support for drawing such curves. How can I draw the curves in the 
arrangement without much duplication in the code? Should I write the draw 
functionalities for circular arcs, bezier curves, etc. from scratch or can I 
use it from somewhere? 






--
Sent from: http://cgal-discuss.949826.n4.nabble.com/