ACS. Python, Scilab and Ipe interfaces to CGAL. Sébastien Loriot Naceur Meskini Sylvain Pion. ACS Technical Report No.

Transcription

1 ACS Algorithms for Complex Shapes with Certified Numerics and Topology Python, Scilab and Ipe interfaces to CGAL Sébastien Loriot Naceur Meskini Sylvain Pion ACS Technical Report No.: ACS-TR Part of deliverable: WP-III/D6 Site: INRIA Month: 36 Project co-funded by the European Commission within FP6 ( ) under contract nr. IST

2 Abstract We present three available software that we have developed as alternative user interfaces to the geometric algorithms and data structures available in CGAL. CGAL is a C++ library and makes use of refined C++ features in order to achieve efficiency and adaptability through genericity. In order to broaden the scope of usability of CGAL, especially targeting the non-c++ expert community, we have therefore started an effort to wrap CGAL in the following three languages and platforms. Python is a general purpose, interpreted, modern and easy to learn language, increasingly used for scientific computation. Scilab is a Matlab-like platform and language for numerical computations, which incorporates an interpreter. Finally, Ipe is an extensible drawing editor heavily used in the computational geometry community, which can call external plugins providing user-defined geometric algorithms for illustration purposes. This paper describes in more detail these three projects. 1

3 1 Introduction CGAL is a wonderful and powerful C++ library of geometric data structures and algorithms. Its key features are genericity, efficiency and robustness. It is a 12 years old project of considerable size: 600,000 lines of C++ code. It is used in numerous application domains in need for geometric computing, such as geographical information systems, geology, structural biology, medical imaging, CAD/CAM... CGAL is available under Open Source and commercial licenses. The mission statement of the CGAL project is to turn research results obtained in the field of computation geometry, into a software library usable in industry and academia. While CGAL is impressive, it is also sometimes hard to use for beginners due to the difficulty to have both simplicity and adaptability/genericity. In particular, CGAL makes use of advanced C++ features such as templates, which are hard to master by beginners in programming. We have therefore made some efforts to bring some important functionalities of CGAL to other communities, in order to reach more people. We have considered two other languages Python and Scilab, and a graphical drawing editor Ipe, and we have made some CGAL functionalities available through them. Scilab is an Open Source equivalent of Matlab, which is used by many engineers as well as in education. Python is an interpreted language which is dynamically typed and easy to learn, and it is increasingly used for scientific computations. Finally Ipe is an extensible graphical drawing editor focused on 2D with good support for geometry. We will present the three projects CGAL-PYTHON, CGLAB and CGAL- IPELETS, which respectively wrap parts of CGAL in Python, Scilab and Ipe, in the following 3 sections. For each of them we describe the design and implementation, give examples, and list the available functionalities. 2 CGAL-PYTHON: the Python interface to CGAL 2.1 Python presentation Quoting Python s web site, Python is a dynamic object-oriented programming language that can be used for many kinds of software development. It offers strong support for integration with other languages and tools, comes with extensive standard libraries, and can be learned in a few days. Many Python programmers report substantial productivity gains and feel the language encourages the development of higher quality, more maintainable code. Python is increasingly used for scientific computing. For example, the SciPy project is a quickly growing collection of scientific tools in Python. We therefore decided to start an effort in order to have parts of CGAL available in Python. 2.2 Implementation and example Python provides facilities to interoperate with C and C++, that is, calling functions from external libraries, passing objects and data around. These libraries can then be loaded from the interpreter at run time in the form of shared libraries. On top of this, and specific to C++, is the Boost.Python library 2

4 doc/libs/1_35_0/libs/python/doc/index.html which provides a convenient way to add C++ types and functions to be made available in Python. On top of this, some tools have been developed to automate the process of listing the functions and types to wrap in Python, in combination with Boost.Python. Such tools are code parsers and generators like Py++ net/pyplusplus/pyplusplus.html that can understand CGAL s functions and classes declarations and generate an input suitable for Boot.Python. At the time we started the project, Py++ was not usable enough, so we chose another tool named Pyste. We decided to start from the output of Pyste, and then improve it by hand. Boost.Python in particular provides a mechanism to add documentation for the online help within the Python interpreter, which is something we used. One difficulty is the fact that template parameters have to be fixed, since we cannot trigger template instantiation from within Python (not easily at least). Some decisions can be differed at run-time, or several instantiations are sometimes possible with a run-time choice on the Python side, but we had to make some decisions also to simplify the interface in the Python side. Typically, iterators in C++ correspond to iterators in Python, but adaptation has to be done. In CGAL, one main choice which had to be made is the choice of a kernel and the number type used in the coordinates. This choice is critical since CGAL algorithms may have different requirements. We aimed here at simplicity and opted for a kernel using coordinates as floating-point, but using exact predicates for robustness and efficiency. Here is an example using the Triangulations 2 module: #Importation of Kernel module is necessary in order to be able to use #the basic geometric objects from CGAL.Kernel import * # we want to use a Delaunay_triangulation_2 from CGAL.Triangulations_2 import * from random import * # we construct the triangulation here dt = Delaunay_triangulation_2() # we generate a random points and insert them in the dt triangulation vertices = {} for i in range(20): vertices[i] = dt.insert(point_2(random(),random())) # cir_faces is a circulator over the incident faces of the Vertex vertices[0] cir_faces = dt.incident_faces(vertices[0]) # use of the incident_faces function # compute the finite faces incident to vertices[0] finite_faces = [] f1 = cir_faces.next() if dt.is_infinite(f1) == False: finite_faces.append(f1) for f in cir_faces: if f == f1: break finite_faces.append(f) 3

5 # the finite edges of the triangulation for e in dt.edges: print e.vertex() #draw_edge(e) # the finite vertices for v in dt.vertices: print v.point().x(),v.point().y() #the finite points: for p in dt.points: print p.x(),p.y() # use of line_walk function # first, we have to define a line that will cross the triangulation p1 = Point_2(0,0) p2 = Point_2(1,1) faces = dt.line_walk(p1,p2) # this function return a list of faces for f in faces: if dt.is_infinite(f) == False: #draw_face(f) print "this face is finite" 2.3 Available functionalities CGAL-PYTHON is available at Here is the list of functionalities available in CGAL-PYTHON, as of version Triangulations 2 This module corresponds to the Triangulation 2 package of CGAL that allows to build and handle various triangulations for point sets in two dimensions. It contains the following classes: Triangulation 2, Delaunay triangulation 2, Delaunay constrained triangulation 2, Constrained triangulation 2, Constrained triangulation plus 2. Triangulations 3 This module allows to build and handle triangulations for point sets in three dimensions. Currently this module provides two classes: Triangulation 3, Delaunay triangulation 3. Alpha shapes 2 Alpha shape 2. Alpha shapes 3 Alpha shape 3. Polyhedron Polyhedron 3. Convex hull 2 convex hull 2, ch akl toussaint, ch graham andrew. Geometric Optimisation Min ellipse 2, Min circle 2, Min sphere 3, Min annulus 2, Min annulus 3. 4

6 Mesh 2 Delaunay mesher 2. Kernel Point 2(3), Ray 2(3), and many other basic geometric objects. The project has several users, and even contributors, since more CGAL modules can be interfaced in CGAL-PYTHON, and extensions like the py.cgal.visual project 3 CGLAB: the Scilab interface to CGAL 3.1 SCILAB presentation Quoting Scilab s web site Scilab is a scientific software package for numerical computations providing a powerful open computing environment for engineering and scientific applications. Scilab is an open source software. Scilab is an environment similar to the commercial platform Matlab by The MathWorks. Its main data type is a matrix of floating-point values. 3.2 Implementation and example Scilab is a special environment, in particular its language is not general purpose, but specialized with a strong emphasis on matrices. In order to make some CGAL algorithms available in Scilab, we decided it was better to try to keep Scilab s native data structures, rather than wrap CGAL s. For example, in CGLAB, a triangulation is encoded as an adjacency matrix, but it is possible to use CGAL s data structure for an easier access to dynamic modification. Compared to Python, the possibility to more or less automatically wrap C++ functionalities in Scilab does not exist, so the wrappers are far less extensive compare to CGAL-PYTHON. We focused on triangulations and meshes. Here is an example of code using Scilab and CGLAB to build and plot a 2D Delaunay triangulation: x = rand(1,100); y = rand(1,100); tri = cgal_delaunay_2(x,y); [nbtri,nb] = size(tri); tri = [tri tri(:,1)]; for k = 1:nbtri plot2d(x(tri(k,:)), y(tri(k,:)), style = 2); end 3.3 Available functionalities CGLAB is available at with an online documentation. As of CGLAB 1.0, the list of available functionalities is the following: 2D and 3D Delaunay triangulations : access to the connectivity, and point insertion and removal. nd Delaunay triangulations : access to the connectivity, and point insertion. 2D Constrained Delaunay Triangulation : access to the connectivity, and point and constraints insertion and removal. 5

7 2D Meshes : access to the connectivity, mesh refinement. 2D and 3D Convex hull of points. Function Interpolation of functions defined on sets of points in 2D and 3D. Streamlines placements in 2D vector fields. 4 CGAL-IPELETS: plugins for the Ipe drawing editor based on CGAL 4.1 IPE presentation The Ipe extensible drawing editor ( is a vector based graphic editor written in C++ and Lua 5.1. This is a free software under GNU GPL license 1 working on Unix, Windows and Mac OS X. In addition to the classical possibility to draw segments, splines, circles, polygons... some advanced features such as different alignments, intersection snapping are provided for more accurate drawing. Written by Otfried Cheong [1], it has a large user base inside the computational geometry community and more generally among computer scientists. It is the natural companion for a latex document as it can call a L A TEX compiler that allows TEX notations on drawings and to save them as a PDF or an EPS file. Moreover since the notions of layers and multi-pages are provided it can be used as a WYSIWYG tool for preparation of presentation. Another reason to use Ipe is the fact that it is an extensible editor. Indeed through the mechanism of ipelets, users can provide a small piece of code that will be used by the software for a special drawing action. This allows you for example to draw figures in the paper for your new algorithm (in 2D of course). Since an ipelet must be written in C++, it comes naturally to interface Ipe with CGAL. Taking advantage of the work done in CGAL, we can provide a bunch of 2D algorithms helpful for illustration of the CGAL documentation, talks or papers, but also to test some ideas using Ipe instead of an erroneous handmade drawing, without writing a line of code. 4.2 Implementation and example The basic idea of the implementation is to provide one ipelet per class of 2D algorithm. Almost all the 2D algorithms of the 3.3 release of CGAL have been interfaced with Ipe. The mechanism is simple: we provide a basic class CGAL::Ipelet base from which your ipelet must inherit, which avoid some annoying and repetitive declarations. Some basic functions are additionally provided for example to convert points from Ipe format to CGAL point type. Using the implemented tools, a Delaunay triangulation ipelet using CGAL is simply the following: #include <CGAL/Delaunay_triangulation_2.h> //CGAL include #include <CGAL_Ipelet_base.h> //CGAL-ipelet include namespace CGAL_triangulation{ typedef CGAL::Delaunay_triangulation_2<KernelCD> Delaunay; const std::string Slab[] = {"Delaunay"}; //label in the menu 1 As a special exception, you have permission to link Ipe with the CGAL library and distribute executables, as long as you follow the requirements of the GNU General Public License in regard to all of the software in the executable aside from CGAL 6

8 const std::string Hmsg[] = { "Draw a Delaunay triangulation of a set of points"}; //help msg class triangulationipelet : public CGAL::Ipelet_base{ public: triangulationipelet() :CGAL::Ipelet_base(2,Slab,Hmsg,"Triangulations"){} void Unsafe_Run(int, IpePage *page, IpeletHelper *helper); }; void triangulationipelet ::Unsafe_Run(int fn, IpePage *page,ipelethelper *helper){ Delaunay dt; } if (fn==1) { Show_help(helper); return; } //Recover all points and insert them in the triangulation for(ipepage::iterator it=page->begin(); it!=page->end(); ++it) if(is_active_ipe_point(it)) dt.insert(ipe_to_cgal_point(it)); //check triangulation is not empty if (!dt.number_of_vertices()) { helper->message("no marks selected"); return; } page->deselectall(); //use implemented function to draw segments draw_segments(dt.finite_edges_begin(), dt.finite_edges_end(),dt,page,helper); //make the triangulation a group page->group(helper->currentlayer()); } //declaration of the ipelet using a macro CGAL_IPELET(CGAL_triangulation::triangulationIpelet) 4.3 Available functionalities In this section we enumerate the ipelets written available in release 0.9. More information can be found on the CGAL-IPELETS web site ( gforge.inria.fr/). Alpha-shape Draw the boundary of the alpha-shape and its faces for the k-th critical spectral value. Arrangement Given a set of circles, segments, polygons and circles arcs, compute the segmentation induced by intersection points and points of discontinuity for x-monotonicity. 7

9 Given a set of general segments, such that each endpoint is shared exactly twice, change this union to a closed path i.e. fillable. Given several closed paths, join them useful to fill a face with several holes. Diagrams Draw power using circles and points, Voronoi using points, segments, and Apollonius using circles and points, diagrams. Hilbert Curve Given a set of points, draw a Hilbert curve sorting these points. Hulls package Draw the minimal convex hull of a set of segments, circles and points. Draw the result of the crust algorithm for a set of points. K-th Delaunay Draw k-th Voronoi diagram or Delaunay triangulation of a set of points. K-th regular Draw the k-th Power diagram or Regular triangulation of a set of weighted points. Mesh 2 Mesh a close domain using algorithm Mesh 2: seeds are specified by circles. Minkowski Sum Draw the Minkowski sum of two simple polygons. Origin is placed at the min point of the bounding box of the selected objects. Draw the offsets of a simple polygon defined by a set of circles. Polygon partition Draw the convex partition of a polygon, several algorithms are available. Random Generators Generate random set of points, circles, segments. Triangulation Draw regular triangulation using circles and points Draw constrained triangulation using points and segments Draw Delaunay, conforming Delaunay and conforming Gabriel triangulations 5 Conclusion and future work We have presented three software projects CGAL-PYTHON, CGLAB and CGAL- IPELETS that deal with interfacing the CGAL library together with Python, Scilab and Ipe. The first two are programming environments which provide interpreters that allow to call CGAL functions directly. Ipe is a extensible drawing editor which can display the result of geometric algorithms available in CGAL. Future work could consist in extending the functionalities already made available in these wrappers, and possibly work on automating the process of wrapping, especially for CGAL-PYTHON. References [1] Otfried Schwarzkopf. The extendible drawing editor Ipe. In Proc. 11th Annu. ACM Sympos. Comput. Geom., pages C10 C11,

10 Figure 1: Using CGAL-IPELETS: ACS from a point cloud to polygons using Crust algorithm, to a mesh using Mesh 2 Figure 2: Using CGAL-IPELETS: Delaunay triangulation of a set of points 9

11 Figure 3: Using CGAL-IPELETS: Partition of a polygon in convex regions Figure 4: Using CGAL-IPELETS: Power diagram of a set of circles 10