diff --git a/Documentation/how_to_cite_cgal.bib b/Documentation/how_to_cite_cgal.bib index f854b88ac17..966dbd1637a 100644 --- a/Documentation/how_to_cite_cgal.bib +++ b/Documentation/how_to_cite_cgal.bib @@ -1,800 +1,858 @@ -@book{ cgal:eb-12b +% please dont't modify the "arobase" string commands +% they are used by the scripts to create the "How to cite CGAL" web page +% thanks - Monique + +@string{ author_create_page = 0 } +@string{ category_create_page = 0 } +@string{ reduced_year_create_page = 0 } +@string{ complete_year_create_page = 0 } + +@string{ index_file_title = "How to cite CGAL" } +@string{ index_page_title = "How to cite CGAL" } + +@string{ complete_biblio_file_title = "CGAL Publications sorted by year" } +@string{ complete_biblio_page_title = "CGAL Publications sorted by year" } +@string{ filename_complete_biblio = "how_to_cite_cgal" } + +@string{ head_tag.end = "layout.html" } +%@string{ header_of_contents = "header_of_contents" } + +@string{ keyword_build_initials_index = 0 } +@string{ keyword_put_initials_in_index = 0 } + +@string{ keyword_write_bibtex_abstract = 0 } +@string{ complete_biblio_write_bibtex_abstract = 0 } + +@string{ disclaimer_2 = ""} +@STRING{ default_header_of_body = "" } +@STRING{ default_footer_of_contents = ""} +@string{ index_write_author = 0 } +@string{ keyword_write_author = 0 } +@string{ complete_biblio_write_author = 0 } + +@string{ index_write_date = 0 } +@string{ keyword_write_date = 0 } +@string{ complete_biblio_write_date = 0 } + + + +@book{ cgal:eb-14b , title = "{CGAL} User and Reference Manual" , author = "{The CGAL Project}" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" -, year = 2012 -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html" +, edition = "{}" +, year = 2014 +, url = "http://doc.cgal.org//Manual/packages.html" } -@incollection{cgal:h-af-12b +@incollection{cgal:h-af-14b , author = "Michael Hemmer" , title = "Algebraic Foundations" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:AlgebraicFoundations" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgAlgebraicFoundationsSummary" +, year = 2014 } -@incollection{cgal:bht-ak-12b -, author = "Eric Berberich and Michael Hemmer and Sylvain Lazard and Luis Pe\~{n}aranda and Monique Teillaud" +@incollection{cgal:bht-ak-14b +, author = "Eric Berberich and Michael Hemmer and Michael Kerber and Sylvain Lazard and Luis Pe{\~n}aranda and Monique Teillaud" , title = "Algebraic Kernel" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:AlgebraicKerneld" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgAlgebraicKerneldSummary" +, year = 2014 } -@incollection{cgal:hhkps-nt-12b +@incollection{cgal:hhkps-nt-14b , author = "Michael Hemmer and Susan Hert and Lutz Kettner and Sylvain Pion and Stefan Schirra" , title = "Number Types" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:NumberTypes" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgNumberTypesSummary" +, year = 2014 } -@incollection{cgal:h-p-12b +@incollection{cgal:h-p-14b , author = "Michael Hemmer" , title = "Polynomial" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Polynomial" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgPolynomialSummary" +, year = 2014 } -@incollection{cgal:h-ma-12b +@incollection{cgal:h-ma-14b , author = "Michael Hemmer" , title = "Modular Arithmetic" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:ModularArithmetic" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgModularArithmeticSummary" +, year = 2014 } -@incollection{cgal:bfghhkps-lgk23-12b +@incollection{cgal:bfghhkps-lgk23-14b , author = "Herv{\'e} Br{\"o}nnimann and Andreas Fabri and Geert-Jan Giezeman and Susan Hert and Michael Hoffmann and Lutz Kettner and Sylvain Pion and Stefan Schirra" , title = "{2D} and {3D} Geometry Kernel" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Kernel23" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgKernel23Summary" +, year = 2014 } -@incollection{cgal:s-gkd-12b +@incollection{cgal:s-gkd-14b , author = "Michael Seel" , title = "{dD} Geometry Kernel" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:KernelD" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgKernelDSummary" +, year = 2014 } -@incollection{cgal:cpt-cgk2-12b +@incollection{cgal:cpt-cgk2-14b , author = "Pedro Machado Manh\~{a}es de Castro and Sylvain Pion and Monique Teillaud" , title = "{2D} Circular Geometry Kernel" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:CircularKernel2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgCircularKernel2Summary" +, year = 2014 } -@incollection{cgal:cclt-sgk3-12b +@incollection{cgal:cclt-sgk3-14b , author = "Pedro Machado Manh\~{a}es de Castro and Fr{\'e}d{\'e}ric Cazals and S{\'e}bastien Loriot and Monique Teillaud" , title = "{3D} Spherical Geometry Kernel" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:SphericalKernel3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgSphericalKernel3Summary" +, year = 2014 } -@incollection{cgal:hs-chep2-12b +@incollection{cgal:hs-chep2-14b , author = "Susan Hert and Stefan Schirra" , title = "{2D} Convex Hulls and Extreme Points" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:ConvexHull2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgConvexHull2Summary" +, year = 2014 } -@incollection{cgal:hs-ch3-12b +@incollection{cgal:hs-ch3-14b , author = "Susan Hert and Stefan Schirra" , title = "{3D} Convex Hulls" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:ConvexHull3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgConvexHull3Summary" +, year = 2014 } -@incollection{cgal:gw-p2-12b +@incollection{cgal:gw-p2-14b , author = "Geert-Jan Giezeman and Wieger Wesselink" , title = "{2D} Polygons" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Polygon2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgPolygon2Summary" +, year = 2014 } -@incollection{cgal:h-pp2-12b +@incollection{cgal:h-pp2-14b , author = "Susan Hert" , title = "{2D} Polygon Partitioning" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:PolygonPartitioning2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgPolygonPartitioning2Summary" +, year = 2014 } -@incollection{cgal:hs-chdt3-12b +@incollection{cgal:hs-chdt3-14b , author = "Susan Hert and Michael Seel" , title = "{dD} Convex Hulls and {Delaunay} Triangulations" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:ConvexHullD" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgConvexHullDSummary" +, year = 2014 } -@incollection{cgal:k-ps-12b +@incollection{cgal:k-ps-14b , author = "Lutz Kettner" , title = "{3D} Polyhedral Surfaces" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Polyhedron" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgPolyhedronSummary" +, year = 2014 } -@incollection{cgal:k-hds-12b +@incollection{cgal:k-hds-14b , author = "Lutz Kettner" , title = "Halfedge Data Structures" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:HDS" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgHDSSummary" +, year = 2014 } -@incollection{cgal:d-cm-12b +@incollection{cgal:d-cm-14b , author = "Guillaume Damiand" , title = "Combinatorial Maps" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:CombinatorialMaps" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgCombinatorialMapsSummary" +, year = 2014 } -@incollection{cgal:d-lcc-12b +@incollection{cgal:d-lcc-14b , author = "Guillaume Damiand" , title = "Linear Cell Complex" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:LinearCellComplex" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgLinearCellComplexSummary" +, year = 2014 } -@incollection{cgal:fwzh-rbso2-12b +@incollection{cgal:fwzh-rbso2-14b , author = "Efi Fogel and Ron Wein and Baruch Zukerman and Dan Halperin" , title = "{2D} Regularized {Boolean} Set-Operations" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:BooleanSetOperations2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgBooleanSetOperations2Summary" +, year = 2014 } -@incollection{cgal:w-rms2-12b +@incollection{cgal:w-rms2-14b , author = "Ron Wein" , title = "{2D} {Minkowski} Sums" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:MinkowskiSum2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgMinkowskiSum2Summary" +, year = 2014 } -@incollection{cgal:s-bonp2-12b +@incollection{cgal:s-bonp2-14b , author = "Michael Seel" , title = "{2D} {Boolean} Operations on {Nef} Polygons" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Nef2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgNef2Summary" +, year = 2014 } -@incollection{cgal:hk-bonpes2-12b +@incollection{cgal:hk-bonpes2-14b , author = "Peter Hachenberger and Lutz Kettner" , title = "{2D} {Boolean} Operations on {Nef} Polygons Embedded on the Sphere" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:NefS2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgNefS2Summary" +, year = 2014 } -@incollection{cgal:hk-bonp3-12b +@incollection{cgal:hk-bonp3-14b , author = "Peter Hachenberger and Lutz Kettner" , title = "{3D} {Boolean} Operations on {Nef} Polyhedra" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Nef3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgNef3Summary" +, year = 2014 } -@incollection{cgal:h-emspe-12b +@incollection{cgal:h-emspe-14b , author = "Peter Hachenberger" , title = "Convex Decomposition of Polyhedra" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:ConvexDecomposition3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgConvexDecomposition3Summary" +, year = 2014 } -@incollection{cgal:h-msp3-12b +@incollection{cgal:h-msp3-14b , author = "Peter Hachenberger" , title = "{3D} {Minkowski} Sum of Polyhedra" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:MinkowskiSum3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgMinkowskiSum3Summary" +, year = 2014 } -@incollection{cgal:c-sspo2-12b +@incollection{cgal:c-sspo2-14b , author = "Fernando Cacciola" , title = "{2D} Straight Skeleton and Polygon Offsetting" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:StraightSkeleton2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgStraightSkeleton2Summary" +, year = 2014 } -@incollection{cgal:wfzh-a2-12b +@incollection{cgal:wfzh-a2-14b , author = "Ron Wein and Eric Berberich and Efi Fogel and Dan Halperin and Michael Hemmer and Oren Salzman and Baruch Zukerman" , title = "{2D} Arrangements" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Arrangement2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgArrangement2Summary" +, year = 2014 } -@incollection{cgal:wfz-ic2-12b +@incollection{cgal:wfz-ic2-14b , author = "Baruch Zukerman and Ron Wein and Efi Fogel" , title = "{2D} Intersection of Curves" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:IntersectionOfCurves2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgIntersectionOfCurves2Summary" +, year = 2014 } -@incollection{cgal:p-sr2-12b +@incollection{cgal:p-sr2-14b , author = "Eli Packer" , title = "{2D} Snap Rounding" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:SnapRounding2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgSnapRounding2Summary" +, year = 2014 } -@incollection{cgal:w-e2-12b +@incollection{cgal:w-e2-14b , author = "Ron Wein" , title = "{2D} Envelopes" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Envelope2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgEnvelope2Summary" +, year = 2014 } -@incollection{cgal:mwz-e3-12b +@incollection{cgal:mwz-e3-14b , author = "Michal Meyerovitch and Ron Wein and Baruch Zukerman" , title = "{3D} Envelopes" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Envelope3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgEnvelope3Summary" +, year = 2014 } -@incollection{cgal:y-t2-12b +@incollection{cgal:y-t2-14b , author = "Mariette Yvinec" , title = "{2D} Triangulations" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Triangulation2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgTriangulation2Summary" +, year = 2014 } -@incollection{cgal:py-tds2-12b +@incollection{cgal:py-tds2-14b , author = "Sylvain Pion and Mariette Yvinec" , title = "{2D} Triangulation Data Structure" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:TDS2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgTDS2Summary" +, year = 2014 } -@incollection{cgal:pt-t3-12b +@incollection{cgal:pt-t3-14b , author = "Sylvain Pion and Monique Teillaud" , title = "{3D} Triangulations" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Triangulation3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgTriangulation3Summary" +, year = 2014 } -@incollection{cgal:pt-tds3-12b +@incollection{cgal:pt-tds3-14b , author = "Sylvain Pion and Monique Teillaud" , title = "{3D} Triangulation Data Structure" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:TDS3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgTDS3Summary" +, year = 2014 } -@incollection{cgal:ct-pt3-12b +@incollection{cgal:k-pt2-14b +, author = "Nico Kruithof" +, title = "{2D} Periodic Triangulations" +, publisher = "{CGAL Editorial Board}" +, edition = "{}" +, booktitle = "{CGAL} User and Reference Manual" +, url = "http://doc.cgal.org//Manual/packages.html#PkgPeriodic3Triangulation3Summary" +, year = 2014 +} + +@incollection{cgal:ct-pt3-14b , author = "Manuel Caroli and Monique Teillaud" , title = "{3D} Periodic Triangulations" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Periodic3Triangulation3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgPeriodic3Triangulation3Summary" +, year = 2014 } -@incollection{cgal:d-as2-12b +@incollection{cgal:d-as2-14b , author = "Tran Kai Frank Da" , title = "{2D} Alpha Shapes" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:AlphaShape2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgAlphaShape2Summary" +, year = 2014 } -@incollection{cgal:dy-as3-12b +@incollection{cgal:dy-as3-14b , author = "Tran Kai Frank Da and Mariette Yvinec" , title = "{3D} Alpha Shapes" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:AlphaShapes3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgAlphaShapes3Summary" +, year = 2014 } -@incollection{cgal:k-sdg2-12b +@incollection{cgal:k-sdg2-14b , author = "Menelaos Karavelas" , title = "{2D} Segment {Delaunay} Graphs" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:SegmentDelaunayGraph2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgSegmentDelaunayGraph2Summary" +, year = 2014 } -@incollection{cgal:ky-ag2-12b +@incollection{cgal:ky-ag2-14b , author = "Menelaos Karavelas and Mariette Yvinec" , title = "{2D} {Apollonius} Graphs ({Delaunay} Graphs of Disks)" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:ApolloniusGraph2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgApolloniusGraph2Summary" +, year = 2014 } -@incollection{cgal:k-vda2-12b +@incollection{cgal:k-vda2-14b , author = "Menelaos Karavelas" , title = "{2D} {Voronoi} Diagram Adaptor" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:VoronoiDiagramAdaptor2" -, Year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgVoronoiDiagramAdaptor2Summary" +, year = 2014 } -@incollection{cgal:r-ctm2-12b +@incollection{cgal:r-ctm2-14b , author = "Laurent Rineau" , title = "{2D} Conforming Triangulations and Meshes" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Mesh2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgMesh2Summary" +, year = 2014 } -@incollection{cgal:ry-smg-12b +@incollection{cgal:ry-smg-14b , author = "Laurent Rineau and Mariette Yvinec" , title = "{3D} Surface Mesh Generation" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:SurfaceMesher3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgSurfaceMesher3Summary" +, year = 2014 } -@incollection{cgal:asg-srps-12b +@incollection{cgal:asg-srps-14b , author = "Pierre Alliez and Laurent Saboret and Gael Guennebaud" , title = "Surface Reconstruction from Point Sets" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:SurfaceReconstructionFromPointSets" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgSurfaceReconstructionFromPointSetsSummary" +, year = 2014 } -@incollection{cgal:k-ssm3-12b +@incollection{cgal:k-ssm3-14b , author = "Nico Kruithof" , title = "{3D} Skin Surface Meshing" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:SkinSurface3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgSkinSurface3Summary" +, year = 2014 } -@incollection{cgal:rty-m3-12b +@incollection{cgal:rty-m3-14b , author = "Pierre Alliez and Laurent Rineau and St\'ephane Tayeb and Jane Tournois and Mariette Yvinec" , title = "{3D} Mesh Generation" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Mesh_3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgMesh_3Summary" +, year = 2014 } -@incollection{cgal:s-ssm2-12b +@incollection{cgal:s-ssm2-14b , author = "Le-Jeng Andy Shiue" , title = "{3D} Surface Subdivision Methods" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:SurfaceSubdivisionMethods3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgSurfaceSubdivisionMethods3Summary" +, year = 2014 } -@incollection{cgal:c-tsms-12b +@incollection{cgal:c-tsms-14b , author = "Fernando Cacciola" , title = "Triangulated Surface Mesh Simplification" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:SurfaceMeshSimplification" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgSurfaceMeshSimplificationSummary" +, year = 2014 } -@incollection{cgal:sal-pptsm2-12b +@incollection{cgal:sal-pptsm2-14b , author = "Laurent Saboret and Pierre Alliez and Bruno L\'evy" , title = "Planar Parameterization of Triangulated Surface Meshes" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:SurfaceParameterization" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgSurfaceParameterizationSummary" +, year = 2014 } -@incollection{cgal:b-ss2-12b -, author = "Matthias Bäsken" +@incollection{cgal:b-ss2-14b +, author = "Matthias B{\"a}sken" , title = "{2D} Range and Neighbor Search" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:PointSet2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgPointSet2Summary" +, year = 2014 } -@incollection{cgal:n-rstd-12b +@incollection{cgal:n-rstd-14b , author = "Gabriele Neyer" , title = "{dD} Range and Segment Trees" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:RangeSegmentTreesD" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgRangeSegmentTreesDSummary" +, year = 2014 } -@incollection{cgal:f-isl-12b +@incollection{cgal:f-isl-14b , author = "Andreas Fabri" , title = "Interval Skip List" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:IntervalSkipList" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgIntervalSkipListSummary" +, year = 2014 } -@incollection{cgal:tf-ssd-12b +@incollection{cgal:tf-ssd-14b , author = "Hans Tangelder and Andreas Fabri" , title = "{dD} Spatial Searching" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:SpatialSearchingD" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgSpatialSearchingDSummary" +, year = 2014 } -@incollection{cgal:kmz-isiobd-12b +@incollection{cgal:kmz-isiobd-14b , author = "Lutz Kettner and Andreas Meyer and Afra Zomorodian" , title = "Intersecting Sequences of {dD} Iso-oriented Boxes" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:BoxIntersectionD" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgBoxIntersectionDSummary" +, year = 2014 } -@incollection{cgal:fghhs-bv-12b +@incollection{cgal:fghhs-bv-14b , author = "Kaspar Fischer and Bernd G{\"a}rtner and Thomas Herrmann and Michael Hoffmann and Sven Sch{\"o}nherr" , title = "Bounding Volumes" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:BoundingVolumes" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgBoundingVolumesSummary" +, year = 2014 } -@incollection{cgal:fgsw-lqps-12b +@incollection{cgal:fgsw-lqps-14b , author = "Kaspar Fischer and Bernd G{\"a}rtner and Sven Sch{\"o}nherr and Frans Wessendorp" , title = "Linear and Quadratic Programming Solver" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:QPSolver" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgQPSolverSummary" +, year = 2014 } -@incollection{cgal:hp-ia-12b +@incollection{cgal:hp-ia-14b , author = "Michael Hoffmann and Eli Packer" , title = "Inscribed Areas" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:InscribedAreas" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgInscribedAreasSummary" +, year = 2014 } -@incollection{cgal:fghhs-od-12b +@incollection{cgal:fghhs-od-14b , author = "Kaspar Fischer and Bernd G{\"a}rtner and Thomas Herrmann and Michael Hoffmann and Sven Sch{\"o}nherr" , title = "Optimal Distances" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:OptimalDistances" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgOptimalDistancesSummary" +, year = 2014 } -@incollection{cgal:f-i-12b +@incollection{cgal:f-i-14b , author = "Julia Fl{\"o}totto" , title = "{2D} and Surface Function Interpolation" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Interpolation2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgInterpolation2Summary" +, year = 2014 } -@incollection{cgal:ap-pcad-12b +@incollection{cgal:ap-pcad-14b , author = "Pierre Alliez and Sylvain Pion and Ankit Gupta" , title = "Principal Component Analysis" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:PrincipalComponentAnalysisD" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgPrincipalComponentAnalysisDSummary" +, year = 2014 } -@incollection{cgal:m-ps-12b +@incollection{cgal:m-ps-14b , author = "Abdelkrim Mebarki" , title = "{2D} Placement of Streamlines" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:PlacementOfStreamlines2" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgPlacementOfStreamlines2Summary" +, year = 2014 } -@incollection{cgal:cp-arutsm-12b +@incollection{cgal:cp-arutsm-14b , author = "Marc Pouget and Fr\'ed\'eric Cazals" , title = "Approximation of Ridges and Umbilics on Triangulated Surface Meshes" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Ridges_3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgRidges_3Summary" +, year = 2014 } -@incollection{cgal:pc-eldp-12b +@incollection{cgal:pc-eldp-14b , author = "Marc Pouget and Fr\'ed\'eric Cazals" , title = "Estimation of Local Differential Properties of Point-Sampled Surfaces" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Jet_fitting_3" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgJet_fitting_3Summary" +, year = 2014 } -@incollection{cgal:ass-psp-12b +@incollection{cgal:ass-psp-14b , author = "Pierre Alliez and Laurent Saboret and Nader Salman" , title = "Point Set Processing" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:PointSetProcessing" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgPointSetProcessingSummary" +, year = 2014 } -@incollection{cgal:r-kds-12b +@incollection{cgal:r-kds-14b , author = "Daniel Russel" , title = "Kinetic Data Structures" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Kds" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgKdsSummary" +, year = 2014 } -@incollection{cgal:r-kdsf-12b +@incollection{cgal:r-kdsf-14b , author = "Daniel Russel" , title = "Kinetic Framework" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:KdsFramework" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgKdsFrameworkSummary" +, year = 2014 } -@incollection{cgal:cfw-cbgl-12b +@incollection{cgal:cfw-cbgl-14b , author = "Andreas Fabri and Fernando Cacciola and Ron Wein" , title = "{CGAL} and the {Boost} Graph Library" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:BGL" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgBGLSummary" +, year = 2014 } -@incollection{cgal:fs-cbpm-12b +@incollection{cgal:fs-cbpm-14b , author = "Andreas Fabri and Laurent Saboret" , title = "{CGAL} and {Boost} Property Maps" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Property_map" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgProperty_mapSummary" +, year = 2014 } -@incollection{cgal:dd-ss-12b +@incollection{cgal:dd-ss-14b , author = "Christophe Delage and Olivier Devillers" , title = "Spatial Sorting" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:SpatialSorting" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgSpatialSortingSummary" +, year = 2014 } -@incollection{cgal:atw-aabb-12b +@incollection{cgal:atw-aabb-14b , author = "Pierre Alliez and St\'ephane Tayeb and Camille Wormser" , title = "3D Fast Intersection and Distance Computation (AABB Tree)" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:AABB_tree" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgAABB_treeSummary" +, year = 2014 } -@incollection{cgal:h-msms-12b +@incollection{cgal:h-msms-14b , author = "Michael Hoffmann" , title = "Monotone and Sorted Matrix Search" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:MatrixSearch" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgMatrixSearchSummary" +, year = 2014 } -@incollection{cgal:hkpw-se-12b +@incollection{cgal:hkpw-se-14b , author = "Michael Hoffmann and Lutz Kettner and Sylvain Pion and Ron Wein" , title = "STL Extensions for {CGAL}" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" -, booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:StlExtension" -, year = 2012 +, edition = "{}" +, booktitle = "{CGAL} User and Reference Manual" +, url = "http://doc.cgal.org//Manual/packages.html#PkgStlExtensionSummary" +, year = 2014 } -@incollection{cgal:dksy-hc-12b +@incollection{cgal:dksy-hc-14b , author = "Olivier Devillers and Lutz Kettner and Michael Seel and Mariette Yvinec" , title = "Handles and Circulators" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:HandlesAndCirculators" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgHandlesAndCirculatorsSummary" +, year = 2014 } -@incollection{cgal:dhhk-gog-12b -, author = "Olivier Devillers and Susan Hert and Michael Hoffmann and Lutz Kettner and Sven Schönherr" +@incollection{cgal:dhhk-gog-14b +, author = "Olivier Devillers and Susan Hert and Michael Hoffmann and Lutz Kettner and Sven Sch{\"o}nherr" , title = "Geometric Object Generators" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Generators" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgGeneratorsSummary" +, year = 2014 } -@incollection{cgal:kps-pthum-12b +@incollection{cgal:kps-pthum-14b , author = "Lutz Kettner and Sylvain Pion and Michael Seel" , title = "Profiling Tools Timers, Hash Map, Union-find, Modifiers" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:ProfilingTools" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgProfilingToolsSummary" +, year = 2014 } -@incollection{cgal:fgk-ios-12b +@incollection{cgal:fgk-ios-14b , author = "Andreas Fabri and Geert-Jan Giezeman and Lutz Kettner" , title = "IO Streams" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:IOstreams" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgIOstreamsSummary" +, year = 2014 } -@incollection{cgal:fp-gv-12b +@incollection{cgal:fp-gv-14b , author = "Andreas Fabri and Sylvain Pion" , title = "Geomview" , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:Geomview" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgGeomviewSummary" +, year = 2014 } -@incollection{cgal:fr-cqgvf-12b +@incollection{cgal:fr-cqgvf-14b , author = "Andreas Fabri and Laurent Rineau" , title = "{CGAL} and the Qt Graphics View Framework " , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:GraphicsView" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgGraphicsViewSummary" +, year = 2014 } -@incollection{cgal:lp-gi-12b +@incollection{cgal:lp-gi-14b , author = "S\'ebastien Loriot and Sylvain Pion" , title = "{CGAL} Ipelets " , publisher = "{CGAL Editorial Board}" -, edition = "{4.1}" +, edition = "{}" , booktitle = "{CGAL} User and Reference Manual" -, url = "http://www.cgal.org/Manual/4.1/doc_html/cgal_manual/packages.html#Pkg:CGALIpelets" -, year = 2012 +, url = "http://doc.cgal.org//Manual/packages.html#PkgCGALIpeletsSummary" +, year = 2014 +} + +@incollection{cgal:yl-tsms-14b +, author = "Ílker O. Yaz and S\'ebastien Loriot" +, title = "Triangulated Surface Mesh Segmentation" +, publisher = "{CGAL Editorial Board}" +, edition = "{}" +, booktitle = "{CGAL} User and Reference Manual" +, url = "http://doc.cgal.org//Manual/packages.html#PkgSurfaceSegmentationSummary" +, year = 2014 } diff --git a/Documentation/pkglist_filter b/Documentation/pkglist_filter index 4c930d5edc9..3a81d330f9b 100755 --- a/Documentation/pkglist_filter +++ b/Documentation/pkglist_filter @@ -1,9 +1,9 @@ #!/bin/sh if which python2 2>/dev/null >/dev/null; then - exec python2 ${CMAKE_BINARY_DIR}/pkglist_filter.py "$1" + exec python2 /cygdrive/c/Users/stephen/Documents/Programming/CGALDev/Documentation/pkglist_filter.py "$1" elif which python2.7 2>/dev/null >/dev/null; then - exec python2.7 ${CMAKE_BINARY_DIR}/pkglist_filter.py "$1" + exec python2.7 /cygdrive/c/Users/stephen/Documents/Programming/CGALDev/Documentation/pkglist_filter.py "$1" elif which python2.6 2>/dev/null >/dev/null; then - exec python2.6 ${CMAKE_BINARY_DIR}/pkglist_filter.py "$1" + exec python2.6 /cygdrive/c/Users/stephen/Documents/Programming/CGALDev/Documentation/pkglist_filter.py "$1" fi diff --git a/Documentation/pkglist_filter.py b/Documentation/pkglist_filter.py index acebdcc0b45..94a8d46173c 100755 --- a/Documentation/pkglist_filter.py +++ b/Documentation/pkglist_filter.py @@ -17,9 +17,9 @@ def main(argv): if(index > 0): top_level = pkg[:index] lower_level = pkg[index+1:] - filename="${CMAKE_SOURCE_DIR}/" + top_level + "/doc/" + lower_level + "/PackageDescription.txt" + filename="/cygdrive/c/Users/stephen/Documents/Programming/CGALDev/Documentation/" + top_level + "/doc/" + lower_level + "/PackageDescription.txt" else: - filename="${CMAKE_SOURCE_DIR}/" + pkg + "/doc/" + pkg + "/PackageDescription.txt" + filename="/cygdrive/c/Users/stephen/Documents/Programming/CGALDev/Documentation/" + pkg + "/doc/" + pkg + "/PackageDescription.txt" pkgdesc = codecs.open(filename, 'r', encoding='utf-8') do_print=False for l in pkgdesc: diff --git a/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/CMakeLists.txt b/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/CMakeLists.txt new file mode 100644 index 00000000000..f08b2823627 --- /dev/null +++ b/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/CMakeLists.txt @@ -0,0 +1,82 @@ +# Created by the script cgal_create_cmake_script_with_options +# This is the CMake script for compiling a set of CGAL applications. + +project( Polyhedron_shortest_path ) + +SET(CMAKE_CXX_FLAGS "-Wall") + +cmake_minimum_required(VERSION 2.6.2) +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" VERSION_GREATER 2.6) + if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION}" VERSION_GREATER 2.8.3) + cmake_policy(VERSION 2.8.4) + else() + cmake_policy(VERSION 2.6) + endif() +endif() + +set( CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true ) + +if ( COMMAND cmake_policy ) + + cmake_policy( SET CMP0003 NEW ) + +endif() + +# CGAL and its components +find_package( CGAL QUIET COMPONENTS ) + +if ( NOT CGAL_FOUND ) + + message(STATUS "This project requires the CGAL library, and will not be compiled.") + return() + +endif() + +# include helper file +include( ${CGAL_USE_FILE} ) + +find_package( OpenMesh QUIET ) + +if ( OpenMesh_FOUND ) +include( UseOpenMesh ) +else() + message(STATUS "Examples that use OpenMesh will not be compiled.") +endif() + +# Boost and its components +find_package( Boost REQUIRED COMPONENTS program_options ) + +if ( NOT Boost_FOUND ) + + message(STATUS "This project requires the Boost library, and will not be compiled.") + + return() + +endif() + +# include for local directory +include_directories( BEFORE include ) + +# include for local package +include_directories( BEFORE ../../include ) + +# Boost linking +add_definitions( "-DCGAL_USE_BOOST_PROGRAM_OPTIONS" ) +list(APPEND CGAL_3RD_PARTY_LIBRARIES ${Boost_PROGRAM_OPTIONS_LIBRARY} ) + + +# Creating entries for all .cpp/.C files with "main" routine +# ########################################################## + +include( CGAL_CreateSingleSourceCGALProgram ) + +create_single_source_cgal_program( "compute_isolines.cpp" ) + +create_single_source_cgal_program( "shortest_paths_elephant.cpp" ) + +create_single_source_cgal_program( "shortest_paths_elephant_multiple_sources.cpp" ) + +if(OpenMesh_FOUND) + create_single_source_cgal_program( "shortest_paths_elephant_OpenMesh.cpp" ) + target_link_libraries( shortest_paths_elephant_OpenMesh ${OPENMESH_LIBRARIES} ) +endif() diff --git a/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/compute_isolines.cpp b/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/compute_isolines.cpp new file mode 100755 index 00000000000..3011fb8ab80 --- /dev/null +++ b/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/compute_isolines.cpp @@ -0,0 +1,575 @@ +// (LicenseStuffHere) +// +// $URL$ +// $Id$ +// +// +// Author(s) : Stephen Kiazyk + +#include + +#include +#include + +#include +#include +#include + +#include +#include + +#include + +#include +#include +#include +#include + +#define UNUSED(X) (void)sizeof(X) + +typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel; +typedef CGAL::Polyhedron_3 Polyhedron_3; +typedef CGAL::Polyhedron_shortest_path_default_traits Traits; +typedef Traits::Point_3 Point_3; +typedef Traits::Vector_3 Vector_3; +typedef Traits::FT FT; +typedef Traits::Barycentric_coordinate Barycentric_coordinate; +typedef CGAL::Polyhedron_shortest_path Polyhedron_shortest_path; +typedef boost::graph_traits GraphTraits; +typedef GraphTraits::vertex_descriptor vertex_descriptor; +typedef GraphTraits::vertex_iterator vertex_iterator; +typedef GraphTraits::halfedge_descriptor halfedge_descriptor; +typedef GraphTraits::halfedge_iterator halfedge_iterator; +typedef GraphTraits::face_descriptor face_descriptor; +typedef GraphTraits::face_iterator face_iterator; + +typedef boost::property_map::type VertexExternalIndexMap; +typedef boost::property_map::type HalfedgeExternalIndexMap; +typedef boost::property_map::type FaceExternalIndexMap; +typedef boost::property_map::type VertexPointMap; + +enum Sequence_item_type +{ + SEQUENCE_ITEM_VERTEX, + SEQUENCE_ITEM_EDGE, + SEQUENCE_ITEM_FACE, +}; + +template +struct Sequence_item +{ + typedef typename Traits::Barycentric_coordinate Barycentric_coordinate; + typedef typename Traits::FT FT; + + Sequence_item_type type; + size_t index; + Barycentric_coordinate faceAlpha; + FT edgeAlpha; + vertex_descriptor vertex; + halfedge_descriptor halfedge; + face_descriptor face; +}; + +Point_3 get_item_location(const Sequence_item& item, Polyhedron_shortest_path& helper) +{ + if (item.type == SEQUENCE_ITEM_VERTEX) + { + return helper.point(item.vertex); + } + else if (item.type == SEQUENCE_ITEM_EDGE) + { + return helper.point(item.halfedge, item.edgeAlpha); + } + else + { + return helper.point(item.face, item.faceAlpha); + } +} + +template ::type, + class HIM = typename boost::property_map::type, + class FIM = typename boost::property_map::type, + class VPM = typename boost::property_map::type> +struct Edge_sequence_collector +{ + typedef typename Traits::FaceGraph FaceGraph; + typedef typename Traits::FT FT; + typedef typename Traits::Barycentric_coordinate Barycentric_coordinate; + typedef VIM VertexIndexMap; + typedef HIM HalfedgeIndexMap; + typedef FIM FaceIndexMap; + typedef typename boost::graph_traits GraphTraits; + typedef typename GraphTraits::vertex_descriptor vertex_descriptor; + typedef typename GraphTraits::halfedge_descriptor halfedge_descriptor; + typedef typename GraphTraits::face_descriptor face_descriptor; + + VertexIndexMap m_vertexIndexMap; + HalfedgeIndexMap m_halfedgeIndexMap; + FaceIndexMap m_faceIndexMap; + + std::vector > m_sequence; + + Edge_sequence_collector(FaceGraph& p) + : m_vertexIndexMap(CGAL::get(boost::vertex_external_index, p)) + , m_halfedgeIndexMap(CGAL::get(CGAL::halfedge_external_index, p)) + , m_faceIndexMap(CGAL::get(CGAL::face_external_index, p)) + { + } + + Edge_sequence_collector(VertexIndexMap& vertexIndexMap, HalfedgeIndexMap& halfedgeIndexMap, FaceIndexMap& faceIndexMap) + : m_vertexIndexMap(vertexIndexMap) + , m_halfedgeIndexMap(halfedgeIndexMap) + , m_faceIndexMap(faceIndexMap) + { + } + + void edge(halfedge_descriptor he, FT alpha) + { + Sequence_item item; + item.type = SEQUENCE_ITEM_EDGE; + item.index = m_halfedgeIndexMap[he]; + item.edgeAlpha = alpha; + item.halfedge = he; + m_sequence.push_back(item); + } + + void vertex(vertex_descriptor v) + { + Sequence_item item; + item.type = SEQUENCE_ITEM_VERTEX; + item.index = m_vertexIndexMap[v]; + item.vertex = v; + m_sequence.push_back(item); + } + + void face(face_descriptor f, Barycentric_coordinate alpha) + { + Sequence_item item; + item.type = SEQUENCE_ITEM_FACE; + item.index = m_faceIndexMap[f]; + item.faceAlpha = alpha; + item.face = f; + m_sequence.push_back(item); + } +}; + +class Edge_sequence_comparator +{ +private: + std::vector m_edges; + Polyhedron_3& m_polyhedron; + + const Sequence_item& second_last(Edge_sequence_collector* list) const + { + return list->m_sequence[list->m_sequence.size() - 2]; + } + + size_t edge_index(halfedge_descriptor e) const + { + for (size_t i = 0; i < m_edges.size(); ++i) + { + if (m_edges[i] == CGAL::opposite(e, m_polyhedron)) + { + return i; + } + } + + assert(false && "Error, edge was not found"); + } + + size_t vertex_index(vertex_descriptor v) const + { + for (size_t i = 0; i < m_edges.size(); ++i) + { + if (CGAL::source(m_edges[i], m_polyhedron) == v) + { + return i; + } + } + + assert(false && "Error, vertex was not found"); + } + + size_t get_index(const Sequence_item& item) const + { + if (item.type == SEQUENCE_ITEM_VERTEX) + { + return vertex_index(item.vertex); + } + else if (item.type == SEQUENCE_ITEM_EDGE) + { + return edge_index(item.halfedge); + } + else + { + assert(false && "Error, face item found"); + } + } + +public: + Edge_sequence_comparator(Polyhedron_3& polyhedron, face_descriptor locationFace) + : m_polyhedron(polyhedron) + { + m_edges.push_back(CGAL::halfedge(locationFace, m_polyhedron)); + m_edges.push_back(CGAL::next(m_edges[0], m_polyhedron)); + m_edges.push_back(CGAL::next(m_edges[1], m_polyhedron)); + } + + Edge_sequence_comparator(Polyhedron_3& polyhedron, vertex_descriptor locationVertex) + : m_polyhedron(polyhedron) + { + halfedge_descriptor startEdge = CGAL::halfedge(locationVertex, m_polyhedron); + + halfedge_descriptor currentEdge = startEdge; + + do + { + currentEdge = CGAL::opposite(currentEdge, m_polyhedron); + m_edges.push_back(CGAL::next(currentEdge, m_polyhedron)); + currentEdge = CGAL::next(m_edges.back(), m_polyhedron); + } + while(currentEdge != startEdge); + } + + Edge_sequence_comparator(Polyhedron_3& polyhedron, halfedge_descriptor locationEdge) + : m_polyhedron(polyhedron) + { + m_edges.push_back(CGAL::next(locationEdge, m_polyhedron)); + m_edges.push_back(CGAL::next(m_edges[0], m_polyhedron)); + m_edges.push_back(CGAL::next(CGAL::opposite(locationEdge, m_polyhedron), m_polyhedron)); + m_edges.push_back(CGAL::next(m_edges[2], m_polyhedron)); + } + + bool operator() (Edge_sequence_collector* lhs, Edge_sequence_collector* rhs) const + { + const Sequence_item& left = second_last(lhs); + const Sequence_item& right = second_last(rhs); + + size_t leftIndex = get_index(left); + size_t rightIndex = get_index(right); + + if (leftIndex < rightIndex) + { + return true; + } + else if (rightIndex < leftIndex) + { + return false; + } + else if (left.type == SEQUENCE_ITEM_VERTEX) + { + return true; + } + else if (right.type == SEQUENCE_ITEM_VERTEX) + { + return false; + } + else + { + return left.edgeAlpha < right.edgeAlpha; + } + } +}; + +void run_isolines_no_id(Traits& traits, Polyhedron_3& polyhedron, Polyhedron_shortest_path& shortestPaths, Polyhedron_shortest_path::Face_location faceLocation, const Edge_sequence_comparator& edgeComparator, FT delta, const std::string& outPathsFilename, const std::string& outIsolinesFilename) +{ + Traits::Compute_squared_distance_3 compute_squared_distance_3(traits.compute_squared_distance_3_object()); + shortestPaths.construct_sequence_tree(faceLocation.first, faceLocation.second); + + vertex_iterator verticesCurrent, verticesEnd; + + std::ofstream outPaths(outPathsFilename.c_str()); + + VertexExternalIndexMap vertexIndexMap(CGAL::get(boost::vertex_external_index, polyhedron)); + HalfedgeExternalIndexMap halfedgeIndexMap(CGAL::get(CGAL::halfedge_external_index, polyhedron)); + FaceExternalIndexMap faceIndexMap(CGAL::get(CGAL::face_external_index, polyhedron)); + + std::vector*> edgeSequences; + + FT maxDistance(0.0); + + for (boost::tie(verticesCurrent, verticesEnd) = boost::vertices(polyhedron); verticesCurrent != verticesEnd; ++verticesCurrent) + { + Edge_sequence_collector* collector = new Edge_sequence_collector(vertexIndexMap, halfedgeIndexMap, faceIndexMap); + + shortestPaths.shortest_path_sequence_to_source_points(*verticesCurrent, *collector); + + maxDistance = std::max(maxDistance, shortestPaths.shortest_distance_to_source_points(*verticesCurrent).first); + + if (collector->m_sequence.size() >= 2) + { + edgeSequences.push_back(collector); + } + + outPaths << collector->m_sequence.size() + 1; + + outPaths << " " << shortestPaths.point(*verticesCurrent); + + for (size_t i = 0; i < collector->m_sequence.size(); ++i) + { + outPaths << " " << get_item_location(collector->m_sequence[i], shortestPaths); + } + + outPaths << std::endl; + } + + outPaths.close(); + + std::sort(edgeSequences.begin(), edgeSequences.end(), edgeComparator); + + size_t numPaths = edgeSequences.size(); + + std::vector currentLocations(numPaths); + std::vector currentItems(numPaths); + std::vector currentlyCompleted(numPaths); + size_t numPathsCompleted = 0; + + Point_3 startPoint = shortestPaths.point(faceLocation.first, faceLocation.second); + + for (size_t i = 0; i < edgeSequences.size(); ++i) + { + currentLocations[i] = startPoint; + currentItems[i] = edgeSequences[i]->m_sequence.size() - 2; + currentlyCompleted[i] = false; + } + + FT currentSampleDistance = FT(0.0); + + std::ofstream outIsoLines(outIsolinesFilename.c_str()); + + while (numPathsCompleted < numPaths - 1) + { + std::vector points; + + currentSampleDistance += delta; + + // advance each path to the next sample point + for (size_t i = 0; i < numPaths; ++i) + { + FT remainingDistance = delta; + + while (!currentlyCompleted[i] && remainingDistance > FT(0.0)) + { + Point_3 nextLocation = get_item_location(edgeSequences[i]->m_sequence[currentItems[i]], shortestPaths); + FT distance = CGAL::sqrt(compute_squared_distance_3(nextLocation, currentLocations[i])); + + //std::cout << distance << std::endl; + + if (distance < remainingDistance) + { + remainingDistance -= distance; + + if (currentItems[i] == 0) + { + currentlyCompleted[i] = true; + ++numPathsCompleted; + } + else + { + --currentItems[i]; + currentLocations[i] = nextLocation; + } + } + else + { + Vector_3 direction = nextLocation - currentLocations[i]; + Vector_3 scaled = direction / distance; + + currentLocations[i] = currentLocations[i] + scaled * remainingDistance; + remainingDistance = FT(0.0); + } + } + } + + //std::cout << "Current Distance: " << currentSampleDistance << std::endl; + //std::cout << "Num Paths Cleared: " << numPathsCompleted << std::endl; + + if (numPathsCompleted >= numPaths - 1) + { + break; + } + + size_t firstPath = 0; + + // connect pairs of adjacent paths + while (currentlyCompleted[firstPath]) + { + ++firstPath; + } + + size_t currentPath = firstPath; + + while (currentPath < numPaths) + { + size_t nextPath = currentPath + 1; + + while (currentlyCompleted[nextPath % numPaths]) + { + ++nextPath; + } + + points.push_back(currentLocations[currentPath]); + + currentPath = nextPath; + } + + outIsoLines << points.size(); + + for (size_t i = 0; i < points.size(); ++i) + { + outIsoLines << " " << points[i]; + } + + outIsoLines << " " << points[0] << std::endl; + } + + outIsoLines.close(); + + for (size_t i = 0; i < edgeSequences.size(); ++i) + { + delete edgeSequences[i]; + } +} + + +int main(int argc, char** argv) +{ + namespace po = boost::program_options ; + po::options_description options; + + options.add_options() + ("help,h", "Display help message") + ("polyhedron,p", po::value(), "Polyhedron input file") + ("vertex,v", po::value(), "Randomization seed value") + ("face,f", po::value(), "Number of trials to run") + ("location,l", po::value(), "Number of source points per trial") + ("delta,d", po::value()->default_value(0.1), "Number of queries to run per trial") + ("output-paths,o", po::value()->default_value("shortestpaths.cgal"), "Filename to write shortest paths output") + ("output-isolines,i", po::value()->default_value("isolines.cgal"), "Filename to write isolines") + ; + + po::variables_map vm; + po::store(po::parse_command_line(argc, argv, options), vm); + po::notify(vm); + + if (vm.count("help")) + { + std::cout << options << std::endl; + } + else if (vm.count("polyhedron")) + { + bool useVertex = false; + bool useFace = false; + + if (vm.count("vertex")) + { + useVertex = true; + } + else if (vm.count("face")) + { + if (vm.count("location")) + { + useFace = true; + } + else + { + std::cerr << "Must specify face location with face." << std::endl; + return EXIT_FAILURE; + } + } + else + { + std::cerr << "Must specify either a face or a vertex." << std::endl; + return EXIT_FAILURE; + } + + if (useVertex || useFace) + { + FT delta(vm["delta"].as()); + + if (delta < FT(0.0)) + { + std::cerr << "Must specify non-negative isoline delta." << std::endl; + return EXIT_FAILURE; + } + + Polyhedron_shortest_path::Face_location faceLocation; + vertex_descriptor targetVertex; + + Polyhedron_3 polyhedron; + std::ifstream inFile(vm["polyhedron"].as().c_str()); + inFile >> polyhedron; + inFile.close(); + + Traits traits; + Polyhedron_shortest_path shortestPaths(polyhedron, traits); + + if (useVertex) + { + size_t vertexIndex = vm["vertex"].as(); + if (vertexIndex >= boost::num_vertices(polyhedron)) + { + std::cerr << "Vertex index out of range (#Vertices = " << boost::num_vertices(polyhedron) << ")." << std::endl; + return EXIT_FAILURE; + } + + vertex_iterator currentVertex, endVertex; + boost::tie(currentVertex, endVertex) = boost::vertices(polyhedron); + + while (vertexIndex > 0) + { + ++currentVertex; + --vertexIndex; + } + + faceLocation = shortestPaths.face_location(*currentVertex); + targetVertex = *currentVertex; + } + else + { + size_t faceIndex = vm["face"].as(); + if (faceIndex >= CGAL::num_faces(polyhedron)) + { + std::cerr << "Face index out of range (#Face = " << CGAL::num_faces(polyhedron) << ")." << std::endl; + return EXIT_FAILURE; + } + + face_iterator currentFace, endFace; + boost::tie(currentFace, endFace) = CGAL::faces(polyhedron); + while (faceIndex > 0) + { + ++currentFace; + --faceIndex; + } + + std::istringstream istr(vm["location"].as().c_str()); + + FT coords[3]; + + istr >> coords[0] >> coords[1] >> coords[2]; + + Barycentric_coordinate location(coords[0], coords[1], coords[2]); + + FT coordinateSum = location[0] + location[1] + location[2]; + + if (CGAL::abs(coordinateSum - FT(1.0)) > FT(0.00001)) + { + std::cerr << "Invalid face location (must be a valid, normalized, barycentric coordinate)." << std::endl; + return EXIT_FAILURE; + } + + faceLocation = Polyhedron_shortest_path::Face_location(*currentFace, location); + } + + run_isolines_no_id(traits, polyhedron, shortestPaths, faceLocation, useVertex ? Edge_sequence_comparator(polyhedron, targetVertex) : Edge_sequence_comparator(polyhedron, faceLocation.first), delta, vm["output-paths"].as(), vm["output-isolines"].as()); + } + } + else + { + std::cout << "Please specify a polyhedron to use. Use option --help for more details." << std::endl; + return EXIT_FAILURE; + } + + return EXIT_SUCCESS; +} diff --git a/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/data/elephant.off b/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/data/elephant.off index cf7cc2b68ca..c4121d0dbdc 100755 --- a/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/data/elephant.off +++ b/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/data/elephant.off @@ -1,6 +1,5 @@ OFF 2775 5558 0 - 0.262933 0.102269 0.138247 0.0843142 0.0418575 -0.0419302 0.0676609 -0.0308717 0.133371 diff --git a/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/shortest_paths_elephant.cpp b/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/shortest_paths_elephant.cpp index 7e82ddac489..3f5577d12d3 100644 --- a/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/shortest_paths_elephant.cpp +++ b/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/shortest_paths_elephant.cpp @@ -50,7 +50,7 @@ int main(int argc, char** argv) const size_t targetFaceIndex = 432; face_iterator facesCurrent, facesEnd; - boost::tie(facesCurrent, facesEnd) = CGAL::faces(polyhedron); + boost::tie(facesCurrent, facesEnd) = faces(polyhedron); size_t currentFaceIndex = 0; @@ -67,6 +67,8 @@ int main(int argc, char** argv) Traits traits; Polyhedron_shortest_path shortestPaths(polyhedron, traits); + shortestPaths.m_debugOutput = true; + shortestPaths.construct_sequence_tree(targetFace, faceLocation); vertex_iterator verticesCurrent, verticesEnd; diff --git a/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/shortest_paths_elephant_OpenMesh.cpp b/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/shortest_paths_elephant_OpenMesh.cpp new file mode 100755 index 00000000000..1f2ac35440d --- /dev/null +++ b/Polyhedron_shortest_path/examples/Polyhedron_shortest_path/shortest_paths_elephant_OpenMesh.cpp @@ -0,0 +1,150 @@ +// (LicenseStuffHere) +// +// $URL$ +// $Id$ +// +// +// Author(s) : Stephen Kiazyk + +#include + +#include +#include + +#include +#include + +#include +#include + +#include + +#include + +#include +#include + +#define UNUSED(X) (void)sizeof(X) + +typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel; + + +typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel; + +typedef OpenMesh::PolyMesh_ArrayKernelT< /* MyTraits*/> Mesh; + +typedef boost::graph_traits GraphTraits; +typedef GraphTraits::vertex_descriptor vertex_descriptor; +typedef GraphTraits::vertex_iterator vertex_iterator; +typedef GraphTraits::halfedge_descriptor halfedge_descriptor; +typedef GraphTraits::halfedge_iterator halfedge_iterator; +typedef GraphTraits::face_descriptor face_descriptor; +typedef GraphTraits::face_iterator face_iterator; + +typedef std::map vertex_int_map; +typedef std::map halfedge_int_map; +typedef std::map face_int_map; + +typedef boost::associative_property_map VertexIndexMap; +typedef boost::associative_property_map HalfedgeIndexMap; +typedef boost::associative_property_map FaceIndexMap; + +typedef CGAL::Polyhedron_shortest_path_default_traits Traits; +typedef CGAL::Polyhedron_shortest_path::type> Polyhedron_shortest_path; + + +int main(int argc, char** argv) +{ + UNUSED(argc); + UNUSED(argv); + + Mesh polyhedron; + + OpenMesh::IO::read_mesh(polyhedron, "data/elephant.off"); + + const size_t targetFaceIndex = 432; + + face_iterator facesCurrent, facesEnd; + boost::tie(facesCurrent, facesEnd) = faces(polyhedron); + + size_t currentFaceIndex = 0; + + face_int_map underlyingFaceMap; + FaceIndexMap faceIndexMap(underlyingFaceMap); + + face_descriptor targetFace; + + while (currentFaceIndex < num_faces(polyhedron)) + { + if (currentFaceIndex == targetFaceIndex) + { + targetFace = *facesCurrent; + } + + faceIndexMap[*facesCurrent] = currentFaceIndex; + ++facesCurrent; + + ++currentFaceIndex; + } + + vertex_int_map underlyingVertexMap; + VertexIndexMap vertexIndexMap(underlyingVertexMap); + size_t currentVertexIndex = 0; + vertex_iterator verticesCurrent, verticesEnd; + boost::tie(verticesCurrent, verticesEnd) = vertices(polyhedron); + + while (currentVertexIndex < num_vertices(polyhedron)) + { + vertexIndexMap[*verticesCurrent] = currentVertexIndex; + ++currentVertexIndex; + ++verticesCurrent; + } + + halfedge_int_map underlyingHalfedgeMap; + HalfedgeIndexMap halfedgeIndexMap(underlyingHalfedgeMap); + size_t currentHalfedgeIndex = 0; + halfedge_iterator halfedgesCurrent, halfedgesEnd; + boost::tie(halfedgesCurrent, halfedgesEnd) = halfedges(polyhedron); + + while (currentHalfedgeIndex < num_halfedges(polyhedron)) + { + halfedgeIndexMap[*halfedgesCurrent] = currentHalfedgeIndex; + ++currentHalfedgeIndex; + ++halfedgesCurrent; + } + + Traits::Barycentric_coordinate faceLocation(Traits::FT(0.25), Traits::FT(0.5), Traits::FT(0.25)); + + Traits traits; + Polyhedron_shortest_path shortestPaths(polyhedron, vertexIndexMap, halfedgeIndexMap, faceIndexMap, boost::get(boost::vertex_point, polyhedron), traits); + + shortestPaths.m_debugOutput = true; + + shortestPaths.construct_sequence_tree(targetFace, faceLocation); + + std::ofstream outPaths("polylines.cgal"); + + for (boost::tie(verticesCurrent, verticesEnd) = boost::vertices(polyhedron); verticesCurrent != verticesEnd; ++verticesCurrent) + { + std::vector points; + + shortestPaths.shortest_path_points_to_source_points(*verticesCurrent, std::back_inserter(points)); + + outPaths << points.size(); + + for (size_t i = 0; i < points.size(); ++i) + { + outPaths << " " << points[i]; + } + + outPaths << std::endl; + } + + outPaths.close(); + + return 0; +} diff --git a/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/Polyhedron_shortest_path.h b/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/Polyhedron_shortest_path.h index 584830160f8..5e0766cec92 100644 --- a/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/Polyhedron_shortest_path.h +++ b/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/Polyhedron_shortest_path.h @@ -25,8 +25,8 @@ #include #include -#include #include +#include namespace CGAL { @@ -52,8 +52,8 @@ Refer to those respective papers for the details of the implementation. template::type, - class HIM = typename boost::property_map::type, - class FIM = typename boost::property_map::type, + class HIM = typename boost::property_map::type, + class FIM = typename boost::property_map::type, class VPM = typename boost::property_map::type> class Polyhedron_shortest_path { @@ -94,12 +94,12 @@ public: typedef typename Traits::Barycentric_coordinate Barycentric_coordinate; /// \brief An ordered pair specifying a location on the surface of the faceGraph. - /// \detail Assuming you are given the pair (`face`, `location`), the weights of + /// \details Assuming you are given the pair (`face`, `location`), the weights of /// `location` are applied to the vertices of `face` in the following way /// the following way: - /// 0 - CGAL::source(CGAL::halfedge(`face`)) - /// 1 - CGAL::target(CGAL::halfedge(`face`)) - /// 2 - CGAL::target(CGAL::next(CGAL::halfedge(`face`))) + /// 0 - source(halfedge(`face`)) + /// 1 - target(halfedge(`face`)) + /// 2 - target(next(halfedge(`face`))) typedef typename std::pair Face_location; /// @} @@ -150,9 +150,9 @@ private: ++m_output; } - void face(face_descriptor face, Barycentric_coordinate location) + void face(face_descriptor f, Barycentric_coordinate location) { - *m_output = m_owner.point(face, location); + *m_output = m_owner.point(f, location); ++m_output; } }; @@ -305,7 +305,7 @@ private: static Triangle_3 triangle_from_halfedge(halfedge_descriptor edge, const FaceGraph& faceGraph) { - return triangle_from_halfedge(edge, faceGraph, CGAL::get(CGAL::vertex_point, faceGraph)); + return triangle_from_halfedge(edge, faceGraph, get(vertex_point, faceGraph)); } static Triangle_3 triangle_from_halfedge(halfedge_descriptor edge, const FaceGraph& faceGraph, VertexPointMap vertexPointMap) @@ -313,19 +313,19 @@ private: return CGAL::internal::triangle_from_halfedge(edge, faceGraph, vertexPointMap); } - Triangle_3 triangle_from_face(face_descriptor face) const + Triangle_3 triangle_from_face(face_descriptor f) const { - return triangle_from_face(face, m_faceGraph, m_vertexPointMap); + return triangle_from_face(f, m_faceGraph, m_vertexPointMap); } - static Triangle_3 triangle_from_face(face_descriptor face, const FaceGraph& faceGraph) + static Triangle_3 triangle_from_face(face_descriptor f, const FaceGraph& faceGraph) { - return triangle_from_halfedge(CGAL::halfedge(face, faceGraph), faceGraph, CGAL::get(CGAL::vertex_point, faceGraph)); + return triangle_from_halfedge(halfedge(f, faceGraph), faceGraph, get(vertex_point, faceGraph)); } - static Triangle_3 triangle_from_face(face_descriptor face, const FaceGraph& faceGraph, VertexPointMap vertexPointMap) + static Triangle_3 triangle_from_face(face_descriptor f, const FaceGraph& faceGraph, VertexPointMap vertexPointMap) { - return triangle_from_halfedge(CGAL::halfedge(face, faceGraph), faceGraph, vertexPointMap); + return triangle_from_halfedge(halfedge(f, faceGraph), faceGraph, vertexPointMap); } bool window_distance_filter(Cone_tree_node* cone, Segment_2 windowSegment, bool reversed) @@ -345,9 +345,9 @@ private: Point_2 v1; Point_2 v3; - size_t v1Index = m_vertexIndexMap[CGAL::source(cone->entry_edge(), m_faceGraph)]; - size_t v2Index = m_vertexIndexMap[cone->target_vertex()]; - size_t v3Index = m_vertexIndexMap[CGAL::target(cone->entry_edge(), m_faceGraph)]; + size_t v1Index = get(m_vertexIndexMap, source(cone->entry_edge(), m_faceGraph)); + size_t v2Index = get(m_vertexIndexMap, cone->target_vertex()); + size_t v3Index = get(m_vertexIndexMap, target(cone->entry_edge(), m_faceGraph)); Node_distance_pair v1Distance = m_closestToVertices[v1Index]; Node_distance_pair v2Distance = m_closestToVertices[v2Index]; @@ -475,7 +475,7 @@ private: } } - void expand_root(face_descriptor face, Barycentric_coordinate location) + void expand_root(face_descriptor f, Barycentric_coordinate location) { typename Traits::Construct_barycentric_coordinate_weight cbcw(m_traits.construct_barycentric_coordinate_weight_object()); typename Traits::Classify_barycentric_coordinate classify_barycentric_coordinate(m_traits.classify_barycentric_coordinate_object()); @@ -487,26 +487,26 @@ private: switch (type) { case CGAL::internal::BARYCENTRIC_COORDINATE_INTERNAL: - expand_face_root(face, location); + expand_face_root(f, location); break; case CGAL::internal::BARYCENTRIC_COORDINATE_EDGE: { - halfedge_descriptor halfedge = CGAL::halfedge(face, m_faceGraph); + halfedge_descriptor he = halfedge(f, m_faceGraph); for (size_t i = 0; i < associatedEdge; ++i) { - halfedge = CGAL::next(halfedge, m_faceGraph); + he = next(he, m_faceGraph); } - expand_edge_root(halfedge, cbcw(location, associatedEdge), cbcw(location, (associatedEdge + 1) % 3)); + expand_edge_root(he, cbcw(location, associatedEdge), cbcw(location, (associatedEdge + 1) % 3)); } break; case CGAL::internal::BARYCENTRIC_COORDINATE_VERTEX: { - halfedge_descriptor halfedge = CGAL::halfedge(face, m_faceGraph); + halfedge_descriptor he = halfedge(f, m_faceGraph); for (size_t i = 0; i < associatedEdge; ++i) { - halfedge = CGAL::next(halfedge, m_faceGraph); + he = next(he, m_faceGraph); } - expand_vertex_root(CGAL::source(halfedge, m_faceGraph)); + expand_vertex_root(source(he, m_faceGraph)); } break; default: @@ -515,12 +515,12 @@ private: } } - void expand_face_root(face_descriptor faceId, Barycentric_coordinate faceLocation) + void expand_face_root(face_descriptor f, Barycentric_coordinate faceLocation) { typename Traits::Project_triangle_3_to_triangle_2 pt3t2(m_traits.project_triangle_3_to_triangle_2_object()); typename Traits::Construct_vertex_2 cv2(m_traits.construct_vertex_2_object()); - halfedge_descriptor start = CGAL::halfedge(faceId, m_faceGraph); + halfedge_descriptor start = halfedge(f, m_faceGraph); halfedge_descriptor current = start; Cone_tree_node* faceRoot = new Cone_tree_node(m_traits, m_faceGraph, m_rootNodes.size()); @@ -530,7 +530,7 @@ private: if (m_debugOutput) { typename Traits::Construct_barycentric_coordinate_weight cbcw(m_traits.construct_barycentric_coordinate_weight_object()); - std::cout << "\tFace Root Expansion: id = " << m_faceIndexMap[faceId] << " , Location = " << cbcw(faceLocation, 0) << " " << cbcw(faceLocation, 1) << " " << cbcw(faceLocation, 2) << " " << std::endl; + std::cout << "\tFace Root Expansion: id = " << get(m_faceIndexMap, f) << " , Location = " << cbcw(faceLocation, 0) << " " << cbcw(faceLocation, 1) << " " << cbcw(faceLocation, 2) << " " << std::endl; } for (size_t currentVertex = 0; currentVertex < 3; ++currentVertex) @@ -553,7 +553,7 @@ private: process_node(child); - current = CGAL::next(current, m_faceGraph); + current = next(current, m_faceGraph); } } @@ -566,12 +566,12 @@ private: if (m_debugOutput) { - std::cout << "\tEdge Root Expansion: faceA = " << m_faceIndexMap[CGAL::face(baseEdge, m_faceGraph)] << " , faceB = " << m_faceIndexMap[CGAL::face(CGAL::opposite(baseEdge, m_faceGraph), m_faceGraph)] << " , t0 = " << t0 << " , t1 = " << t1 << std::endl; + std::cout << "\tEdge Root Expansion: faceA = " << get(m_faceIndexMap, face(baseEdge, m_faceGraph)) << " , faceB = " << get(m_faceIndexMap, face(opposite(baseEdge, m_faceGraph), m_faceGraph)) << " , t0 = " << t0 << " , t1 = " << t1 << std::endl; } halfedge_descriptor baseEdges[2]; baseEdges[0] = baseEdge; - baseEdges[1] = CGAL::opposite(baseEdge, m_faceGraph); + baseEdges[1] = opposite(baseEdge, m_faceGraph); Triangle_3 faces3d[2]; Triangle_2 layoutFaces[2]; @@ -604,7 +604,7 @@ private: edgeRoot->push_middle_child(mainChild); process_node(mainChild); - Cone_tree_node* oppositeChild = new Cone_tree_node(m_traits, m_faceGraph, CGAL::prev(baseEdges[side], m_faceGraph), ct2(cv2(layoutFaces[side], 2), cv2(layoutFaces[side], 0), cv2(layoutFaces[side], 1)), sourcePoints[side], FT(0.0), cv2(layoutFaces[side], 2), cv2(layoutFaces[side], 1), Cone_tree_node::EDGE_SOURCE); + Cone_tree_node* oppositeChild = new Cone_tree_node(m_traits, m_faceGraph, prev(baseEdges[side], m_faceGraph), ct2(cv2(layoutFaces[side], 2), cv2(layoutFaces[side], 0), cv2(layoutFaces[side], 1)), sourcePoints[side], FT(0.0), cv2(layoutFaces[side], 2), cv2(layoutFaces[side], 1), Cone_tree_node::EDGE_SOURCE); node_created(); edgeRoot->push_middle_child(oppositeChild); process_node(oppositeChild); @@ -615,15 +615,15 @@ private: { if (m_debugOutput) { - std::cout << "\tVertex Root Expansion: Vertex = " << m_vertexIndexMap[vertex] << std::endl; + std::cout << "\tVertex Root Expansion: Vertex = " << get(m_vertexIndexMap, vertex) << std::endl; } - Cone_tree_node* vertexRoot = new Cone_tree_node(m_traits, m_faceGraph, m_rootNodes.size(), CGAL::prev(CGAL::halfedge(vertex, m_faceGraph), m_faceGraph)); + Cone_tree_node* vertexRoot = new Cone_tree_node(m_traits, m_faceGraph, m_rootNodes.size(), prev(halfedge(vertex, m_faceGraph), m_faceGraph)); node_created(); m_rootNodes.push_back(vertexRoot); - m_closestToVertices[m_vertexIndexMap[vertex]] = Node_distance_pair(vertexRoot, FT(0.0)); + m_closestToVertices[get(m_vertexIndexMap, vertex)] = Node_distance_pair(vertexRoot, FT(0.0)); expand_pseudo_source(vertexRoot); } @@ -637,8 +637,8 @@ private: vertex_descriptor expansionVertex = parent->target_vertex(); - halfedge_descriptor startEdge = CGAL::halfedge(expansionVertex, m_faceGraph); - halfedge_descriptor currentEdge = CGAL::halfedge(expansionVertex, m_faceGraph); + halfedge_descriptor startEdge = halfedge(expansionVertex, m_faceGraph); + halfedge_descriptor currentEdge = halfedge(expansionVertex, m_faceGraph); FT distanceFromTargetToRoot = parent->distance_from_target_to_root(); @@ -657,9 +657,9 @@ private: if (m_debugOutput) { std::cout << "Expanding PsuedoSource: id = "; - if (CGAL::face(currentEdge, m_faceGraph) != GraphTraits::null_face()) + if (face(currentEdge, m_faceGraph) != GraphTraits::null_face()) { - std::cout << m_faceIndexMap[CGAL::face(currentEdge, m_faceGraph)]; + std::cout << get(m_faceIndexMap, face(currentEdge, m_faceGraph)); } else { @@ -674,7 +674,7 @@ private: parent->push_middle_child(child); process_node(child); - currentEdge = CGAL::opposite(CGAL::next(currentEdge, m_faceGraph), m_faceGraph); + currentEdge = opposite(next(currentEdge, m_faceGraph), m_faceGraph); } while (currentEdge != startEdge); @@ -719,7 +719,7 @@ private: { LineLineIntersectResult cgalIntersection = i2(cl2(segment), cl2(leftBoundary)); - if (!cgalIntersection || !boost::get(&*cgalIntersection)) + if (!cgalIntersection || !boost::get(&*cgalIntersection)) { if (m_debugOutput) { @@ -729,7 +729,7 @@ private: } else { - Point_2* result = boost::get(&*cgalIntersection); + Point_2* result = boost::get(&*cgalIntersection); FT t0 = pdas2(cs2(segment), ct2(segment), *result); if (t0 >= FT(1.00000)) @@ -779,7 +779,7 @@ private: { LineLineIntersectResult cgalIntersection = i2(cl2(segment), cl2(rightBoundary)); - if (!cgalIntersection || !boost::get(&*cgalIntersection)) + if (!cgalIntersection || !boost::get(&*cgalIntersection)) { if (m_debugOutput) { @@ -789,7 +789,7 @@ private: } else { - Point_2* result = boost::get(&*cgalIntersection); + Point_2* result = boost::get(&*cgalIntersection); FT t0 = pdas2(cs2(segment), ct2(segment), *result); if (t0 <= FT(0.00000)) @@ -865,8 +865,8 @@ private: halfedge_descriptor current = node->entry_edge(); for (size_t i = 0; i < 3; ++i) { - std::cout << m_vertexIndexMap[CGAL::source(current, m_faceGraph)] << " "; - current = CGAL::next(current, m_faceGraph); + std::cout << get(m_vertexIndexMap, source(current, m_faceGraph)) << " "; + current = next(current, m_faceGraph); } std::cout << std::endl; std::cout << "\tSource Image = " << node->source_image() << std::endl; @@ -882,7 +882,7 @@ private: std::cout << "\tContains target vertex" << std::endl; } - size_t entryEdgeIndex = m_halfedgeIndexMap[node->entry_edge()]; + size_t entryEdgeIndex = get(m_halfedgeIndexMap, node->entry_edge()); Node_distance_pair currentOccupier = m_vertexOccupiers[entryEdgeIndex]; FT currentNodeDistance = node->distance_from_target_to_root(); @@ -892,7 +892,7 @@ private: if (m_debugOutput) { std::cout << "\t Entry Edge = " << entryEdgeIndex << std::endl; - std::cout << "\t Target vertex = " << m_vertexIndexMap[node->target_vertex()] << std::endl; + std::cout << "\t Target vertex = " << get(m_vertexIndexMap, node->target_vertex()) << std::endl; } if (currentOccupier.first != NULL) @@ -988,7 +988,7 @@ private: } } - size_t targetVertexIndex = m_vertexIndexMap[node->target_vertex()]; + size_t targetVertexIndex = get(m_vertexIndexMap, node->target_vertex()); // Check if this is now the absolute closest node, and replace the current closest as appropriate Node_distance_pair currentClosest = m_closestToVertices[targetVertexIndex]; @@ -1084,7 +1084,7 @@ private: { typename Traits::Compute_squared_distance_2 csd2(m_traits.compute_squared_distance_2_object()); - if (CGAL::face(parent->left_child_edge(), m_faceGraph) != GraphTraits::null_face()) + if (face(parent->left_child_edge(), m_faceGraph) != GraphTraits::null_face()) { Segment_2 leftWindow; @@ -1125,7 +1125,7 @@ private: { typename Traits::Compute_squared_distance_2 csd2(m_traits.compute_squared_distance_2_object()); - if (CGAL::face(parent->right_child_edge(), m_faceGraph) != GraphTraits::null_face()) + if (face(parent->right_child_edge(), m_faceGraph) != GraphTraits::null_face()) { Segment_2 rightWindow; bool result = clip_to_bounds(parent->right_child_base_segment(), parent->left_boundary(), parent->right_boundary(), rightWindow); @@ -1231,13 +1231,13 @@ private: // to the original faceGraph, and deletion without if (!node->is_root_node() && !destruction) { - size_t entryEdgeIndex = m_halfedgeIndexMap[node->entry_edge()]; + size_t entryEdgeIndex = get(m_halfedgeIndexMap, node->entry_edge()); if (m_vertexOccupiers[entryEdgeIndex].first == node) { m_vertexOccupiers[entryEdgeIndex].first = NULL; - size_t targetVertexIndex = m_vertexIndexMap[node->target_vertex()]; + size_t targetVertexIndex = get(m_vertexIndexMap, node->target_vertex()); if (m_closestToVertices[targetVertexIndex].first == node) { @@ -1258,7 +1258,7 @@ private: for (boost::tie(current, end) = boost::vertices(m_faceGraph); current != end; ++current) { - size_t vertexIndex = m_vertexIndexMap[*current]; + size_t vertexIndex = get(m_vertexIndexMap, *current); if (is_saddle_vertex(*current) || is_boundary_vertex(*current)) { @@ -1278,17 +1278,17 @@ private: bool is_boundary_vertex(vertex_descriptor v) { - halfedge_descriptor h = CGAL::halfedge(v, m_faceGraph); + halfedge_descriptor h = halfedge(v, m_faceGraph); halfedge_descriptor first = h; do { - if (CGAL::face(h, m_faceGraph) == GraphTraits::null_face() || CGAL::face(CGAL::opposite(h, m_faceGraph), m_faceGraph) == GraphTraits::null_face()) + if (face(h, m_faceGraph) == GraphTraits::null_face() || face(opposite(h, m_faceGraph), m_faceGraph) == GraphTraits::null_face()) { return true; } - h = CGAL::opposite(CGAL::next(h, m_faceGraph), m_faceGraph); + h = opposite(next(h, m_faceGraph), m_faceGraph); } while(h != first); @@ -1307,7 +1307,7 @@ private: { m_closestToVertices.resize(boost::num_vertices(m_faceGraph)); std::fill(m_closestToVertices.begin(), m_closestToVertices.end(), Node_distance_pair(NULL, FT(0.0))); - m_vertexOccupiers.resize(CGAL::num_halfedges(m_faceGraph)); + m_vertexOccupiers.resize(num_halfedges(m_faceGraph)); std::fill(m_vertexOccupiers.begin(), m_vertexOccupiers.end(), Node_distance_pair(NULL, FT(0.0))); while (!m_expansionPriqueue.empty()) @@ -1353,6 +1353,8 @@ private: while (!current->is_root_node()) { + std::cout << "Node Type : " << current->node_type() << std::endl; + switch (current->node_type()) { case Cone_tree_node::INTERVAL: @@ -1365,7 +1367,9 @@ private: assert(cgalIntersection); - Point_2* result = boost::get(&*cgalIntersection); + // TODO: This isn't getting template substituted properly in the OpenMesh version + // I have no fucking clue why + Point_2* result = boost::get(&*cgalIntersection); assert(result && "Error, did not get point intersection on path walk to source"); @@ -1374,12 +1378,12 @@ private: if (m_debugOutput) { std::cout << "Current Node: " << current << " , Face = " << current->layout_face() << std::endl; - halfedge_descriptor halfedge = current->entry_edge(); + halfedge_descriptor he = current->entry_edge(); std::cout << "Face vertices: "; for (size_t i = 0; i < 3; ++i) { - std::cout << m_vertexIndexMap[CGAL::source(halfedge, m_faceGraph)] << ","; - halfedge = CGAL::next(halfedge, m_faceGraph); + std::cout << get(m_vertexIndexMap, source(he, m_faceGraph)) << ","; + he = next(he, m_faceGraph); } std::cout << std::endl; std::cout << "Current Location: " << currentLocation << std::endl; @@ -1390,7 +1394,7 @@ private: std::cout << "Current Left Window: " << current->window_left() << " , " << m_traits.parametric_distance_along_segment_2_object()(entrySegment.start(), entrySegment.end(), current->window_left()) << std::endl; std::cout << "Current Right Window: " << current->window_right() << " , " << m_traits.parametric_distance_along_segment_2_object()(entrySegment.start(), entrySegment.end(), current->window_right()) << std::endl; std::cout << "Current Segment Intersection: " << *result << std::endl; - std::cout << "Edge: (" << m_vertexIndexMap[CGAL::source(current->entry_edge(), m_faceGraph)] << "," << m_vertexIndexMap[CGAL::target(current->entry_edge(), m_faceGraph)] << ") : " << t0 << std::endl; + std::cout << "Edge: (" << get(m_vertexIndexMap, source(current->entry_edge(), m_faceGraph)) << "," << get(m_vertexIndexMap, target(current->entry_edge(), m_faceGraph)) << ") : " << t0 << std::endl; } visitor.edge(current->entry_edge(), t0); @@ -1411,7 +1415,7 @@ private: } break; case Cone_tree_node::VERTEX_SOURCE: - visitor.vertex(CGAL::target(current->entry_edge(), m_faceGraph)); + visitor.vertex(target(current->entry_edge(), m_faceGraph)); currentLocation = current->parent()->tarpoint(); current = current->parent(); break; @@ -1430,7 +1434,7 @@ private: { if (!node->is_root_node() && !node->is_null_face()) { - size_t faceIndex = m_faceIndexMap[node->current_face()]; + size_t faceIndex = get(m_faceIndexMap, node->current_face()); m_faceOccupiers[faceIndex].push_back(node); } @@ -1467,12 +1471,10 @@ private: return cbc(cbcw(location, shift), cbcw(location, (shift + 1) % 3), cbcw(location, (shift + 2) % 3)); } - std::pair nearest_on_face(face_descriptor face, Barycentric_coordinate location) + std::pair nearest_on_face(face_descriptor f, Barycentric_coordinate location) { - size_t faceIndex = m_faceIndexMap[face]; + size_t faceIndex = get(m_faceIndexMap, f); - halfedge_descriptor halfedge = CGAL::halfedge(face, m_faceGraph); - Cone_tree_node* closest = NULL; FT closestDistance; @@ -1511,7 +1513,7 @@ private: } } - std::pair nearest_to_location(face_descriptor face, Barycentric_coordinate location) + std::pair nearest_to_location(face_descriptor f, Barycentric_coordinate location) { typename Traits::Construct_barycentric_coordinate_weight cbcw(m_traits.construct_barycentric_coordinate_weight_object()); typename Traits::Construct_barycentric_coordinate cbc(m_traits.construct_barycentric_coordinate_object()); @@ -1524,17 +1526,17 @@ private: switch (type) { case CGAL::internal::BARYCENTRIC_COORDINATE_INTERNAL: - return nearest_on_face(face, location); + return nearest_on_face(f, location); case CGAL::internal::BARYCENTRIC_COORDINATE_EDGE: { - halfedge_descriptor halfedge = CGAL::halfedge(face, m_faceGraph); + halfedge_descriptor he = halfedge(f, m_faceGraph); for (size_t i = 0; i < associatedEdge; ++i) { - halfedge = CGAL::next(halfedge, m_faceGraph); + he = next(he, m_faceGraph); } - expand_edge_root(halfedge, cbcw(location, associatedEdge), cbcw(location, (associatedEdge + 1) % 3)); + expand_edge_root(he, cbcw(location, associatedEdge), cbcw(location, (associatedEdge + 1) % 3)); - halfedge_descriptor oppositeHalfedge = CGAL::opposite(halfedge, m_faceGraph); + halfedge_descriptor oppositeHalfedge = opposite(he, m_faceGraph); size_t oppositeIndex = internal::edge_index(oppositeHalfedge, m_faceGraph); @@ -1543,9 +1545,9 @@ private: oppositeLocationCoords[oppositeIndex] = cbcw(location, (associatedEdge + 1) % 3); oppositeLocationCoords[(oppositeIndex + 1) % 3] = cbcw(location, associatedEdge); - std::pair mainFace = nearest_on_face(face, location); + std::pair mainFace = nearest_on_face(f, location); Barycentric_coordinate oppositeLocation(cbc(oppositeLocationCoords[0], oppositeLocationCoords[1], oppositeLocationCoords[2])); - std::pair otherFace = nearest_on_face(CGAL::face(oppositeHalfedge, m_faceGraph), oppositeLocation); + std::pair otherFace = nearest_on_face(face(oppositeHalfedge, m_faceGraph), oppositeLocation); if (mainFace.first.first == NULL) { @@ -1563,16 +1565,16 @@ private: break; case CGAL::internal::BARYCENTRIC_COORDINATE_VERTEX: { - halfedge_descriptor halfedge = CGAL::halfedge(face, m_faceGraph); + halfedge_descriptor he = halfedge(f, m_faceGraph); for (size_t i = 0; i < associatedEdge; ++i) { - halfedge = CGAL::next(halfedge, m_faceGraph); + he = next(he, m_faceGraph); } - vertex_descriptor vertex = CGAL::source(halfedge, m_faceGraph); + vertex_descriptor vertex = source(he, m_faceGraph); - return std::make_pair(m_closestToVertices[m_vertexIndexMap[vertex]], Barycentric_coordinate(FT(0.0), FT(0.0), FT(1.0))); + return std::make_pair(m_closestToVertices[get(m_vertexIndexMap, vertex)], Barycentric_coordinate(FT(0.0), FT(0.0), FT(1.0))); } break; @@ -1592,8 +1594,8 @@ private: reset_algorithm(false); set_vertex_types(); - m_vertexOccupiers.resize(CGAL::num_halfedges(m_faceGraph)); - m_closestToVertices.resize(CGAL::num_vertices(m_faceGraph)); + m_vertexOccupiers.resize(num_halfedges(m_faceGraph)); + m_closestToVertices.resize(boost::num_vertices(m_faceGraph)); if (m_debugOutput) { @@ -1603,7 +1605,7 @@ private: for (boost::tie(current,end) = boost::vertices(m_faceGraph); current != end; ++current) { - std::cout << "Vertex#" << numVertices << ": p = " << m_vertexPointMap[*current] << " , Saddle Vertex: " << (is_saddle_vertex(*current) ? "yes" : "no") << " , Boundary Vertex: " << (is_boundary_vertex(*current) ? "yes" : "no") << std::endl; + std::cout << "Vertex#" << numVertices << ": p = " << get(m_vertexPointMap,*current) << " , Saddle Vertex: " << (is_saddle_vertex(*current) ? "yes" : "no") << " , Boundary Vertex: " << (is_boundary_vertex(*current) ? "yes" : "no") << std::endl; ++numVertices; } } @@ -1615,18 +1617,18 @@ private: { size_t numFaces = 0; - for (boost::tie(facesCurrent, facesEnd) = CGAL::faces(m_faceGraph); facesCurrent != facesEnd; ++facesCurrent) + for (boost::tie(facesCurrent, facesEnd) = faces(m_faceGraph); facesCurrent != facesEnd; ++facesCurrent) { std::cout << "Face#" << numFaces << ": Vertices = ("; ++numFaces; - halfedge_iterator faceEdgesStart = CGAL::halfedge(*facesCurrent, m_faceGraph); - halfedge_iterator faceEdgesCurrent = faceEdgesStart; + halfedge_descriptor faceEdgesStart = halfedge(*facesCurrent, m_faceGraph); + halfedge_descriptor faceEdgesCurrent = faceEdgesStart; do { - std::cout << m_vertexIndexMap[CGAL::source(*faceEdgesCurrent, m_faceGraph)]; + std::cout << get(m_vertexIndexMap, boost::source(faceEdgesCurrent, m_faceGraph)); - faceEdgesCurrent = CGAL::next(*faceEdgesCurrent, m_faceGraph); + faceEdgesCurrent = next(faceEdgesCurrent, m_faceGraph); if (faceEdgesCurrent != faceEdgesStart) { @@ -1648,7 +1650,7 @@ private: { if (m_debugOutput) { - std::cout << "Root: " << m_faceIndexMap[m_faceLocations[i].first] << " , " << m_faceLocations[i].second[0] << " " << m_faceLocations[i].second[1] << " " << m_faceLocations[i].second[2] << " " << std::endl; + std::cout << "Root: " << get(m_faceIndexMap, m_faceLocations[i].first) << " , " << m_faceLocations[i].second[0] << " " << m_faceLocations[i].second[1] << " " << m_faceLocations[i].second[2] << " " << std::endl; } expand_root(m_faceLocations[i].first, m_faceLocations[i].second); @@ -1678,7 +1680,7 @@ private: case Cone_expansion_event::PSEUDO_SOURCE: if (m_debugOutput) { - std::cout << "PseudoSource Expansion: Parent = " << parent << " , Vertex = " << m_vertexIndexMap[event->m_parent->target_vertex()] << " , Distance = " << event->m_distanceEstimate << " , Level = " << event->m_parent->level() + 1 << std::endl; + std::cout << "PseudoSource Expansion: Parent = " << parent << " , Vertex = " << get(m_vertexIndexMap, event->m_parent->target_vertex()) << " , Distance = " << event->m_distanceEstimate << " , Level = " << event->m_parent->level() + 1 << std::endl; } expand_pseudo_source(parent); @@ -1686,7 +1688,7 @@ private: case Cone_expansion_event::LEFT_CHILD: if (m_debugOutput) { - std::cout << "Left Expansion: Parent = " << parent << " Edge = (" << m_vertexIndexMap[CGAL::source(event->m_parent->left_child_edge(), m_faceGraph)] << "," << m_vertexIndexMap[CGAL::target(event->m_parent->left_child_edge(), m_faceGraph)] << ") , Distance = " << event->m_distanceEstimate << " , Level = " << event->m_parent->level() + 1 << std::endl; + std::cout << "Left Expansion: Parent = " << parent << " Edge = (" << get(m_vertexIndexMap, source(event->m_parent->left_child_edge(), m_faceGraph)) << "," << get(m_vertexIndexMap, target(event->m_parent->left_child_edge(), m_faceGraph)) << ") , Distance = " << event->m_distanceEstimate << " , Level = " << event->m_parent->level() + 1 << std::endl; } expand_left_child(parent, event->m_windowSegment); @@ -1694,7 +1696,7 @@ private: case Cone_expansion_event::RIGHT_CHILD: if (m_debugOutput) { - std::cout << "Right Expansion: Parent = " << parent << " , Edge = (" << m_vertexIndexMap[CGAL::source(event->m_parent->right_child_edge(), m_faceGraph)] << "," << m_vertexIndexMap[CGAL::target(event->m_parent->right_child_edge(), m_faceGraph)] << ") , Distance = " << event->m_distanceEstimate << " , Level = " << event->m_parent->level() + 1 << std::endl; + std::cout << "Right Expansion: Parent = " << parent << " , Edge = (" << get(m_vertexIndexMap, source(event->m_parent->right_child_edge(), m_faceGraph)) << "," << get(m_vertexIndexMap, target(event->m_parent->right_child_edge(), m_faceGraph)) << ") , Distance = " << event->m_distanceEstimate << " , Level = " << event->m_parent->level() + 1 << std::endl; } expand_right_child(parent, event->m_windowSegment); @@ -1710,7 +1712,7 @@ private: } m_faceOccupiers.clear(); - m_faceOccupiers.resize(CGAL::num_faces(m_faceGraph)); + m_faceOccupiers.resize(num_faces(m_faceGraph)); for (size_t i = 0; i < m_rootNodes.size(); ++i) { @@ -1766,8 +1768,8 @@ public: : m_traits(traits) , m_faceGraph(faceGraph) , m_vertexIndexMap(CGAL::get(boost::vertex_external_index, faceGraph)) - , m_halfedgeIndexMap(CGAL::get(CGAL::halfedge_external_index, faceGraph)) - , m_faceIndexMap(CGAL::get(CGAL::face_external_index, faceGraph)) + , m_halfedgeIndexMap(CGAL::get(halfedge_external_index, faceGraph)) + , m_faceIndexMap(CGAL::get(face_external_index, faceGraph)) , m_vertexPointMap(CGAL::get(CGAL::vertex_point, faceGraph)) , m_debugOutput(false) { @@ -1828,9 +1830,7 @@ public: \details Constructs a shortest paths sequence tree that covers shortest surface paths to all locations on the faceGraph from the given source vertex. - \param face Handle to the face on which the source originates. - - \param location Barycentric coordinate on face specifying the source location. + \param vertex Vertex to serve as the root location of the sequence tree */ void construct_sequence_tree(vertex_descriptor vertex) { @@ -1845,14 +1845,13 @@ public: \details Constructs a shortest paths sequence tree that covers shortest surface paths to all locations on the faceGraph reachable from the given source point. - \param face Handle to the face on which the source originates. - + \param f Handle to the face on which the source originates. \param location Barycentric coordinate on face specifying the source location. */ - void construct_sequence_tree(face_descriptor face, Barycentric_coordinate location) + void construct_sequence_tree(face_descriptor f, Barycentric_coordinate location) { m_faceLocations.clear(); - m_faceLocations.push_back(std::make_pair(face, location)); + m_faceLocations.push_back(std::make_pair(f, location)); construct_sequence_tree_internal(); } @@ -1864,9 +1863,8 @@ public: \tparam InputIterator a ForwardIterator type which dereferences to Face_location. - \param faceLocationsBegin iterator to the first in the list of face location pairs. - - \param faceLocationsEnd iterator to one past the end of the list of face location pairs. + \param begin iterator to the first in the list of vertices + \param end iterator to one past the end of the list of vertices */ template typename boost::enable_if::value_type, vertex_descriptor>::value, void>::type construct_sequence_tree(InputIterator begin, InputIterator end) @@ -1887,9 +1885,9 @@ public: \tparam InputIterator a ForwardIterator type which dereferences to Face_location. - \param faceLocationsBegin iterator to the first in the list of face location pairs. + \param begin iterator to the first in the list of face location pairs. - \param faceLocationsEnd iterator to one past the end of the list of face location pairs. + \param end iterator to one past the end of the list of face location pairs. */ template typename boost::enable_if::value_type, Face_location>::type, void>::type construct_sequence_tree(InputIterator begin, InputIterator end) @@ -1945,7 +1943,7 @@ public: */ std::pair shortest_distance_to_source_points(vertex_descriptor v) { - Node_distance_pair result = m_closestToVertices[m_vertexIndexMap[v]]; + Node_distance_pair result = m_closestToVertices[get(m_vertexIndexMap, v)]; Cone_tree_node* current = result.first; @@ -1962,7 +1960,7 @@ public: /*! \brief Computes the shortest surface distance from any surface location to any source point - \param face Face of the faceGraph of the query point + \param f Face of the faceGraph of the query point \param location Barycentric coordinate on face of the query point @@ -1971,9 +1969,9 @@ public: reachable, the distance will be a negative value and the source location will be an index greater than the number of source points. */ - std::pair shortest_distance_to_source_points(face_descriptor face, Barycentric_coordinate location) + std::pair shortest_distance_to_source_points(face_descriptor f, Barycentric_coordinate location) { - std::pair result = nearest_to_location(face, location); + std::pair result = nearest_to_location(f, location); Cone_tree_node* current = result.first.first; @@ -2002,7 +2000,7 @@ public: template bool shortest_path_sequence_to_source_points(vertex_descriptor v, Visitor& visitor) { - Cone_tree_node* current = m_closestToVertices[m_vertexIndexMap[v]].first; + Cone_tree_node* current = m_closestToVertices[get(m_vertexIndexMap, v)].first; if (current) { @@ -2019,16 +2017,16 @@ public: \brief Visits the sequence of edges, vertices and faces traversed by the shortest path from any surface location to any source point. - \param face Face of the faceGraph of the query point + \param f Face of the faceGraph of the query point \param location Barycentric coordinate on face of the query point \param visitor A model of FaceGraphShortestPathVisitor to receive the shortest path */ template - bool shortest_path_sequence_to_source_points(face_descriptor face, Barycentric_coordinate location, Visitor& visitor) + bool shortest_path_sequence_to_source_points(face_descriptor f, Barycentric_coordinate location, Visitor& visitor) { - std::pair result = nearest_to_location(face, location); + std::pair result = nearest_to_location(f, location); Cone_tree_node* current = result.first.first; if (current) @@ -2064,17 +2062,17 @@ public: \brief Visits the sequence of points in the surface-restricted polyline from any surface location to any source point (used for visualization of the shortest path). - \param face Face of the faceGraph of the query point + \param f Face of the faceGraph of the query point \param location Barycentric coordinate on face of the query point \param output An OutputIterator to receive the shortest path points as Point_3 */ template - void shortest_path_points_to_source_points(face_descriptor face, Barycentric_coordinate location, OutputIterator output) + void shortest_path_points_to_source_points(face_descriptor f, Barycentric_coordinate location, OutputIterator output) { - *output = point(face, location); + *output = point(f, location); ++output; Point_path_visitor_wrapper wrapper(*this, output); - shortest_path_sequence_to_source_points(face, location, wrapper); + shortest_path_sequence_to_source_points(f, location, wrapper); } /// @} @@ -2085,38 +2083,39 @@ public: /*! \brief Returns the 3-dimensional coordinate of the given face and face location on the faceGraph. - \param face Face of the faceGraph of the query point + \param f Face of the faceGraph of the query point \param location Barycentric coordinate on face of the query point */ - Point_3 point(face_descriptor face, Barycentric_coordinate location) const + Point_3 point(face_descriptor f, Barycentric_coordinate location) const { - return point(face, location, m_faceGraph, m_vertexPointMap, m_traits); + return point(f, location, m_faceGraph, m_vertexPointMap, m_traits); } /*! \brief Returns the 3-dimensional coordinate of the given face and face location on the faceGraph. - \param face Face of the faceGraph of the query point + \param f Face of the faceGraph of the query point \param location Barycentric coordinate on face of the query point \param faceGraph face graph to create face location on \param traits Optional traits class to use */ - static Point_3 point(face_descriptor face, Barycentric_coordinate location, const FaceGraph& faceGraph, const Traits& traits = Traits()) + static Point_3 point(face_descriptor f, Barycentric_coordinate location, const FaceGraph& faceGraph, const Traits& traits = Traits()) { - return point(face, location, faceGraph, CGAL::get(CGAL::vertex_point, faceGraph), traits); + return point(f, location, faceGraph, CGAL::get(CGAL::vertex_point, faceGraph), traits); } /*! \brief Returns the 3-dimensional coordinate of the given face and face location on the faceGraph. - \param face Face of the faceGraph of the query point + \param f Face of the faceGraph of the query point \param location Barycentric coordinate on face of the query point \param faceGraph face graph to create face location on + \param vertexPointMap Point property map to get the 3d points of faceGraph \param traits Optional traits class to use */ - static Point_3 point(face_descriptor face, Barycentric_coordinate location, const FaceGraph& faceGraph, VertexPointMap vertexPointMap, const Traits& traits = Traits()) + static Point_3 point(face_descriptor f, Barycentric_coordinate location, const FaceGraph& faceGraph, VertexPointMap vertexPointMap, const Traits& traits = Traits()) { - return construct_barycenter_in_triangle_3(triangle_from_face(face, faceGraph, vertexPointMap), location, traits); + return construct_barycenter_in_triangle_3(triangle_from_face(f, faceGraph, vertexPointMap), location, traits); } /*! @@ -2149,6 +2148,7 @@ public: \param edge Edge of the faceGraph to use \param t Parametric distance along edge \param faceGraph face graph to create face location on + \param vertexPointMap Point property map to get the 3d points of faceGraph \param traits Optional traits class to use */ static Point_3 point(halfedge_descriptor edge, FT t, const FaceGraph& faceGraph, VertexPointMap vertexPointMap, const Traits& traits = Traits()) @@ -2156,7 +2156,7 @@ public: typename Traits::Construct_barycenter_3 construct_barycenter_3(traits.construct_barycenter_3_object()); // Note: the parameter t is meant to be the weighted coordinate on the _endpoint_ (i.e. target) of the segment - return construct_barycenter_3(vertexPointMap[CGAL::target(edge, faceGraph)], t, vertexPointMap[CGAL::source(edge, faceGraph)]); + return construct_barycenter_3(get(vertexPointMap, target(edge, faceGraph)), t, get(vertexPointMap, source(edge, faceGraph))); } /*! @@ -2166,7 +2166,7 @@ public: */ Point_3 point(vertex_descriptor vertex) const { - return m_vertexPointMap[vertex]; + return get(m_vertexPointMap, vertex); } /*! @@ -2189,8 +2189,8 @@ public: static Face_location face_location(vertex_descriptor vertex, const FaceGraph& faceGraph, const Traits& traits = Traits()) { typename Traits::Construct_barycentric_coordinate construct_barycentric_coordinate(traits.construct_barycentric_coordinate_object()); - halfedge_descriptor he = CGAL::next(CGAL::halfedge(vertex, faceGraph), faceGraph); - face_descriptor locationFace = CGAL::face(he, faceGraph); + halfedge_descriptor he = next(halfedge(vertex, faceGraph), faceGraph); + face_descriptor locationFace = face(he, faceGraph); size_t edgeIndex = CGAL::internal::edge_index(he, faceGraph); FT coords[3] = { FT(0.0), FT(0.0), FT(0.0) }; @@ -2222,7 +2222,7 @@ public: static Face_location face_location(halfedge_descriptor he, FT t, const FaceGraph& faceGraph, const Traits& traits = Traits()) { typename Traits::Construct_barycentric_coordinate cbc(traits.construct_barycentric_coordinate_object()); - face_descriptor locationFace = CGAL::face(he, faceGraph); + face_descriptor locationFace = face(he, faceGraph); size_t edgeIndex = CGAL::internal::edge_index(he, faceGraph); const FT oneMinusT(FT(1.0) - t); @@ -2238,7 +2238,7 @@ public: /*! \brief Return the nearest face location to the given point. - \param point Point to locate on the faceGraph + \param location Point to locate on the faceGraph \param tree A cached AABB to perform the point location */ template @@ -2250,7 +2250,7 @@ public: /*! \brief Return the nearest face location to the given point. - \param point Point to locate on the faceGraph + \param location Point to locate on the faceGraph \param tree A cached AABB to perform the point location \param faceGraph faceGraph Face graph to intersect \param vertexPointMap Vertex point mapping for `faceGraph` @@ -2262,9 +2262,9 @@ public: typename Traits::Construct_barycentric_coordinate_in_triangle_3 cbcit3(traits.construct_barycentric_coordinate_in_triangle_3_object()); typename AABB_face_graph_tree::Point_and_primitive_id result = tree.closest_point_and_primitive(location); - face_descriptor face = result.second; - Barycentric_coordinate b = cbcit3(triangle_from_face(face, faceGraph, vertexPointMap), result.first); - return Face_location(face, b); + face_descriptor f = result.second; + Barycentric_coordinate b = cbcit3(triangle_from_face(f, faceGraph, vertexPointMap), result.first); + return Face_location(f, b); } /*! @@ -2273,7 +2273,7 @@ public: other version in conjunction with `fill_aabb_tree' if you need to call this method more than once. - \param point Point to locate on the faceGraph + \param location Point to locate on the faceGraph */ template Face_location locate(const Point_3& location) const @@ -2287,7 +2287,7 @@ public: other version in conjunction with `fill_aabb_tree' if you need to call this method more than once. - \param point Point to locate on the faceGraph + \param location Point to locate on the faceGraph \param faceGraph faceGraph Face graph to intersect \param vertexPointMap Vertex point mapping for `faceGraph` \param traits Optional traits class to use @@ -2428,7 +2428,7 @@ public: static void fill_aabb_tree(const FaceGraph& faceGraph, AABB_face_graph_tree& outTree) { face_iterator facesStart, facesEnd; - boost::tie(facesStart, facesEnd) = CGAL::faces(faceGraph); + boost::tie(facesStart, facesEnd) = faces(faceGraph); outTree.rebuild(facesStart, facesEnd, faceGraph); outTree.build(); } diff --git a/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/Polyhedron_shortest_path_traits.h b/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/Polyhedron_shortest_path_traits.h index 40b4a410f66..e87fc584e9f 100644 --- a/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/Polyhedron_shortest_path_traits.h +++ b/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/Polyhedron_shortest_path_traits.h @@ -13,8 +13,8 @@ #include #include -#include -#include +//#include +//#include #include #include diff --git a/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/internal/Cone_tree.h b/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/internal/Cone_tree.h index 9ee29f0f78d..160af99e109 100644 --- a/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/internal/Cone_tree.h +++ b/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/internal/Cone_tree.h @@ -170,7 +170,7 @@ public: face_descriptor current_face() const { - return CGAL::face(m_entryEdge, m_faceGraph); + return face(m_entryEdge, m_faceGraph); } bool is_null_face() const @@ -190,17 +190,17 @@ public: halfedge_descriptor left_child_edge() const { - return CGAL::opposite(CGAL::prev(m_entryEdge, m_faceGraph), m_faceGraph); + return opposite(prev(m_entryEdge, m_faceGraph), m_faceGraph); } halfedge_descriptor right_child_edge() const { - return CGAL::opposite(CGAL::next(m_entryEdge, m_faceGraph), m_faceGraph); + return opposite(next(m_entryEdge, m_faceGraph), m_faceGraph); } vertex_descriptor target_vertex() const { - return CGAL::target(CGAL::next(m_entryEdge, m_faceGraph), m_faceGraph); + return target(next(m_entryEdge, m_faceGraph), m_faceGraph); } Point_2 source_image() const diff --git a/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/internal/function_objects.h b/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/internal/function_objects.h index 4ef94d87810..f661157ea1f 100644 --- a/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/internal/function_objects.h +++ b/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/internal/function_objects.h @@ -391,7 +391,7 @@ public: if (intersectResult1) { - Point_2* result = boost::get(&*intersectResult1); + Point_2* result = boost::get(&*intersectResult1); assert(result && "Intersection should have been a point"); @@ -412,7 +412,7 @@ public: if (intersectResult2) { - Point_2* result = boost::get(&*intersectResult2); + Point_2* result = boost::get(&*intersectResult2); assert(result && "Intersection should have been a point"); @@ -487,24 +487,24 @@ public: result_type operator() (vertex_descriptor v, FaceGraph& faceGraph) const { - return (*this)(v, faceGraph, CGAL::get(CGAL::vertex_point, faceGraph)); + return (*this)(v, faceGraph, get(boost::vertex_point, faceGraph)); } template result_type operator() (vertex_descriptor v, const FaceGraph& faceGraph, VertexPointMap const& pointMap) const { - halfedge_descriptor startEdge = CGAL::halfedge(v, faceGraph); + halfedge_descriptor startEdge = halfedge(v, faceGraph); - Point_3 rootPoint(pointMap[v]); - Point_3 prevPoint(pointMap[CGAL::source(startEdge, faceGraph)]); + Point_3 rootPoint(get(pointMap, v)); + Point_3 prevPoint(get(pointMap, source(startEdge, faceGraph))); - halfedge_descriptor currentEdge = CGAL::next(startEdge, faceGraph); + halfedge_descriptor currentEdge = next(startEdge, faceGraph); - Point_3 nextPoint(pointMap[CGAL::target(currentEdge, faceGraph)]); + Point_3 nextPoint(get(pointMap, target(currentEdge, faceGraph))); Triangle_3 baseFace3(rootPoint, nextPoint, prevPoint); - currentEdge = CGAL::opposite(currentEdge, faceGraph); + currentEdge = opposite(currentEdge, faceGraph); Triangle_2 baseFace2(m_project_triangle_3_to_triangle_2(baseFace3)); @@ -523,9 +523,9 @@ public: do { prevPoint = nextPoint; - currentEdge = CGAL::next(currentEdge, faceGraph); - nextPoint = pointMap[CGAL::target(currentEdge, faceGraph)]; - currentEdge = CGAL::opposite(currentEdge, faceGraph); + currentEdge = next(currentEdge, faceGraph); + nextPoint = get(pointMap, target(currentEdge, faceGraph)); + currentEdge = opposite(currentEdge, faceGraph); Triangle_3 currentFace3(m_construct_triangle_3(rootPoint, nextPoint, prevPoint)); Triangle_2 currentFace2(m_flatten_triangle_3_along_segment_2(currentFace3, 2, nextSegment)); diff --git a/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/internal/misc_functions.h b/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/internal/misc_functions.h index 631b33508a5..75fbd71d20b 100644 --- a/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/internal/misc_functions.h +++ b/Polyhedron_shortest_path/include/CGAL/Polyhedron_shortest_path/internal/misc_functions.h @@ -26,15 +26,15 @@ Triangle_3 triangle_from_halfedge(typename boost::graph_traits::halfe typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; halfedge_descriptor e0 = edge; - halfedge_descriptor e1 = CGAL::next(edge, faceGraph); + halfedge_descriptor e1 = next(edge, faceGraph); - return Triangle_3(vertexPointMap[boost::source(e0, faceGraph)], vertexPointMap[boost::target(e0, faceGraph)], vertexPointMap[boost::target(e1, faceGraph)]); + return Triangle_3(get(vertexPointMap, boost::source(e0, faceGraph)), get(vertexPointMap, boost::target(e0, faceGraph)), get(vertexPointMap, boost::target(e1, faceGraph))); } template Triangle_3 triangle_from_halfedge(typename boost::graph_traits::halfedge_descriptor edge, const FaceGraph& faceGraph) { - return triangle_from_halfedge::type>(edge, faceGraph, CGAL::get(CGAL::vertex_point, faceGraph)); + return triangle_from_halfedge::type>(edge, faceGraph, get(boost::vertex_point, faceGraph)); } @@ -45,16 +45,16 @@ size_t edge_index(typename boost::graph_traits::halfedge_descriptor h typedef typename GraphTraits::face_descriptor face_descriptor; typedef typename GraphTraits::halfedge_descriptor halfedge_descriptor; - face_descriptor f = CGAL::face(he, p); + face_descriptor f = face(he, p); - halfedge_descriptor start = CGAL::halfedge(f, p); + halfedge_descriptor start = halfedge(f, p); halfedge_descriptor current = start; size_t count = 0; while (current != he) { - current = CGAL::next(current, p); + current = next(current, p); ++count; } diff --git a/Polyhedron_shortest_path/test/Polyhedron_shortest_path/Polyhedron_shortest_path_test_2.cpp b/Polyhedron_shortest_path/test/Polyhedron_shortest_path/Polyhedron_shortest_path_test_2.cpp index 51c446e7b5d..ed30f9da919 100644 --- a/Polyhedron_shortest_path/test/Polyhedron_shortest_path/Polyhedron_shortest_path_test_2.cpp +++ b/Polyhedron_shortest_path/test/Polyhedron_shortest_path/Polyhedron_shortest_path_test_2.cpp @@ -14,13 +14,16 @@ #include #include +#include +#include + #include #include #include #include #include -#include + #include #include diff --git a/Surface_mesh_segmentation/examples/Surface_mesh_segmentation/segmentation_from_sdf_values_OpenMesh_example.cpp b/Surface_mesh_segmentation/examples/Surface_mesh_segmentation/segmentation_from_sdf_values_OpenMesh_example.cpp index f0a0e954878..56dd6ad74ad 100644 --- a/Surface_mesh_segmentation/examples/Surface_mesh_segmentation/segmentation_from_sdf_values_OpenMesh_example.cpp +++ b/Surface_mesh_segmentation/examples/Surface_mesh_segmentation/segmentation_from_sdf_values_OpenMesh_example.cpp @@ -28,6 +28,10 @@ int main(int argc, char** argv ) else OpenMesh::IO::read_mesh(mesh, "data/cactus.off"); + std::cout << "#F : " << num_faces(mesh) << std::endl; + std::cout << "#H : " << num_halfedges(mesh) << std::endl; + std::cout << "#V : " << num_vertices(mesh) << std::endl; + // create a property-map for SDF values typedef std::map Facet_double_map; Facet_double_map internal_sdf_map;