From 70e0f04c804702b31dac83db03068543e60d3368 Mon Sep 17 00:00:00 2001 From: Michael Hemmer Date: Fri, 31 May 2013 15:49:31 +0200 Subject: [PATCH 01/66] Skeleton of Doc for Visibility package --- Documentation/doxyassist.xml | 18 ++++ .../doc/Visibility_2/Concepts/Visibility_2.h | 78 ++++++++++++++++++ .../doc/Visibility_2/PackageDescription.txt | 31 +++++++ Visibility_2/doc/Visibility_2/examples.txt | 3 + .../Visibility_2/fig/visibility-teaser.png | Bin 0 -> 8433 bytes .../doc/Visibility_2/visibility_2.txt | 65 +++++++++++++++ 6 files changed, 195 insertions(+) create mode 100644 Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h create mode 100644 Visibility_2/doc/Visibility_2/PackageDescription.txt create mode 100644 Visibility_2/doc/Visibility_2/examples.txt create mode 100644 Visibility_2/doc/Visibility_2/fig/visibility-teaser.png create mode 100644 Visibility_2/doc/Visibility_2/visibility_2.txt diff --git a/Documentation/doxyassist.xml b/Documentation/doxyassist.xml index dd8a568ad17..a3a9d3bea2b 100644 --- a/Documentation/doxyassist.xml +++ b/Documentation/doxyassist.xml @@ -718,8 +718,24 @@ namespace for the XML file to be processed properly. --> ./tags/Arrangement_on_surface_2.tag=../../CGAL.CGAL.2D-Arrangements/html + + + + 2D Visibility + ../Visibility_2/doc/Visibility_2 + + ../Visibility_2/doc/Visibility_2/ + ../Visibility_2/doc/Visibility_2/ + ./tags/Visibility_2.tag + ../Visibility_2/examples + ../Visibility_2/doc/Visibility_2/fig + + ./tags/Arrangement_on_surface_2.tag=../../CGAL.CGAL.2D-Arrangements/html + + + 2D Minkowski Sums ../Minkowski_sum_2/doc/Minkowski_sum_2 @@ -1440,6 +1456,7 @@ namespace for the XML file to be processed properly. --> ../Convex_hull_d/doc/Convex_hull_d/fig ../Envelope_2/doc/Envelope_2/fig ../Envelope_3/doc/Envelope_3/fig + ../Visibility_2/doc/Visibility_2/fig ../Generator/doc/Generator/fig ../Geomview/doc/Geomview/fig ../GraphicsView/doc/GraphicsView/fig @@ -1520,6 +1537,7 @@ namespace for the XML file to be processed properly. --> ./tags/Convex_hull_d.tag=../../CGAL.CGAL.dD-Convex-Hulls-and-Delaunay-Triangulations/html ./tags/Envelope_2.tag=../../CGAL.CGAL.2D-Envelopes/html ./tags/Envelope_3.tag=../../CGAL.CGAL.3D-Envelopes/html + ./tags/Visibility_2.tag=../../CGAL.CGAL.2D-Visibility/html ./tags/Generator.tag=../../CGAL.CGAL.Geometric-Object-Generators/html ./tags/Geomview.tag=../../CGAL.CGAL.Geomview/html ./tags/GraphicsView.tag=../../CGAL.CGAL.CGAL-and-the-Qt-Graphics-View-Framework/html diff --git a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h new file mode 100644 index 00000000000..7be76fa77c4 --- /dev/null +++ b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h @@ -0,0 +1,78 @@ + +/*! +\ingroup PkgVisibility_2Concepts +\cgalConcept + +A model of the concept `Visibility_2` offers visibility queries within +an Arrangement. + +\cgalHasModel `CGAL::Naive_visibility_2` + +\sa `CGAL::Naive_visibility_2` + +*/ +class Visibility_2 { +public: + +/// \name Types +/// @{ + + /*! + The supported Arrangement type. + */ + typedef Hidden_type Arrangement_2; + + /*! + The supported Point_2 type which is used for queries . + */ + typedef Hidden_type Point_2; + + /*! + Tag identifying whether `Visibility_2` computes regularized visbility area. + */ + typedef Hidden_type Regularization_tag; + +/// @} + +/// \name Constructors +/// @{ + +/*! +Constructs a `Visibility_2` object from a given `Arrangement_2` +*/ +Visibility_2(const Arrangement_2& arr); + +/// @} + + +/// \name functions +/// @{ + + +// to be added in doxygen style +// bool is_attached ()// whether the object is attachted to an arrangement +// void attach ( Arrangement_2 arr) // attaches visibility object to the given arrangement arr. +// void detach () // detaches vb from the arrangement it is currently attached to. +// Arrangement_2 arr() // access to the attached Arrangement_2 + +/*! +Computes the visibility region for the given query point q. +\pre face is a face of this->arr() +\pre p is in the interior of face + +*/ + Arrangement_2 visibility_region(const Point_2& q, const Face& face); + +/*! +Computes for the given query point q the visibility region that is on the side of the given halfedge. +\pre half_edge is a half edge of this->arr() +\pre p is on halfedge + +*/ + Arrangement_2 visibility_region(const Point_2& q, const Halfedge& halfedge); + +/// @} + + +}; /* end Visibility_2 */ + diff --git a/Visibility_2/doc/Visibility_2/PackageDescription.txt b/Visibility_2/doc/Visibility_2/PackageDescription.txt new file mode 100644 index 00000000000..fbd997fcc5e --- /dev/null +++ b/Visibility_2/doc/Visibility_2/PackageDescription.txt @@ -0,0 +1,31 @@ +/// \defgroup PkgVisibility_2 Visibility_2 Reference + +/// \defgroup PkgVisibility_2Concepts Concepts +/// \ingroup PkgVisibility_2 + +/*! +\addtogroup PkgVisibility_2 +\cgalPkgDescriptionBegin{2D Visibility Computation,PkgVisibility_2Summary} +\cgalPkgPicture{visibility_2-teaser-thumb.png} +\cgalPkgSummaryBegin +\cgalPkgAuthors{Michael Hemmer, Kan Huang, Francisc Bungiu} +\cgalPkgDesc{The 2D Visibility component offers several variants for +viibility computation amidst liniar geometry in the plain.} +\cgalPkgManuals{Chapter_2D_Visibility_Computation,PkgVisibility_2} +\cgalPkgSummaryEnd +\cgalPkgShortInfoBegin +\cgalPkgSince{99.99} +\cgalPkgBib{cgal:hhb-visibility-2} +\cgalPkgLicense{\ref licensesGPL "GPL"} +\cgalPkgShortInfoEnd +\cgalPkgDescriptionEnd + +\cgalClassifedRefPages + +## Concepts ## +- `Visibility_2` + +## Classes ## +- `CGAL::Naive_visibility_2 + +*/ diff --git a/Visibility_2/doc/Visibility_2/examples.txt b/Visibility_2/doc/Visibility_2/examples.txt new file mode 100644 index 00000000000..6cbca787b83 --- /dev/null +++ b/Visibility_2/doc/Visibility_2/examples.txt @@ -0,0 +1,3 @@ +/*! +\example Visibility_2/Visibility_2_example.cpp +*/ diff --git a/Visibility_2/doc/Visibility_2/fig/visibility-teaser.png b/Visibility_2/doc/Visibility_2/fig/visibility-teaser.png new file mode 100644 index 0000000000000000000000000000000000000000..15a1d0aedd80abea51d728966088dbdcd37ea9d4 GIT binary patch literal 8433 zcmaia2{=^$-{>JSh!BH_CXpCRjD4R-S+g{DLovpdeM{Cx!Y@m*?>otseaTj`lU-y> zhzZHg;GXgR-`{)heeUyIp5dJHJ>Sp1em@iTP)n7D>M9ig05lKoE9(LPi7WU)K}f+T z$G$=S;6D;KT~#DdI>5dP-dudFuBr^25q~p37Q}*2D4p*cxd8z672<~kNKRz|A5yqK z&{UzAA?KuGkfsk(LIc2c;DNG|zW3C6nxFm^o9508Ku$bd6XkQeTD;12;`)uOX(o4_ za!|FB)J*ezvNuC*x($=ze9P4@1NEv3hX zXI)!Nn?DD+EfvcqqRJkI*nsr4yncv~Gy@v9c6N3?<&mqF{h%Uk zmCg?S5Vu7=h2{tsoT}A@pL)VnbY#3X*sopV#$BSJDKTqA<>`{w_=RWJ2%Tz8yJe*L z2!S7qFz?-dQei0G&!zhEsWBFDRidA(Xe{HKgLvbN{|SL( zxwF;NrTVtS8}9?WlLGYGA8`@@b_4P{lg%-zMWS&r>wb@qh&{BEs)G_BK}H^`Cr_o)#}x+9HOyQB&}srRGK4kgW_{FFeSb?>4?mwpZCA) z*T^IoZx~h?i{MA*nr1hhwr%jeX!)aGIUE7Ley5@`o9p{tDFA@7U#c10Z)WA5K2?6x z`?sO@Gs?SmvVI)dwO%{te-cNs(o-y?!^_W)?0 zwT*41q;AA9Bq&zAziA(yVx6qOS-dji+8fsOhwGz+v?8nCD;4uO2!E_(W-Ap_@mM{DNdC}LW zVJZb26fq%Rx!Ugd`o$nLWolo597r1vOI2=B|NX9cZID9s=G>^)$E9fd)#LFudJ+Oh zujr7aX1FV?Ea* zP`%41QK8p!o-eM&unL_ZIxU0~HS%W~y*61-XCtrhvp*rI{upPzNAu-#r|;Zp`DqO3 z7j>Pi+YyAZUU`{8_7QqS_n-}G+V6zel%%C_9uC4xBJeo zA^VBa+l*9sx~uZ#j)dSno9P5`#QRGQn;Tbn03biDDBdBdz;$`_y}}VL)JNM&K(w6V5MuUr9*=4PIZ*|F}&^ZJ`i;o}RzTJjXx|Cr{2dsX=KH2#|ai z(m*d``iQtjgxjp?=4R6^_uk|Q6$MH|D)7R1x>n2r0Mrxh96Q<$$k(F+b`|fwX!rTS zv{FpnB|gdy{s}D z1yHWSFQ{)|VDL5pjks#|rG^AJ&{X~x{o$o$ha#kYlK3|#-Chq<(z~uiQz>56rB>w??jx!Lb{%@S; zl*(8JjX?s|1Yj{G9Y^Yl5tKUu87Fr{}A6k`Y-Y4d|BH4H(%%IGnv}_ zUH|tD#HauFJ@8-5|4YcZSpKseeD_>niu_N%B2K34%dRQ-e|Hd90Hd3>!bz1rUkFjS zq+UH-QL?VtAJY!Elzn|29UXa}`h#2N!XPvGj^fi_zdpPl<-fl%Lt7yH+)^YiAtAI- zOkYPQCN0fTB>=ZlOZ}J~%@9Y75s;`=BJ42xo@(X`6IIA@d*Z=C zU0vPRbw&({g>>}?XG^rJYl?Z<<)OXao}TZ_@@ItYEPKy3IG_<=TvVz>X=b5Qq+jjf zF~kt|q&onMFsX5%{1o;AgezW>oBNpoiDWh$wcBlNZGAaB{QmcESVZ2341|B zt_7A_*WZa!LfUy$Mz2-iP$8oaI68*xSxfEtDNQ1Me}qeD=3f;E1^Tu za*D&z=?H1H(1t{5GmH|3Ne>`Cf4j90o)MXX)S@6T-+c~S2UFz{#JRoq z#gj%|pzb48tgHS3ffMAjKx3u1Y+i!EIy$bM8!joh3Yb*ih;9W95GG1f`RU`mnxy3O$>@ZH+tF+^N#u(B3xTZe)6@1C4(4E@ zii2Atgx0qI>bKjnw!%R#)R>4Qe`M*BNbUgzN^r8}4&R3P3rA=w0W9~=pu936)rUc# zB_b`7=j`enj8y%b3(JI14{u%bfCg4EAZghTP7k-crPH*qE7yqFvXF2nGc^6=6DO4V z&*&#OV60>TI_LZ=6pr1{0@|vcJ?TtGLHj&l{JqXcbI$f!|MF=#8IvgpEWGuDj-p=6X8Xgs-b&ScQ;<x8@DfGs!n_jK(|0nKnChG-O>A+Z9n z2gwAL_EoKrRQ>4&%?lWX0fcz#?7a~3b5uX3&B9{&7lkl&ASz!?P3`w^o};!r>$ize zdorS+?l&FTQ4#f&$wWr!GkwO2JO*G1o z!w@Gepddo6XiRBjF@)c(!w~r+590ogsrcqVyzZE2MM7>1ZnRo&4}gh7+;Iv=Br-$N zv+w(4U19CSKl~I#2CzZar-a0UjE#;s&`0dUetf6rl)-3enmLFhJ(T>@0Vngj3m9(+ zlt*W0bG#tgrv#zIU3WPsw>)$ua;(VT#w99x<$svQA<0yuWJE>XK(OIdJ1z${&>b3* zTqY-W8O%VhNtpU8B81GgOAYJmVxj>6QL@2IhL2-@S%PLrrcgeQYzJ+J@@nX1w!eQx zR{DItJ+1)bh6jG!@}g8CxrPvZs{FI${Nmzbg|p|s+y}jyg_Fb`zt=rKbOp;SGd~IH zqnALH>lF_V4^7pmDK2W2E3fX60I7|lOsVV_PFlla0O*|cg)afb6I5$^KD%AFo8g5iGF;02Kg>Fk63 z7Vu9zuFqvml(cye;GaBUQhxCv5ApF3u^ zzdo%x;-0wAPu2p4s7zx^Qgt)48TV^I%Ly?A+J#WUefNG-23XL)0+C)Gv5&?FV5UG%u^#-RgFGyatvMX3gDPTvW}?-8V@FV`a)KQoLOAbPcFU zaYSUlKj`1|^mpyYt@84|`7smUhET_LzfDc;Q?DdjX8veihAO6}q5_q+ZM(WI)@x<8 zjd^6b@NHqC@a4-me@b!;J?~z$j{c}%g4g6XHBV1ZGqW@^VM91{IsBC}roJhsuy6*8 z5NYWd9E`g8c`E~%Rc;8ElQY<;@AMy(+e=U9ZX2agR>B8*CUf zG_2P3kd|0Zvj#+RJVwFCb&DqE@MV`QeYM>UyD^#=Bg7Ck3jTX78|ku=BX*Mvmx5vs z>cAqX4%wVn(!6MCXhkSP=pIMG|6zCH#+f3n-ra{Vh)@qx4PJ;qmj$nIQc_alqPw=n zA-)bcxp)_~DrE*{X6A;p86xkOG*o*-!EdiKc3$f!_V3sg}1 zc5C(oo_x2+*S8;B<%{D3BbkLo=6|^@!Sk-It+ll^3+)BW0)KF639&T*%Vecpiq+kt zpr9bo#iZoLRCIQCcX828O-;gsYr)bW)Vn2twiFm8E(lNs#wJptzXaZXEX?BS>e|!W zOALI0^N>7HpoN9l&d6(E05>LSqgO+tGmJ}?AMZnn76KtUTeyJ+kDitm?F#MjXpx?Z zipss57(6n_D3gf;?5*FU_*X8@yc@HtHtw&qCjt2-DCG?4KYFwv3s%fvOy!FUr@K*A zfFlwB5iA#0F|r(30KoSkaHV@?6DvP|7LKif<-bT(6&jbaio=yNZ!=o?ysxvuJzB2J^i+Rbb#9?Kj#>^x=riqF?)HX+=(EyZ+p%k z=xgB*MFazi_7GzdfS4LrKo0=>Bo=oH5b<>^vgqBrVJw2Trybs;oGGUSHfT|2M~m9> zhd4T2Jv}!N^y%qoRu&A|HC1hY*S!|M`wRoWgkvzR%yfF?f!iqAQc+oV^`Wpw+c_bw z&iTWo-$eiZ{hRA9TBvF2Eq~1Y@bD=|aTB`zvC+}ohrEnbDtdac*KokOMepyJwiQ`i zXm=#*w)z0}j=1QBfSC-1eSC8PUHukRj=U%o(zZ29dYIzlJ*}NqFYE$j&a7@$vDE&Sj3QVv{`y;j7{=-7TPs ze+si?&}kU)NMtD`+lL zZk)w(g4@b~p zxw*NerIB)>xw=KBYmH!nYo~np;bi>wO_oJHWN1#nlwEbYvrgL1k*N8I+oag@r8`O?NJClO&?4 zFqERa-~O`apZ)4f5|vJ)wfTg8*cO5U0*$^xNa3wkB3Y-wM2NxNK^G_<&V>+(*8uCA zt>*v;?|?>g#Cx@YnFp^BY-$nTIv>zIen)<(D~79XRvr|ViAjoDUVD)<36p7VT*{ZG zg~!Kn=y^sfD0T^|)wV6K^w~lfQV-GzF#rkuMYMNva}WuxkV%p|*TVmHqRK1dAieg$ z&Qq?jM*^vma~S4CGyD=~L-vqdpJz zS4XC696z-{9qty4FflTMG1Fjg-L2l7P22$tbFZ&M#e#=NMjEv4bU;8`ro@8xWb}s zD1G8zJ$?E@6?!kS*0==4fd#9BTN1SbVjeDDwMO%pg&GtiRY%yK=a<{`dxomUtSl^w zALB!Q{`{GWb@C!e(pRe?hP>}8^YINd|7q_#-iTN}di27GrOwRcHXom>3l+@jH^k4PGw0Wi|B_oFkG*kl6Z=y;AV8MOsX$b zOdKDi`G`~ zo9~I^2a{aoH;4Lq?!x#A&e(2!bMvR-DPHSSaY;$5&7|9eo#p;_g9@C+b>%_={mo8u z32}{rW{TY(Ml|hfs<{ zah>iQQ@)X8K9i)%ys-bBr27WU9dV~zB*`J_#$ZPk-OV%4sMws;GB6_qmj3YP;l^0Z z!au0+2${s*3k81yv$C>qI9%p&2;J~x-K(OO@_wOU5o(F5cFDXfOYW!l=R1UGX!xDJ zzp`8tg6~8)_qCIhwBBwNN<4~)K!fRX@?ik|E2GI$CdrV5#Quf4qSO;zW3`IhW`45D za$}IasQT>znNLY**>SIeUZExlYV~U5h`a0G(0hwC;2uM{{sxAN-;bj({a4fCkEmPv z+wYY~erc+%!OYW=!FGEQ<6b@v&~aPxMJze8TspB}RzCU5DOYoHh#4pjvfz%#meVkw z9d(v9p(X@%1Q;nGp#i7c8Smx9L(wlobK3RhmNJYcvq1r2jbrZLge!D)r(cGIpuI8B z8m#r$yQl?5m?AM)vsD=5@%Va?dModvr~@k~3JVrFTzBqdmpPHAwmV(Ac=z$+ANjA@ zC}An$Pn-5)bBSZybZ*p_{m^NFqk;?n^bst3$964R4;3LA@@|q)H1wxs61Hl`v zrlH|(OVRPU6W!n*HkbEo`Q#>8jng9&_bJ#V|M+n#h^Ve?T=p`y{8HfV5jM}51&dQl zNlD2`ds+PXb0=7?%zB;OIqax!#{bG_w)S7ZVkqs6+Y%)d&lAP`yv6h91hBuw9g11Z z28@C>L-)bmcCffC-#g$8u_B^=0BQi39}-GSCJCeTVHTRf>*W(fD4|FoK(HAG9IU?uhbXkXwn*8_&>UhffAJ2*+XQH|pK9|* zlXde7LwL$^4A)%=0mRkU;MM5bpo4hI%+nTs|I6DsGZGHs)6-EZy-U~nFiD)EBE|yH zh;2J?>a>0gPMt1I3~qK04tmwwn4!QL(j4{2d(hmmr+;uzNI-!2m(R{-!*9hAV`C#z z<3n9y>ev(4EA!pSo1wbru)I`!sR6!qTCupem}aoYn-9p#0;HW!Xr0k*`;B7d?21iJ z1B)}wwjAAESda0s-EH5S3}HeG!BRX4+8w{UI?#Q|5IArU*~vctAy|WFTb-ZeC*Z_A zJuN?XjCt#De5Lf06<+X)$-<1_;K6tQ*0x1{Rt*1(a0+L!LTDr|I^peb04g37T z$rkZBob=%6?s*J+9+bm3(*g6KjGS}Ux4`mpci)p1PND2gseq#kvud9aTaeWY(Rp#u z0L)XHy8Cy6sqv_zO*Waq+QSy0=}VBEgd0Qbv=@1;1rR(%O0BRVRBZA>8&9 zXF0&d0|K+vThJwGg~=`hNXX2G<(WpcPr@HYV=nNF_58ys3W3Rcw)e5g{5Wn_&n^MS zN*md)LhCI93~TrG*y$XH-TIi0!r#X89gk@v7rT zPlBslxcH*)^h~kl>&2~uFQA-y@`eN@@(tnX$D5nC<9f*Fgo&e>R~|d3-zsf{49l+{ z_L^wC>b;}`d%7rVtQ86RdIo~Ro3moY1(DwC+Bs?7IVq1ZG{3n;$c#RwljHOv1O5c} zI{vc$)pYD=jkqc!BV(4nlk{8MDjjfUwcD)Q(koWrnx$Cpu@c#DO!nE}m62(ztQ^52 z>=0L13jSgDwf3A}vMd075f1Gg%QsyfB>6}AB5<%fSl($99GrfkOCVz|NrUEI4tS(x zhe*!P=ZSjL=yMP7&8WF9@AcjNk2^K&mXh95Kqd1zIeUd zla9@`Re&drF`}c#ELqB_bl;0qrop-&pPfM_OB(vrNYCE4c(I7(?LNt$YZZTAudEQ{ z0y}?Ull`{@bXqTTCQ_u`@;}`rbE!@56<=#y+H4^#p4d+lk~8OxkD3Ej=l?-}J#FA# zkOB|e0l=F0T>zJptkmlR5fp*ftJ)*k=kfT?FGAQ|x86^pmG9duqI;K|sQ{9*PlQFZ z+}E#}e@=Krk~F~TEJzN40B78*`^*NLqf&&x+N-3k+LanlXai9Ipmfnmj0~Ki0f6WB ZS%^1|jsAFz_#Fn|fr^%LDbgbNe*u=cjBx+} literal 0 HcmV?d00001 diff --git a/Visibility_2/doc/Visibility_2/visibility_2.txt b/Visibility_2/doc/Visibility_2/visibility_2.txt new file mode 100644 index 00000000000..55c02ac0de4 --- /dev/null +++ b/Visibility_2/doc/Visibility_2/visibility_2.txt @@ -0,0 +1,65 @@ +namespace CGAL { + +/*! + +\mainpage User Manual +\anchor Chapter_2D_Visibility_Computation +\cgalAutoToc + +\authors Michael Hemmer, Kan Huang, Francisc Bungiu + +\section visibility_2_introduction Introduction + +\cgalFigureBegin{exaample_figure,visibility-teaser.png} +An example figure. +\cgalFigureEnd + +\section visibility_2_interface Interface + + +The following is a cut and paste from the minutes of the CGAL developer meeting in Nancy: + +Status of Visibility computation: +Currently there is some code within the Art Gallery project that does visibility computation without preprocessing. The output is essentially an arrangement. But it is probably better to start new code in CGAL style. +Design of Visibility package which should be the result of GSoC 2013: +Goals: + + The package should be able to optionally handle degenerated outputs, i.e., one dimensional needles -- this is why I put visibility "polygon" in "" + + the package should be able to associate the origin of an edge in the output to its counter part in the input or to the vertex that "caused" the creation of the edge. + + there should be the option to do visibility computation with and without preprocessing + +Principal design idea: + + The main concept is that of a visibility object that allows visibility queries. We will have at least two different strategies in different classes: + + naive visibility -- without preprocessing + + visibility with preprocessing (some algo) + + The object is constructed from a full arrangement which is stored and which allows preprocessing inside if needed. Visibility queries are then to that object. This allows to have both strategies in the same interface. It is worth considering distinguishing the regularized and non-regularized in compile time (e.g., using a template Boolean parameter.) + + The constructor takes an additional bool whether the output should be regularized or not. This is already in the constructor as this may effect potential preprocessing + + Template parameters are the Arrangement type (allows access to traits and kernel) + + A query is a point and: + + a face if the point is inside the interior of the face + + a half edge if the point is on the boundary, this avoid ambiguity on which polygon is to be computed (e.g. which side of the edge is seen.) + + Output: The output is an "extended" Arrangement (using [1]) such that additional data members of vertex/edge/face give pointers to their counterparts in the input arrangement if they exists. -- view edges don't have counter parts, but they can link to the vertex that caused them. The data member of the face can probably be empty (but it can not hurt to point to the original face either.) + + using the arrangement as output it easy to also report needles in case the (regularize) bool is not set. Otherwise we report the regularized version of the visibility area. Also as an extended arrangement. Though in this case it is indeed a polygon that could be reported. + +[1] http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Arrangement_on_surface_2_ref/Class_Arr_extended_dcel.html + + + + + +*/ + +} From ad34122474d550d421ffde69b3093424f1efac0e Mon Sep 17 00:00:00 2001 From: kanhuang Date: Tue, 4 Jun 2013 00:32:39 -0400 Subject: [PATCH 02/66] complete four functions of Visibility_2 --- .../doc/Visibility_2/Concepts/Visibility_2.h | 26 +++++++++++++++---- 1 file changed, 21 insertions(+), 5 deletions(-) diff --git a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h index 7be76fa77c4..e7fbcb4f0c7 100644 --- a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h +++ b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h @@ -49,11 +49,27 @@ Visibility_2(const Arrangement_2& arr); /// @{ -// to be added in doxygen style -// bool is_attached ()// whether the object is attachted to an arrangement -// void attach ( Arrangement_2 arr) // attaches visibility object to the given arrangement arr. -// void detach () // detaches vb from the arrangement it is currently attached to. -// Arrangement_2 arr() // access to the attached Arrangement_2 + +/*! +Return whether the object is attachted to an arrangement. +*/ + bool is_attached (); + +/*! +Attaches visibility object to the given arrangement arr. +*/ + void attach ( Arrangement_2 arr); + + +/*! +Detaches the object from the arrangement it is currently attached to. +*/ + void detach (); + +/*! +Access to the attached Arrangement_2. +*/ + Arrangement_2 arr(); /*! Computes the visibility region for the given query point q. From c73859eb821379e2dd594578dd2426ed97ca39ec Mon Sep 17 00:00:00 2001 From: kanhuang Date: Mon, 10 Jun 2013 16:17:05 -0400 Subject: [PATCH 03/66] add two classes of visibility and one traits class --- .../Visibility_2/CGAL/Naive_visibility_2.h | 95 ++++++++++++++++++ .../CGAL/Preprocessed_visibility_2.h | 96 +++++++++++++++++++ .../Concepts/ArrExtensionTraits_2.h | 25 +++++ .../doc/Visibility_2/Concepts/Visibility_2.h | 15 ++- 4 files changed, 227 insertions(+), 4 deletions(-) create mode 100644 Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h create mode 100644 Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h create mode 100644 Visibility_2/doc/Visibility_2/Concepts/ArrExtensionTraits_2.h diff --git a/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h new file mode 100644 index 00000000000..af1d424a4ec --- /dev/null +++ b/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h @@ -0,0 +1,95 @@ +namespace CGAL { +/*! +\ingroup PkgVisibility_2Classes + +This class is a model of the concept `Visibility_2` offers visibility queries within +an Arrangement. The algorithm it applies to obtain visibility is without preprocessing. + +\sa `Visibility_2` + +*/ +template +class Naive_visibility_2 { +public: + +/// \name Types +/// @{ + + + /*! + The Point_2 type which is used for queries . + */ + typedef Arrangement_2::Point_2 Point_2; + + /*! + Tag identifying whether `Visibility_2` computes regularized visbility area. + */ + typedef bool Regularization_tag; + + /*! + The Arrangement type which is used for output . + */ + typedef notknown Arrangement_output_2; + +/// @} + +/// \name Constructors +/// @{ + +/*! +Constructs a `Visibility_2` object from a given `Arrangement_2` +*/ +Naive_visibility_2(const Arrangement_2& arr); + +/// @} + + +/// \name functions +/// @{ + + + +/*! +Return whether the object is attachted to an arrangement. +*/ + bool is_attached (); + +/*! +Attaches visibility object to the given arrangement arr. +*/ + void attach ( Arrangement_2 arr); + + +/*! +Detaches the object from the arrangement it is currently attached to. +*/ + void detach (); + +/*! +Access to the attached Arrangement_2. +*/ + Arrangement_2 arr(); + +/*! +Computes the visibility region for the given query point q. +\pre face is a face of this->arr() +\pre p is in the interior of face + +*/ + Arrangement_output_2 visibility_region(const Point_2& q, const Face& face); + +/*! +Computes for the given query point q the visibility region that is on the side of the given halfedge. +\pre half_edge is a half edge of this->arr() +\pre p is on halfedge + +*/ + Arrangement_output_2 visibility_region(const Point_2& q, const Halfedge& halfedge); + +/// @} + + +}; /* end Visibility_2 */ + + +} diff --git a/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h new file mode 100644 index 00000000000..63c8bda0718 --- /dev/null +++ b/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h @@ -0,0 +1,96 @@ +namespace CGAL { +/*! +\ingroup PkgVisibility_2Classes + +This class is a model of the concept `Visibility_2` offers visibility queries within +an Arrangement. The algorithm it applies to obtain visibility is using preprocessing. + +\sa `Visibility_2` +\sa `CGAL::Naive_visibility_2` + +*/ +template +class Preprocessed_visibility_2 { +public: + +/// \name Types +/// @{ + + + /*! + The Point_2 type which is used for queries . + */ + typedef Arrangement_2::Point_2 Point_2; + + /*! + Tag identifying whether `Visibility_2` computes regularized visbility area. + */ + typedef bool Regularization_tag; + + /*! + The Arrangement type which is used for output . + */ + typedef notknown Arrangement_output_2; + +/// @} + +/// \name Constructors +/// @{ + +/*! +Constructs a `Visibility_2` object from a given `Arrangement_2` +*/ +Naive_visibility_2(const Arrangement_2& arr); + +/// @} + + +/// \name functions +/// @{ + + + +/*! +Return whether the object is attachted to an arrangement. +*/ + bool is_attached (); + +/*! +Attaches visibility object to the given arrangement arr. +*/ + void attach ( Arrangement_2 arr); + + +/*! +Detaches the object from the arrangement it is currently attached to. +*/ + void detach (); + +/*! +Access to the attached Arrangement_2. +*/ + Arrangement_2 arr(); + +/*! +Computes the visibility region for the given query point q. +\pre face is a face of this->arr() +\pre p is in the interior of face + +*/ + Arrangement_output_2 visibility_region(const Point_2& q, const Face& face); + +/*! +Computes for the given query point q the visibility region that is on the side of the given halfedge. +\pre half_edge is a half edge of this->arr() +\pre p is on halfedge + +*/ + Arrangement_output_2 visibility_region(const Point_2& q, const Halfedge& halfedge); + +/// @} + + +}; /* end Visibility_2 */ + + +} /* namespace CGAL */ diff --git a/Visibility_2/doc/Visibility_2/Concepts/ArrExtensionTraits_2.h b/Visibility_2/doc/Visibility_2/Concepts/ArrExtensionTraits_2.h new file mode 100644 index 00000000000..7f26b9e68af --- /dev/null +++ b/Visibility_2/doc/Visibility_2/Concepts/ArrExtensionTraits_2.h @@ -0,0 +1,25 @@ +/*! +\ingroup PkgVisibility_2Concepts +\cgalConcept + +All visibility polgyon algorithms provided in \cgal are parameterized with a traits class 'Traits', which defines the extension of Arrangement_2 the output will have. + +\cgalHasModel `CGAL::Arr_extension_default_traits_2` + +\sa `Visibility_2` + +*/ +class ArrExtensionTraits_2 { +public : + +/// \name Creation +/// @{ +/*! +copy creator +*/ +ArrExtensionTraits_2 (const ArrExtensionTraits_2 & Traits); + +/// @} + +} + diff --git a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h index e7fbcb4f0c7..7d2f6e2311a 100644 --- a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h +++ b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h @@ -6,9 +6,11 @@ A model of the concept `Visibility_2` offers visibility queries within an Arrangement. -\cgalHasModel `CGAL::Naive_visibility_2` +\cgalHasModel `CGAL::Naive_visibility_2` +\cgalHasModel `CGAL::Preprocessed_visibility_2` -\sa `CGAL::Naive_visibility_2` +\sa `CGAL::Naive_visibility_2` +\sa `CGAL::Preprocessed_visibility_2` */ class Visibility_2 { @@ -31,6 +33,11 @@ public: Tag identifying whether `Visibility_2` computes regularized visbility area. */ typedef Hidden_type Regularization_tag; + + /*! + Traits showing what kind of arrangement extension the output will have + */ + typedef Hidden_type Traits; /// @} @@ -38,9 +45,9 @@ public: /// @{ /*! -Constructs a `Visibility_2` object from a given `Arrangement_2` +Constructs a `Visibility_2` object from a given `Arrangement_2` and a given Regularization tag. */ -Visibility_2(const Arrangement_2& arr); +Visibility_2(const Arrangement_2& arr, Regularization_tag Rt); /// @} From 230b8c9c968ab3449f4bf650fa3785fbe1b83666 Mon Sep 17 00:00:00 2001 From: Francisc Date: Mon, 17 Jun 2013 22:38:14 +0200 Subject: [PATCH 04/66] added input/output arrangement types and modified visibility_region() to void --- .../Visibility_2/CGAL/Naive_visibility_2.h | 26 ++++++++++--------- .../CGAL/Preprocessed_visibility_2.h | 26 ++++++++++--------- 2 files changed, 28 insertions(+), 24 deletions(-) diff --git a/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h index af1d424a4ec..55bb44b1d06 100644 --- a/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h +++ b/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h @@ -17,19 +17,19 @@ public: /*! - The Point_2 type which is used for queries . + The Point_2 type which is used for queries. */ typedef Arrangement_2::Point_2 Point_2; /*! - Tag identifying whether `Visibility_2` computes regularized visbility area. + Tag identifying whether `Visibility_2` computes the regularized visibility area. */ typedef bool Regularization_tag; /*! - The Arrangement type which is used for output . + The Arrangement type which is used for output. */ - typedef notknown Arrangement_output_2; + typedef notknown Output_Arrangement_2; /// @} @@ -37,9 +37,9 @@ public: /// @{ /*! -Constructs a `Visibility_2` object from a given `Arrangement_2` +Constructs a `Visibility_2` object from a given `Input_Arrangement_2` */ -Naive_visibility_2(const Arrangement_2& arr); +Naive_visibility_2(const Input_Arrangement_2& arr); /// @} @@ -50,14 +50,14 @@ Naive_visibility_2(const Arrangement_2& arr); /*! -Return whether the object is attachted to an arrangement. +Return whether the object is attached to an arrangement. */ bool is_attached (); /*! Attaches visibility object to the given arrangement arr. */ - void attach ( Arrangement_2 arr); + void attach ( Input_Arrangement_2 arr); /*! @@ -68,23 +68,25 @@ Detaches the object from the arrangement it is currently attached to. /*! Access to the attached Arrangement_2. */ - Arrangement_2 arr(); + Input_Arrangement_2 arr(); /*! Computes the visibility region for the given query point q. \pre face is a face of this->arr() -\pre p is in the interior of face +\pre p is in the interior of face +\pre out_arr is the output arrangement */ - Arrangement_output_2 visibility_region(const Point_2& q, const Face& face); + void visibility_region(const Point_2& q, const Face& face, Output_Arrangement_2& out_arr); /*! Computes for the given query point q the visibility region that is on the side of the given halfedge. \pre half_edge is a half edge of this->arr() \pre p is on halfedge +\pre out_arr is the output arrangement */ - Arrangement_output_2 visibility_region(const Point_2& q, const Halfedge& halfedge); + void visibility_region(const Point_2& q, const Halfedge& halfedge, Output_Arrangement_2& out_arr); /// @} diff --git a/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h index 63c8bda0718..dc2e6f79198 100644 --- a/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h +++ b/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h @@ -18,19 +18,19 @@ public: /*! - The Point_2 type which is used for queries . + The Point_2 type which is used for queries. */ typedef Arrangement_2::Point_2 Point_2; /*! - Tag identifying whether `Visibility_2` computes regularized visbility area. + Tag identifying whether `Visibility_2` computes regularized visibility area. */ typedef bool Regularization_tag; /*! - The Arrangement type which is used for output . + The Arrangement type which is used for output. */ - typedef notknown Arrangement_output_2; + typedef notknown Ouput_Arrangement_2; /// @} @@ -38,9 +38,9 @@ public: /// @{ /*! -Constructs a `Visibility_2` object from a given `Arrangement_2` +Constructs a `Visibility_2` object from a given `Input_Arrangement_2` */ -Naive_visibility_2(const Arrangement_2& arr); +Naive_visibility_2(const Input_Arrangement_2& arr); /// @} @@ -51,14 +51,14 @@ Naive_visibility_2(const Arrangement_2& arr); /*! -Return whether the object is attachted to an arrangement. +Return whether the object is attached to an arrangement. */ bool is_attached (); /*! Attaches visibility object to the given arrangement arr. */ - void attach ( Arrangement_2 arr); + void attach ( Input_Arrangement_2 arr); /*! @@ -69,23 +69,25 @@ Detaches the object from the arrangement it is currently attached to. /*! Access to the attached Arrangement_2. */ - Arrangement_2 arr(); + Input_Arrangement_2 arr(); /*! Computes the visibility region for the given query point q. \pre face is a face of this->arr() \pre p is in the interior of face +\pre out_arr is the output arrangement */ - Arrangement_output_2 visibility_region(const Point_2& q, const Face& face); + void visibility_region(const Point_2& q, const Face& face, Output_Arrangement_2& out_arr); /*! Computes for the given query point q the visibility region that is on the side of the given halfedge. \pre half_edge is a half edge of this->arr() -\pre p is on halfedge +\pre p is on halfedge +\pre out_arr is the output arrangement */ - Arrangement_output_2 visibility_region(const Point_2& q, const Halfedge& halfedge); + void visibility_region(const Point_2& q, const Halfedge& halfedge, Output_Arrangement_2& out_arr); /// @} From d76d83e74dc54b36a3415034f33e4f76f5a1ea74 Mon Sep 17 00:00:00 2001 From: Francisc Date: Mon, 17 Jun 2013 22:39:37 +0200 Subject: [PATCH 05/66] added input/output arrangement types and modified visibility_region() to void --- .../doc/Visibility_2/Concepts/Visibility_2.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h index 7d2f6e2311a..711d8eeebf5 100644 --- a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h +++ b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h @@ -22,7 +22,7 @@ public: /*! The supported Arrangement type. */ - typedef Hidden_type Arrangement_2; + typedef Hidden_type Input_Arrangement_2; /*! The supported Point_2 type which is used for queries . @@ -47,7 +47,7 @@ public: /*! Constructs a `Visibility_2` object from a given `Arrangement_2` and a given Regularization tag. */ -Visibility_2(const Arrangement_2& arr, Regularization_tag Rt); +Visibility_2(const Input_Arrangement_2& arr, Regularization_tag Rt); /// @} @@ -65,7 +65,7 @@ Return whether the object is attachted to an arrangement. /*! Attaches visibility object to the given arrangement arr. */ - void attach ( Arrangement_2 arr); + void attach ( Input_Arrangement_2 arr); /*! @@ -76,7 +76,7 @@ Detaches the object from the arrangement it is currently attached to. /*! Access to the attached Arrangement_2. */ - Arrangement_2 arr(); + Input_Arrangement_2 arr(); /*! Computes the visibility region for the given query point q. @@ -84,7 +84,7 @@ Computes the visibility region for the given query point q. \pre p is in the interior of face */ - Arrangement_2 visibility_region(const Point_2& q, const Face& face); + void visibility_region(const Point_2& q, const Face& face, Output_Arrangement_2& out_arr); /*! Computes for the given query point q the visibility region that is on the side of the given halfedge. @@ -92,7 +92,7 @@ Computes for the given query point q the visibility region that is on the side o \pre p is on halfedge */ - Arrangement_2 visibility_region(const Point_2& q, const Halfedge& halfedge); + void visibility_region(const Point_2& q, const Halfedge& halfedge, Output_Arrangement_2& out_arr); /// @} From bb9c1c91787f0cbc24de991e7ad5a4f8518a5f3c Mon Sep 17 00:00:00 2001 From: kanhuang Date: Wed, 19 Jun 2013 23:21:20 -0400 Subject: [PATCH 06/66] add functor types and their creation methods to ArrExtensionTraits_2 --- .../Concepts/ArrExtensionTraits_2.h | 56 ++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) diff --git a/Visibility_2/doc/Visibility_2/Concepts/ArrExtensionTraits_2.h b/Visibility_2/doc/Visibility_2/Concepts/ArrExtensionTraits_2.h index 7f26b9e68af..5a270f2471e 100644 --- a/Visibility_2/doc/Visibility_2/Concepts/ArrExtensionTraits_2.h +++ b/Visibility_2/doc/Visibility_2/Concepts/ArrExtensionTraits_2.h @@ -4,7 +4,7 @@ All visibility polgyon algorithms provided in \cgal are parameterized with a traits class 'Traits', which defines the extension of Arrangement_2 the output will have. -\cgalHasModel `CGAL::Arr_extension_default_traits_2` +\cgalHasModel `CGAL::Arr_extension_default_traits_2` \sa `Visibility_2` @@ -12,6 +12,41 @@ All visibility polgyon algorithms provided in \cgal are parameterized with a tra class ArrExtensionTraits_2 { public : + + +/// \name Types +/// @{ + +/*! + * The vertex handle type on which the functors will operate. + */ +typedef Hidden_type Vertex_handle; + +/*! + * The halfedge handle type on which the functors will operate. + */ +typedef Hidden_type Halfedge_handle; + +/*! + * The face handle type on which the functors will operate. + */ +typedef Hidden_type Face_handle; + +/*! + * Add auxiliary information to vertex. + */ +typedef Hidden_type Extend_vertex; + +/*! + * Add auxiliary information to halfedge. + */ +typedef Hidden_type Extend_halfedge; + +/*! + * Add auxiliary information to face. + */ +typedef Hidden_type Extend_face; + /// \name Creation /// @{ /*! @@ -21,5 +56,24 @@ ArrExtensionTraits_2 (const ArrExtensionTraits_2 & Traits); /// @} +/// \name Operations +/// The following member functions to create instances of the above predicate oject types. +/// @{ + +Extend_vertex extend_vertex_object(); + +/*! + +*/ +Extend_halfedge extend_halfedge_object(); + +/*! + * + */ +Extend_face extend_face_object(); + +/// @} + + } From d968a2d6ae1f171078a0200b094c8f0419f5093d Mon Sep 17 00:00:00 2001 From: kanhuang Date: Sun, 23 Jun 2013 00:22:27 -0400 Subject: [PATCH 07/66] add Arr_extension_default_traits_2 --- .../CGAL/Arr_extension_default_traits_2.h | 80 +++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 Visibility_2/doc/Visibility_2/CGAL/Arr_extension_default_traits_2.h diff --git a/Visibility_2/doc/Visibility_2/CGAL/Arr_extension_default_traits_2.h b/Visibility_2/doc/Visibility_2/CGAL/Arr_extension_default_traits_2.h new file mode 100644 index 00000000000..40d8baa9328 --- /dev/null +++ b/Visibility_2/doc/Visibility_2/CGAL/Arr_extension_default_traits_2.h @@ -0,0 +1,80 @@ +namespace CGAL { + +/*! +\ingroup PkgArrExtensionTraits + +The class `Arr_extension_default_traits_2` serves as a traits class for all visibility polygon calculation function. +This class extends the vertex, halfedges and face. User also may define their own traits class to choose which to extend. + +\cgalModels `ArrExtensionTraits_2` + +\sa `CGAL::Arr_extended_dcel` + + +*/ + +template< typename A_ > +class Arr_extension_default_traits_2 { +public: + + /// \name Types + /// @{ + /*! + * + */ + typedef A_::Vertex_iterator Vertex_iterator; + + /*! + * + */ + typedef A_::Halfedge_iterator Halfedge_iterator; + + /*! + * + */ + typedef A_::Fayce_iterator Face_iterator; + + /// @} + + /// \name Functor classes + /// @{ + + /*! + * + */ + class Extend_vertex; + + /*! + * + */ + class Extend_halfedge; + + /*! + * + */ + class Extend_face; + /// @} + + /// \name Operations + /// @{ + + /*! + * + */ + Extend_vertex extend_vertex_object(); + + /*! + * + */ + Extend_halfedge extend_halfedge_object(); + + /*! + * + */ + Extend_face extend_face_object(); + + /// @} + +}; + +} /* end namespace CGAL */ From f4e62773ac3f8637b9fc398d0f131664ca506f85 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Sun, 23 Jun 2013 00:30:56 -0400 Subject: [PATCH 08/66] add Arr_extension_default_traits_2 --- .../doc/Visibility_2/Concepts/ArrExtensionTraits_2.h | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/Visibility_2/doc/Visibility_2/Concepts/ArrExtensionTraits_2.h b/Visibility_2/doc/Visibility_2/Concepts/ArrExtensionTraits_2.h index 5a270f2471e..f7b2e3f3aa8 100644 --- a/Visibility_2/doc/Visibility_2/Concepts/ArrExtensionTraits_2.h +++ b/Visibility_2/doc/Visibility_2/Concepts/ArrExtensionTraits_2.h @@ -49,6 +49,11 @@ typedef Hidden_type Extend_face; /// \name Creation /// @{ +/*! +default creator +*/ +ArrExtensionTraits_2 (); + /*! copy creator */ @@ -60,11 +65,14 @@ ArrExtensionTraits_2 (const ArrExtensionTraits_2 & Traits); /// The following member functions to create instances of the above predicate oject types. /// @{ +/*! + * + */ Extend_vertex extend_vertex_object(); /*! - -*/ + * + */ Extend_halfedge extend_halfedge_object(); /*! From fc825a4239f0cd309dcefc0e1080f7a3cfe454cb Mon Sep 17 00:00:00 2001 From: Francisc Date: Sun, 23 Jun 2013 12:43:22 +0300 Subject: [PATCH 09/66] added simple_visibility_2 class --- .../Visibility_2/CGAL/Simple_visibility_2.h | 97 +++++++++++++++++++ .../doc/Visibility_2/PackageDescription.txt | 2 + .../doc/Visibility_2/visibility_2.txt | 4 +- 3 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h diff --git a/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h new file mode 100644 index 00000000000..d0a1ae0ceec --- /dev/null +++ b/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h @@ -0,0 +1,97 @@ +namespace CGAL { +/*! +\ingroup PkgVisibility_2Classes + +This class is a model of the concept `Visibility_2` offers visibility queries within +a simple Arrangement (no holes). Uses a linear algorithm to obtain visibility. + +\sa `Visibility_2` + +*/ +template +class Simple_visibility_2 { +public: + +/// \name Types +/// @{ + + + /*! + The Point_2 type which is used for queries. + */ + typedef Arrangement_2::Point_2 Point_2; + + /*! + Tag identifying whether `Visibility_2` computes the regularized visibility area. + */ + typedef bool Regularization_tag; + + /*! + The Arrangement type which is used for output. + */ + typedef notknown Output_Arrangement_2; + +/// @} + +/// \name Constructors +/// @{ + +/*! +Constructs a `Visibility_2` object from a given `Input_Arrangement_2` +*/ +Simple_visibility_2(const Input_Arrangement_2& arr); + +/// @} + + +/// \name functions +/// @{ + + + +/*! +Return whether the object is attached to an arrangement. +*/ + bool is_attached (); + +/*! +Attaches visibility object to the given arrangement arr. +*/ + void attach ( Input_Arrangement_2 arr); + + +/*! +Detaches the object from the arrangement it is currently attached to. +*/ + void detach (); + +/*! +Access to the attached Arrangement_2. +*/ + Input_Arrangement_2 arr(); + +/*! +Computes the visibility region for the given query point q. +\pre face is a face of this->arr() +\pre p is in the interior of face +\pre out_arr is the output arrangement + +*/ + void visibility_region(const Point_2& q, const Face& face, Output_Arrangement_2& out_arr); + +/*! +Computes for the given query point q the visibility region that is on the side of the given halfedge. +\pre half_edge is a half edge of this->arr() +\pre p is on halfedge +\pre out_arr is the output arrangement + +*/ + void visibility_region(const Point_2& q, const Halfedge& halfedge, Output_Arrangement_2& out_arr); + +/// @} + + +}; /* end Visibility_2 */ + + +} diff --git a/Visibility_2/doc/Visibility_2/PackageDescription.txt b/Visibility_2/doc/Visibility_2/PackageDescription.txt index fbd997fcc5e..9eb990fe59b 100644 --- a/Visibility_2/doc/Visibility_2/PackageDescription.txt +++ b/Visibility_2/doc/Visibility_2/PackageDescription.txt @@ -26,6 +26,8 @@ viibility computation amidst liniar geometry in the plain.} - `Visibility_2` ## Classes ## +- `CGAL::Simple_visibility_2 - `CGAL::Naive_visibility_2 +- `CGAL::Preprocessed_visibility_2 */ diff --git a/Visibility_2/doc/Visibility_2/visibility_2.txt b/Visibility_2/doc/Visibility_2/visibility_2.txt index 55c02ac0de4..024817273de 100644 --- a/Visibility_2/doc/Visibility_2/visibility_2.txt +++ b/Visibility_2/doc/Visibility_2/visibility_2.txt @@ -32,7 +32,9 @@ Goals: Principal design idea: - The main concept is that of a visibility object that allows visibility queries. We will have at least two different strategies in different classes: + The main concept is that of a visibility object that allows visibility queries. We will have at least three different strategies in different classes: + + simple visibility (for arrangements with no holes) naive visibility -- without preprocessing From 36f0ef666f0a5926d0b9e87756011f04ccdc4d5d Mon Sep 17 00:00:00 2001 From: Francisc Date: Sun, 23 Jun 2013 15:14:55 +0300 Subject: [PATCH 10/66] added precondition --- .../Visibility_2/CGAL/Simple_visibility_2.h | 26 ++----------------- 1 file changed, 2 insertions(+), 24 deletions(-) diff --git a/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h index d0a1ae0ceec..cb7027bb9ce 100644 --- a/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h +++ b/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h @@ -3,7 +3,7 @@ namespace CGAL { \ingroup PkgVisibility_2Classes This class is a model of the concept `Visibility_2` offers visibility queries within -a simple Arrangement (no holes). Uses a linear algorithm to obtain visibility. +a simple polygon with no holes. Uses a linear algorithm to obtain visibility. \sa `Visibility_2` @@ -47,32 +47,10 @@ Simple_visibility_2(const Input_Arrangement_2& arr); /// \name functions /// @{ - - /*! -Return whether the object is attached to an arrangement. -*/ - bool is_attached (); -/*! -Attaches visibility object to the given arrangement arr. -*/ - void attach ( Input_Arrangement_2 arr); - - -/*! -Detaches the object from the arrangement it is currently attached to. -*/ - void detach (); - -/*! -Access to the attached Arrangement_2. -*/ - Input_Arrangement_2 arr(); - -/*! Computes the visibility region for the given query point q. -\pre face is a face of this->arr() +\pre face is a face of this->arr() with no holes \pre p is in the interior of face \pre out_arr is the output arrangement From 9c5b350b082b6ebf0f96f00ec346926f478e7052 Mon Sep 17 00:00:00 2001 From: Francisc Date: Tue, 25 Jun 2013 19:25:12 +0300 Subject: [PATCH 11/66] added Visibility_2 class definition --- .../CGAL/Visibility_2/Concepts/Visibility_2.h | 59 +++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 Visibility_2/include/CGAL/Visibility_2/Concepts/Visibility_2.h diff --git a/Visibility_2/include/CGAL/Visibility_2/Concepts/Visibility_2.h b/Visibility_2/include/CGAL/Visibility_2/Concepts/Visibility_2.h new file mode 100644 index 00000000000..70ea560d2ad --- /dev/null +++ b/Visibility_2/include/CGAL/Visibility_2/Concepts/Visibility_2.h @@ -0,0 +1,59 @@ +#ifndef CGAL_VISIBILITY_2_H +#define CGAL_VISIBILITY_2_H + +#include + +namespace CGAL { + +namespace Visibility_2 { + +template +class Visibility_2 +{ +public: + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + // Currently only consider with same type for both + typedef Input_Arrangement_2 Arrangement_2; + typedef Output_Arrangement_2 Arrangement_2; + + typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle; + typedef typename Arrangement_2::Face_const_handle Face_const_handle; + + typedef typename Geometry_traits_2::Point_2 Point_2; + + // TODO: Add RegularizationTag + + Visibility_2(const Input_Arrangement_2 &arr/*, Regularization_tag r_t*/): p_arr(arr) {}; + + bool is_attached() { + return (p_arr != NULL); + } + + void attach(const Input_Arrangement_2 &arr) { + p_arr = arr; + } + + void detach() { + p_arr = NULL; + } + + Input_Arrangement_2 arr() { + return (*p_arr); + } + + void visibility_region(const Point_2 &q, + const Face_const_handle f, + Output_Arrangement_2 &out_arr + ); + void visibility_region(const Point_2 &q, + const Halfedge_const_handle he, + Output_Arrangement_2 &out_arr + ); +protected: + Input_Arrangement_2 *p_arr; +}; + +} // namespace Visibility_2 +} // namespace CGAL + +#endif \ No newline at end of file From 7c197c6d9fe2981d935ba935cdede1069abc70e5 Mon Sep 17 00:00:00 2001 From: Francisc Date: Tue, 25 Jun 2013 19:26:46 +0300 Subject: [PATCH 12/66] added reference to algo --- .../doc/Visibility_2/CGAL/Simple_visibility_2.h | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h index cb7027bb9ce..eebab0939b2 100644 --- a/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h +++ b/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h @@ -3,7 +3,8 @@ namespace CGAL { \ingroup PkgVisibility_2Classes This class is a model of the concept `Visibility_2` offers visibility queries within -a simple polygon with no holes. Uses a linear algorithm to obtain visibility. +a simple polygon with no holes. Uses the linear algorithm of B.Joe and R.B.Simpson [1] to obtain +the visibility polygon. \sa `Visibility_2` @@ -71,5 +72,8 @@ Computes for the given query point q the visibility region that is on the side o }; /* end Visibility_2 */ - -} +/*! +[1] B. Joe, R. B. Simpson, "Corrections to Lee's visibility polygon algorithm", BIT Numerical Mathematics +Volume 27, Issue 4 , pp 458-473 +*/ +} \ No newline at end of file From 1a69029daf4233d68cfd7cd6b5b67627add68b05 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Thu, 27 Jun 2013 17:37:45 -0400 Subject: [PATCH 13/66] clean up docs, change some names, moving Regularization_tag to template parameter list as a typename --- .../Visibility_2/CGAL/Naive_visibility_2.h | 46 +++++++++++++------ .../CGAL/Preprocessed_visibility_2.h | 37 ++++++++++----- .../Visibility_2/CGAL/Simple_visibility_2.h | 25 +++++----- .../doc/Visibility_2/Concepts/Visibility_2.h | 38 ++++++++++----- 4 files changed, 98 insertions(+), 48 deletions(-) diff --git a/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h index 55bb44b1d06..37423e14e97 100644 --- a/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h +++ b/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h @@ -3,33 +3,51 @@ namespace CGAL { \ingroup PkgVisibility_2Classes This class is a model of the concept `Visibility_2` offers visibility queries within -an Arrangement. The algorithm it applies to obtain visibility is without preprocessing. +an Arrangement. The algorithm it applies to obtain visibility is without preprocessing. ArrExtensionTraits_2 gives information of input/output Arrangement and the extension between them. Regularization_tag indicates whether the result is regularized, i.e., if user needs regularized output, defined it as `Tag_true`. \sa `Visibility_2` */ -template +template class Naive_visibility_2 { public: /// \name Types /// @{ + /*! + *The type of Arrangement Extension Traits. + */ + typedef ArrExtensionTraits_2 Arr_extension_traits_2; + /*! + The type of input Arrangement. + */ + typedef Arr_extension_traits_2::Input_Arrangement_2 Input_Arrangement_2; + + /*! + The type of output Arrangement. + */ + typedef Arr_extension_traits_2::Output_Arrangement_2 Output_Arrangement_2; + + /*! The Point_2 type which is used for queries. */ - typedef Arrangement_2::Point_2 Point_2; - - /*! - Tag identifying whether `Visibility_2` computes the regularized visibility area. - */ - typedef bool Regularization_tag; + typedef Input_Arrangement_2::Point_2 Point_2; /*! - The Arrangement type which is used for output. - */ - typedef notknown Output_Arrangement_2; + Face_handle type of input Arrangement. + */ + typedef Input_Arrangement_2::Face_handle Face_handle; + + /*! + Halfedge_handle type of input Arrangement. + */ + typedef Input_Arrangement_2::Halfedge_handle Halfedge_handle; + + + /// @} @@ -66,7 +84,7 @@ Detaches the object from the arrangement it is currently attached to. void detach (); /*! -Access to the attached Arrangement_2. +Access to the attached Arrangement. */ Input_Arrangement_2 arr(); @@ -77,7 +95,7 @@ Computes the visibility region for the given query point q. \pre out_arr is the output arrangement */ - void visibility_region(const Point_2& q, const Face& face, Output_Arrangement_2& out_arr); + void visibility_region(const Point_2& q, const Face_handle& face, Output_Arrangement_2& out_arr); /*! Computes for the given query point q the visibility region that is on the side of the given halfedge. @@ -86,7 +104,7 @@ Computes for the given query point q the visibility region that is on the side o \pre out_arr is the output arrangement */ - void visibility_region(const Point_2& q, const Halfedge& halfedge, Output_Arrangement_2& out_arr); + void visibility_region(const Point_2& q, const Halfedge_handle& halfedge, Output_Arrangement_2& out_arr); /// @} diff --git a/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h index dc2e6f79198..dd60b08d6eb 100644 --- a/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h +++ b/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h @@ -6,31 +6,46 @@ This class is a model of the concept `Visibility_2` offers visibility queries wi an Arrangement. The algorithm it applies to obtain visibility is using preprocessing. \sa `Visibility_2` -\sa `CGAL::Naive_visibility_2` +\sa `CGAL::Naive_visibility_2` +\sa */ -template +template class Preprocessed_visibility_2 { public: /// \name Types /// @{ + /*! + *The type of Arrangement extension traits. + */ + typedef ArrExtensionTraits_2 Arr_extension_traits_2 + /*! + The type of input Arrangement. + */ + typedef Arr_extension_traits_2::Input_Arrangement_2 Input_Arrangement_2; + + /*! + The type of output Arrangement. + */ + typedef Arr_extension_traits_2::Output_Arrangement_2 Output_Arrangement_2; /*! The Point_2 type which is used for queries. */ - typedef Arrangement_2::Point_2 Point_2; - - /*! - Tag identifying whether `Visibility_2` computes regularized visibility area. - */ - typedef bool Regularization_tag; + typedef Input_Arrangement_2::Point_2 Point_2; /*! - The Arrangement type which is used for output. - */ - typedef notknown Ouput_Arrangement_2; + Face_handle type of input Arrangement. + */ + typedef Input_Arrangement_2::Face_handle Face_handle; + + /*! + Halfedge_handle type of input Arrangement. + */ + typedef Input_Arrangement_2::Halfedge_handle Halfedge_handle; + /// @} diff --git a/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h index eebab0939b2..fb1aa32b9e7 100644 --- a/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h +++ b/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h @@ -9,28 +9,31 @@ the visibility polygon. \sa `Visibility_2` */ -template +template class Simple_visibility_2 { public: /// \name Types /// @{ + typedef ArrExtensionTraits_2 Arr_extension_traits_2; + /*! + The Arrangement type is used for input. + */ + typedef Arr_extension_traits_2::Input_Arrangement_2 Input_Arrangement_2; + + /*! + *The Arrangement type is used for output. + */ + typedef Arr_extension_traits_2::Output_Arrangement_2 Output_Arrangement_2; /*! The Point_2 type which is used for queries. */ - typedef Arrangement_2::Point_2 Point_2; + typedef Input_Arrangement_2::Point_2 Point_2; + - /*! - Tag identifying whether `Visibility_2` computes the regularized visibility area. - */ - typedef bool Regularization_tag; - /*! - The Arrangement type which is used for output. - */ - typedef notknown Output_Arrangement_2; /// @} @@ -76,4 +79,4 @@ Computes for the given query point q the visibility region that is on the side o [1] B. Joe, R. B. Simpson, "Corrections to Lee's visibility polygon algorithm", BIT Numerical Mathematics Volume 27, Issue 4 , pp 458-473 */ -} \ No newline at end of file +} diff --git a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h index 711d8eeebf5..c09e1b29141 100644 --- a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h +++ b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h @@ -6,11 +6,12 @@ A model of the concept `Visibility_2` offers visibility queries within an Arrangement. -\cgalHasModel `CGAL::Naive_visibility_2` -\cgalHasModel `CGAL::Preprocessed_visibility_2` +\cgalHasModel `CGAL::Naive_visibility_2` +\cgalHasModel `CGAL::Preprocessed_visibility_2` -\sa `CGAL::Naive_visibility_2` -\sa `CGAL::Preprocessed_visibility_2` +\sa `CGAL::Naive_visibility_2` +\sa `CGAL::Preprocessed_visibility_2` +\sa `CGAL::Simple_visibility_2` */ class Visibility_2 { @@ -20,24 +21,37 @@ public: /// @{ /*! - The supported Arrangement type. + The supported Arrangement type of input. */ typedef Hidden_type Input_Arrangement_2; + /*! + The supported Arrangement type of output. + */ + typedef Hidden_type Output_Arrangement_2; + /*! The supported Point_2 type which is used for queries . */ typedef Hidden_type Point_2; + /*! + * The supported Face handle type of Arrangement. + */ + typedef Hidden_type Face_handle; + + /*! + * The supported Halfedge handle type of Arrangement. + */ + typedef Hidden_type Halfedge_handle; + /*! Tag identifying whether `Visibility_2` computes regularized visbility area. */ typedef Hidden_type Regularization_tag; - /*! - Traits showing what kind of arrangement extension the output will have - */ - typedef Hidden_type Traits; + + /// @} @@ -47,7 +61,7 @@ public: /*! Constructs a `Visibility_2` object from a given `Arrangement_2` and a given Regularization tag. */ -Visibility_2(const Input_Arrangement_2& arr, Regularization_tag Rt); +Visibility_2(const Input_Arrangement_2& arr); /// @} @@ -84,7 +98,7 @@ Computes the visibility region for the given query point q. \pre p is in the interior of face */ - void visibility_region(const Point_2& q, const Face& face, Output_Arrangement_2& out_arr); + void visibility_region(const Point_2& q, const Face_handle& face, Output_Arrangement_2& out_arr); /*! Computes for the given query point q the visibility region that is on the side of the given halfedge. @@ -92,7 +106,7 @@ Computes for the given query point q the visibility region that is on the side o \pre p is on halfedge */ - void visibility_region(const Point_2& q, const Halfedge& halfedge, Output_Arrangement_2& out_arr); + void visibility_region(const Point_2& q, const Halfedge_handle& halfedge, Output_Arrangement_2& out_arr); /// @} From 4badcc6be035db7dd700550473a71610734119c5 Mon Sep 17 00:00:00 2001 From: Francisc Date: Fri, 28 Jun 2013 11:59:15 +0300 Subject: [PATCH 14/66] added Simple_Visibility_2 progress --- .../CGAL/Visibility_2/Simple_visibility_2.h | 63 +++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h diff --git a/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h b/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h new file mode 100644 index 00000000000..70b6cde5142 --- /dev/null +++ b/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h @@ -0,0 +1,63 @@ +#ifndef CGAL_SIMPLE_VISIBILITY_2_H +#define CGAL_SIMPLE_VISIBILITY_2_H + +#include + +namespace CGAL { + +namespace Visibility_2 { + +template +class Simple_visibility_2 +{ +public: + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + // Currently only consider with same type for both + typedef Arrangement_2 Input_Arrangement_2; + typedef Arrangement_2 Output_Arrangement_2; + + typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle; + typedef typename Arrangement_2::Face_const_handle Face_const_handle; + + typedef typename Geometry_traits_2::Point_2 Point_2; + + // TODO: Add RegularizationTag + + /*! Constructor given an arrangement and the Regularization tag. */ + Simple_visibility_2(const Input_Arrangement_2 &arr/*, Regularization_tag r_t*/): p_arr(arr) {}; + + bool is_attached() { + return (p_arr != NULL); + } + + void attach(const Input_Arrangement_2 &arr) { + p_arr = arr; + } + + void detach() { + p_arr = NULL; + } + + Input_Arrangement_2 arr() { + return (*p_arr); + } + + void visibility_region(const Point_2 &q, + const Face_const_handle f, + Output_Arrangement_2 &out_arr + ) { + } + void visibility_region(const Point_2 &q, + const Halfedge_const_handle he, + Output_Arrangement_2 &out_arr + ) { + + } +protected: + Input_Arrangement_2 *p_arr; +}; + +} // namespace Visibility_2 +} // namespace CGAL + +#endif \ No newline at end of file From 3d0d2b4387b6177be95ac4b253cac18639a572d4 Mon Sep 17 00:00:00 2001 From: Francisc Date: Fri, 28 Jun 2013 12:02:12 +0300 Subject: [PATCH 15/66] removed file --- .../CGAL/Visibility_2/Concepts/Visibility_2.h | 59 ------------------- 1 file changed, 59 deletions(-) delete mode 100644 Visibility_2/include/CGAL/Visibility_2/Concepts/Visibility_2.h diff --git a/Visibility_2/include/CGAL/Visibility_2/Concepts/Visibility_2.h b/Visibility_2/include/CGAL/Visibility_2/Concepts/Visibility_2.h deleted file mode 100644 index 70ea560d2ad..00000000000 --- a/Visibility_2/include/CGAL/Visibility_2/Concepts/Visibility_2.h +++ /dev/null @@ -1,59 +0,0 @@ -#ifndef CGAL_VISIBILITY_2_H -#define CGAL_VISIBILITY_2_H - -#include - -namespace CGAL { - -namespace Visibility_2 { - -template -class Visibility_2 -{ -public: - typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; - // Currently only consider with same type for both - typedef Input_Arrangement_2 Arrangement_2; - typedef Output_Arrangement_2 Arrangement_2; - - typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle; - typedef typename Arrangement_2::Face_const_handle Face_const_handle; - - typedef typename Geometry_traits_2::Point_2 Point_2; - - // TODO: Add RegularizationTag - - Visibility_2(const Input_Arrangement_2 &arr/*, Regularization_tag r_t*/): p_arr(arr) {}; - - bool is_attached() { - return (p_arr != NULL); - } - - void attach(const Input_Arrangement_2 &arr) { - p_arr = arr; - } - - void detach() { - p_arr = NULL; - } - - Input_Arrangement_2 arr() { - return (*p_arr); - } - - void visibility_region(const Point_2 &q, - const Face_const_handle f, - Output_Arrangement_2 &out_arr - ); - void visibility_region(const Point_2 &q, - const Halfedge_const_handle he, - Output_Arrangement_2 &out_arr - ); -protected: - Input_Arrangement_2 *p_arr; -}; - -} // namespace Visibility_2 -} // namespace CGAL - -#endif \ No newline at end of file From 134a2617c96cf8030516ebed609a473c5668959e Mon Sep 17 00:00:00 2001 From: Francisc Date: Tue, 2 Jul 2013 12:00:03 +0300 Subject: [PATCH 16/66] finished implementation --- .../CGAL/Visibility_2/Simple_visibility_2.h | 373 +++++++++++++++++- 1 file changed, 359 insertions(+), 14 deletions(-) diff --git a/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h b/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h index 70b6cde5142..c24abb86438 100644 --- a/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h @@ -2,26 +2,28 @@ #define CGAL_SIMPLE_VISIBILITY_2_H #include +#include namespace CGAL { namespace Visibility_2 { template -class Simple_visibility_2 -{ +class Simple_visibility_2 { + public: - typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; // Currently only consider with same type for both - typedef Arrangement_2 Input_Arrangement_2; - typedef Arrangement_2 Output_Arrangement_2; + typedef Arrangement_2 Input_Arrangement_2; + typedef Arrangement_2 Output_Arrangement_2; - typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle; - typedef typename Arrangement_2::Face_const_handle Face_const_handle; + typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle; + typedef typename Arrangement_2::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; + typedef typename Arrangement_2::Face_const_handle Face_const_handle; - typedef typename Geometry_traits_2::Point_2 Point_2; - - // TODO: Add RegularizationTag + typedef typename Geometry_traits_2::Point_2 Point_2; + typedef typename Geometry_traits_2::Vector_2 Vector_2; + typedef typename Geometry_traits_2::Segment_2 Segment_2; /*! Constructor given an arrangement and the Regularization tag. */ Simple_visibility_2(const Input_Arrangement_2 &arr/*, Regularization_tag r_t*/): p_arr(arr) {}; @@ -39,14 +41,127 @@ public: } Input_Arrangement_2 arr() { - return (*p_arr); + return p_arr; } - void visibility_region(const Point_2 &q, - const Face_const_handle f, + void visibility_region(Point_2 &q, + const Face_const_handle face, Output_Arrangement_2 &out_arr ) { + + int i = 0; + bool ccw = false; + + typename Input_Arrangement_2::Ccb_halfedge_const_circulator circ = face->outer_ccb(); + typename Input_Arrangement_2::Ccb_halfedge_const_circulator curr = circ; + typename Input_Arrangement_2::Halfedge_const_handle he = curr; + + int parity = 0; + + std::vector translated_vertices; + int index_v0 = 0; + int index = 0; + double curr_min_x = 1000000; + // Push all vertices and translate coordinate system such that query point is at the origin + do { + he = curr; + Point_2 curr_vertex = he->target()->point(); + Point_2 translated_vertex = Point_2(curr_vertex.x() - q.x(), curr_vertex.y() - q.y()); + if (CGAL::to_double(translated_vertex.x()) < curr_min_x && CGAL::to_double(translated_vertex.x()) > 0) { + curr_min_x = CGAL::to_double(translated_vertex.x()); + index_v0 = index; + } + translated_vertices.push_back(translated_vertex); + index++; + } while (++curr != circ); + + // Now create vector so that first vertex v0 has the smallest positive x-coordinate (thus - visible from the query point) + for (unsigned int k = index_v0 ; k < translated_vertices.size() ; k++) { + vertices.push_back(translated_vertices[k]); + } + for (unsigned int k = 0 ; k < index_v0 ; k++) { + vertices.push_back(translated_vertices[k]); + } + // Push first vertex again to fulfill algo precondition + vertices.push_back(vertices[0]); + + std::cout << "Vertices:\n"; + for (unsigned int k = 0 ; k < vertices.size() ; k++) { + std::cout << vertices[k] << std::endl; + } + + Point_2 w; + + if (CGAL::orientation(q, vertices[0], vertices[1]) == CGAL::LEFT_TURN) { + i = 1; + w = vertices[1]; + s.push(vertices[0]); + s.push(vertices[1]); + left(i, w, q); + } + else { + i = 1; + w = vertices[1]; + s.push(vertices[0]); + scana(i, w, q); + } + std::cout << "gets here\n"; + Point_2 stored_q(q); + q = Point_2(0, 0); + do { + switch(upcase) { + case LEFT: + left(i, w, q); + break; + case RIGHT: + right(i, w, q); + break; + case SCANA: + scana(i, w, q); + break; + case SCANB: + scanb(i, w, q); + break; + case SCANC: + scanc(i, w, q); + break; + case SCAND: + scand(i, w, q); + break; + } + if (upcase == LEFT) { + // Check if (s_t-1, s_t) intersects (q, vn) + Point_2 s_t = s.top(); + s.pop(); + Point_2 s_t_prev = s.top(); + Segment_2 s1(s_t_prev, s_t); + Segment_2 s2(q, vertices[vertices.size()-1]); + CGAL::Object result = CGAL::intersection(s1, s2); + + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + upcase = SCANB; + Segment_2 s3(s_t_prev, vertices[i]); + CGAL::Object result2 = CGAL::intersection(s3, s2); + if (const Point_2 *vertex_new = CGAL::object_cast(&result2)) { + s.push(*vertex_new); + } + } + else { // Do not alter stack if it doesn't intersect - push back s_t + s.push(s_t); + } + } + } while(upcase != FINISH); + + std::cout << "RESULT: " << std::endl; + + while(!s.empty()) { + Point_2 curr_pt = s.top(); + Point_2 final_pt(curr_pt.x() + stored_q.x(), curr_pt.y() + stored_q.y()); + std::cout << final_pt << std::endl; + s.pop(); + } } + void visibility_region(const Point_2 &q, const Halfedge_const_handle he, Output_Arrangement_2 &out_arr @@ -54,7 +169,237 @@ public: } protected: - Input_Arrangement_2 *p_arr; + Input_Arrangement_2 p_arr; + std::stack s; + std::vector vertices; + enum {LEFT, RIGHT, SCANA, SCANB, SCANC, SCAND, FINISH} upcase; + + bool do_overlap(const Point_2 &a, const Point_2 &b, const Point_2 &c) { + + if (CGAL::collinear(a, b, c)) { + Segment_2 s1(a, b); + Segment_2 s2(a, c); + const Segment_2 *seg_overlap; + CGAL::Object result = CGAL::intersection(s1, s2); + if (seg_overlap = CGAL::object_cast(&result)) { + return true; + } + } + return false; + } + + void left(int &i, Point_2 &w, const Point_2 &query_pt) { + + if (i == vertices.size()) { + upcase = FINISH; + } + else if (CGAL::orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::LEFT_TURN) { + upcase = LEFT; + s.push(vertices[i+1]); + w = vertices[i+1]; + i++; + } + else if (CGAL::orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { + Point_2 s_t = s.top(); + s.pop(); + Point_2 s_t_prev = s.top(); + s.pop(); + if (CGAL::orientation(s_t_prev, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { + upcase = SCANA; + i++; + } + s.push(s_t_prev); + s.push(s_t); + w = vertices[i+1]; + } + else { + upcase = RIGHT; + i++; + w = vertices[i]; + } + } + + void right(int &i, Point_2 &w, const Point_2 &query_pt) { + // Scan s_t, s_t-1, ..., s_1, s_0 for the first edge (s_j, s_j-1) such that + // (a) (z, s_j, v_i) is a right turn and (z, s_j-1, v_i) is a left turn, or + // (b) (z, s_j-1, s_j) is a forward move and (v_i-1, v_i) intersects (s_j-1, s_j) + bool found = false; + + while(!found) { + Point_2 s_j = s.top(); + if (!s.empty()) { + s.pop(); + Point_2 s_j_prev = s.top(); + + // Check condition (a) + if ((CGAL::orientation(query_pt, s_j, vertices[i]) == CGAL::RIGHT_TURN) + && (CGAL::orientation(query_pt, s_j_prev, vertices[i]) == CGAL::LEFT_TURN)) { + found = true; + Segment_2 s1(s_j_prev, s_j); + Segment_2 s2(query_pt, vertices[i]); + CGAL::Object result = CGAL::intersection(s1, s2); + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + s_j = *ipoint; + } + + if (CGAL::orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { + upcase = RIGHT; + s.push(s_j); + i++; + w = vertices[i]; + } + else if ((CGAL::orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::LEFT_TURN) + && (CGAL::orientation(vertices[i-1], vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN)) { + + upcase = LEFT; + i++; + s.push(s_j); + s.push(vertices[i]); + s.push(vertices[i+1]); + w = vertices[i+1]; + } + else { + upcase = SCANC; + i++; + s.push(s_j); + } + } + else { // Case (b) + Segment_2 s1(s_j_prev, s_j); + Segment_2 s2(vertices[i-1], vertices[i]); + CGAL::Object result = CGAL::intersection(s1, s2); + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + // Keep s_j off the stack + upcase = SCAND; + w = *ipoint; + } + } + } + } + } + + void scana(int &i, Point_2 &w, const Point_2 &query_pt) { + // Scan v_i, v_i+1, ..., v_n for the first edge to intersect (z, s_t) + bool found = false; + int k = i; + const Point_2 *ipoint; + while (k+1 < vertices.size()-1) { + Segment_2 s1(vertices[k], vertices[k+1]); + Segment_2 s2(query_pt, s.top()); + CGAL::Object result = CGAL::intersection(s1, s2); + if (ipoint = CGAL::object_cast(&result)) { + found = true; + break; + } + k++; + } + if (found) { + if ((CGAL::orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::RIGHT_TURN) + && (do_overlap(query_pt, s.top(), *ipoint))) { + + upcase = RIGHT; + i = k+1; + w = *ipoint; + } + else if ((CGAL::orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::RIGHT_TURN) + && (!do_overlap(query_pt, s.top(), *ipoint))) { + + upcase = SCAND; + i = k+1; + w = *ipoint; + } + else if ((CGAL::orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::LEFT_TURN) + && (!do_overlap(query_pt, s.top(), *ipoint))) { + + upcase = LEFT; + i = k+1; + s.push(*ipoint); + s.push(vertices[k+1]); + w = vertices[k+1]; + } + else { + // This case never occurs + } + } + } + + void scanb(int &i, Point_2 &w, const Point_2 &query_pt) { + // Scan v_i, v_i+1, ..., v_n-1, v_n for the first edge to intersect (s_t, v_n] + Point_2 s_t = s.top(); + int k = i; + bool found = false; + const Point_2 *ipoint; + while (k+1 < vertices.size()-1) { + Segment_2 s1(vertices[k], vertices[k+1]); + Segment_2 s2(s_t, vertices[vertices.size()-1]); + CGAL::Object result = CGAL::intersection(s1, s2); + if (ipoint = CGAL::object_cast(&result)) { + found = true; + break; + } + k++; + } + if (found) { + if ((*ipoint == vertices[k+1]) && (*ipoint == vertices[vertices.size()-1])) { + upcase = FINISH; + w = vertices[vertices.size()-1]; + s.push(vertices[vertices.size()-1]); + } + else { + upcase = RIGHT; + i = k+1; + w = *ipoint; + } + } + } + + void scanc(int &i,Point_2 &w, const Point_2 &query_pt) { + // Scan v_i, v_i+1, ..., v_n-1, v_n for the first edge to intersect (s_t, w) + Point_2 s_t = s.top(); + int k = i; + bool found = false; + const Point_2 *ipoint; + while (k+1 < vertices.size()-1) { + Segment_2 s1(vertices[k], vertices[k+1]); + Segment_2 s2(s_t, w); + CGAL::Object result = CGAL::intersection(s1, s2); + if (ipoint = CGAL::object_cast(&result)) { + found = true; + break; + } + k++; + } + if (found) { + upcase = RIGHT; + i = k+1; + w = *ipoint; + } + } + + void scand(int &i, Point_2 &w, const Point_2 &query_pt) { + // Scan v_i, v_i+1, v_n-1, v_n for the fist edge to intersect (s_t, w) + Point_2 s_t = s.top(); + int k = i; + bool found = false; + const Point_2 *ipoint; + while (k+1 < vertices.size()-1) { + Segment_2 s1(vertices[k], vertices[k+1]); + Segment_2 s2(s_t, w); + CGAL::Object result = CGAL::intersection(s1, s2); + if (ipoint = CGAL::object_cast(&result)) { + found = true; + break; + } + k++; + } + if (found) { + upcase = LEFT; + i = k+1; + s.push(*ipoint); + s.push(vertices[k+1]); + w = vertices[k+1]; + } + } }; } // namespace Visibility_2 From da6d2ee5785dfe4128f89b549dba1744799b85ce Mon Sep 17 00:00:00 2001 From: Francisc Date: Tue, 2 Jul 2013 12:00:55 +0300 Subject: [PATCH 17/66] finished implementation --- Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h | 1 - 1 file changed, 1 deletion(-) diff --git a/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h b/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h index c24abb86438..33ca807b19c 100644 --- a/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h @@ -105,7 +105,6 @@ public: s.push(vertices[0]); scana(i, w, q); } - std::cout << "gets here\n"; Point_2 stored_q(q); q = Point_2(0, 0); do { From 022d788ac262bddaafa423cf22edcbeba859351c Mon Sep 17 00:00:00 2001 From: Francisc Date: Thu, 4 Jul 2013 11:17:33 +0300 Subject: [PATCH 18/66] corrected bug --- .../CGAL/Visibility_2/Simple_visibility_2.h | 38 ++++++++++++++----- 1 file changed, 29 insertions(+), 9 deletions(-) diff --git a/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h b/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h index 33ca807b19c..9175811e222 100644 --- a/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h @@ -91,26 +91,31 @@ public: } Point_2 w; + Point_2 stored_q(q); + q = Point_2(0, 0); if (CGAL::orientation(q, vertices[0], vertices[1]) == CGAL::LEFT_TURN) { + std::cout << "left" << std::endl; + upcase = LEFT; i = 1; w = vertices[1]; s.push(vertices[0]); s.push(vertices[1]); - left(i, w, q); } else { + std::cout << "right" << std::endl; + upcase = SCANA; i = 1; w = vertices[1]; s.push(vertices[0]); - scana(i, w, q); } - Point_2 stored_q(q); - q = Point_2(0, 0); do { + std::cout << "CASE: " << upcase << std::endl; switch(upcase) { case LEFT: + std::cout << "before entering left" << std::endl; left(i, w, q); + std::cout << "after exiting left" << std::endl; break; case RIGHT: right(i, w, q); @@ -131,24 +136,37 @@ public: if (upcase == LEFT) { // Check if (s_t-1, s_t) intersects (q, vn) Point_2 s_t = s.top(); + std::cout << "s_t= " << s_t << std::endl; s.pop(); Point_2 s_t_prev = s.top(); + std::cout << "s_t-1= " << s_t_prev << std::endl; Segment_2 s1(s_t_prev, s_t); Segment_2 s2(q, vertices[vertices.size()-1]); CGAL::Object result = CGAL::intersection(s1, s2); if (const Point_2 *ipoint = CGAL::object_cast(&result)) { - upcase = SCANB; Segment_2 s3(s_t_prev, vertices[i]); CGAL::Object result2 = CGAL::intersection(s3, s2); if (const Point_2 *vertex_new = CGAL::object_cast(&result2)) { - s.push(*vertex_new); + if ((*vertex_new) != (s_t_prev) && (*vertex_new != s_t)) { + std::cout << "switch to scanb" << std::endl; + upcase = SCANB; + s.push(*vertex_new); + } + else { // Do not alter stack if it doesn't intersect - push back s_t + std::cout << "skipping because it is endpoint" << std::endl; + s.push(s_t); + } + } + else { + s.push(s_t); } } - else { // Do not alter stack if it doesn't intersect - push back s_t + else { s.push(s_t); } } + std::cout << "gets out" << std::endl; } while(upcase != FINISH); std::cout << "RESULT: " << std::endl; @@ -188,11 +206,13 @@ protected: } void left(int &i, Point_2 &w, const Point_2 &query_pt) { - - if (i == vertices.size()) { + std::cout << "begin with i = " << i << std::endl; + if (i == vertices.size() - 1) { + std::cout << "done" << std::endl; upcase = FINISH; } else if (CGAL::orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::LEFT_TURN) { + std::cout << "left::left turn with i =" << i << std::endl; upcase = LEFT; s.push(vertices[i+1]); w = vertices[i+1]; From 6068adb5999ab385788e3c8edb5e8de00db448db Mon Sep 17 00:00:00 2001 From: Francisc Date: Sat, 6 Jul 2013 14:41:34 +0300 Subject: [PATCH 19/66] refined documentation, added citations --- .../Visibility_2/CGAL/Naive_visibility_2.h | 21 ++++++++++++------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h index 37423e14e97..7a0f1de8cf4 100644 --- a/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h +++ b/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h @@ -3,9 +3,19 @@ namespace CGAL { \ingroup PkgVisibility_2Classes This class is a model of the concept `Visibility_2` offers visibility queries within -an Arrangement. The algorithm it applies to obtain visibility is without preprocessing. ArrExtensionTraits_2 gives information of input/output Arrangement and the extension between them. Regularization_tag indicates whether the result is regularized, i.e., if user needs regularized output, defined it as `Tag_true`. +an Arrangement. The algorithm it applies to obtain visibility is without preprocessing. +It relies on the algorithm of T. Asano \cite ta-aeafvpprh-85 based on angular plane sweep, +with a time complexity of O (n log n) in the number of vertices. -\sa `Visibility_2` +ArrExtensionTraits_2 gives information about the input/output Arrangements and the extension between them. +The Regularization_tag indicates whether the output Arrangement result should be regularized. It can be +specified by one of the following: CGAL::Tag_true or CGAL::Tag_false. + +\cgalModels `Visibility_2` + +\sa 'CGAL::Visibility_2' +\sa `CGAL::Simple_visibility_2` +\sa `CGAL::Preprocessed_visibility_2` */ template @@ -29,7 +39,6 @@ public: */ typedef Arr_extension_traits_2::Output_Arrangement_2 Output_Arrangement_2; - /*! The Point_2 type which is used for queries. @@ -46,9 +55,6 @@ public: */ typedef Input_Arrangement_2::Halfedge_handle Halfedge_handle; - - - /// @} /// \name Constructors @@ -66,7 +72,6 @@ Naive_visibility_2(const Input_Arrangement_2& arr); /// @{ - /*! Return whether the object is attached to an arrangement. */ @@ -112,4 +117,4 @@ Computes for the given query point q the visibility region that is on the side o }; /* end Visibility_2 */ -} +} \ No newline at end of file From 6d7d0d29636d80d1795df1ef916e697933712e8e Mon Sep 17 00:00:00 2001 From: Francisc Date: Sat, 6 Jul 2013 14:42:06 +0300 Subject: [PATCH 20/66] refined documentation, added citations --- .../CGAL/Preprocessed_visibility_2.h | 17 ++++++++-------- .../Visibility_2/CGAL/Simple_visibility_2.h | 16 +++++++++------ .../doc/Visibility_2/Concepts/Visibility_2.h | 20 ++++++++++++------- 3 files changed, 32 insertions(+), 21 deletions(-) diff --git a/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h index dd60b08d6eb..345f59814db 100644 --- a/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h +++ b/Visibility_2/doc/Visibility_2/CGAL/Preprocessed_visibility_2.h @@ -5,9 +5,11 @@ namespace CGAL { This class is a model of the concept `Visibility_2` offers visibility queries within an Arrangement. The algorithm it applies to obtain visibility is using preprocessing. -\sa `Visibility_2` +\cgalModels `Visibility_2` + +\sa 'CGAL::Visibility_2' +\sa `CGAL::Simple_visibility_2` \sa `CGAL::Naive_visibility_2` -\sa */ template @@ -17,10 +19,11 @@ public: /// \name Types /// @{ - /*! - *The type of Arrangement extension traits. - */ - typedef ArrExtensionTraits_2 Arr_extension_traits_2 + /*! + The type of Arrangement extension traits. + */ + typedef ArrExtensionTraits_2 Arr_extension_traits_2; + /*! The type of input Arrangement. */ @@ -63,8 +66,6 @@ Naive_visibility_2(const Input_Arrangement_2& arr); /// \name functions /// @{ - - /*! Return whether the object is attached to an arrangement. */ diff --git a/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h index fb1aa32b9e7..bd4c50b9a1e 100644 --- a/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h +++ b/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h @@ -3,10 +3,16 @@ namespace CGAL { \ingroup PkgVisibility_2Classes This class is a model of the concept `Visibility_2` offers visibility queries within -a simple polygon with no holes. Uses the linear algorithm of B.Joe and R.B.Simpson [1] to obtain -the visibility polygon. +a simple polygon with no holes. Uses the algorithm of B.Joe and R.B.Simpson \cite bjrb-clvpa-87 to obtain +the visibility polygon, based on a scan of the boundary of the polygon and the notion of angular +displacement as a control variable. The time complexity is O(n) in the number of the vertices +of the polygon. -\sa `Visibility_2` +\cgalModels `Visibility_2` + +\sa 'CGAL::Visibility_2' +\sa `CGAL::Naive_visibility_2` +\sa `CGAL::Preprocessed_visibility_2` */ template @@ -31,9 +37,7 @@ public: The Point_2 type which is used for queries. */ typedef Input_Arrangement_2::Point_2 Point_2; - - - + /// @} diff --git a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h index c09e1b29141..612c8620478 100644 --- a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h +++ b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h @@ -6,12 +6,13 @@ A model of the concept `Visibility_2` offers visibility queries within an Arrangement. +\cgalHasModel `CGAL::Simple_visibility_2` \cgalHasModel `CGAL::Naive_visibility_2` \cgalHasModel `CGAL::Preprocessed_visibility_2` +\sa `CGAL::Simple_visibility_2` \sa `CGAL::Naive_visibility_2` \sa `CGAL::Preprocessed_visibility_2` -\sa `CGAL::Simple_visibility_2` */ class Visibility_2 { @@ -31,19 +32,19 @@ public: typedef Hidden_type Output_Arrangement_2; /*! - The supported Point_2 type which is used for queries . + The supported Point_2 type of the input type, used for queries. */ - typedef Hidden_type Point_2; + typedef Hidden_type Input_Arrangement_2::Point_2; /*! - * The supported Face handle type of Arrangement. + * The supported Face handle type of the input Arrangement. */ - typedef Hidden_type Face_handle; + typedef Hidden_type Input_Arrangement_2::Face_handle; /*! - * The supported Halfedge handle type of Arrangement. + * The supported Halfedge handle type of the input Arrangement. */ - typedef Hidden_type Halfedge_handle; + typedef Hidden_type Input_Arrangement_2::Halfedge_handle; /*! Tag identifying whether `Visibility_2` computes regularized visbility area. @@ -58,6 +59,11 @@ public: /// \name Constructors /// @{ +/*! +default constructor. +*/ +Visibility_2(); + /*! Constructs a `Visibility_2` object from a given `Arrangement_2` and a given Regularization tag. */ From 3da4808ae17c20b0e26a91ad5f326493fbe80a77 Mon Sep 17 00:00:00 2001 From: Francisc Date: Sat, 6 Jul 2013 20:28:08 +0300 Subject: [PATCH 21/66] small modifications --- .../CGAL/Visibility_2/Simple_visibility_2.h | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h b/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h index 9175811e222..5587144803d 100644 --- a/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h @@ -58,29 +58,29 @@ public: int parity = 0; - std::vector translated_vertices; + std::vector temp_vertices; int index_v0 = 0; int index = 0; - double curr_min_x = 1000000; - // Push all vertices and translate coordinate system such that query point is at the origin + Point_2 curr_min = he->source()->point(); + + // Push all vertices do { - he = curr; + he = curr; Point_2 curr_vertex = he->target()->point(); - Point_2 translated_vertex = Point_2(curr_vertex.x() - q.x(), curr_vertex.y() - q.y()); - if (CGAL::to_double(translated_vertex.x()) < curr_min_x && CGAL::to_double(translated_vertex.x()) > 0) { - curr_min_x = CGAL::to_double(translated_vertex.x()); + if (curr_vertex.x() < curr_min.x() && curr_vertex.x() > 0) { + curr_min = curr_vertex; index_v0 = index; } - translated_vertices.push_back(translated_vertex); + temp_vertices.push_back(curr_vertex); index++; } while (++curr != circ); // Now create vector so that first vertex v0 has the smallest positive x-coordinate (thus - visible from the query point) - for (unsigned int k = index_v0 ; k < translated_vertices.size() ; k++) { - vertices.push_back(translated_vertices[k]); + for (unsigned int k = index_v0 ; k < temp_vertices.size() ; k++) { + vertices.push_back(temp_vertices[k]); } for (unsigned int k = 0 ; k < index_v0 ; k++) { - vertices.push_back(translated_vertices[k]); + vertices.push_back(temp_vertices[k]); } // Push first vertex again to fulfill algo precondition vertices.push_back(vertices[0]); @@ -91,8 +91,8 @@ public: } Point_2 w; - Point_2 stored_q(q); - q = Point_2(0, 0); +// Point_2 stored_q(q); +// q = Point_2(0, 0); if (CGAL::orientation(q, vertices[0], vertices[1]) == CGAL::LEFT_TURN) { std::cout << "left" << std::endl; @@ -173,7 +173,7 @@ public: while(!s.empty()) { Point_2 curr_pt = s.top(); - Point_2 final_pt(curr_pt.x() + stored_q.x(), curr_pt.y() + stored_q.y()); + Point_2 final_pt(curr_pt.x(), curr_pt.y()); std::cout << final_pt << std::endl; s.pop(); } From c3f6f0bf4ac88db6a91a7dad1f5d4b799702029b Mon Sep 17 00:00:00 2001 From: Francisc Date: Sun, 7 Jul 2013 23:47:39 +0300 Subject: [PATCH 22/66] moved file one folder down --- .../include/CGAL/{Visibility_2 => }/Simple_visibility_2.h | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Visibility_2/include/CGAL/{Visibility_2 => }/Simple_visibility_2.h (100%) diff --git a/Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h b/Visibility_2/include/CGAL/Simple_visibility_2.h similarity index 100% rename from Visibility_2/include/CGAL/Visibility_2/Simple_visibility_2.h rename to Visibility_2/include/CGAL/Simple_visibility_2.h From e7de4069b458d2cb4fafdb4c379a10a88db40cb3 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Sun, 7 Jul 2013 23:18:28 -0400 Subject: [PATCH 23/66] need polish. the needle function is not right --- .../CGAL/Visibility_2/Naive_visibility_2.h | 674 ++++++++++++++++++ 1 file changed, 674 insertions(+) create mode 100644 Visibility_2/include/CGAL/Visibility_2/Naive_visibility_2.h diff --git a/Visibility_2/include/CGAL/Visibility_2/Naive_visibility_2.h b/Visibility_2/include/CGAL/Visibility_2/Naive_visibility_2.h new file mode 100644 index 00000000000..e004bcaf7fc --- /dev/null +++ b/Visibility_2/include/CGAL/Visibility_2/Naive_visibility_2.h @@ -0,0 +1,674 @@ +//kan's version +#ifndef CGAL_NAIVE_VISIBILITY_2_H +#define CGAL_NAIVE_VISIBILITY_2_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace CGAL { + +namespace Visibility_2 { + +//debug +template +void print(std::vector ps){ + for (int i=0; ipoint().x()<<","<point().y()< +class Naive_visibility_2 { + typedef typename Arrangement_2::Traits_2 Traits_2; + typedef typename Traits_2::Kernel Kernel; + typedef typename Traits_2::Point_2 Point_2; + typedef typename CGAL::Segment_2 Segment_2; + + typedef typename Arrangement_2::Halfedge Halfedge; + typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle; + typedef typename Arrangement_2::Vertex_const_handle Vertex_const_handle; + typedef typename Arrangement_2::Face_const_handle Face_const_handle; + + typedef typename CGAL::Vector_2 Vector_2; + typedef typename CGAL::Direction_2 Direction_2; + typedef typename CGAL::Ray_2 Ray_2; + + enum Intersection_type { UNBOUNDED, CORNER, INNER }; + +public: + //members + Arrangement_2 arr; + + //functions + Naive_visibility_2(const Arrangement_2 &arr):arr(arr), attach_tag(true) {} + + Naive_visibility_2(): attach_tag(false) {} + + + void visibility_region(const Point_2 &q, const Halfedge &edge, Arrangement_2 &out_arr) { + + } + + void visibility_region(const Point_2 &query, Face_const_handle fh, Arrangement_2 &out_arr) { + visibility_region_impl(query, fh, out_arr, Regularization_tag()); + + } + + void visibility_region_impl(const Point_2 &query, Face_const_handle fh, Arrangement_2 &out_arr, CGAL::Tag_true) { + std::vector vertices; //all vertices of the face. + std::vector edges, active_edges; //edges stores all halfedges of the face; and active_edges stores all halfedges that is currently intersected by the view ray. + //preprocess the face + input_face(fh, vertices, edges, query); + //initiation of vision ray + Vector_2 dir; + if (Direction_2(-1, 0) < Direction_2(Vector_2(query, (*vertices.rbegin())->point()))) + { + dir = Vector_2(1, 0) + Vector_2(query, (*vertices.rbegin())->point()); + } + else { + dir = Vector_2(0, -1); + } + Ray_2 init_vision_ray(query, dir); + + //initiation of active_edges + typename std::vector::iterator iter1; + for (iter1 = edges.begin(); iter1 != edges.end(); iter1++) + { + insert_halfedge(active_edges, init_vision_ray, *iter1); + } + + //angular sweep + std::vector polygon; + Ray_2 curr_vision_ray = init_vision_ray; + typename std::vector::iterator vit = vertices.begin(), begin_it, end_it; + Halfedge_const_handle closest_edge; + bool is_init_empty = active_edges.empty(); + while (vit != vertices.end()) + { + if (active_edges.empty()) + { + begin_it = vit; + end_it = vit; + curr_vision_ray= Ray_2(query, (*begin_it)->point()); + Direction_2 d1(curr_vision_ray), d2; + do { + d2 = Direction_2(Ray_2(query, (*end_it)->point())); + if (d1 != d2) break; + } while (++end_it != vertices.end()); + add_edges(begin_it, end_it, active_edges, curr_vision_ray); + + //since active_edges is empty, that means adding new edges will bring in an unbounded edge to arrangement. + closest_edge = active_edges[0]; + remove_edges(active_edges, curr_vision_ray); + + if (active_edges.empty()) { + //this means in input, there is no edge that intersects curr_vision_ray + //except those collinear ones. + //because one unbounded ray has been inserted before, + //we don't need to do anything here. + } + else { + //add new edge; + Point_2 p1 = intersection_point(curr_vision_ray, closest_edge); + Point_2 p2 = intersection_point(curr_vision_ray, active_edges[0]); + update_visibility(p1, polygon, out_arr); + update_visibility(p2, polygon, out_arr); + + } + } + else { + closest_edge = active_edges[0]; + begin_it = vit; //all vertices between begin_it and end_it(not included) are collinear with query point. + end_it = vit; + curr_vision_ray = Ray_2(query, (*begin_it)->point()); + Direction_2 d1(curr_vision_ray), d2; + do { + d2 = Direction_2(Ray_2(query, (*end_it)->point())); + if (d1 != d2) break; + } while (++end_it != vertices.end()); + add_edges(begin_it, end_it, active_edges, curr_vision_ray); + + if (closest_edge != active_edges[0]) + { + //add new edge; + Point_2 p1 = intersection_point(curr_vision_ray, closest_edge); + Point_2 p2 = intersection_point(curr_vision_ray, active_edges[0]); + update_visibility(p1, polygon, out_arr); + update_visibility(p2, polygon, out_arr); + + } + + closest_edge = active_edges[0]; + remove_edges(active_edges, curr_vision_ray); + + if (active_edges.empty()) { + //add an unbounded edge +//todo CGAL::insert_curve(out_arr, Ray_2((*begin_it)->point(), Direction_2(curr_vision_ray))); + } + else { + if (closest_edge != active_edges[0]) { + //add new edge; + Point_2 p1 = intersection_point(curr_vision_ray, closest_edge); + Point_2 p2 = intersection_point(curr_vision_ray, active_edges[0]); + update_visibility(p1, polygon, out_arr); + update_visibility(p2, polygon, out_arr); + } + } + } + vit = end_it; + } + if (!is_init_empty) { + CGAL::insert_curve(out_arr, Segment_2(polygon[0], polygon.back())); + } + } + + void visibility_region_impl(const Point_2 &query, Face_const_handle fh, Arrangement_2 &out_arr, CGAL::Tag_false) { + std::vector vertices; //all vertices of the face. + std::vector edges, active_edges; //edges stores all halfedges of the face; and active_edges stores all halfedges that is currently intersected by the view ray. + //preprocess the face + input_face(fh, vertices, edges, query); + print(vertices); + //initiation of vision ray + Vector_2 dir; + if (Direction_2(-1, 0) < Direction_2(Vector_2(query, (*vertices.rbegin())->point()))) + { + dir = Vector_2(1, 0) + Vector_2(query, (*vertices.rbegin())->point()); + } + else { + dir = Vector_2(0, -1); + } + Ray_2 init_vision_ray(query, dir); + + //initiation of active_edges + typename std::vector::iterator iter1; + for (iter1 = edges.begin(); iter1 != edges.end(); iter1++) + { + insert_halfedge(active_edges, init_vision_ray, *iter1); + } + + //angular sweep + std::vector polygon; + Ray_2 curr_vision_ray = init_vision_ray; + typename std::vector::iterator vit = vertices.begin(), begin_it, end_it; + Halfedge_const_handle closest_edge; + bool is_init_empty = active_edges.empty(); + while (vit != vertices.end()) + { + if (active_edges.empty()) + { + begin_it = vit; + end_it = vit; + curr_vision_ray= Ray_2(query, (*begin_it)->point()); + Direction_2 d1(curr_vision_ray), d2; + do { + d2 = Direction_2(Ray_2(query, (*end_it)->point())); + if (d1 != d2) break; + } while (++end_it != vertices.end()); + add_edges(begin_it, end_it, active_edges, curr_vision_ray); + + //since active_edges is empty, that means adding new edges will bring in an unbounded edge to arrangement. + Point_2 p1 = intersection_point(curr_vision_ray, active_edges[0]); + polygon.push_back(p1); +//todo CGAL::insert_curve(out_arr, Ray_2(p1, d1)); + + closest_edge = active_edges[0]; + remove_edges(active_edges, curr_vision_ray); + + if (active_edges.empty()) { + //this means there is no edge that intersects curr_vision_ray + //except those collinear ones. + //because one unbounded ray has been inserted before, + //we don't need to do anything here. + } + else { + //add new edge; + //Point_2 p1 = intersection_point(curr_vision_ray, closest_edge); + Point_2 p2 = intersection_point(curr_vision_ray, active_edges[0]); + //update_visibility(p1, polygon, out_arr); + update_visibility(p2, polygon, out_arr); + + } + } + else { + Point_2 right_p, left_p, mid_p, furthest_p; + begin_it = vit; + end_it = vit; //all vertices between begin_it and end_it(not included) are collinear with query point. + curr_vision_ray= Ray_2(query, (*begin_it)->point()); + right_p = intersection_point(curr_vision_ray, active_edges[0]); + Direction_2 d1(curr_vision_ray), d2; + do { + d2 = Direction_2(Ray_2(query, (*end_it)->point())); + if (d1 != d2) break; + } while (++end_it != vertices.end()); + add_edges(begin_it, end_it, active_edges, curr_vision_ray); + + mid_p = intersection_point(curr_vision_ray, active_edges[0]); + + Intersection_type i_type = needle(active_edges, curr_vision_ray, furthest_p); + switch (i_type) { + case UNBOUNDED : + //remove right and collinear; + remove_edges(active_edges, curr_vision_ray); + update_visibility(right_p, polygon, out_arr); + update_visibility(mid_p, polygon, out_arr); + //todo CGAL::insert_curve(); + if (!active_edges.empty()) { + left_p = intersection_point(curr_vision_ray, active_edges[0]); + update_visibility(left_p, polygon, out_arr); + } + break; + case CORNER : + //remove right and collinear; + remove_edges(active_edges, curr_vision_ray); + left_p = intersection_point(curr_vision_ray, active_edges[0]); + update_visibility(right_p, polygon, out_arr); + update_visibility(furthest_p, polygon, out_arr); + update_visibility(mid_p, polygon, out_arr); + update_visibility(left_p, polygon, out_arr); + break; + case INNER : + //remove right and collinear; + remove_edges(active_edges, curr_vision_ray); + if (mid_p == furthest_p) { + //this means mid_p = left_p = right_p = furthest_p. no new vertex is found. + } + else { + left_p = intersection_point(curr_vision_ray, active_edges[0]); + update_visibility(right_p, polygon, out_arr); + update_visibility(mid_p, polygon, out_arr); + update_visibility(left_p, polygon, out_arr); + } + break; + } + } + vit = end_it; + } + if (!is_init_empty) { + CGAL::insert_curve(out_arr, Segment_2(polygon.front(), polygon.back())); + } + } + + + bool is_attached() { + return attach_tag; + } + + void attach(Arrangement_2 arr) { + this->arr = arr; + this->attach_tag = true; + } + + void detach() { + attach_tag = false; + } + + +private: + + bool attach_tag; + + // return the intersection of a ray and a segment. if the intersection is a segment, return the end closer to the source of ray. + // if there is no intersection, return the source of ray. + Point_2 intersection_point(Ray_2 ray, Segment_2 seg ) + { + + CGAL::Object result = CGAL::intersection(ray, seg); + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + return *ipoint; + } else + //if result is a segment, return the end closer to the source of ray. + if (const Segment_2 *iseg = CGAL::object_cast(&result)) { + switch (CGAL::compare_distance_to_point(ray.source(), iseg->source(), iseg->target())) { + case (CGAL::SMALLER): + return iseg->source(); + break; + case (CGAL::LARGER) : + return iseg->target(); + break; + } + + } else { + // if no intersection, return the source of ray. + return ray.source(); + } + } + + Point_2 intersection_point(Ray_2 ray, Halfedge_const_handle seg) { + return intersection_point(ray, halfedge2seg(seg)); + } + + //convertor for halfedge to segment + Segment_2 halfedge2seg(Halfedge_const_handle e){ + return Segment_2(e->source()->point(), e->target()->point()); + } + + + //insert newly-discovered edges into active_edges according to its intersection with the view ray. + void insert_halfedge(std::vector &active_edges, const Ray_2 &ray, Halfedge_const_handle edge) + { + Point_2 cross_of_e = intersection_point(ray, halfedge2seg(edge)); + if (cross_of_e != ray.source()) + { + typename std::vector::iterator first = active_edges.begin(); + while (first != active_edges.end()) + { + + Point_2 cross_of_first = intersection_point(ray, halfedge2seg(*first)); + if (CGAL::compare_distance_to_point(ray.source(), cross_of_e, cross_of_first) == CGAL::SMALLER) { + break; + } + if (CGAL::compare_distance_to_point(ray.source(), cross_of_e, cross_of_first) == CGAL::EQUAL && CGAL::right_turn((*first)->source()->point(), cross_of_e, edge->source()->point()) ) { + break; + } + ++first; + } + active_edges.insert(first, edge); + } + } + + + + + //check whether any edges incident to the vertice, vh, are on the right side of view ray. if yes, then it blocks the view ray. + bool Is_block(Vertex_const_handle vh, const Ray_2& ray) + { + typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; + first = curr = vh->incident_halfedges(); + do { + Vertex_const_handle u = curr->source(); + if (CGAL::right_turn(ray.source(), vh->point(), u->point())) { + return true; + } + } while (++curr != first); + return false; + } + + //insert vh into vertices by the angle between ray and positive x-ray. + //if the angles are the same, compare their distances to p. + void sort_vertex(std::vector& vertices, Vertex_const_handle vh, const Point_2& p) + { + typename std::vector::iterator first = vertices.begin(); + Vector_2 vector_of_v(p, vh->point()); + Direction_2 dir_of_v(vector_of_v); + while (first != vertices.end()) + { + if (vh->point() == (*first)->point()) { + return; + } + Vector_2 vector1(p, (*first)->point()); + Direction_2 d1(vector1); + if (dir_of_v < d1) + break; + //if same angles are the same, put the vertex which is closer to query point before. + if (dir_of_v == d1 && CGAL::compare_distance_to_point(p, vh->point(), (*first)->point()) == CGAL::SMALLER) + break; + ++first; + } + vertices.insert(first, vh); + } + + + //sort vertex vh by the angle between vector and positive x-ray. + //if the angles are the same, place them in a 'circular' way. + //we do this because the output is not regularized, i.e. 1-d needle is reserved in output. +// void sort_vertex(vector& vertices, Vertex_const_handle vh, const Point_2& p, CGAL::Tag_false) +// { +// Ray_2 ray(p, vh->point()); +// typename vector::iterator first = vertices.begin(); +// while (first != vertices.end()) +// { +// Ray_2 r(p, (*first)->point()); +// Direction_2 d1(r); +// if (ray.direction() < d1) +// break; +// //if angles are the same, then using Isblock() to decide the order of vertices on the view ray. +// if (ray.direction() == d1) +// { +// if (Is_block(vh, ray) && (!Is_block(*first, ray))) +// break; +// if (Is_block(vh, ray) && Is_block(*first, ray) && CGAL::compare_distance_to_point(p, vh->point(), (*first)->point()) == CGAL::SMALLER) +// break; +// if (!Is_block(vh, ray) && !Is_block(*first, ray) && CGAL::compare_distance_to_point(p, vh->point(), (*first)->point()) == CGAL::LARGER) +// break; +// } +// ++first; +// } +// vertices.insert(first, vh); +// } + + //traverse the face to get all edges and sort vertices in counter-clockwise order. + void input_face (Face_const_handle fh, + std::vector& vertices, + std::vector& edges, + const Point_2& p) + { + typename Arrangement_2::Ccb_halfedge_const_circulator curr = fh->outer_ccb(); + typename Arrangement_2::Ccb_halfedge_const_circulator circ = curr; + do { + sort_vertex(vertices, curr->source(), p); + edges.push_back(curr); + } while (++curr != circ); + typename Arrangement_2::Hole_const_iterator hi; + for (hi = fh->holes_begin(); hi != fh->holes_end(); ++hi) { + typename Arrangement_2::Ccb_halfedge_const_circulator c1 = *hi, c2 = *hi; + do { + sort_vertex(vertices, c1->source(), p); + edges.push_back(c1); + } while (++c1 != c2); + } + } + + + + + //insert new vertice to polygon. before insertion, check if this vertice has been added before. + void update_visibility(const Point_2 p, std::vector &polygon, Arrangement_2& arr){ + if (polygon.empty()) + polygon.push_back(p); + else + { + if (polygon.back() != p){ + CGAL::insert_curve(arr, Segment_2(polygon.back(), p)); + polygon.push_back(p); + } + } + } + + //add a new edge when vision ray passes a vertex + void add_edge(Vertex_const_handle vh, + std::vector& edges, + const Ray_2& r) { + typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; + first = curr = vh->incident_halfedges(); + do { + if (!CGAL::right_turn(r.source(), vh->point(), curr->source()->point())) + { + insert_halfedge(edges, r, curr); + } + } while (++curr != first); + + } + //add new edges + void add_edges(typename std::vector::iterator begin_it, + typename std::vector::iterator end_it, + std::vector& edges, + const Ray_2& r) + { + do { + add_edge(*begin_it, edges, r); + } while (++begin_it != end_it); + + //debug + std::cout<<"after adding"<& edges, const Ray_2& r) { + typename std::vector::iterator eit = edges.begin(); + while (eit != edges.end()) { + Point_2 p1 = (*eit)->target()->point(); + Point_2 p2 = (*eit)->source()->point(); + bool is_incident(false); + if (is_on_ray(r, p1)) { + is_incident = true; + } + else if (is_on_ray(r, p2)) { + Point_2 tmp = p1; + p1 = p2; + p2 = p1; + is_incident = true; + } + + + if ( is_incident && !CGAL::left_turn(r.source(), p1, p2)) + { + eit = edges.erase(eit); + } + else { + eit++; + } + } + //debug + std::cout<<"after remove"<& edges, Ray_2& r, Point_2& furthest_p) { + typename std::vector::iterator eit = edges.begin(); + Point_2 p = r.source(), target_p, source_p; + do { + target_p = (*eit)->target()->point(); + source_p = (*eit)->source()->point(); + if (target_p != p) { + p = target_p; + Point_2 intersection = intersection_point(r, *eit); + if (intersection != target_p && intersection != source_p) { + furthest_p = intersection; + return INNER; + } + bool has_right(false), has_left(false); + Vertex_const_handle vertex = (*eit)->target(); + typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; + first = curr = vertex->incident_halfedges(); + do { + switch (CGAL::orientation(r.source(), curr->target()->point(), curr->source()->point())) { + case CGAL::RIGHT_TURN: + has_right = true; + break; + case CGAL::LEFT_TURN: + has_left = true; + break; + } + } while (++curr != first); + if (has_right && has_left) { + furthest_p = intersection; + return CORNER; + } + } + } while (++eit != edges.end()); + return UNBOUNDED; + } + + void print_active(std::vector& edges){ + for (int i = 0; i != edges.size(); i++) { + Point_2 p1, p2; + p1 = edges[i]->source()->point(); + p2 = edges[i]->target()->point(); + std::cout<"< &active_edges, const Point_2 &query, Vertex_const_handle vh, std::vector &polygon ) + { + //closest_edge_copy is a copy of the closest edge to query point in active_edges before sweeping. + Halfedge_const_handle closest_edge_copy = active_edges[0]; + Ray_2 ray(query, vh->point()); + int add_count(0); + int del_count(0); + + //delete all edges in active_edges which is incident to v, because they has been sweeped over + typename std::vector::iterator edge_iter = active_edges.begin(); + while (edge_iter != active_edges.end()) { + if (((*edge_iter)->source()->point() == vh->point()) || ((*edge_iter)->target()->point() == vh->point())) + { + edge_iter = active_edges.erase(edge_iter); + ++del_count; + } + else { + ++edge_iter; + } + } + + //add all edges which is incident to v but not in active_edges before to active_edges + typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; + first = curr = vh->incident_halfedges(); + do { + if (CGAL::left_turn(query, vh->point(), curr->source()->point())) + { + insert_halfedge(active_edges, ray, curr); + ++add_count; + } + else if (CGAL::collinear(query, vh->point(), curr->source()->point()) && + CGAL::compare_distance_to_point(query, vh->point(), curr->source()->point()) == CGAL::SMALLER) + { + insert_halfedge(active_edges, ray, curr); + ++add_count; + } + } while (++curr != first); + + //update the visibility region + if (closest_edge_copy != active_edges[0]) { + //when the closest edge changed + if (del_count > 0 && add_count > 0) { + //some edges are added and some are deleted, which means the vertice sweeped is a vertice of visibility polygon. + update_visibility(vh->point(), polygon); + } + if (del_count == 0 && add_count > 0) { + //only add some edges, means the view ray is blocked by new edges. + //therefore first add the intersection of view ray and former closet edge, then add the vertice sweeped. + update_visibility(intersection_point(ray, halfedge2seg(closest_edge_copy)), polygon); + update_visibility(vh->point(), polygon); + } + if (del_count > 0 && add_count == 0) { + //only delete some edges, means some block is moved and the view ray can reach the segments after the block. + update_visibility(vh->point(), polygon); + update_visibility(intersection_point(ray, halfedge2seg(active_edges[0])), polygon); + } + } + + } + +}; + +//debug. Print all edges of arrangements into console. +template +void print_arrangement(const Arrangement_2 &arr) { + typedef typename Arrangement_2::Edge_const_iterator Edge_const_iterator; + Edge_const_iterator eit; + std::cout << arr.number_of_edges() << " edges:" << std::endl; + for (eit = arr.edges_begin(); eit != arr.edges_end(); ++eit) + std::cout << "[" << eit->curve() << "]" << std::endl; +} + +} // namespace Visibility_2 +} // namespace CGAL + +#endif + + From 0c7083069521b7f0c070f5c969aeb3fd40ea59be Mon Sep 17 00:00:00 2001 From: kanhuang Date: Sun, 7 Jul 2013 23:23:50 -0400 Subject: [PATCH 24/66] need polish. the needle function is not right --- .../include/CGAL/Naive_visibility_2.h | 674 ++++++++++++++++++ 1 file changed, 674 insertions(+) create mode 100644 Visibility_2/include/CGAL/Naive_visibility_2.h diff --git a/Visibility_2/include/CGAL/Naive_visibility_2.h b/Visibility_2/include/CGAL/Naive_visibility_2.h new file mode 100644 index 00000000000..e004bcaf7fc --- /dev/null +++ b/Visibility_2/include/CGAL/Naive_visibility_2.h @@ -0,0 +1,674 @@ +//kan's version +#ifndef CGAL_NAIVE_VISIBILITY_2_H +#define CGAL_NAIVE_VISIBILITY_2_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace CGAL { + +namespace Visibility_2 { + +//debug +template +void print(std::vector ps){ + for (int i=0; ipoint().x()<<","<point().y()< +class Naive_visibility_2 { + typedef typename Arrangement_2::Traits_2 Traits_2; + typedef typename Traits_2::Kernel Kernel; + typedef typename Traits_2::Point_2 Point_2; + typedef typename CGAL::Segment_2 Segment_2; + + typedef typename Arrangement_2::Halfedge Halfedge; + typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle; + typedef typename Arrangement_2::Vertex_const_handle Vertex_const_handle; + typedef typename Arrangement_2::Face_const_handle Face_const_handle; + + typedef typename CGAL::Vector_2 Vector_2; + typedef typename CGAL::Direction_2 Direction_2; + typedef typename CGAL::Ray_2 Ray_2; + + enum Intersection_type { UNBOUNDED, CORNER, INNER }; + +public: + //members + Arrangement_2 arr; + + //functions + Naive_visibility_2(const Arrangement_2 &arr):arr(arr), attach_tag(true) {} + + Naive_visibility_2(): attach_tag(false) {} + + + void visibility_region(const Point_2 &q, const Halfedge &edge, Arrangement_2 &out_arr) { + + } + + void visibility_region(const Point_2 &query, Face_const_handle fh, Arrangement_2 &out_arr) { + visibility_region_impl(query, fh, out_arr, Regularization_tag()); + + } + + void visibility_region_impl(const Point_2 &query, Face_const_handle fh, Arrangement_2 &out_arr, CGAL::Tag_true) { + std::vector vertices; //all vertices of the face. + std::vector edges, active_edges; //edges stores all halfedges of the face; and active_edges stores all halfedges that is currently intersected by the view ray. + //preprocess the face + input_face(fh, vertices, edges, query); + //initiation of vision ray + Vector_2 dir; + if (Direction_2(-1, 0) < Direction_2(Vector_2(query, (*vertices.rbegin())->point()))) + { + dir = Vector_2(1, 0) + Vector_2(query, (*vertices.rbegin())->point()); + } + else { + dir = Vector_2(0, -1); + } + Ray_2 init_vision_ray(query, dir); + + //initiation of active_edges + typename std::vector::iterator iter1; + for (iter1 = edges.begin(); iter1 != edges.end(); iter1++) + { + insert_halfedge(active_edges, init_vision_ray, *iter1); + } + + //angular sweep + std::vector polygon; + Ray_2 curr_vision_ray = init_vision_ray; + typename std::vector::iterator vit = vertices.begin(), begin_it, end_it; + Halfedge_const_handle closest_edge; + bool is_init_empty = active_edges.empty(); + while (vit != vertices.end()) + { + if (active_edges.empty()) + { + begin_it = vit; + end_it = vit; + curr_vision_ray= Ray_2(query, (*begin_it)->point()); + Direction_2 d1(curr_vision_ray), d2; + do { + d2 = Direction_2(Ray_2(query, (*end_it)->point())); + if (d1 != d2) break; + } while (++end_it != vertices.end()); + add_edges(begin_it, end_it, active_edges, curr_vision_ray); + + //since active_edges is empty, that means adding new edges will bring in an unbounded edge to arrangement. + closest_edge = active_edges[0]; + remove_edges(active_edges, curr_vision_ray); + + if (active_edges.empty()) { + //this means in input, there is no edge that intersects curr_vision_ray + //except those collinear ones. + //because one unbounded ray has been inserted before, + //we don't need to do anything here. + } + else { + //add new edge; + Point_2 p1 = intersection_point(curr_vision_ray, closest_edge); + Point_2 p2 = intersection_point(curr_vision_ray, active_edges[0]); + update_visibility(p1, polygon, out_arr); + update_visibility(p2, polygon, out_arr); + + } + } + else { + closest_edge = active_edges[0]; + begin_it = vit; //all vertices between begin_it and end_it(not included) are collinear with query point. + end_it = vit; + curr_vision_ray = Ray_2(query, (*begin_it)->point()); + Direction_2 d1(curr_vision_ray), d2; + do { + d2 = Direction_2(Ray_2(query, (*end_it)->point())); + if (d1 != d2) break; + } while (++end_it != vertices.end()); + add_edges(begin_it, end_it, active_edges, curr_vision_ray); + + if (closest_edge != active_edges[0]) + { + //add new edge; + Point_2 p1 = intersection_point(curr_vision_ray, closest_edge); + Point_2 p2 = intersection_point(curr_vision_ray, active_edges[0]); + update_visibility(p1, polygon, out_arr); + update_visibility(p2, polygon, out_arr); + + } + + closest_edge = active_edges[0]; + remove_edges(active_edges, curr_vision_ray); + + if (active_edges.empty()) { + //add an unbounded edge +//todo CGAL::insert_curve(out_arr, Ray_2((*begin_it)->point(), Direction_2(curr_vision_ray))); + } + else { + if (closest_edge != active_edges[0]) { + //add new edge; + Point_2 p1 = intersection_point(curr_vision_ray, closest_edge); + Point_2 p2 = intersection_point(curr_vision_ray, active_edges[0]); + update_visibility(p1, polygon, out_arr); + update_visibility(p2, polygon, out_arr); + } + } + } + vit = end_it; + } + if (!is_init_empty) { + CGAL::insert_curve(out_arr, Segment_2(polygon[0], polygon.back())); + } + } + + void visibility_region_impl(const Point_2 &query, Face_const_handle fh, Arrangement_2 &out_arr, CGAL::Tag_false) { + std::vector vertices; //all vertices of the face. + std::vector edges, active_edges; //edges stores all halfedges of the face; and active_edges stores all halfedges that is currently intersected by the view ray. + //preprocess the face + input_face(fh, vertices, edges, query); + print(vertices); + //initiation of vision ray + Vector_2 dir; + if (Direction_2(-1, 0) < Direction_2(Vector_2(query, (*vertices.rbegin())->point()))) + { + dir = Vector_2(1, 0) + Vector_2(query, (*vertices.rbegin())->point()); + } + else { + dir = Vector_2(0, -1); + } + Ray_2 init_vision_ray(query, dir); + + //initiation of active_edges + typename std::vector::iterator iter1; + for (iter1 = edges.begin(); iter1 != edges.end(); iter1++) + { + insert_halfedge(active_edges, init_vision_ray, *iter1); + } + + //angular sweep + std::vector polygon; + Ray_2 curr_vision_ray = init_vision_ray; + typename std::vector::iterator vit = vertices.begin(), begin_it, end_it; + Halfedge_const_handle closest_edge; + bool is_init_empty = active_edges.empty(); + while (vit != vertices.end()) + { + if (active_edges.empty()) + { + begin_it = vit; + end_it = vit; + curr_vision_ray= Ray_2(query, (*begin_it)->point()); + Direction_2 d1(curr_vision_ray), d2; + do { + d2 = Direction_2(Ray_2(query, (*end_it)->point())); + if (d1 != d2) break; + } while (++end_it != vertices.end()); + add_edges(begin_it, end_it, active_edges, curr_vision_ray); + + //since active_edges is empty, that means adding new edges will bring in an unbounded edge to arrangement. + Point_2 p1 = intersection_point(curr_vision_ray, active_edges[0]); + polygon.push_back(p1); +//todo CGAL::insert_curve(out_arr, Ray_2(p1, d1)); + + closest_edge = active_edges[0]; + remove_edges(active_edges, curr_vision_ray); + + if (active_edges.empty()) { + //this means there is no edge that intersects curr_vision_ray + //except those collinear ones. + //because one unbounded ray has been inserted before, + //we don't need to do anything here. + } + else { + //add new edge; + //Point_2 p1 = intersection_point(curr_vision_ray, closest_edge); + Point_2 p2 = intersection_point(curr_vision_ray, active_edges[0]); + //update_visibility(p1, polygon, out_arr); + update_visibility(p2, polygon, out_arr); + + } + } + else { + Point_2 right_p, left_p, mid_p, furthest_p; + begin_it = vit; + end_it = vit; //all vertices between begin_it and end_it(not included) are collinear with query point. + curr_vision_ray= Ray_2(query, (*begin_it)->point()); + right_p = intersection_point(curr_vision_ray, active_edges[0]); + Direction_2 d1(curr_vision_ray), d2; + do { + d2 = Direction_2(Ray_2(query, (*end_it)->point())); + if (d1 != d2) break; + } while (++end_it != vertices.end()); + add_edges(begin_it, end_it, active_edges, curr_vision_ray); + + mid_p = intersection_point(curr_vision_ray, active_edges[0]); + + Intersection_type i_type = needle(active_edges, curr_vision_ray, furthest_p); + switch (i_type) { + case UNBOUNDED : + //remove right and collinear; + remove_edges(active_edges, curr_vision_ray); + update_visibility(right_p, polygon, out_arr); + update_visibility(mid_p, polygon, out_arr); + //todo CGAL::insert_curve(); + if (!active_edges.empty()) { + left_p = intersection_point(curr_vision_ray, active_edges[0]); + update_visibility(left_p, polygon, out_arr); + } + break; + case CORNER : + //remove right and collinear; + remove_edges(active_edges, curr_vision_ray); + left_p = intersection_point(curr_vision_ray, active_edges[0]); + update_visibility(right_p, polygon, out_arr); + update_visibility(furthest_p, polygon, out_arr); + update_visibility(mid_p, polygon, out_arr); + update_visibility(left_p, polygon, out_arr); + break; + case INNER : + //remove right and collinear; + remove_edges(active_edges, curr_vision_ray); + if (mid_p == furthest_p) { + //this means mid_p = left_p = right_p = furthest_p. no new vertex is found. + } + else { + left_p = intersection_point(curr_vision_ray, active_edges[0]); + update_visibility(right_p, polygon, out_arr); + update_visibility(mid_p, polygon, out_arr); + update_visibility(left_p, polygon, out_arr); + } + break; + } + } + vit = end_it; + } + if (!is_init_empty) { + CGAL::insert_curve(out_arr, Segment_2(polygon.front(), polygon.back())); + } + } + + + bool is_attached() { + return attach_tag; + } + + void attach(Arrangement_2 arr) { + this->arr = arr; + this->attach_tag = true; + } + + void detach() { + attach_tag = false; + } + + +private: + + bool attach_tag; + + // return the intersection of a ray and a segment. if the intersection is a segment, return the end closer to the source of ray. + // if there is no intersection, return the source of ray. + Point_2 intersection_point(Ray_2 ray, Segment_2 seg ) + { + + CGAL::Object result = CGAL::intersection(ray, seg); + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + return *ipoint; + } else + //if result is a segment, return the end closer to the source of ray. + if (const Segment_2 *iseg = CGAL::object_cast(&result)) { + switch (CGAL::compare_distance_to_point(ray.source(), iseg->source(), iseg->target())) { + case (CGAL::SMALLER): + return iseg->source(); + break; + case (CGAL::LARGER) : + return iseg->target(); + break; + } + + } else { + // if no intersection, return the source of ray. + return ray.source(); + } + } + + Point_2 intersection_point(Ray_2 ray, Halfedge_const_handle seg) { + return intersection_point(ray, halfedge2seg(seg)); + } + + //convertor for halfedge to segment + Segment_2 halfedge2seg(Halfedge_const_handle e){ + return Segment_2(e->source()->point(), e->target()->point()); + } + + + //insert newly-discovered edges into active_edges according to its intersection with the view ray. + void insert_halfedge(std::vector &active_edges, const Ray_2 &ray, Halfedge_const_handle edge) + { + Point_2 cross_of_e = intersection_point(ray, halfedge2seg(edge)); + if (cross_of_e != ray.source()) + { + typename std::vector::iterator first = active_edges.begin(); + while (first != active_edges.end()) + { + + Point_2 cross_of_first = intersection_point(ray, halfedge2seg(*first)); + if (CGAL::compare_distance_to_point(ray.source(), cross_of_e, cross_of_first) == CGAL::SMALLER) { + break; + } + if (CGAL::compare_distance_to_point(ray.source(), cross_of_e, cross_of_first) == CGAL::EQUAL && CGAL::right_turn((*first)->source()->point(), cross_of_e, edge->source()->point()) ) { + break; + } + ++first; + } + active_edges.insert(first, edge); + } + } + + + + + //check whether any edges incident to the vertice, vh, are on the right side of view ray. if yes, then it blocks the view ray. + bool Is_block(Vertex_const_handle vh, const Ray_2& ray) + { + typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; + first = curr = vh->incident_halfedges(); + do { + Vertex_const_handle u = curr->source(); + if (CGAL::right_turn(ray.source(), vh->point(), u->point())) { + return true; + } + } while (++curr != first); + return false; + } + + //insert vh into vertices by the angle between ray and positive x-ray. + //if the angles are the same, compare their distances to p. + void sort_vertex(std::vector& vertices, Vertex_const_handle vh, const Point_2& p) + { + typename std::vector::iterator first = vertices.begin(); + Vector_2 vector_of_v(p, vh->point()); + Direction_2 dir_of_v(vector_of_v); + while (first != vertices.end()) + { + if (vh->point() == (*first)->point()) { + return; + } + Vector_2 vector1(p, (*first)->point()); + Direction_2 d1(vector1); + if (dir_of_v < d1) + break; + //if same angles are the same, put the vertex which is closer to query point before. + if (dir_of_v == d1 && CGAL::compare_distance_to_point(p, vh->point(), (*first)->point()) == CGAL::SMALLER) + break; + ++first; + } + vertices.insert(first, vh); + } + + + //sort vertex vh by the angle between vector and positive x-ray. + //if the angles are the same, place them in a 'circular' way. + //we do this because the output is not regularized, i.e. 1-d needle is reserved in output. +// void sort_vertex(vector& vertices, Vertex_const_handle vh, const Point_2& p, CGAL::Tag_false) +// { +// Ray_2 ray(p, vh->point()); +// typename vector::iterator first = vertices.begin(); +// while (first != vertices.end()) +// { +// Ray_2 r(p, (*first)->point()); +// Direction_2 d1(r); +// if (ray.direction() < d1) +// break; +// //if angles are the same, then using Isblock() to decide the order of vertices on the view ray. +// if (ray.direction() == d1) +// { +// if (Is_block(vh, ray) && (!Is_block(*first, ray))) +// break; +// if (Is_block(vh, ray) && Is_block(*first, ray) && CGAL::compare_distance_to_point(p, vh->point(), (*first)->point()) == CGAL::SMALLER) +// break; +// if (!Is_block(vh, ray) && !Is_block(*first, ray) && CGAL::compare_distance_to_point(p, vh->point(), (*first)->point()) == CGAL::LARGER) +// break; +// } +// ++first; +// } +// vertices.insert(first, vh); +// } + + //traverse the face to get all edges and sort vertices in counter-clockwise order. + void input_face (Face_const_handle fh, + std::vector& vertices, + std::vector& edges, + const Point_2& p) + { + typename Arrangement_2::Ccb_halfedge_const_circulator curr = fh->outer_ccb(); + typename Arrangement_2::Ccb_halfedge_const_circulator circ = curr; + do { + sort_vertex(vertices, curr->source(), p); + edges.push_back(curr); + } while (++curr != circ); + typename Arrangement_2::Hole_const_iterator hi; + for (hi = fh->holes_begin(); hi != fh->holes_end(); ++hi) { + typename Arrangement_2::Ccb_halfedge_const_circulator c1 = *hi, c2 = *hi; + do { + sort_vertex(vertices, c1->source(), p); + edges.push_back(c1); + } while (++c1 != c2); + } + } + + + + + //insert new vertice to polygon. before insertion, check if this vertice has been added before. + void update_visibility(const Point_2 p, std::vector &polygon, Arrangement_2& arr){ + if (polygon.empty()) + polygon.push_back(p); + else + { + if (polygon.back() != p){ + CGAL::insert_curve(arr, Segment_2(polygon.back(), p)); + polygon.push_back(p); + } + } + } + + //add a new edge when vision ray passes a vertex + void add_edge(Vertex_const_handle vh, + std::vector& edges, + const Ray_2& r) { + typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; + first = curr = vh->incident_halfedges(); + do { + if (!CGAL::right_turn(r.source(), vh->point(), curr->source()->point())) + { + insert_halfedge(edges, r, curr); + } + } while (++curr != first); + + } + //add new edges + void add_edges(typename std::vector::iterator begin_it, + typename std::vector::iterator end_it, + std::vector& edges, + const Ray_2& r) + { + do { + add_edge(*begin_it, edges, r); + } while (++begin_it != end_it); + + //debug + std::cout<<"after adding"<& edges, const Ray_2& r) { + typename std::vector::iterator eit = edges.begin(); + while (eit != edges.end()) { + Point_2 p1 = (*eit)->target()->point(); + Point_2 p2 = (*eit)->source()->point(); + bool is_incident(false); + if (is_on_ray(r, p1)) { + is_incident = true; + } + else if (is_on_ray(r, p2)) { + Point_2 tmp = p1; + p1 = p2; + p2 = p1; + is_incident = true; + } + + + if ( is_incident && !CGAL::left_turn(r.source(), p1, p2)) + { + eit = edges.erase(eit); + } + else { + eit++; + } + } + //debug + std::cout<<"after remove"<& edges, Ray_2& r, Point_2& furthest_p) { + typename std::vector::iterator eit = edges.begin(); + Point_2 p = r.source(), target_p, source_p; + do { + target_p = (*eit)->target()->point(); + source_p = (*eit)->source()->point(); + if (target_p != p) { + p = target_p; + Point_2 intersection = intersection_point(r, *eit); + if (intersection != target_p && intersection != source_p) { + furthest_p = intersection; + return INNER; + } + bool has_right(false), has_left(false); + Vertex_const_handle vertex = (*eit)->target(); + typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; + first = curr = vertex->incident_halfedges(); + do { + switch (CGAL::orientation(r.source(), curr->target()->point(), curr->source()->point())) { + case CGAL::RIGHT_TURN: + has_right = true; + break; + case CGAL::LEFT_TURN: + has_left = true; + break; + } + } while (++curr != first); + if (has_right && has_left) { + furthest_p = intersection; + return CORNER; + } + } + } while (++eit != edges.end()); + return UNBOUNDED; + } + + void print_active(std::vector& edges){ + for (int i = 0; i != edges.size(); i++) { + Point_2 p1, p2; + p1 = edges[i]->source()->point(); + p2 = edges[i]->target()->point(); + std::cout<"< &active_edges, const Point_2 &query, Vertex_const_handle vh, std::vector &polygon ) + { + //closest_edge_copy is a copy of the closest edge to query point in active_edges before sweeping. + Halfedge_const_handle closest_edge_copy = active_edges[0]; + Ray_2 ray(query, vh->point()); + int add_count(0); + int del_count(0); + + //delete all edges in active_edges which is incident to v, because they has been sweeped over + typename std::vector::iterator edge_iter = active_edges.begin(); + while (edge_iter != active_edges.end()) { + if (((*edge_iter)->source()->point() == vh->point()) || ((*edge_iter)->target()->point() == vh->point())) + { + edge_iter = active_edges.erase(edge_iter); + ++del_count; + } + else { + ++edge_iter; + } + } + + //add all edges which is incident to v but not in active_edges before to active_edges + typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; + first = curr = vh->incident_halfedges(); + do { + if (CGAL::left_turn(query, vh->point(), curr->source()->point())) + { + insert_halfedge(active_edges, ray, curr); + ++add_count; + } + else if (CGAL::collinear(query, vh->point(), curr->source()->point()) && + CGAL::compare_distance_to_point(query, vh->point(), curr->source()->point()) == CGAL::SMALLER) + { + insert_halfedge(active_edges, ray, curr); + ++add_count; + } + } while (++curr != first); + + //update the visibility region + if (closest_edge_copy != active_edges[0]) { + //when the closest edge changed + if (del_count > 0 && add_count > 0) { + //some edges are added and some are deleted, which means the vertice sweeped is a vertice of visibility polygon. + update_visibility(vh->point(), polygon); + } + if (del_count == 0 && add_count > 0) { + //only add some edges, means the view ray is blocked by new edges. + //therefore first add the intersection of view ray and former closet edge, then add the vertice sweeped. + update_visibility(intersection_point(ray, halfedge2seg(closest_edge_copy)), polygon); + update_visibility(vh->point(), polygon); + } + if (del_count > 0 && add_count == 0) { + //only delete some edges, means some block is moved and the view ray can reach the segments after the block. + update_visibility(vh->point(), polygon); + update_visibility(intersection_point(ray, halfedge2seg(active_edges[0])), polygon); + } + } + + } + +}; + +//debug. Print all edges of arrangements into console. +template +void print_arrangement(const Arrangement_2 &arr) { + typedef typename Arrangement_2::Edge_const_iterator Edge_const_iterator; + Edge_const_iterator eit; + std::cout << arr.number_of_edges() << " edges:" << std::endl; + for (eit = arr.edges_begin(); eit != arr.edges_end(); ++eit) + std::cout << "[" << eit->curve() << "]" << std::endl; +} + +} // namespace Visibility_2 +} // namespace CGAL + +#endif + + From 45593271a045341b50a4064dc76c78b46b5595a4 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Mon, 8 Jul 2013 12:34:18 -0400 Subject: [PATCH 25/66] add package_info directory --- Visibility_2/package_info/README | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 Visibility_2/package_info/README diff --git a/Visibility_2/package_info/README b/Visibility_2/package_info/README new file mode 100644 index 00000000000..e69de29bb2d From fc3733b214090bf089993ce90b1d02259ca28615 Mon Sep 17 00:00:00 2001 From: Francisc Date: Mon, 8 Jul 2013 21:06:54 +0300 Subject: [PATCH 26/66] setup for test suite and script for running all executables --- .../test/include/CGAL/test_model_methods.h | 20 ++++ Visibility_2/test/run_tests.sh | 15 +++ Visibility_2/test/test_simple_visibility.cpp | 109 ++++++++++++++++++ 3 files changed, 144 insertions(+) create mode 100644 Visibility_2/test/include/CGAL/test_model_methods.h create mode 100644 Visibility_2/test/run_tests.sh create mode 100644 Visibility_2/test/test_simple_visibility.cpp diff --git a/Visibility_2/test/include/CGAL/test_model_methods.h b/Visibility_2/test/include/CGAL/test_model_methods.h new file mode 100644 index 00000000000..81c8c251c06 --- /dev/null +++ b/Visibility_2/test/include/CGAL/test_model_methods.h @@ -0,0 +1,20 @@ +/* + * Author: Francisc Bungiu + * E-mail: fbungiu@gmail.com + */ + +#ifndef CGAL_TEST_MODEL_METHODS_H +#define CGAL_TEST_MODEL_METHODS_H + +#include +#include + +namespace CGAL { + +template +bool test_is_attached(_Visibility_2 visibility) { + return true; +} + +} // end CGAL namespace +#endif \ No newline at end of file diff --git a/Visibility_2/test/run_tests.sh b/Visibility_2/test/run_tests.sh new file mode 100644 index 00000000000..dd4d808f211 --- /dev/null +++ b/Visibility_2/test/run_tests.sh @@ -0,0 +1,15 @@ +#!/bin/sh +# Author: Francisc Bungiu +# E-mail: fbungiu@gmail.com + +for file in * +do + if ! [[ -d $file ]] + then + if [[ -x $file ]] + then + echo "Executing '$file'..." + ./$file + fi + fi +done \ No newline at end of file diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp new file mode 100644 index 00000000000..4203b279e86 --- /dev/null +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -0,0 +1,109 @@ +/* + * Author: Francisc Bungiu + * E-mail: fbungiu@gmail.com + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +int main() { + typedef CGAL::Gmpq Number_type; + typedef CGAL::Cartesian Kernel; + typedef CGAL::Arr_segment_traits_2 Traits_2; + typedef Traits_2::Point_2 Point_2; + typedef Traits_2::X_monotone_curve_2 Segment_2; + typedef CGAL::Arrangement_2 Arrangement_2; + + Point_2 p1(0, 0), p2(8, 0), p3(8, 8), p4(0, 8); + + Arrangement_2 arr; + Segment_2 segments[4]; + + segments[0] = Segment_2(p1, p2); + segments[1] = Segment_2(p2, p3); + segments[2] = Segment_2(p3, p4); + segments[3] = Segment_2(p4, p1); + + Point_2 q_point(4, 4); + + CGAL::insert(arr, &segments[0], &segments[4]); + + CGAL::Visibility_2::Simple_visibility_2 visibility(arr); + assert(true == (CGAL::test_is_attached >(visibility))); + return 0; +} +/*#include +#include +#include +#include +#include +#include + +typedef CGAL::Gmpq Number_type; +typedef CGAL::Cartesian Kernel; +typedef CGAL::Arr_segment_traits_2 Traits_2; +typedef Traits_2::Point_2 Point_2; +typedef Traits_2::X_monotone_curve_2 Segment_2; +typedef CGAL::Arrangement_2 Arrangement_2; + +void test1() { + Point_2 p1(0, 0), p2(8, 0), p3(8, 8), p4(0, 8); + + Arrangement_2 arr, out_arr; + Segment_2 segments[4]; + + segments[0] = Segment_2(p1, p2); + segments[1] = Segment_2(p2, p3); + segments[2] = Segment_2(p3, p4); + segments[3] = Segment_2(p4, p1); + + Point_2 q_point(4, 4); + + CGAL::insert(arr, &segments[0], &segments[4]); + + CGAL::Visibility_2::Simple_visibility_2 visibility(arr); + Arrangement_2::Face_const_iterator fit; + + for (fit = arr.faces_begin(); fit != arr.faces_end(); ++fit) { + if (!fit->is_unbounded()) { + visibility.visibility_region(q_point, fit, out_arr); + } + } +} + +void test2() { + + Point_2 p1(0, 0), p2(4, 4), p3(8, 4), p4(0, 8); + + Arrangement_2 arr, out_arr; + Segment_2 segments[4]; + // Insert outer segments + segments[0] = Segment_2(p1, p2); + segments[1] = Segment_2(p2, p3); + segments[2] = Segment_2(p3, p4); + segments[3] = Segment_2(p4, p1); + + Point_2 q_point(2, 3); + + CGAL::insert(arr, &segments[0], &segments[4]); + + CGAL::Visibility_2::Simple_visibility_2 visibility(arr); + Arrangement_2::Face_const_iterator fit; + + for (fit = arr.faces_begin(); fit != arr.faces_end(); ++fit) { + if (!fit->is_unbounded()) { + visibility.visibility_region(q_point, fit, out_arr); + } + } +} + +int main() { + test2(); + return 0; +}*/ \ No newline at end of file From fff5297246930849e934e66e00a80ac31020766d Mon Sep 17 00:00:00 2001 From: kanhuang Date: Tue, 9 Jul 2013 00:16:47 -0400 Subject: [PATCH 27/66] update function insert_halfedge() --- .../include/CGAL/Naive_visibility_2.h | 104 ++- .../CGAL/Visibility_2/Naive_visibility_2.h | 674 ------------------ 2 files changed, 67 insertions(+), 711 deletions(-) delete mode 100644 Visibility_2/include/CGAL/Visibility_2/Naive_visibility_2.h diff --git a/Visibility_2/include/CGAL/Naive_visibility_2.h b/Visibility_2/include/CGAL/Naive_visibility_2.h index e004bcaf7fc..9398f333c12 100644 --- a/Visibility_2/include/CGAL/Naive_visibility_2.h +++ b/Visibility_2/include/CGAL/Naive_visibility_2.h @@ -1,4 +1,3 @@ -//kan's version #ifndef CGAL_NAIVE_VISIBILITY_2_H #define CGAL_NAIVE_VISIBILITY_2_H @@ -12,9 +11,9 @@ #include #include -namespace CGAL { +//namespace CGAL { -namespace Visibility_2 { +//namespace Visibility_2 { //debug template @@ -350,27 +349,56 @@ private: return Segment_2(e->source()->point(), e->target()->point()); } + //check whether two halfedges are the same segment. + bool is_same_edge(Halfedge_const_handle e1, Halfedge_const_handle e2) { + + } + + //given two edges incident to a vision ray at the same point, find which one is first seen in sweeping. + bool is_closer(const Ray_2 &ray, Halfedge_const_handle seg1, Halfedge_const_handle seg2) { + Point_2 shared = intersection_point(ray, seg1); + Point_2 end1, end2; + if (shared == seg1->source()->point()) + end1 = seg1->target()->point(); + else + end1 = seg1->source()->point(); + + if (shared == seg2->source()->point()) + end2 = seg2->target()->point(); + else + end2 = seg2->source()->point(); + if (CGAL::right_turn(ray.source(), shared, end1) && !CGAL::right_turn(ray.source(), shared, end2)) + return true; + if (CGAL::right_turn(ray.source(), shared, end2) && !CGAL::right_turn(ray.source(), shared, end1)) + return false; + switch (CGAL::orientation(ray.source(), shared, end1)) { + case CGAL::COLLINEAR: + return (CGAL::left_turn(ray.source(), shared, end2)); + case CGAL::RIGHT_TURN: + return (CGAL::right_turn(end1, shared, end2)); + case CGAL::LEFT_TURN: + return (CGAL::left_turn(end1, shared, end2)); + } + } //insert newly-discovered edges into active_edges according to its intersection with the view ray. void insert_halfedge(std::vector &active_edges, const Ray_2 &ray, Halfedge_const_handle edge) { - Point_2 cross_of_e = intersection_point(ray, halfedge2seg(edge)); + Point_2 cross_of_e = intersection_point(ray, edge); if (cross_of_e != ray.source()) { - typename std::vector::iterator first = active_edges.begin(); - while (first != active_edges.end()) + typename std::vector::iterator curr = active_edges.begin(); + while (curr != active_edges.end()) { - Point_2 cross_of_first = intersection_point(ray, halfedge2seg(*first)); - if (CGAL::compare_distance_to_point(ray.source(), cross_of_e, cross_of_first) == CGAL::SMALLER) { + Point_2 cross_of_curr = intersection_point(ray, *curr); + if (CGAL::compare_distance_to_point(ray.source(), cross_of_e, cross_of_curr) == CGAL::SMALLER) + break; + if (cross_of_curr == cross_of_e && is_closer(ray, edge, *curr)) break; - } - if (CGAL::compare_distance_to_point(ray.source(), cross_of_e, cross_of_first) == CGAL::EQUAL && CGAL::right_turn((*first)->source()->point(), cross_of_e, edge->source()->point()) ) { - break; - } - ++first; + ++curr; } - active_edges.insert(first, edge); + active_edges.insert(curr, edge); } } @@ -378,18 +406,18 @@ private: //check whether any edges incident to the vertice, vh, are on the right side of view ray. if yes, then it blocks the view ray. - bool Is_block(Vertex_const_handle vh, const Ray_2& ray) - { - typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; - first = curr = vh->incident_halfedges(); - do { - Vertex_const_handle u = curr->source(); - if (CGAL::right_turn(ray.source(), vh->point(), u->point())) { - return true; - } - } while (++curr != first); - return false; - } +// bool Is_block(Vertex_const_handle vh, const Ray_2& ray) +// { +// typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; +// first = curr = vh->incident_halfedges(); +// do { +// Vertex_const_handle u = curr->source(); +// if (CGAL::right_turn(ray.source(), vh->point(), u->point())) { +// return true; +// } +// } while (++curr != first); +// return false; +// } //insert vh into vertices by the angle between ray and positive x-ray. //if the angles are the same, compare their distances to p. @@ -547,21 +575,23 @@ private: return Direction_2(Vector_2(r.source(), p)) == Direction_2(r); } - Intersection_type needle(std::vector& edges, Ray_2& r, Point_2& furthest_p) { - typename std::vector::iterator eit = edges.begin(); + Intersection_type needle(std::vector& edges, Ray_2& r, Point_2& furthest_p, std::vector& collinear_vertices) { + typename std::vector::iterator curr = edges.begin(); Point_2 p = r.source(), target_p, source_p; + Vertex_const_handle curr_v; do { - target_p = (*eit)->target()->point(); - source_p = (*eit)->source()->point(); + target_p = (*curr)->target()->point(); + source_p = (*curr)->source()->point(); + if (target_p != p) { p = target_p; - Point_2 intersection = intersection_point(r, *eit); + Point_2 intersection = intersection_point(r, *curr); if (intersection != target_p && intersection != source_p) { furthest_p = intersection; return INNER; } bool has_right(false), has_left(false); - Vertex_const_handle vertex = (*eit)->target(); + Vertex_const_handle vertex = (*curr)->target(); typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; first = curr = vertex->incident_halfedges(); do { @@ -579,10 +609,10 @@ private: return CORNER; } } - } while (++eit != edges.end()); + } while (++curr != edges.end()); return UNBOUNDED; } - +//debug void print_active(std::vector& edges){ for (int i = 0; i != edges.size(); i++) { Point_2 p1, p2; @@ -656,7 +686,7 @@ private: }; -//debug. Print all edges of arrangements into console. +//For debug. Print all edges of arrangements into console. template void print_arrangement(const Arrangement_2 &arr) { typedef typename Arrangement_2::Edge_const_iterator Edge_const_iterator; @@ -666,8 +696,8 @@ void print_arrangement(const Arrangement_2 &arr) { std::cout << "[" << eit->curve() << "]" << std::endl; } -} // namespace Visibility_2 -} // namespace CGAL +//} // namespace Visibility_2 +//} // namespace CGAL #endif diff --git a/Visibility_2/include/CGAL/Visibility_2/Naive_visibility_2.h b/Visibility_2/include/CGAL/Visibility_2/Naive_visibility_2.h deleted file mode 100644 index e004bcaf7fc..00000000000 --- a/Visibility_2/include/CGAL/Visibility_2/Naive_visibility_2.h +++ /dev/null @@ -1,674 +0,0 @@ -//kan's version -#ifndef CGAL_NAIVE_VISIBILITY_2_H -#define CGAL_NAIVE_VISIBILITY_2_H - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -namespace CGAL { - -namespace Visibility_2 { - -//debug -template -void print(std::vector ps){ - for (int i=0; ipoint().x()<<","<point().y()< -class Naive_visibility_2 { - typedef typename Arrangement_2::Traits_2 Traits_2; - typedef typename Traits_2::Kernel Kernel; - typedef typename Traits_2::Point_2 Point_2; - typedef typename CGAL::Segment_2 Segment_2; - - typedef typename Arrangement_2::Halfedge Halfedge; - typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle; - typedef typename Arrangement_2::Vertex_const_handle Vertex_const_handle; - typedef typename Arrangement_2::Face_const_handle Face_const_handle; - - typedef typename CGAL::Vector_2 Vector_2; - typedef typename CGAL::Direction_2 Direction_2; - typedef typename CGAL::Ray_2 Ray_2; - - enum Intersection_type { UNBOUNDED, CORNER, INNER }; - -public: - //members - Arrangement_2 arr; - - //functions - Naive_visibility_2(const Arrangement_2 &arr):arr(arr), attach_tag(true) {} - - Naive_visibility_2(): attach_tag(false) {} - - - void visibility_region(const Point_2 &q, const Halfedge &edge, Arrangement_2 &out_arr) { - - } - - void visibility_region(const Point_2 &query, Face_const_handle fh, Arrangement_2 &out_arr) { - visibility_region_impl(query, fh, out_arr, Regularization_tag()); - - } - - void visibility_region_impl(const Point_2 &query, Face_const_handle fh, Arrangement_2 &out_arr, CGAL::Tag_true) { - std::vector vertices; //all vertices of the face. - std::vector edges, active_edges; //edges stores all halfedges of the face; and active_edges stores all halfedges that is currently intersected by the view ray. - //preprocess the face - input_face(fh, vertices, edges, query); - //initiation of vision ray - Vector_2 dir; - if (Direction_2(-1, 0) < Direction_2(Vector_2(query, (*vertices.rbegin())->point()))) - { - dir = Vector_2(1, 0) + Vector_2(query, (*vertices.rbegin())->point()); - } - else { - dir = Vector_2(0, -1); - } - Ray_2 init_vision_ray(query, dir); - - //initiation of active_edges - typename std::vector::iterator iter1; - for (iter1 = edges.begin(); iter1 != edges.end(); iter1++) - { - insert_halfedge(active_edges, init_vision_ray, *iter1); - } - - //angular sweep - std::vector polygon; - Ray_2 curr_vision_ray = init_vision_ray; - typename std::vector::iterator vit = vertices.begin(), begin_it, end_it; - Halfedge_const_handle closest_edge; - bool is_init_empty = active_edges.empty(); - while (vit != vertices.end()) - { - if (active_edges.empty()) - { - begin_it = vit; - end_it = vit; - curr_vision_ray= Ray_2(query, (*begin_it)->point()); - Direction_2 d1(curr_vision_ray), d2; - do { - d2 = Direction_2(Ray_2(query, (*end_it)->point())); - if (d1 != d2) break; - } while (++end_it != vertices.end()); - add_edges(begin_it, end_it, active_edges, curr_vision_ray); - - //since active_edges is empty, that means adding new edges will bring in an unbounded edge to arrangement. - closest_edge = active_edges[0]; - remove_edges(active_edges, curr_vision_ray); - - if (active_edges.empty()) { - //this means in input, there is no edge that intersects curr_vision_ray - //except those collinear ones. - //because one unbounded ray has been inserted before, - //we don't need to do anything here. - } - else { - //add new edge; - Point_2 p1 = intersection_point(curr_vision_ray, closest_edge); - Point_2 p2 = intersection_point(curr_vision_ray, active_edges[0]); - update_visibility(p1, polygon, out_arr); - update_visibility(p2, polygon, out_arr); - - } - } - else { - closest_edge = active_edges[0]; - begin_it = vit; //all vertices between begin_it and end_it(not included) are collinear with query point. - end_it = vit; - curr_vision_ray = Ray_2(query, (*begin_it)->point()); - Direction_2 d1(curr_vision_ray), d2; - do { - d2 = Direction_2(Ray_2(query, (*end_it)->point())); - if (d1 != d2) break; - } while (++end_it != vertices.end()); - add_edges(begin_it, end_it, active_edges, curr_vision_ray); - - if (closest_edge != active_edges[0]) - { - //add new edge; - Point_2 p1 = intersection_point(curr_vision_ray, closest_edge); - Point_2 p2 = intersection_point(curr_vision_ray, active_edges[0]); - update_visibility(p1, polygon, out_arr); - update_visibility(p2, polygon, out_arr); - - } - - closest_edge = active_edges[0]; - remove_edges(active_edges, curr_vision_ray); - - if (active_edges.empty()) { - //add an unbounded edge -//todo CGAL::insert_curve(out_arr, Ray_2((*begin_it)->point(), Direction_2(curr_vision_ray))); - } - else { - if (closest_edge != active_edges[0]) { - //add new edge; - Point_2 p1 = intersection_point(curr_vision_ray, closest_edge); - Point_2 p2 = intersection_point(curr_vision_ray, active_edges[0]); - update_visibility(p1, polygon, out_arr); - update_visibility(p2, polygon, out_arr); - } - } - } - vit = end_it; - } - if (!is_init_empty) { - CGAL::insert_curve(out_arr, Segment_2(polygon[0], polygon.back())); - } - } - - void visibility_region_impl(const Point_2 &query, Face_const_handle fh, Arrangement_2 &out_arr, CGAL::Tag_false) { - std::vector vertices; //all vertices of the face. - std::vector edges, active_edges; //edges stores all halfedges of the face; and active_edges stores all halfedges that is currently intersected by the view ray. - //preprocess the face - input_face(fh, vertices, edges, query); - print(vertices); - //initiation of vision ray - Vector_2 dir; - if (Direction_2(-1, 0) < Direction_2(Vector_2(query, (*vertices.rbegin())->point()))) - { - dir = Vector_2(1, 0) + Vector_2(query, (*vertices.rbegin())->point()); - } - else { - dir = Vector_2(0, -1); - } - Ray_2 init_vision_ray(query, dir); - - //initiation of active_edges - typename std::vector::iterator iter1; - for (iter1 = edges.begin(); iter1 != edges.end(); iter1++) - { - insert_halfedge(active_edges, init_vision_ray, *iter1); - } - - //angular sweep - std::vector polygon; - Ray_2 curr_vision_ray = init_vision_ray; - typename std::vector::iterator vit = vertices.begin(), begin_it, end_it; - Halfedge_const_handle closest_edge; - bool is_init_empty = active_edges.empty(); - while (vit != vertices.end()) - { - if (active_edges.empty()) - { - begin_it = vit; - end_it = vit; - curr_vision_ray= Ray_2(query, (*begin_it)->point()); - Direction_2 d1(curr_vision_ray), d2; - do { - d2 = Direction_2(Ray_2(query, (*end_it)->point())); - if (d1 != d2) break; - } while (++end_it != vertices.end()); - add_edges(begin_it, end_it, active_edges, curr_vision_ray); - - //since active_edges is empty, that means adding new edges will bring in an unbounded edge to arrangement. - Point_2 p1 = intersection_point(curr_vision_ray, active_edges[0]); - polygon.push_back(p1); -//todo CGAL::insert_curve(out_arr, Ray_2(p1, d1)); - - closest_edge = active_edges[0]; - remove_edges(active_edges, curr_vision_ray); - - if (active_edges.empty()) { - //this means there is no edge that intersects curr_vision_ray - //except those collinear ones. - //because one unbounded ray has been inserted before, - //we don't need to do anything here. - } - else { - //add new edge; - //Point_2 p1 = intersection_point(curr_vision_ray, closest_edge); - Point_2 p2 = intersection_point(curr_vision_ray, active_edges[0]); - //update_visibility(p1, polygon, out_arr); - update_visibility(p2, polygon, out_arr); - - } - } - else { - Point_2 right_p, left_p, mid_p, furthest_p; - begin_it = vit; - end_it = vit; //all vertices between begin_it and end_it(not included) are collinear with query point. - curr_vision_ray= Ray_2(query, (*begin_it)->point()); - right_p = intersection_point(curr_vision_ray, active_edges[0]); - Direction_2 d1(curr_vision_ray), d2; - do { - d2 = Direction_2(Ray_2(query, (*end_it)->point())); - if (d1 != d2) break; - } while (++end_it != vertices.end()); - add_edges(begin_it, end_it, active_edges, curr_vision_ray); - - mid_p = intersection_point(curr_vision_ray, active_edges[0]); - - Intersection_type i_type = needle(active_edges, curr_vision_ray, furthest_p); - switch (i_type) { - case UNBOUNDED : - //remove right and collinear; - remove_edges(active_edges, curr_vision_ray); - update_visibility(right_p, polygon, out_arr); - update_visibility(mid_p, polygon, out_arr); - //todo CGAL::insert_curve(); - if (!active_edges.empty()) { - left_p = intersection_point(curr_vision_ray, active_edges[0]); - update_visibility(left_p, polygon, out_arr); - } - break; - case CORNER : - //remove right and collinear; - remove_edges(active_edges, curr_vision_ray); - left_p = intersection_point(curr_vision_ray, active_edges[0]); - update_visibility(right_p, polygon, out_arr); - update_visibility(furthest_p, polygon, out_arr); - update_visibility(mid_p, polygon, out_arr); - update_visibility(left_p, polygon, out_arr); - break; - case INNER : - //remove right and collinear; - remove_edges(active_edges, curr_vision_ray); - if (mid_p == furthest_p) { - //this means mid_p = left_p = right_p = furthest_p. no new vertex is found. - } - else { - left_p = intersection_point(curr_vision_ray, active_edges[0]); - update_visibility(right_p, polygon, out_arr); - update_visibility(mid_p, polygon, out_arr); - update_visibility(left_p, polygon, out_arr); - } - break; - } - } - vit = end_it; - } - if (!is_init_empty) { - CGAL::insert_curve(out_arr, Segment_2(polygon.front(), polygon.back())); - } - } - - - bool is_attached() { - return attach_tag; - } - - void attach(Arrangement_2 arr) { - this->arr = arr; - this->attach_tag = true; - } - - void detach() { - attach_tag = false; - } - - -private: - - bool attach_tag; - - // return the intersection of a ray and a segment. if the intersection is a segment, return the end closer to the source of ray. - // if there is no intersection, return the source of ray. - Point_2 intersection_point(Ray_2 ray, Segment_2 seg ) - { - - CGAL::Object result = CGAL::intersection(ray, seg); - if (const Point_2 *ipoint = CGAL::object_cast(&result)) { - return *ipoint; - } else - //if result is a segment, return the end closer to the source of ray. - if (const Segment_2 *iseg = CGAL::object_cast(&result)) { - switch (CGAL::compare_distance_to_point(ray.source(), iseg->source(), iseg->target())) { - case (CGAL::SMALLER): - return iseg->source(); - break; - case (CGAL::LARGER) : - return iseg->target(); - break; - } - - } else { - // if no intersection, return the source of ray. - return ray.source(); - } - } - - Point_2 intersection_point(Ray_2 ray, Halfedge_const_handle seg) { - return intersection_point(ray, halfedge2seg(seg)); - } - - //convertor for halfedge to segment - Segment_2 halfedge2seg(Halfedge_const_handle e){ - return Segment_2(e->source()->point(), e->target()->point()); - } - - - //insert newly-discovered edges into active_edges according to its intersection with the view ray. - void insert_halfedge(std::vector &active_edges, const Ray_2 &ray, Halfedge_const_handle edge) - { - Point_2 cross_of_e = intersection_point(ray, halfedge2seg(edge)); - if (cross_of_e != ray.source()) - { - typename std::vector::iterator first = active_edges.begin(); - while (first != active_edges.end()) - { - - Point_2 cross_of_first = intersection_point(ray, halfedge2seg(*first)); - if (CGAL::compare_distance_to_point(ray.source(), cross_of_e, cross_of_first) == CGAL::SMALLER) { - break; - } - if (CGAL::compare_distance_to_point(ray.source(), cross_of_e, cross_of_first) == CGAL::EQUAL && CGAL::right_turn((*first)->source()->point(), cross_of_e, edge->source()->point()) ) { - break; - } - ++first; - } - active_edges.insert(first, edge); - } - } - - - - - //check whether any edges incident to the vertice, vh, are on the right side of view ray. if yes, then it blocks the view ray. - bool Is_block(Vertex_const_handle vh, const Ray_2& ray) - { - typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; - first = curr = vh->incident_halfedges(); - do { - Vertex_const_handle u = curr->source(); - if (CGAL::right_turn(ray.source(), vh->point(), u->point())) { - return true; - } - } while (++curr != first); - return false; - } - - //insert vh into vertices by the angle between ray and positive x-ray. - //if the angles are the same, compare their distances to p. - void sort_vertex(std::vector& vertices, Vertex_const_handle vh, const Point_2& p) - { - typename std::vector::iterator first = vertices.begin(); - Vector_2 vector_of_v(p, vh->point()); - Direction_2 dir_of_v(vector_of_v); - while (first != vertices.end()) - { - if (vh->point() == (*first)->point()) { - return; - } - Vector_2 vector1(p, (*first)->point()); - Direction_2 d1(vector1); - if (dir_of_v < d1) - break; - //if same angles are the same, put the vertex which is closer to query point before. - if (dir_of_v == d1 && CGAL::compare_distance_to_point(p, vh->point(), (*first)->point()) == CGAL::SMALLER) - break; - ++first; - } - vertices.insert(first, vh); - } - - - //sort vertex vh by the angle between vector and positive x-ray. - //if the angles are the same, place them in a 'circular' way. - //we do this because the output is not regularized, i.e. 1-d needle is reserved in output. -// void sort_vertex(vector& vertices, Vertex_const_handle vh, const Point_2& p, CGAL::Tag_false) -// { -// Ray_2 ray(p, vh->point()); -// typename vector::iterator first = vertices.begin(); -// while (first != vertices.end()) -// { -// Ray_2 r(p, (*first)->point()); -// Direction_2 d1(r); -// if (ray.direction() < d1) -// break; -// //if angles are the same, then using Isblock() to decide the order of vertices on the view ray. -// if (ray.direction() == d1) -// { -// if (Is_block(vh, ray) && (!Is_block(*first, ray))) -// break; -// if (Is_block(vh, ray) && Is_block(*first, ray) && CGAL::compare_distance_to_point(p, vh->point(), (*first)->point()) == CGAL::SMALLER) -// break; -// if (!Is_block(vh, ray) && !Is_block(*first, ray) && CGAL::compare_distance_to_point(p, vh->point(), (*first)->point()) == CGAL::LARGER) -// break; -// } -// ++first; -// } -// vertices.insert(first, vh); -// } - - //traverse the face to get all edges and sort vertices in counter-clockwise order. - void input_face (Face_const_handle fh, - std::vector& vertices, - std::vector& edges, - const Point_2& p) - { - typename Arrangement_2::Ccb_halfedge_const_circulator curr = fh->outer_ccb(); - typename Arrangement_2::Ccb_halfedge_const_circulator circ = curr; - do { - sort_vertex(vertices, curr->source(), p); - edges.push_back(curr); - } while (++curr != circ); - typename Arrangement_2::Hole_const_iterator hi; - for (hi = fh->holes_begin(); hi != fh->holes_end(); ++hi) { - typename Arrangement_2::Ccb_halfedge_const_circulator c1 = *hi, c2 = *hi; - do { - sort_vertex(vertices, c1->source(), p); - edges.push_back(c1); - } while (++c1 != c2); - } - } - - - - - //insert new vertice to polygon. before insertion, check if this vertice has been added before. - void update_visibility(const Point_2 p, std::vector &polygon, Arrangement_2& arr){ - if (polygon.empty()) - polygon.push_back(p); - else - { - if (polygon.back() != p){ - CGAL::insert_curve(arr, Segment_2(polygon.back(), p)); - polygon.push_back(p); - } - } - } - - //add a new edge when vision ray passes a vertex - void add_edge(Vertex_const_handle vh, - std::vector& edges, - const Ray_2& r) { - typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; - first = curr = vh->incident_halfedges(); - do { - if (!CGAL::right_turn(r.source(), vh->point(), curr->source()->point())) - { - insert_halfedge(edges, r, curr); - } - } while (++curr != first); - - } - //add new edges - void add_edges(typename std::vector::iterator begin_it, - typename std::vector::iterator end_it, - std::vector& edges, - const Ray_2& r) - { - do { - add_edge(*begin_it, edges, r); - } while (++begin_it != end_it); - - //debug - std::cout<<"after adding"<& edges, const Ray_2& r) { - typename std::vector::iterator eit = edges.begin(); - while (eit != edges.end()) { - Point_2 p1 = (*eit)->target()->point(); - Point_2 p2 = (*eit)->source()->point(); - bool is_incident(false); - if (is_on_ray(r, p1)) { - is_incident = true; - } - else if (is_on_ray(r, p2)) { - Point_2 tmp = p1; - p1 = p2; - p2 = p1; - is_incident = true; - } - - - if ( is_incident && !CGAL::left_turn(r.source(), p1, p2)) - { - eit = edges.erase(eit); - } - else { - eit++; - } - } - //debug - std::cout<<"after remove"<& edges, Ray_2& r, Point_2& furthest_p) { - typename std::vector::iterator eit = edges.begin(); - Point_2 p = r.source(), target_p, source_p; - do { - target_p = (*eit)->target()->point(); - source_p = (*eit)->source()->point(); - if (target_p != p) { - p = target_p; - Point_2 intersection = intersection_point(r, *eit); - if (intersection != target_p && intersection != source_p) { - furthest_p = intersection; - return INNER; - } - bool has_right(false), has_left(false); - Vertex_const_handle vertex = (*eit)->target(); - typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; - first = curr = vertex->incident_halfedges(); - do { - switch (CGAL::orientation(r.source(), curr->target()->point(), curr->source()->point())) { - case CGAL::RIGHT_TURN: - has_right = true; - break; - case CGAL::LEFT_TURN: - has_left = true; - break; - } - } while (++curr != first); - if (has_right && has_left) { - furthest_p = intersection; - return CORNER; - } - } - } while (++eit != edges.end()); - return UNBOUNDED; - } - - void print_active(std::vector& edges){ - for (int i = 0; i != edges.size(); i++) { - Point_2 p1, p2; - p1 = edges[i]->source()->point(); - p2 = edges[i]->target()->point(); - std::cout<"< &active_edges, const Point_2 &query, Vertex_const_handle vh, std::vector &polygon ) - { - //closest_edge_copy is a copy of the closest edge to query point in active_edges before sweeping. - Halfedge_const_handle closest_edge_copy = active_edges[0]; - Ray_2 ray(query, vh->point()); - int add_count(0); - int del_count(0); - - //delete all edges in active_edges which is incident to v, because they has been sweeped over - typename std::vector::iterator edge_iter = active_edges.begin(); - while (edge_iter != active_edges.end()) { - if (((*edge_iter)->source()->point() == vh->point()) || ((*edge_iter)->target()->point() == vh->point())) - { - edge_iter = active_edges.erase(edge_iter); - ++del_count; - } - else { - ++edge_iter; - } - } - - //add all edges which is incident to v but not in active_edges before to active_edges - typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; - first = curr = vh->incident_halfedges(); - do { - if (CGAL::left_turn(query, vh->point(), curr->source()->point())) - { - insert_halfedge(active_edges, ray, curr); - ++add_count; - } - else if (CGAL::collinear(query, vh->point(), curr->source()->point()) && - CGAL::compare_distance_to_point(query, vh->point(), curr->source()->point()) == CGAL::SMALLER) - { - insert_halfedge(active_edges, ray, curr); - ++add_count; - } - } while (++curr != first); - - //update the visibility region - if (closest_edge_copy != active_edges[0]) { - //when the closest edge changed - if (del_count > 0 && add_count > 0) { - //some edges are added and some are deleted, which means the vertice sweeped is a vertice of visibility polygon. - update_visibility(vh->point(), polygon); - } - if (del_count == 0 && add_count > 0) { - //only add some edges, means the view ray is blocked by new edges. - //therefore first add the intersection of view ray and former closet edge, then add the vertice sweeped. - update_visibility(intersection_point(ray, halfedge2seg(closest_edge_copy)), polygon); - update_visibility(vh->point(), polygon); - } - if (del_count > 0 && add_count == 0) { - //only delete some edges, means some block is moved and the view ray can reach the segments after the block. - update_visibility(vh->point(), polygon); - update_visibility(intersection_point(ray, halfedge2seg(active_edges[0])), polygon); - } - } - - } - -}; - -//debug. Print all edges of arrangements into console. -template -void print_arrangement(const Arrangement_2 &arr) { - typedef typename Arrangement_2::Edge_const_iterator Edge_const_iterator; - Edge_const_iterator eit; - std::cout << arr.number_of_edges() << " edges:" << std::endl; - for (eit = arr.edges_begin(); eit != arr.edges_end(); ++eit) - std::cout << "[" << eit->curve() << "]" << std::endl; -} - -} // namespace Visibility_2 -} // namespace CGAL - -#endif - - From e553deaab91557a5e9a572de729a1c13793f53d7 Mon Sep 17 00:00:00 2001 From: Francisc Date: Tue, 9 Jul 2013 11:18:00 +0300 Subject: [PATCH 28/66] test cases progress --- .../include/CGAL/Simple_visibility_2.h | 46 ++++++------ .../test/include/CGAL/test_model_methods.h | 2 +- Visibility_2/test/test_simple_visibility.cpp | 75 ++----------------- 3 files changed, 30 insertions(+), 93 deletions(-) diff --git a/Visibility_2/include/CGAL/Simple_visibility_2.h b/Visibility_2/include/CGAL/Simple_visibility_2.h index 5587144803d..62e7a3e9574 100644 --- a/Visibility_2/include/CGAL/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Simple_visibility_2.h @@ -25,15 +25,17 @@ public: typedef typename Geometry_traits_2::Vector_2 Vector_2; typedef typename Geometry_traits_2::Segment_2 Segment_2; + Simple_visibility_2() {}; + /*! Constructor given an arrangement and the Regularization tag. */ - Simple_visibility_2(const Input_Arrangement_2 &arr/*, Regularization_tag r_t*/): p_arr(arr) {}; + Simple_visibility_2(const Input_Arrangement_2 &arr/*, Regularization_tag r_t*/): p_arr(&arr) {}; bool is_attached() { return (p_arr != NULL); } void attach(const Input_Arrangement_2 &arr) { - p_arr = arr; + p_arr = &arr; } void detach() { @@ -94,7 +96,7 @@ public: // Point_2 stored_q(q); // q = Point_2(0, 0); - if (CGAL::orientation(q, vertices[0], vertices[1]) == CGAL::LEFT_TURN) { + if (orientation(q, vertices[0], vertices[1]) == CGAL::LEFT_TURN) { std::cout << "left" << std::endl; upcase = LEFT; i = 1; @@ -186,14 +188,14 @@ public: } protected: - Input_Arrangement_2 p_arr; + const Input_Arrangement_2 *p_arr; std::stack s; std::vector vertices; enum {LEFT, RIGHT, SCANA, SCANB, SCANC, SCAND, FINISH} upcase; bool do_overlap(const Point_2 &a, const Point_2 &b, const Point_2 &c) { - if (CGAL::collinear(a, b, c)) { + if (collinear(a, b, c)) { Segment_2 s1(a, b); Segment_2 s2(a, c); const Segment_2 *seg_overlap; @@ -211,19 +213,19 @@ protected: std::cout << "done" << std::endl; upcase = FINISH; } - else if (CGAL::orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::LEFT_TURN) { + else if (orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::LEFT_TURN) { std::cout << "left::left turn with i =" << i << std::endl; upcase = LEFT; s.push(vertices[i+1]); w = vertices[i+1]; i++; } - else if (CGAL::orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { + else if (orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { Point_2 s_t = s.top(); s.pop(); Point_2 s_t_prev = s.top(); s.pop(); - if (CGAL::orientation(s_t_prev, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { + if (orientation(s_t_prev, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { upcase = SCANA; i++; } @@ -251,24 +253,24 @@ protected: Point_2 s_j_prev = s.top(); // Check condition (a) - if ((CGAL::orientation(query_pt, s_j, vertices[i]) == CGAL::RIGHT_TURN) - && (CGAL::orientation(query_pt, s_j_prev, vertices[i]) == CGAL::LEFT_TURN)) { + if ((orientation(query_pt, s_j, vertices[i]) == CGAL::RIGHT_TURN) + && (orientation(query_pt, s_j_prev, vertices[i]) == CGAL::LEFT_TURN)) { found = true; Segment_2 s1(s_j_prev, s_j); Segment_2 s2(query_pt, vertices[i]); - CGAL::Object result = CGAL::intersection(s1, s2); + CGAL::Object result = intersection(s1, s2); if (const Point_2 *ipoint = CGAL::object_cast(&result)) { s_j = *ipoint; } - if (CGAL::orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { + if (orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { upcase = RIGHT; s.push(s_j); i++; w = vertices[i]; } - else if ((CGAL::orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::LEFT_TURN) - && (CGAL::orientation(vertices[i-1], vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN)) { + else if ((orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::LEFT_TURN) + && (orientation(vertices[i-1], vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN)) { upcase = LEFT; i++; @@ -286,7 +288,7 @@ protected: else { // Case (b) Segment_2 s1(s_j_prev, s_j); Segment_2 s2(vertices[i-1], vertices[i]); - CGAL::Object result = CGAL::intersection(s1, s2); + CGAL::Object result = intersection(s1, s2); if (const Point_2 *ipoint = CGAL::object_cast(&result)) { // Keep s_j off the stack upcase = SCAND; @@ -305,7 +307,7 @@ protected: while (k+1 < vertices.size()-1) { Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(query_pt, s.top()); - CGAL::Object result = CGAL::intersection(s1, s2); + CGAL::Object result = intersection(s1, s2); if (ipoint = CGAL::object_cast(&result)) { found = true; break; @@ -313,21 +315,21 @@ protected: k++; } if (found) { - if ((CGAL::orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::RIGHT_TURN) + if ((orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::RIGHT_TURN) && (do_overlap(query_pt, s.top(), *ipoint))) { upcase = RIGHT; i = k+1; w = *ipoint; } - else if ((CGAL::orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::RIGHT_TURN) + else if ((orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::RIGHT_TURN) && (!do_overlap(query_pt, s.top(), *ipoint))) { upcase = SCAND; i = k+1; w = *ipoint; } - else if ((CGAL::orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::LEFT_TURN) + else if ((orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::LEFT_TURN) && (!do_overlap(query_pt, s.top(), *ipoint))) { upcase = LEFT; @@ -351,7 +353,7 @@ protected: while (k+1 < vertices.size()-1) { Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(s_t, vertices[vertices.size()-1]); - CGAL::Object result = CGAL::intersection(s1, s2); + CGAL::Object result = intersection(s1, s2); if (ipoint = CGAL::object_cast(&result)) { found = true; break; @@ -381,7 +383,7 @@ protected: while (k+1 < vertices.size()-1) { Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(s_t, w); - CGAL::Object result = CGAL::intersection(s1, s2); + CGAL::Object result = intersection(s1, s2); if (ipoint = CGAL::object_cast(&result)) { found = true; break; @@ -404,7 +406,7 @@ protected: while (k+1 < vertices.size()-1) { Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(s_t, w); - CGAL::Object result = CGAL::intersection(s1, s2); + CGAL::Object result = intersection(s1, s2); if (ipoint = CGAL::object_cast(&result)) { found = true; break; diff --git a/Visibility_2/test/include/CGAL/test_model_methods.h b/Visibility_2/test/include/CGAL/test_model_methods.h index 81c8c251c06..4110e302765 100644 --- a/Visibility_2/test/include/CGAL/test_model_methods.h +++ b/Visibility_2/test/include/CGAL/test_model_methods.h @@ -13,7 +13,7 @@ namespace CGAL { template bool test_is_attached(_Visibility_2 visibility) { - return true; + return visibility.is_attached(); } } // end CGAL namespace diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp index 4203b279e86..c2f826895bf 100644 --- a/Visibility_2/test/test_simple_visibility.cpp +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -36,74 +36,9 @@ int main() { CGAL::Visibility_2::Simple_visibility_2 visibility(arr); assert(true == (CGAL::test_is_attached >(visibility))); + visibility.detach(); + assert(false == (CGAL::test_is_attached >(visibility))); + visibility.attach(arr); + assert(true == (CGAL::test_is_attached >(visibility))); return 0; -} -/*#include -#include -#include -#include -#include -#include - -typedef CGAL::Gmpq Number_type; -typedef CGAL::Cartesian Kernel; -typedef CGAL::Arr_segment_traits_2 Traits_2; -typedef Traits_2::Point_2 Point_2; -typedef Traits_2::X_monotone_curve_2 Segment_2; -typedef CGAL::Arrangement_2 Arrangement_2; - -void test1() { - Point_2 p1(0, 0), p2(8, 0), p3(8, 8), p4(0, 8); - - Arrangement_2 arr, out_arr; - Segment_2 segments[4]; - - segments[0] = Segment_2(p1, p2); - segments[1] = Segment_2(p2, p3); - segments[2] = Segment_2(p3, p4); - segments[3] = Segment_2(p4, p1); - - Point_2 q_point(4, 4); - - CGAL::insert(arr, &segments[0], &segments[4]); - - CGAL::Visibility_2::Simple_visibility_2 visibility(arr); - Arrangement_2::Face_const_iterator fit; - - for (fit = arr.faces_begin(); fit != arr.faces_end(); ++fit) { - if (!fit->is_unbounded()) { - visibility.visibility_region(q_point, fit, out_arr); - } - } -} - -void test2() { - - Point_2 p1(0, 0), p2(4, 4), p3(8, 4), p4(0, 8); - - Arrangement_2 arr, out_arr; - Segment_2 segments[4]; - // Insert outer segments - segments[0] = Segment_2(p1, p2); - segments[1] = Segment_2(p2, p3); - segments[2] = Segment_2(p3, p4); - segments[3] = Segment_2(p4, p1); - - Point_2 q_point(2, 3); - - CGAL::insert(arr, &segments[0], &segments[4]); - - CGAL::Visibility_2::Simple_visibility_2 visibility(arr); - Arrangement_2::Face_const_iterator fit; - - for (fit = arr.faces_begin(); fit != arr.faces_end(); ++fit) { - if (!fit->is_unbounded()) { - visibility.visibility_region(q_point, fit, out_arr); - } - } -} - -int main() { - test2(); - return 0; -}*/ \ No newline at end of file +} \ No newline at end of file From 4ab16a45a6e414c977fe504dfaf964ac4f473786 Mon Sep 17 00:00:00 2001 From: Francisc Date: Tue, 9 Jul 2013 14:24:35 +0300 Subject: [PATCH 29/66] started arrangement comparison function --- Visibility_2/test/include/CGAL/test_utils.h | 38 +++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 Visibility_2/test/include/CGAL/test_utils.h diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h new file mode 100644 index 00000000000..601616507e9 --- /dev/null +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -0,0 +1,38 @@ +/* + * Author: Francisc Bungiu + * E-mail: fbungiu@gmail.com + * Description: This file contains useful functions for testing the + * Visibility_2 package, such as comparing two Arrangements + */ + +#ifndef CGAL_TEST_UTILS_H +#define CGAL_TEST_UTILS_H + +#include + +namespace CGAL { + +/* + * Function to compare two arrangements; first determines lowest vertex + * from each arrangements, then it walks the edges and compares them + */ +template +bool test_are_equal(_Arrangement_2 &arr1, _Arrangement_2 &arr2) { + + typedef _Arrangement_2 Arrangement_2; + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + typedef typename Arrangement_2::Vertex_const_iterator Vertex_const_iterator; + typedef typename Geometry_traits_2::Point_2 Point_2; + + Vertex_const_iterator vit_fst, vit_snd; + vit_fst = arr1.vertices_begin(); + vit_snd = arr2.vertices_begin(); + + Point_2 min_fst = vit_fst->point(); + Point_2 min_snd = vit_fst->point(); + + return true; +} +} // end namespace CGAL + +#endif \ No newline at end of file From f7d3913de290295c981388e0159c1877ec0fb986 Mon Sep 17 00:00:00 2001 From: Francisc Date: Tue, 9 Jul 2013 14:25:06 +0300 Subject: [PATCH 30/66] started arrangement comparison function --- Visibility_2/test/test_simple_visibility.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp index c2f826895bf..91890ca6857 100644 --- a/Visibility_2/test/test_simple_visibility.cpp +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include int main() { @@ -40,5 +41,8 @@ int main() { assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); assert(true == (CGAL::test_is_attached >(visibility))); + + assert(true == (CGAL::test_are_equal(arr, arr))); + return 0; } \ No newline at end of file From ba3321f8c4f88ec46d5a50d03bbe4d94b497ae00 Mon Sep 17 00:00:00 2001 From: Francisc Date: Tue, 9 Jul 2013 16:42:20 +0300 Subject: [PATCH 31/66] test suite progress - added arrangment comparison function --- Visibility_2/test/include/CGAL/test_utils.h | 75 +++++++++++++++++++- Visibility_2/test/test_simple_visibility.cpp | 23 +++--- 2 files changed, 88 insertions(+), 10 deletions(-) diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index 601616507e9..3135c31a3c3 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -22,17 +22,88 @@ bool test_are_equal(_Arrangement_2 &arr1, _Arrangement_2 &arr2) { typedef _Arrangement_2 Arrangement_2; typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; typedef typename Arrangement_2::Vertex_const_iterator Vertex_const_iterator; + typedef typename Arrangement_2::Edge_const_iterator Edge_const_iterator; + typedef typename Geometry_traits_2::Segment_2 Segment_2; typedef typename Geometry_traits_2::Point_2 Point_2; + // First make sure they have the same size + if (arr1.number_of_vertices() != arr2.number_of_vertices()) { + return false; + } + if (arr1.number_of_edges() != arr2.number_of_edges()) { + return false; + } + Vertex_const_iterator vit_fst, vit_snd; vit_fst = arr1.vertices_begin(); vit_snd = arr2.vertices_begin(); Point_2 min_fst = vit_fst->point(); - Point_2 min_snd = vit_fst->point(); + Point_2 min_snd = vit_snd->point(); + vit_fst++; + vit_snd++; + for (vit_fst ; vit_fst != arr1.vertices_end(); ++vit_fst) { + if (vit_fst->point().y() < min_fst.y()) { + min_fst = vit_fst->point(); + } + else if (vit_fst->point().y() == min_fst.y() && + vit_fst->point().x() < min_fst.x()) { + min_fst = vit_fst->point(); + } + } + + for (vit_snd ; vit_snd != arr2.vertices_end() ; ++vit_snd) { + if (vit_snd->point().y() < min_snd.y()) { + min_snd = vit_snd->point(); + } + else if (vit_snd->point().y() == min_snd.y() && + vit_snd->point().x() < min_snd.y()) { + min_snd = vit_snd->point(); + } + } + + // Determine from which edge to start from + // (the one that contains the minimum vertex) + Edge_const_iterator eit_fst, eit_snd, eit_fst_mid, eit_snd_mid; + + for (eit_fst = arr1.edges_begin(); eit_fst != arr1.edges_end(); ++eit_fst) { + Segment_2 curr = eit_fst->curve(); + if (curr.source() == min_fst || curr.target() == min_fst) { + break; + } + } + + for (eit_snd = arr2.edges_begin() ; eit_snd != arr2.edges_end(); ++eit_snd){ + Segment_2 curr = eit_snd->curve(); + if (curr.source() == min_snd || curr.target() == min_snd) { + break; + } + } + eit_fst_mid = eit_fst; + eit_snd_mid = eit_snd; + // Now we know where to start the edge comparisons from + for (eit_fst, eit_snd ; eit_fst != arr1.edges_end(), + eit_snd != arr2.edges_end() ; ++eit_fst, ++eit_snd) { + + Segment_2 seg_fst = eit_fst->curve(); + Segment_2 seg_snd = eit_snd->curve(); + if (seg_fst != seg_snd) { + return false; + } + } + // Check first edges as well + for (eit_fst = arr1.edges_begin(), eit_snd = arr2.edges_begin() ; + eit_fst != eit_fst_mid, eit_snd != eit_snd_mid ; ++eit_fst, ++eit_snd){ + + Segment_2 seg_fst = eit_fst->curve(); + Segment_2 seg_snd = eit_snd->curve(); + if (seg_fst != seg_snd) { + return false; + } + } return true; } } // end namespace CGAL -#endif \ No newline at end of file +#endif \ No newline at end of file diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp index 91890ca6857..8711bfeed0f 100644 --- a/Visibility_2/test/test_simple_visibility.cpp +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -22,18 +22,25 @@ int main() { typedef CGAL::Arrangement_2 Arrangement_2; Point_2 p1(0, 0), p2(8, 0), p3(8, 8), p4(0, 8); + Point_2 r1(0, 0), r2(5, 1), r3(7,9), r4(10, 15); - Arrangement_2 arr; - Segment_2 segments[4]; + Arrangement_2 arr, arr1; + Segment_2 segments_p[4], segments_r[4]; - segments[0] = Segment_2(p1, p2); - segments[1] = Segment_2(p2, p3); - segments[2] = Segment_2(p3, p4); - segments[3] = Segment_2(p4, p1); + segments_p[0] = Segment_2(p1, p2); + segments_p[1] = Segment_2(p2, p3); + segments_p[2] = Segment_2(p3, p4); + segments_p[3] = Segment_2(p4, p1); + + segments_r[0] = Segment_2(r1, r2); + segments_r[1] = Segment_2(r2, r3); + segments_r[2] = Segment_2(r3, r4); + segments_r[3] = Segment_2(r4, r1); Point_2 q_point(4, 4); - CGAL::insert(arr, &segments[0], &segments[4]); + CGAL::insert(arr, &segments_p[0], &segments_p[4]); + CGAL::insert(arr1, &segments_r[0], &segments_r[2]); CGAL::Visibility_2::Simple_visibility_2 visibility(arr); assert(true == (CGAL::test_is_attached >(visibility))); @@ -42,7 +49,7 @@ int main() { visibility.attach(arr); assert(true == (CGAL::test_is_attached >(visibility))); - assert(true == (CGAL::test_are_equal(arr, arr))); + assert(false == (CGAL::test_are_equal(arr, arr1))); return 0; } \ No newline at end of file From 30dc3b2d959d2f3613b1b56c853c6c7fcdc2257c Mon Sep 17 00:00:00 2001 From: kanhuang Date: Tue, 9 Jul 2013 23:04:10 -0400 Subject: [PATCH 32/66] 1. finish needle() in Naive_visibility_2.h. 2. add a function to create arrangement from file. 3. add an arbitrary arrangement test case, arr1 in /test/data. --- .../include/CGAL/Naive_visibility_2.h | 83 ++++++++++--------- Visibility_2/test/data/arr1 | 8 ++ Visibility_2/test/include/CGAL/test_utils.h | 32 ++++++- 3 files changed, 82 insertions(+), 41 deletions(-) create mode 100644 Visibility_2/test/data/arr1 diff --git a/Visibility_2/include/CGAL/Naive_visibility_2.h b/Visibility_2/include/CGAL/Naive_visibility_2.h index 9398f333c12..34403028c9d 100644 --- a/Visibility_2/include/CGAL/Naive_visibility_2.h +++ b/Visibility_2/include/CGAL/Naive_visibility_2.h @@ -402,23 +402,6 @@ private: } } - - - - //check whether any edges incident to the vertice, vh, are on the right side of view ray. if yes, then it blocks the view ray. -// bool Is_block(Vertex_const_handle vh, const Ray_2& ray) -// { -// typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; -// first = curr = vh->incident_halfedges(); -// do { -// Vertex_const_handle u = curr->source(); -// if (CGAL::right_turn(ray.source(), vh->point(), u->point())) { -// return true; -// } -// } while (++curr != first); -// return false; -// } - //insert vh into vertices by the angle between ray and positive x-ray. //if the angles are the same, compare their distances to p. void sort_vertex(std::vector& vertices, Vertex_const_handle vh, const Point_2& p) @@ -577,35 +560,55 @@ private: Intersection_type needle(std::vector& edges, Ray_2& r, Point_2& furthest_p, std::vector& collinear_vertices) { typename std::vector::iterator curr = edges.begin(); - Point_2 p = r.source(), target_p, source_p; - Vertex_const_handle curr_v; + Point_2 p = r.source(), end1, end2; + Vertex_const_handle vision_v, vertex1, vertex2; + //flag shows whether the left side or right side of needle is blocked. + bool block_left, block_right; do { - target_p = (*curr)->target()->point(); - source_p = (*curr)->source()->point(); + Point_2 cross = intersection_point(r, *curr); + if (cross != (*curr)->source()->point() && cross != (*curr)->target()->point()) + return INNER; + if (cross == (*curr)->source()->point()) { + vertex1 = (*curr)->source(); + vertex2 = (*curr)->target(); + } + else { + vertex1 = (*curr)->target(); + vertex2 = (*curr)->source(); + } + if (collinear_vertices.empty() || vertex1 != collinear_vertices.back()) { + collinear_vertices.push_back(vertex1); + //flag shows whether the left side or right side of current vertex is blocked. + //has_predecessor indicates whether this vertex is incident to an edge whose another end is between the source of ray and it, + //because that will effect the value of block_left, block_right. + bool left_v(false), right_v(false), has_predecessor(false); - if (target_p != p) { - p = target_p; - Point_2 intersection = intersection_point(r, *curr); - if (intersection != target_p && intersection != source_p) { - furthest_p = intersection; - return INNER; - } - bool has_right(false), has_left(false); - Vertex_const_handle vertex = (*curr)->target(); - typename Arrangement_2::Halfedge_around_vertex_const_circulator first, curr; - first = curr = vertex->incident_halfedges(); + typename Arrangement_2::Halfedge_around_vertex_const_circulator first_edge, curr_edge; + first_edge = curr_edge = vh->incident_halfedges(); do { - switch (CGAL::orientation(r.source(), curr->target()->point(), curr->source()->point())) { - case CGAL::RIGHT_TURN: - has_right = true; + switch (CGAL::orientation(r.source(), curr_edge->target()->point(), curr_edge->source()->point())) { + case CGAL::RIGHT_TURN : + right_v = true; break; - case CGAL::LEFT_TURN: - has_left = true; + case CGAL::LEFT_TURN : + left_v = true; break; + case CGAL::COLLINEAR : + if (CGAL::compare_distance_to_point(r.source(), curr_edge->target()->point(), curr_edge->source()->point()) == CGAL::LARGER) { + has_predecessor = true; + } } - } while (++curr != first); - if (has_right && has_left) { - furthest_p = intersection; + + } while (++curr_edge != first_edge); + if (has_predecessor) { + block_left = block_left || left_v; + block_right = block_right || right_v; + } + else { + block_left = left_v; + block_right = right_v; + } + if (block_left && block_right) { return CORNER; } } diff --git a/Visibility_2/test/data/arr1 b/Visibility_2/test/data/arr1 new file mode 100644 index 00000000000..03555aea7f1 --- /dev/null +++ b/Visibility_2/test/data/arr1 @@ -0,0 +1,8 @@ +4 +2 0 +4 0 +6 0 +8 0 +2 +0 1 +2 3 diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index 3135c31a3c3..1fcc80d9abf 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -9,6 +9,8 @@ #define CGAL_TEST_UTILS_H #include +#include +#include namespace CGAL { @@ -104,6 +106,34 @@ bool test_are_equal(_Arrangement_2 &arr1, _Arrangement_2 &arr2) { } return true; } + +template +bool create_arrangement_from_input(_Arrangement_2 &arr, std::ifstream& input) { + + typedef _Arrangement_2 Arrangement_2; + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + typedef typename Geometry_traits_2::Segment_2 Segment_2; + typedef typename Geometry_traits_2::Point_2 Point_2; + + std::vector points; + std::vector segments; + int number_of_points; + input >> number_of_points; + for (int i = 0; i != number_of_points; i++) { + double x,y; + input >> x >> y; + points.push_back(Point_2(x, y)); + } + int number_of_edges; + input >> number_of_edges; + for (int i = 0; i != number_of_edges; i++) { + unsigned i1,i2; + input >> i1 >> i2; + segments.push_back(Segment_2(points[i1], points[i2])); + } + CGAL::insert(arr, segments.begin(), segments.end()); +} + } // end namespace CGAL -#endif \ No newline at end of file +#endif From 5451b73f6b93cb4f92db2f84460c66cfd7d2550a Mon Sep 17 00:00:00 2001 From: Francisc Date: Wed, 10 Jul 2013 14:12:58 +0300 Subject: [PATCH 33/66] added first test case and added tests for the Visibility_2 concept methods --- .../include/CGAL/Simple_visibility_2.h | 4 +- .../test/data/simple_polygon_test_case_1.dat | 10 +++++ Visibility_2/test/test_simple_visibility.cpp | 39 +++++++------------ 3 files changed, 25 insertions(+), 28 deletions(-) create mode 100644 Visibility_2/test/data/simple_polygon_test_case_1.dat diff --git a/Visibility_2/include/CGAL/Simple_visibility_2.h b/Visibility_2/include/CGAL/Simple_visibility_2.h index 62e7a3e9574..e4d5ad91eaa 100644 --- a/Visibility_2/include/CGAL/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Simple_visibility_2.h @@ -25,7 +25,7 @@ public: typedef typename Geometry_traits_2::Vector_2 Vector_2; typedef typename Geometry_traits_2::Segment_2 Segment_2; - Simple_visibility_2() {}; + Simple_visibility_2() : p_arr(NULL) {}; /*! Constructor given an arrangement and the Regularization tag. */ Simple_visibility_2(const Input_Arrangement_2 &arr/*, Regularization_tag r_t*/): p_arr(&arr) {}; @@ -43,7 +43,7 @@ public: } Input_Arrangement_2 arr() { - return p_arr; + return *p_arr; } void visibility_region(Point_2 &q, diff --git a/Visibility_2/test/data/simple_polygon_test_case_1.dat b/Visibility_2/test/data/simple_polygon_test_case_1.dat new file mode 100644 index 00000000000..0fae69df1c3 --- /dev/null +++ b/Visibility_2/test/data/simple_polygon_test_case_1.dat @@ -0,0 +1,10 @@ +4 +0 0 +8 0 +8 8 +0 8 +4 +0 1 +1 2 +2 3 +3 1 diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp index 8711bfeed0f..fe4ebb8a739 100644 --- a/Visibility_2/test/test_simple_visibility.cpp +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -13,7 +13,11 @@ #include #include +#include +#include + int main() { +{ typedef CGAL::Gmpq Number_type; typedef CGAL::Cartesian Kernel; typedef CGAL::Arr_segment_traits_2 Traits_2; @@ -21,35 +25,18 @@ int main() { typedef Traits_2::X_monotone_curve_2 Segment_2; typedef CGAL::Arrangement_2 Arrangement_2; - Point_2 p1(0, 0), p2(8, 0), p3(8, 8), p4(0, 8); - Point_2 r1(0, 0), r2(5, 1), r3(7,9), r4(10, 15); - - Arrangement_2 arr, arr1; - Segment_2 segments_p[4], segments_r[4]; - - segments_p[0] = Segment_2(p1, p2); - segments_p[1] = Segment_2(p2, p3); - segments_p[2] = Segment_2(p3, p4); - segments_p[3] = Segment_2(p4, p1); - - segments_r[0] = Segment_2(r1, r2); - segments_r[1] = Segment_2(r2, r3); - segments_r[2] = Segment_2(r3, r4); - segments_r[3] = Segment_2(r4, r1); - - Point_2 q_point(4, 4); - - CGAL::insert(arr, &segments_p[0], &segments_p[4]); - CGAL::insert(arr1, &segments_r[0], &segments_r[2]); - - CGAL::Visibility_2::Simple_visibility_2 visibility(arr); + // First read arrangement + Arrangement_2 arr; + std::ifstream input("./data/simple_polygon_test_case_1.dat"); + CGAL::create_arrangement_from_input(arr, input); + CGAL::Visibility_2::Simple_visibility_2 visibility; + assert(false == (CGAL::test_is_attached >(visibility))); + visibility.attach(arr); assert(true == (CGAL::test_is_attached >(visibility))); visibility.detach(); assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); - assert(true == (CGAL::test_is_attached >(visibility))); - - assert(false == (CGAL::test_are_equal(arr, arr1))); - +// assert(false == (CGAL::test_are_equal(arr, visibility.arr()))); +} return 0; } \ No newline at end of file From 7626f79dea338f545dfd4dc3398440e3b428016a Mon Sep 17 00:00:00 2001 From: Francisc Date: Wed, 10 Jul 2013 17:24:10 +0300 Subject: [PATCH 34/66] completed first test case --- .../test/data/simple_polygon_test_case_1.in | 11 +++++++ .../test/data/simple_polygon_test_case_1.out | 10 ++++++ Visibility_2/test/include/CGAL/test_utils.h | 2 +- Visibility_2/test/test_simple_visibility.cpp | 32 +++++++++++++++++-- 4 files changed, 52 insertions(+), 3 deletions(-) create mode 100644 Visibility_2/test/data/simple_polygon_test_case_1.in create mode 100644 Visibility_2/test/data/simple_polygon_test_case_1.out diff --git a/Visibility_2/test/data/simple_polygon_test_case_1.in b/Visibility_2/test/data/simple_polygon_test_case_1.in new file mode 100644 index 00000000000..40a20cca857 --- /dev/null +++ b/Visibility_2/test/data/simple_polygon_test_case_1.in @@ -0,0 +1,11 @@ +4 +0 0 +8 0 +8 8 +0 8 +4 +0 1 +1 2 +2 3 +3 0 +4 4 \ No newline at end of file diff --git a/Visibility_2/test/data/simple_polygon_test_case_1.out b/Visibility_2/test/data/simple_polygon_test_case_1.out new file mode 100644 index 00000000000..068e55863cf --- /dev/null +++ b/Visibility_2/test/data/simple_polygon_test_case_1.out @@ -0,0 +1,10 @@ +4 +0 0 +8 0 +8 8 +0 8 +4 +0 1 +1 2 +2 3 +3 0 \ No newline at end of file diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index 1fcc80d9abf..24b06e9fd69 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -19,7 +19,7 @@ namespace CGAL { * from each arrangements, then it walks the edges and compares them */ template -bool test_are_equal(_Arrangement_2 &arr1, _Arrangement_2 &arr2) { +bool test_are_equal(const _Arrangement_2 &arr1, const _Arrangement_2 &arr2) { typedef _Arrangement_2 Arrangement_2; typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp index fe4ebb8a739..4e0af6158d0 100644 --- a/Visibility_2/test/test_simple_visibility.cpp +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -6,11 +6,13 @@ #include #include #include +#include #include #include #include #include #include +#include #include #include @@ -27,7 +29,7 @@ int main() { // First read arrangement Arrangement_2 arr; - std::ifstream input("./data/simple_polygon_test_case_1.dat"); + std::ifstream input("./data/simple_polygon_test_case_1.in"); CGAL::create_arrangement_from_input(arr, input); CGAL::Visibility_2::Simple_visibility_2 visibility; assert(false == (CGAL::test_is_attached >(visibility))); @@ -36,7 +38,33 @@ int main() { visibility.detach(); assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); -// assert(false == (CGAL::test_are_equal(arr, visibility.arr()))); + assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); + + // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases + assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); +} +{ + typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel; + typedef CGAL::Arr_segment_traits_2 Traits_2; + typedef Traits_2::Point_2 Point_2; + typedef Traits_2::X_monotone_curve_2 Segment_2; + typedef CGAL::Arrangement_2 Arrangement_2; + + // First read arrangement + Arrangement_2 arr; + std::ifstream input("./data/simple_polygon_test_case_1.in"); + CGAL::create_arrangement_from_input(arr, input); + CGAL::Visibility_2::Simple_visibility_2 visibility; + assert(false == (CGAL::test_is_attached >(visibility))); + visibility.attach(arr); + assert(true == (CGAL::test_is_attached >(visibility))); + visibility.detach(); + assert(false == (CGAL::test_is_attached >(visibility))); + visibility.attach(arr); + assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); + + // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases + assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); } return 0; } \ No newline at end of file From 6b76dcc0328efe86a91f8bce9d4f914b2b6ac6bc Mon Sep 17 00:00:00 2001 From: Francisc Date: Wed, 10 Jul 2013 17:25:33 +0300 Subject: [PATCH 35/66] deleted .dat file - no longer needed --- Visibility_2/test/data/simple_polygon_test_case_1.dat | 10 ---------- 1 file changed, 10 deletions(-) delete mode 100644 Visibility_2/test/data/simple_polygon_test_case_1.dat diff --git a/Visibility_2/test/data/simple_polygon_test_case_1.dat b/Visibility_2/test/data/simple_polygon_test_case_1.dat deleted file mode 100644 index 0fae69df1c3..00000000000 --- a/Visibility_2/test/data/simple_polygon_test_case_1.dat +++ /dev/null @@ -1,10 +0,0 @@ -4 -0 0 -8 0 -8 8 -0 8 -4 -0 1 -1 2 -2 3 -3 1 From 064e193fc78664737ecb1ca4ddf20ad49e78bf5a Mon Sep 17 00:00:00 2001 From: Francisc Date: Wed, 10 Jul 2013 17:26:22 +0300 Subject: [PATCH 36/66] added new header file for testing simple polygons --- .../test/include/CGAL/test_simple_polygons.h | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 Visibility_2/test/include/CGAL/test_simple_polygons.h diff --git a/Visibility_2/test/include/CGAL/test_simple_polygons.h b/Visibility_2/test/include/CGAL/test_simple_polygons.h new file mode 100644 index 00000000000..8288b367d81 --- /dev/null +++ b/Visibility_2/test/include/CGAL/test_simple_polygons.h @@ -0,0 +1,47 @@ +/* + * Author: Francisc Bungiu + * E-mail: fbungiu@gmail.com + */ + +#ifndef CGAL_TEST_SIMPLE_POLYGONS_H +#define CGAL_TEST_SIMPLE_POLYGONS_H + +namespace CGAL { + +template < class _Visibility_2, class _Arrangement_2 > +bool simple_polygon_test_case_1() { + + typedef _Visibility_2 Visibility_2; + typedef _Arrangement_2 Arrangement_2; + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + typedef typename Geometry_traits_2::Point_2 Point_2; + + Visibility_2 visibility; + + // First read arrangement + Arrangement_2 arr, out_arr, correct_out_arr; + std::ifstream input("./data/simple_polygon_test_case_1.in"); + CGAL::create_arrangement_from_input(arr, input); + + // Read query point from file + double x, y; + input >> x >> y; + Point_2 query_pt(x, y); + + std::ifstream correct_output("./data/simple_polygon_test_case_1.out"); + CGAL::create_arrangement_from_input(correct_out_arr, correct_output); + + typename Arrangement_2::Face_const_iterator fit; + + for (fit = arr.faces_begin(); fit != arr.faces_end(); ++fit) { + if (!fit->is_unbounded()) { + visibility.visibility_region(query_pt, fit, out_arr); + } + } + + return CGAL::test_are_equal(correct_out_arr, out_arr); +} + +} // end namespace CGAL + +#endif \ No newline at end of file From 447e39b548971655fad0cd4c2818d0243ba9c821 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Wed, 10 Jul 2013 20:01:48 -0400 Subject: [PATCH 37/66] improve functions to create arrangement from file --- Visibility_2/test/include/CGAL/test_utils.h | 120 +++++++++++++++++--- 1 file changed, 102 insertions(+), 18 deletions(-) diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index 24b06e9fd69..c15ea36c9f7 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -11,6 +11,10 @@ #include #include #include +#include +#include +#include + namespace CGAL { @@ -19,7 +23,7 @@ namespace CGAL { * from each arrangements, then it walks the edges and compares them */ template -bool test_are_equal(const _Arrangement_2 &arr1, const _Arrangement_2 &arr2) { +bool test_are_equal(_Arrangement_2 &arr1, _Arrangement_2 &arr2) { typedef _Arrangement_2 Arrangement_2; typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; @@ -107,31 +111,111 @@ bool test_are_equal(const _Arrangement_2 &arr1, const _Arrangement_2 &arr2) { return true; } -template -bool create_arrangement_from_input(_Arrangement_2 &arr, std::ifstream& input) { +template +Number_type string2num(const std::string& s) { + int i; + if (i = s.find('/')) { + std::string p = s.substr(0, i); + std::string q = s.substr(i+1); + std::stringstream convert(p); + int n, d; + convert >> n; + std::stringstream convert2(q); + convert2 >> d; + Number_type num(n, d); + return num; + } + else { + std::stringstream convert(s); + double n; + convert >> n; + Number_type num(n); + return num; + } +} + +template +void create_arrangement_from_input(_Arrangement_2 &arr, std::ifstream& input) { typedef _Arrangement_2 Arrangement_2; typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; typedef typename Geometry_traits_2::Segment_2 Segment_2; typedef typename Geometry_traits_2::Point_2 Point_2; + typedef typename Geometry_traits_2::FT Number_type; + if (input) { + std::string line; + while (std::getline(input, line)) { + if (line[0] != '#' && line[0] != '/') + break; + } + std::vector points; + std::vector segments; + std::stringstream convert(line); + int number_of_points; + convert >> number_of_points; - std::vector points; - std::vector segments; - int number_of_points; - input >> number_of_points; - for (int i = 0; i != number_of_points; i++) { - double x,y; - input >> x >> y; - points.push_back(Point_2(x, y)); + for (int i = 0; i != number_of_points; i++) { + std::getline(input, line); + std::string n1, n2; + std::istringstream iss(line); + iss>> n1 >> n2; + points.push_back(Point_2(string2num(n1), string2num(n2))); + } + int number_of_edges; + input >> number_of_edges; + for (int i = 0; i != number_of_edges; i++) { + unsigned i1,i2; + input >> i1 >> i2; + segments.push_back(Segment_2(points[i1], points[i2])); + } + CGAL::insert(arr, segments.begin(), segments.end()); } - int number_of_edges; - input >> number_of_edges; - for (int i = 0; i != number_of_edges; i++) { - unsigned i1,i2; - input >> i1 >> i2; - segments.push_back(Segment_2(points[i1], points[i2])); + else { + std::cout<<"Can't open the file. Check the file name."; } - CGAL::insert(arr, segments.begin(), segments.end()); +} + +template +void create_polygons_from_input(_Arrangement_2 &arr, std::ifstream& input) { + typedef _Arrangement_2 Arrangement_2; + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + typedef typename Geometry_traits_2::Segment_2 Segment_2; + typedef typename Geometry_traits_2::Point_2 Point_2; + typedef typename Geometry_traits_2::FT Number_type; + if (input) { + std::string line; + while (std::getline(input, line)) { + if (line[0] != '#' && line[0] != '/') + break; + } + std::stringstream convert(line); + int number_of_polygons; + convert >> number_of_polygons; + for (int i = 0; i != number_of_polygons; i++) { + std::vector points; + std::vector segments; + int number_of_vertex; + input >> number_of_vertex; + for (int j = 0; j != number_of_vertex-1; j++) { + std::getline(input, line); + std::string n1, n2; + std::istringstream iss(line); + iss >> n1 >> n2; + points.push_back(Point_2(string2num(n1), string2num(n2))); + } + for (int j = 0; j != number_of_vertex-1; j++) { + + segments.push_back(Segment_2(points[j], points[j+1])); + } + segments.push_back(Segment_2(points.front(), points.back())); + CGAL::insert(arr, segments.begin(), segments.end()); + } + + } + else { + std::cout<<"Can't open the file. Check the file name."; + } + } } // end namespace CGAL From abe5b6a1727a3101c0e147a0c3640e3e16d11557 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Wed, 10 Jul 2013 20:10:27 -0400 Subject: [PATCH 38/66] improve functions to create arrangement from file --- Visibility_2/test/include/CGAL/test_utils.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index c15ea36c9f7..929ab0421bb 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -136,7 +136,7 @@ Number_type string2num(const std::string& s) { } template -void create_arrangement_from_input(_Arrangement_2 &arr, std::ifstream& input) { +void create_arrangement_from_file(_Arrangement_2 &arr, std::ifstream& input) { typedef _Arrangement_2 Arrangement_2; typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; typedef typename Geometry_traits_2::Segment_2 Segment_2; @@ -176,7 +176,7 @@ void create_arrangement_from_input(_Arrangement_2 &arr, std::ifstream& input) { } template -void create_polygons_from_input(_Arrangement_2 &arr, std::ifstream& input) { +void create_polygons_from_file(_Arrangement_2 &arr, std::ifstream& input) { typedef _Arrangement_2 Arrangement_2; typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; typedef typename Geometry_traits_2::Segment_2 Segment_2; From ac2a27a17241afce894f3a6714e60e5eb6e863d7 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Thu, 11 Jul 2013 01:02:08 -0400 Subject: [PATCH 39/66] fix a bug in string2num() --- Visibility_2/test/include/CGAL/test_utils.h | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index 929ab0421bb..43370e52c8e 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -111,27 +111,28 @@ bool test_are_equal(_Arrangement_2 &arr1, _Arrangement_2 &arr2) { return true; } + + template Number_type string2num(const std::string& s) { int i; - if (i = s.find('/')) { + if (s.find("/") != std::string::npos) { + i = s.find("/"); std::string p = s.substr(0, i); std::string q = s.substr(i+1); std::stringstream convert(p); int n, d; convert >> n; std::stringstream convert2(q); - convert2 >> d; - Number_type num(n, d); - return num; + convert2 >> d; + return Number_type(n)/Number_type(d); } else { std::stringstream convert(s); double n; convert >> n; - Number_type num(n); - return num; + return Number_type(n); } } From 74ce50cd4b62ac611953792f7b07003b6795568c Mon Sep 17 00:00:00 2001 From: Francisc Date: Thu, 11 Jul 2013 14:12:35 +0300 Subject: [PATCH 40/66] added second test case and corrected bug --- .../include/CGAL/Simple_visibility_2.h | 86 ++++++++++++------- .../test/data/simple_polygon_test_case_1.in | 1 + .../test/include/CGAL/test_simple_polygons.h | 39 ++++++++- Visibility_2/test/test_simple_visibility.cpp | 6 +- 4 files changed, 95 insertions(+), 37 deletions(-) diff --git a/Visibility_2/include/CGAL/Simple_visibility_2.h b/Visibility_2/include/CGAL/Simple_visibility_2.h index e4d5ad91eaa..3ac9ea806a4 100644 --- a/Visibility_2/include/CGAL/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Simple_visibility_2.h @@ -22,7 +22,7 @@ public: typedef typename Arrangement_2::Face_const_handle Face_const_handle; typedef typename Geometry_traits_2::Point_2 Point_2; - typedef typename Geometry_traits_2::Vector_2 Vector_2; + typedef typename Geometry_traits_2::Ray_2 Ray_2; typedef typename Geometry_traits_2::Segment_2 Segment_2; Simple_visibility_2() : p_arr(NULL) {}; @@ -69,7 +69,7 @@ public: do { he = curr; Point_2 curr_vertex = he->target()->point(); - if (curr_vertex.x() < curr_min.x() && curr_vertex.x() > 0) { + if (curr_vertex.x() < curr_min.x() && (curr_vertex.x() > q.x())) { curr_min = curr_vertex; index_v0 = index; } @@ -93,8 +93,6 @@ public: } Point_2 w; -// Point_2 stored_q(q); -// q = Point_2(0, 0); if (orientation(q, vertices[0], vertices[1]) == CGAL::LEFT_TURN) { std::cout << "left" << std::endl; @@ -105,12 +103,13 @@ public: s.push(vertices[1]); } else { - std::cout << "right" << std::endl; + std::cout << "scana" << std::endl; upcase = SCANA; i = 1; w = vertices[1]; s.push(vertices[0]); } + int counter = 0; do { std::cout << "CASE: " << upcase << std::endl; switch(upcase) { @@ -169,16 +168,28 @@ public: } } std::cout << "gets out" << std::endl; + if (counter == 2) { + // exit(0); + } + counter++; } while(upcase != FINISH); std::cout << "RESULT: " << std::endl; - - while(!s.empty()) { - Point_2 curr_pt = s.top(); - Point_2 final_pt(curr_pt.x(), curr_pt.y()); - std::cout << final_pt << std::endl; + typename std::list segments; + if (!s.empty()) { + Point_2 prev_pt = s.top(); s.pop(); + while(!s.empty()) { + Point_2 curr_pt = s.top(); + segments.push_front(Segment_2(curr_pt, prev_pt)); + prev_pt = curr_pt; + s.pop(); + } } + for (typename std::list::iterator it = segments.begin(); it != segments.end(); it++) { + std::cout << it->source() << " " << it->target() << std::endl; + } + CGAL::insert(out_arr, segments.begin(), segments.end()); } void visibility_region(const Point_2 &q, @@ -194,8 +205,8 @@ protected: enum {LEFT, RIGHT, SCANA, SCANB, SCANC, SCAND, FINISH} upcase; bool do_overlap(const Point_2 &a, const Point_2 &b, const Point_2 &c) { - if (collinear(a, b, c)) { + std::cout << a << " " << b << " " << c << " are collinear" << std::endl; Segment_2 s1(a, b); Segment_2 s2(a, c); const Segment_2 *seg_overlap; @@ -303,42 +314,48 @@ protected: // Scan v_i, v_i+1, ..., v_n for the first edge to intersect (z, s_t) bool found = false; int k = i; - const Point_2 *ipoint; + Point_2 intersection_pt; while (k+1 < vertices.size()-1) { + std::cout << "Considering edge: " << vertices[k] << " " << vertices[k+1] << std::endl; Segment_2 s1(vertices[k], vertices[k+1]); - Segment_2 s2(query_pt, s.top()); + std::cout << "With edge: " << query_pt << " " << s.top() << std::endl; + Ray_2 s2(query_pt, s.top()); CGAL::Object result = intersection(s1, s2); - if (ipoint = CGAL::object_cast(&result)) { + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { found = true; + std::cout << " found edge!" << std::endl; + intersection_pt = *ipoint; + std::cout << intersection_pt << std::endl; break; } k++; } if (found) { if ((orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::RIGHT_TURN) - && (do_overlap(query_pt, s.top(), *ipoint))) { - + && (!do_overlap(query_pt, s.top(), intersection_pt))) { + std::cout << "if1" << std::endl; upcase = RIGHT; i = k+1; - w = *ipoint; + w = intersection_pt; } else if ((orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::RIGHT_TURN) - && (!do_overlap(query_pt, s.top(), *ipoint))) { - + && (do_overlap(query_pt, s.top(), intersection_pt))) { + std::cout << "elseif1" << std::endl; upcase = SCAND; i = k+1; - w = *ipoint; + w = intersection_pt; } else if ((orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::LEFT_TURN) - && (!do_overlap(query_pt, s.top(), *ipoint))) { - + && (do_overlap(query_pt, s.top(), intersection_pt))) { + std::cout << "elseif2" << std::endl; upcase = LEFT; i = k+1; - s.push(*ipoint); + s.push(intersection_pt); s.push(vertices[k+1]); w = vertices[k+1]; } else { + std::cout << "should never occur" << std::endl; // This case never occurs } } @@ -349,19 +366,20 @@ protected: Point_2 s_t = s.top(); int k = i; bool found = false; - const Point_2 *ipoint; + Point_2 intersection_pt; while (k+1 < vertices.size()-1) { Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(s_t, vertices[vertices.size()-1]); CGAL::Object result = intersection(s1, s2); - if (ipoint = CGAL::object_cast(&result)) { + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + intersection_pt = *ipoint; found = true; break; } k++; } if (found) { - if ((*ipoint == vertices[k+1]) && (*ipoint == vertices[vertices.size()-1])) { + if ((intersection_pt == vertices[k+1]) && (intersection_pt == vertices[vertices.size()-1])) { upcase = FINISH; w = vertices[vertices.size()-1]; s.push(vertices[vertices.size()-1]); @@ -369,7 +387,7 @@ protected: else { upcase = RIGHT; i = k+1; - w = *ipoint; + w = intersection_pt; } } } @@ -379,13 +397,14 @@ protected: Point_2 s_t = s.top(); int k = i; bool found = false; - const Point_2 *ipoint; + Point_2 intersection_pt; while (k+1 < vertices.size()-1) { Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(s_t, w); CGAL::Object result = intersection(s1, s2); - if (ipoint = CGAL::object_cast(&result)) { + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { found = true; + intersection_pt = *ipoint; break; } k++; @@ -393,7 +412,7 @@ protected: if (found) { upcase = RIGHT; i = k+1; - w = *ipoint; + w = intersection_pt; } } @@ -402,13 +421,14 @@ protected: Point_2 s_t = s.top(); int k = i; bool found = false; - const Point_2 *ipoint; + Point_2 intersection_pt; while (k+1 < vertices.size()-1) { Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(s_t, w); CGAL::Object result = intersection(s1, s2); - if (ipoint = CGAL::object_cast(&result)) { + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { found = true; + intersection_pt = *ipoint; break; } k++; @@ -416,7 +436,7 @@ protected: if (found) { upcase = LEFT; i = k+1; - s.push(*ipoint); + s.push(intersection_pt); s.push(vertices[k+1]); w = vertices[k+1]; } diff --git a/Visibility_2/test/data/simple_polygon_test_case_1.in b/Visibility_2/test/data/simple_polygon_test_case_1.in index 40a20cca857..26f74cedc8d 100644 --- a/Visibility_2/test/data/simple_polygon_test_case_1.in +++ b/Visibility_2/test/data/simple_polygon_test_case_1.in @@ -1,3 +1,4 @@ +# Test case 1 for simple polygons. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases 4 0 0 8 0 diff --git a/Visibility_2/test/include/CGAL/test_simple_polygons.h b/Visibility_2/test/include/CGAL/test_simple_polygons.h index 8288b367d81..af2eb2390e5 100644 --- a/Visibility_2/test/include/CGAL/test_simple_polygons.h +++ b/Visibility_2/test/include/CGAL/test_simple_polygons.h @@ -21,7 +21,7 @@ bool simple_polygon_test_case_1() { // First read arrangement Arrangement_2 arr, out_arr, correct_out_arr; std::ifstream input("./data/simple_polygon_test_case_1.in"); - CGAL::create_arrangement_from_input(arr, input); + CGAL::create_arrangement_from_file(arr, input); // Read query point from file double x, y; @@ -29,7 +29,7 @@ bool simple_polygon_test_case_1() { Point_2 query_pt(x, y); std::ifstream correct_output("./data/simple_polygon_test_case_1.out"); - CGAL::create_arrangement_from_input(correct_out_arr, correct_output); + CGAL::create_arrangement_from_file(correct_out_arr, correct_output); typename Arrangement_2::Face_const_iterator fit; @@ -42,6 +42,41 @@ bool simple_polygon_test_case_1() { return CGAL::test_are_equal(correct_out_arr, out_arr); } +template < class _Visibility_2, class _Arrangement_2 > +bool simple_polygon_test_case_2() { + + typedef _Visibility_2 Visibility_2; + typedef _Arrangement_2 Arrangement_2; + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + typedef typename Geometry_traits_2::Point_2 Point_2; + + Visibility_2 visibility; + + // First read arrangement + Arrangement_2 arr, out_arr, correct_out_arr; + std::ifstream input("./data/simple_polygon_test_case_2.in"); + CGAL::create_arrangement_from_file(arr, input); + + // Read query point from file + double x, y; + input >> x >> y; + Point_2 query_pt(x, y); + + std::ifstream correct_output("./data/simple_polygon_test_case_2.out"); + CGAL::create_arrangement_from_file(correct_out_arr, correct_output); + + typename Arrangement_2::Face_const_iterator fit; + + for (fit = arr.faces_begin(); fit != arr.faces_end(); ++fit) { + if (!fit->is_unbounded()) { + visibility.visibility_region(query_pt, fit, out_arr); + } + } + + return CGAL::test_are_equal(correct_out_arr, out_arr); + +} + } // end namespace CGAL #endif \ No newline at end of file diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp index 4e0af6158d0..b4e513c0f6f 100644 --- a/Visibility_2/test/test_simple_visibility.cpp +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -30,7 +30,7 @@ int main() { // First read arrangement Arrangement_2 arr; std::ifstream input("./data/simple_polygon_test_case_1.in"); - CGAL::create_arrangement_from_input(arr, input); + CGAL::create_arrangement_from_file(arr, input); CGAL::Visibility_2::Simple_visibility_2 visibility; assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); @@ -42,6 +42,7 @@ int main() { // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); } { typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel; @@ -53,7 +54,7 @@ int main() { // First read arrangement Arrangement_2 arr; std::ifstream input("./data/simple_polygon_test_case_1.in"); - CGAL::create_arrangement_from_input(arr, input); + CGAL::create_arrangement_from_file(arr, input); CGAL::Visibility_2::Simple_visibility_2 visibility; assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); @@ -65,6 +66,7 @@ int main() { // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); } return 0; } \ No newline at end of file From 35bcb9f528ef6f7f585459ba1e69b3ff4672853f Mon Sep 17 00:00:00 2001 From: Francisc Date: Thu, 11 Jul 2013 14:13:08 +0300 Subject: [PATCH 41/66] added test case 2 data files --- Visibility_2/test/data/simple_polygon_test_case_2.in | 12 ++++++++++++ .../test/data/simple_polygon_test_case_2.out | 10 ++++++++++ 2 files changed, 22 insertions(+) create mode 100644 Visibility_2/test/data/simple_polygon_test_case_2.in create mode 100644 Visibility_2/test/data/simple_polygon_test_case_2.out diff --git a/Visibility_2/test/data/simple_polygon_test_case_2.in b/Visibility_2/test/data/simple_polygon_test_case_2.in new file mode 100644 index 00000000000..726d765637a --- /dev/null +++ b/Visibility_2/test/data/simple_polygon_test_case_2.in @@ -0,0 +1,12 @@ +# Test case 2 for simple polygons. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +4 +0 0 +4 4 +8 4 +0 8 +4 +0 1 +1 2 +2 3 +3 0 +1 3 \ No newline at end of file diff --git a/Visibility_2/test/data/simple_polygon_test_case_2.out b/Visibility_2/test/data/simple_polygon_test_case_2.out new file mode 100644 index 00000000000..f725e56ccff --- /dev/null +++ b/Visibility_2/test/data/simple_polygon_test_case_2.out @@ -0,0 +1,10 @@ +4 +0 0 +4 4 +32/5 24/5 +0 8 +4 +0 1 +1 2 +2 3 +3 0 \ No newline at end of file From c2e3d1dd16243826e44fdbba247b9699d0b19a05 Mon Sep 17 00:00:00 2001 From: Francisc Date: Thu, 11 Jul 2013 14:14:52 +0300 Subject: [PATCH 42/66] added const to arguments in test_are_equal --- Visibility_2/test/include/CGAL/test_utils.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index 43370e52c8e..394a6bd2ba9 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -23,7 +23,7 @@ namespace CGAL { * from each arrangements, then it walks the edges and compares them */ template -bool test_are_equal(_Arrangement_2 &arr1, _Arrangement_2 &arr2) { +bool test_are_equal(const _Arrangement_2 &arr1, const _Arrangement_2 &arr2) { typedef _Arrangement_2 Arrangement_2; typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; From 4d4937ae75a83768b41dfe7f2567e822c80e8139 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Fri, 12 Jul 2013 22:54:24 -0400 Subject: [PATCH 43/66] add test input files --- Visibility_2/test/data/Arrangement_Test/in1 | 17 +++++++++ Visibility_2/test/data/Arrangement_Test/in2 | 29 +++++++++++++++ Visibility_2/test/data/Arrangement_Test/in3 | 19 ++++++++++ Visibility_2/test/data/Arrangement_Test/in4 | 40 +++++++++++++++++++++ Visibility_2/test/data/Arrangement_Test/in5 | 35 ++++++++++++++++++ 5 files changed, 140 insertions(+) create mode 100644 Visibility_2/test/data/Arrangement_Test/in1 create mode 100644 Visibility_2/test/data/Arrangement_Test/in2 create mode 100644 Visibility_2/test/data/Arrangement_Test/in3 create mode 100644 Visibility_2/test/data/Arrangement_Test/in4 create mode 100644 Visibility_2/test/data/Arrangement_Test/in5 diff --git a/Visibility_2/test/data/Arrangement_Test/in1 b/Visibility_2/test/data/Arrangement_Test/in1 new file mode 100644 index 00000000000..2700fe53598 --- /dev/null +++ b/Visibility_2/test/data/Arrangement_Test/in1 @@ -0,0 +1,17 @@ +# Test case 1 for arbitrary arrangement. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +8 +2 0 +4 0 +6 0 +8 0 +-10 10 +10 10 +10 -10 +-10 -10 +6 +0 1 +2 3 +4 5 +5 6 +6 7 +7 4 diff --git a/Visibility_2/test/data/Arrangement_Test/in2 b/Visibility_2/test/data/Arrangement_Test/in2 new file mode 100644 index 00000000000..69304687bd6 --- /dev/null +++ b/Visibility_2/test/data/Arrangement_Test/in2 @@ -0,0 +1,29 @@ +# Test case 2 for arbitrary arrangement. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +16 +2 2 +2 0 +5 1 +5 0 +8 1 +8 0 +3 -1 +3 -3 +6 -2 +6 -3 +7 0 +7 -2 +-10 10 +10 10 +10 -10 +-10 -10 +10 +0 1 +2 3 +4 5 +6 7 +8 9 +10 11 +12 13 +13 14 +14 15 +15 12 diff --git a/Visibility_2/test/data/Arrangement_Test/in3 b/Visibility_2/test/data/Arrangement_Test/in3 new file mode 100644 index 00000000000..39dd279c79b --- /dev/null +++ b/Visibility_2/test/data/Arrangement_Test/in3 @@ -0,0 +1,19 @@ +# Test case 2 for arbitrary arrangement. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +8 +-1 4 +3 0 +6 4 +6 0 +5 0 +5 -4 +1 0 +-1 -4 +8 +0 1 +1 2 +2 3 +3 4 +4 5 +5 6 +6 7 +7 0 diff --git a/Visibility_2/test/data/Arrangement_Test/in4 b/Visibility_2/test/data/Arrangement_Test/in4 new file mode 100644 index 00000000000..6b68c501674 --- /dev/null +++ b/Visibility_2/test/data/Arrangement_Test/in4 @@ -0,0 +1,40 @@ +# Test case 4 for arbitrary arrangement. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +19 +-1 3 +0 3 +0 2 +3 3 +1 1 +3 0 +4 0 +5 0 +4 -1 +7 0 +7 -4 +2 -4 +1 -2 +2 0 +-1 -4 +-10 10 +10 10 +10 -10 +-10 -10 +18 +0 1 +1 2 +1 3 +3 4 +3 5 +5 6 +7 8 +7 9 +9 10 +10 11 +11 12 +12 13 +11 14 +14 0 +15 16 +16 17 +17 18 +18 15 diff --git a/Visibility_2/test/data/Arrangement_Test/in5 b/Visibility_2/test/data/Arrangement_Test/in5 new file mode 100644 index 00000000000..5e26ca7b6a7 --- /dev/null +++ b/Visibility_2/test/data/Arrangement_Test/in5 @@ -0,0 +1,35 @@ +# Test case 5 for arbitrary arrangement. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +17 +5 2 +7 2 +2 1 +1 0 +2 0 +3 0 +5 0 +6 0 +7 0 +1 -2 +2 -2 +3 -2 +4 -2 +-10 10 +10 10 +10 -10 +-10 -10 +15 +0 7 +1 7 +2 3 +4 5 +6 7 +7 8 +9 4 +10 4 +11 4 +12 5 +12 6 +13 14 +14 15 +15 16 +16 13 From 52fad87853e790f79343d625d5f3b173336b3ba4 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Sat, 13 Jul 2013 16:38:10 -0400 Subject: [PATCH 44/66] Add test data and clean up doc 1. add non-regularized visibility output files to test/data 2. add a Out_face_handle parameter into visibility_region function to save the face of visibility polygon --- .../Visibility_2/CGAL/Naive_visibility_2.h | 10 ++- .../doc/Visibility_2/Concepts/Visibility_2.h | 20 +++-- .../data/Arrangement_Test/non_regular_out1 | 20 +++++ .../data/Arrangement_Test/non_regular_out2 | 35 ++++++++ .../data/Arrangement_Test/non_regular_out3 | 15 ++++ .../data/Arrangement_Test/non_regular_out4 | 29 +++++++ .../data/Arrangement_Test/non_regular_out5 | 26 ++++++ Visibility_2/test/data/arr1 | 8 -- Visibility_2/test/include/CGAL/test_utils.h | 4 +- Visibility_2/test/test_Naive_visibility.cpp | 86 +++++++++++++++++++ 10 files changed, 233 insertions(+), 20 deletions(-) create mode 100644 Visibility_2/test/data/Arrangement_Test/non_regular_out1 create mode 100644 Visibility_2/test/data/Arrangement_Test/non_regular_out2 create mode 100644 Visibility_2/test/data/Arrangement_Test/non_regular_out3 create mode 100644 Visibility_2/test/data/Arrangement_Test/non_regular_out4 create mode 100644 Visibility_2/test/data/Arrangement_Test/non_regular_out5 delete mode 100644 Visibility_2/test/data/arr1 create mode 100644 Visibility_2/test/test_Naive_visibility.cpp diff --git a/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h index 7a0f1de8cf4..7a0a1845ebe 100644 --- a/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h +++ b/Visibility_2/doc/Visibility_2/CGAL/Naive_visibility_2.h @@ -54,6 +54,10 @@ public: Halfedge_handle type of input Arrangement. */ typedef Input_Arrangement_2::Halfedge_handle Halfedge_handle; + /*! + * Face_handle type of output Arrangement. + */ + typedef Output_Arrangement_2::Face_handle Out_face_handle; /// @} @@ -100,7 +104,7 @@ Computes the visibility region for the given query point q. \pre out_arr is the output arrangement */ - void visibility_region(const Point_2& q, const Face_handle& face, Output_Arrangement_2& out_arr); + void visibility_region(const Point_2& q, const Face_handle& face, Output_Arrangement_2& out_arr, Out_face_handle& out_face); /*! Computes for the given query point q the visibility region that is on the side of the given halfedge. @@ -109,7 +113,7 @@ Computes for the given query point q the visibility region that is on the side o \pre out_arr is the output arrangement */ - void visibility_region(const Point_2& q, const Halfedge_handle& halfedge, Output_Arrangement_2& out_arr); + void visibility_region(const Point_2& q, const Halfedge_handle& halfedge, Output_Arrangement_2& out_arr, Out_face_handle& out_face); /// @} @@ -117,4 +121,4 @@ Computes for the given query point q the visibility region that is on the side o }; /* end Visibility_2 */ -} \ No newline at end of file +} diff --git a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h index 612c8620478..ba8b571de6c 100644 --- a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h +++ b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h @@ -34,17 +34,23 @@ public: /*! The supported Point_2 type of the input type, used for queries. */ - typedef Hidden_type Input_Arrangement_2::Point_2; + typedef Input_Arrangement_2::Point_2 Point_2; /*! * The supported Face handle type of the input Arrangement. */ - typedef Hidden_type Input_Arrangement_2::Face_handle; + typedef Input_Arrangement_2::Face_handle Face_handle; /*! * The supported Halfedge handle type of the input Arrangement. */ - typedef Hidden_type Input_Arrangement_2::Halfedge_handle; + typedef Input_Arrangement_2::Halfedge_handle Halfedge_handle; + /*! + * The supported Face_handle type of output Arrangement. + */ + typedef Output_Arrangement_2::Face_handle Out_face_handle; + + /*! Tag identifying whether `Visibility_2` computes regularized visbility area. @@ -99,20 +105,20 @@ Access to the attached Arrangement_2. Input_Arrangement_2 arr(); /*! -Computes the visibility region for the given query point q. +Computes the visibility region for the given query point q. Visibility polygon of q and its face will be saved to out_arr and out_face. \pre face is a face of this->arr() \pre p is in the interior of face */ - void visibility_region(const Point_2& q, const Face_handle& face, Output_Arrangement_2& out_arr); + void visibility_region(const Point_2& q, const Face_handle& face, Output_Arrangement_2& out_arr, const Out_face_handle& out_face); /*! -Computes for the given query point q the visibility region that is on the side of the given halfedge. +Computes for the given query point q the visibility region that is on the side of the given halfedge. Visibility polygon of q and its face will be saved to out_arr and out_face. \pre half_edge is a half edge of this->arr() \pre p is on halfedge */ - void visibility_region(const Point_2& q, const Halfedge_handle& halfedge, Output_Arrangement_2& out_arr); + void visibility_region(const Point_2& q, const Halfedge_handle& halfedge, Output_Arrangement_2& out_arr, const Out_face_handle& out_face); /// @} diff --git a/Visibility_2/test/data/Arrangement_Test/non_regular_out1 b/Visibility_2/test/data/Arrangement_Test/non_regular_out1 new file mode 100644 index 00000000000..9652c0f85ea --- /dev/null +++ b/Visibility_2/test/data/Arrangement_Test/non_regular_out1 @@ -0,0 +1,20 @@ +9 +2 0 +4 0 +6 0 +8 0 +10 0 +10 10 +-10 10 +-10 -10 +10 -10 +9 +0 1 +1 2 +2 3 +3 4 +4 5 +5 6 +6 7 +7 8 +8 4 \ No newline at end of file diff --git a/Visibility_2/test/data/Arrangement_Test/non_regular_out2 b/Visibility_2/test/data/Arrangement_Test/non_regular_out2 new file mode 100644 index 00000000000..1e99dfa0792 --- /dev/null +++ b/Visibility_2/test/data/Arrangement_Test/non_regular_out2 @@ -0,0 +1,35 @@ +# Non-regularized visibility result of Test case 2 for arbitrary arrangement. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +16 +10 10 +2 2 +2 0 +5 0 +7 0 +8 0 +10 0 +7 -2 +10 -20/7 +3 -1 +6 -2 +10 -10/3 +3 -3 +10 -10 +-10 -10 +-10 10 +16 +1 0 +1 2 +2 3 +3 4 +4 5 +5 6 +4 7 +7 8 +8 11 +9 10 +10 11 +9 12 +12 13 +13 14 +14 15 +15 0 diff --git a/Visibility_2/test/data/Arrangement_Test/non_regular_out3 b/Visibility_2/test/data/Arrangement_Test/non_regular_out3 new file mode 100644 index 00000000000..cdd4288c369 --- /dev/null +++ b/Visibility_2/test/data/Arrangement_Test/non_regular_out3 @@ -0,0 +1,15 @@ +# Non-regularized visibility result of Test case 3 for arbitrary arrangement. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +6 +-1 4 +-1 -4 +1 0 +3 0 +5 0 +6 0 +6 +0 1 +1 2 +2 3 +3 4 +4 5 +0 3 diff --git a/Visibility_2/test/data/Arrangement_Test/non_regular_out4 b/Visibility_2/test/data/Arrangement_Test/non_regular_out4 new file mode 100644 index 00000000000..a4b6e2671d1 --- /dev/null +++ b/Visibility_2/test/data/Arrangement_Test/non_regular_out4 @@ -0,0 +1,29 @@ +# Non-regularized visibility result of Test case 4 for arbitrary arrangement. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +12 +0 2 +0 3 +-1 3 +-1 -4 +2 -4 +1 -2 +2 0 +3 0 +4 0 +5 0 +7 0 +10 0 +14 +0 1 +1 2 +2 3 +3 4 +4 5 +5 6 +6 7 +7 8 +8 9 +9 10 +10 11 +7 12 +12 13 +1 12 diff --git a/Visibility_2/test/data/Arrangement_Test/non_regular_out5 b/Visibility_2/test/data/Arrangement_Test/non_regular_out5 new file mode 100644 index 00000000000..2d97d1a932b --- /dev/null +++ b/Visibility_2/test/data/Arrangement_Test/non_regular_out5 @@ -0,0 +1,26 @@ +12 +1 0 +2 0 +3 0 +5 0 +6 0 +1 -2 +5 -10 +-10 -10 +-10 10 +10 10 +10 5 +2 1 +12 +0 1 +1 2 +2 3 +3 4 +1 5 +5 6 +6 7 +7 8 +8 9 +9 10 +10 11 +11 0 \ No newline at end of file diff --git a/Visibility_2/test/data/arr1 b/Visibility_2/test/data/arr1 deleted file mode 100644 index 03555aea7f1..00000000000 --- a/Visibility_2/test/data/arr1 +++ /dev/null @@ -1,8 +0,0 @@ -4 -2 0 -4 0 -6 0 -8 0 -2 -0 1 -2 3 diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index 394a6bd2ba9..33f151cfdcc 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -1,6 +1,6 @@ /* - * Author: Francisc Bungiu - * E-mail: fbungiu@gmail.com + * Author: Francisc Bungiu, Kan Huang + * E-mail: fbungiu@gmail.com, huangkandiy@gmail.com * Description: This file contains useful functions for testing the * Visibility_2 package, such as comparing two Arrangements */ diff --git a/Visibility_2/test/test_Naive_visibility.cpp b/Visibility_2/test/test_Naive_visibility.cpp new file mode 100644 index 00000000000..14f0ded69e2 --- /dev/null +++ b/Visibility_2/test/test_Naive_visibility.cpp @@ -0,0 +1,86 @@ +/* + * Author: Kan Huang + * E-mail: huangkandiy@gmail.com + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include +#include +#include + +int main() { +{ + typedef CGAL::Gmpq Number_type; + typedef CGAL::Cartesian Kernel; + typedef CGAL::Arr_segment_traits_2 Traits_2; + typedef Traits_2::Point_2 Point_2; + typedef Traits_2::X_monotone_curve_2 Segment_2; + typedef CGAL::Arrangement_2 Arrangement_2; + + + + std::cout<<"Kernel Cartesian"<(arr_in, input); + CGAL::create_arrangement_from_file(arr_out, ans_input); + + CGAL::Visibility_2::Naive_visibility_2 visibility; + + + } + + + assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); + + + // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases + assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); + + + typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel_b; + typedef CGAL::Arr_segment_traits_2 Traits_2_b; + typedef Traits_2::Point_2 Point_2_b; + typedef Traits_2::X_monotone_curve_2 Segment_2_b; + typedef CGAL::Arrangement_2 Arrangement_2_b; + + + // First read arrangement + Arrangement_2 arr; + + + std::ifstream input("./data/simple_polygon_test_case_1.in"); + CGAL::create_arrangement_from_file(arr, input); + + assert(false == (CGAL::test_is_attached >(visibility))); + visibility.attach(arr); + assert(true == (CGAL::test_is_attached >(visibility))); + visibility.detach(); + assert(false == (CGAL::test_is_attached >(visibility))); + visibility.attach(arr); + assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); + + // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases + assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); + + return 0; +} From 5afd53d4a0371145393055387f61919c62b8659e Mon Sep 17 00:00:00 2001 From: kanhuang Date: Sun, 14 Jul 2013 15:04:24 -0400 Subject: [PATCH 45/66] test_naive_visibility --- .../include/CGAL/Naive_visibility_2.h | 71 +++++++++------ Visibility_2/test/test_Naive_visibility.cpp | 86 ------------------- Visibility_2/test/test_naive_visibility.cpp | 76 ++++++++++++++++ 3 files changed, 121 insertions(+), 112 deletions(-) delete mode 100644 Visibility_2/test/test_Naive_visibility.cpp create mode 100644 Visibility_2/test/test_naive_visibility.cpp diff --git a/Visibility_2/include/CGAL/Naive_visibility_2.h b/Visibility_2/include/CGAL/Naive_visibility_2.h index 34403028c9d..d48afdc4b2a 100644 --- a/Visibility_2/include/CGAL/Naive_visibility_2.h +++ b/Visibility_2/include/CGAL/Naive_visibility_2.h @@ -11,9 +11,9 @@ #include #include -//namespace CGAL { +namespace CGAL { -//namespace Visibility_2 { +namespace Visibility_2 { //debug template @@ -23,6 +23,11 @@ void print(std::vector ps){ std::cout<point().x()<<","<point().y()< +void print_point(const Point_2& p) { + std::cout<<"["< class Naive_visibility_2 { @@ -237,7 +242,7 @@ public: } } else { - Point_2 right_p, left_p, mid_p, furthest_p; + Point_2 right_p, left_p, mid_p; begin_it = vit; end_it = vit; //all vertices between begin_it and end_it(not included) are collinear with query point. curr_vision_ray= Ray_2(query, (*begin_it)->point()); @@ -250,8 +255,8 @@ public: add_edges(begin_it, end_it, active_edges, curr_vision_ray); mid_p = intersection_point(curr_vision_ray, active_edges[0]); - - Intersection_type i_type = needle(active_edges, curr_vision_ray, furthest_p); + std::vector collinear_vertices; + Intersection_type i_type = needle(active_edges, curr_vision_ray, collinear_vertices); switch (i_type) { case UNBOUNDED : //remove right and collinear; @@ -269,20 +274,21 @@ public: remove_edges(active_edges, curr_vision_ray); left_p = intersection_point(curr_vision_ray, active_edges[0]); update_visibility(right_p, polygon, out_arr); - update_visibility(furthest_p, polygon, out_arr); - update_visibility(mid_p, polygon, out_arr); + + update_visibility(collinear_vertices, polygon, out_arr); +// update_visibility(mid_p, polygon, out_arr); update_visibility(left_p, polygon, out_arr); break; case INNER : //remove right and collinear; remove_edges(active_edges, curr_vision_ray); - if (mid_p == furthest_p) { + if (collinear_vertices.size() < 2) { //this means mid_p = left_p = right_p = furthest_p. no new vertex is found. } else { left_p = intersection_point(curr_vision_ray, active_edges[0]); update_visibility(right_p, polygon, out_arr); - update_visibility(mid_p, polygon, out_arr); + update_visibility(collinear_vertices, polygon, out_arr); update_visibility(left_p, polygon, out_arr); } break; @@ -291,7 +297,7 @@ public: vit = end_it; } if (!is_init_empty) { - CGAL::insert_curve(out_arr, Segment_2(polygon.front(), polygon.back())); + CGAL::insert_curve(out_arr, Segment_2(polygon.front(),polygon.back())); } } @@ -481,7 +487,7 @@ private: //insert new vertice to polygon. before insertion, check if this vertice has been added before. - void update_visibility(const Point_2 p, std::vector &polygon, Arrangement_2& arr){ + void update_visibility(const Point_2 p, std::vector& polygon, Arrangement_2& arr){ if (polygon.empty()) polygon.push_back(p); else @@ -493,6 +499,13 @@ private: } } + void update_visibility(const std::vector& points, std::vector& polygon, Arrangement_2 &arr){ + for (int i = 0; i != points.size(); i++) { + update_visibility(points[i], polygon, arr); + } + } + + //add a new edge when vision ray passes a vertex void add_edge(Vertex_const_handle vh, std::vector& edges, @@ -519,7 +532,7 @@ private: //debug std::cout<<"after adding"<& edges, Ray_2& r, Point_2& furthest_p, std::vector& collinear_vertices) { + //return the type of the needle. + //the vertices on the needle will be saved in collinear_vertices. + Intersection_type needle(std::vector& edges, Ray_2& r, std::vector& collinear_vertices) { typename std::vector::iterator curr = edges.begin(); - Point_2 p = r.source(), end1, end2; - Vertex_const_handle vision_v, vertex1, vertex2; +// Point_2 p = r.source(), end1, end2; + Vertex_const_handle vertex1, vertex2; //flag shows whether the left side or right side of needle is blocked. bool block_left, block_right; do { Point_2 cross = intersection_point(r, *curr); - if (cross != (*curr)->source()->point() && cross != (*curr)->target()->point()) + print_point(cross); + if (cross != (*curr)->source()->point() && cross != (*curr)->target()->point()) { + collinear_vertices.push_back(cross); return INNER; + } if (cross == (*curr)->source()->point()) { vertex1 = (*curr)->source(); vertex2 = (*curr)->target(); @@ -576,15 +591,15 @@ private: vertex1 = (*curr)->target(); vertex2 = (*curr)->source(); } - if (collinear_vertices.empty() || vertex1 != collinear_vertices.back()) { - collinear_vertices.push_back(vertex1); + if (collinear_vertices.empty() || vertex1->point() != collinear_vertices.back()) { + collinear_vertices.push_back(vertex1->point()); //flag shows whether the left side or right side of current vertex is blocked. //has_predecessor indicates whether this vertex is incident to an edge whose another end is between the source of ray and it, //because that will effect the value of block_left, block_right. bool left_v(false), right_v(false), has_predecessor(false); typename Arrangement_2::Halfedge_around_vertex_const_circulator first_edge, curr_edge; - first_edge = curr_edge = vh->incident_halfedges(); + first_edge = curr_edge = vertex1->incident_halfedges(); do { switch (CGAL::orientation(r.source(), curr_edge->target()->point(), curr_edge->source()->point())) { case CGAL::RIGHT_TURN : @@ -616,7 +631,7 @@ private: return UNBOUNDED; } //debug - void print_active(std::vector& edges){ + void print_edges(std::vector& edges){ for (int i = 0; i != edges.size(); i++) { Point_2 p1, p2; p1 = edges[i]->source()->point(); @@ -699,8 +714,12 @@ void print_arrangement(const Arrangement_2 &arr) { std::cout << "[" << eit->curve() << "]" << std::endl; } -//} // namespace Visibility_2 -//} // namespace CGAL + + +} // namespace Visibility_2 +} // namespace CGAL + + #endif diff --git a/Visibility_2/test/test_Naive_visibility.cpp b/Visibility_2/test/test_Naive_visibility.cpp deleted file mode 100644 index 14f0ded69e2..00000000000 --- a/Visibility_2/test/test_Naive_visibility.cpp +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Author: Kan Huang - * E-mail: huangkandiy@gmail.com - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - - - -#include -#include -#include - -int main() { -{ - typedef CGAL::Gmpq Number_type; - typedef CGAL::Cartesian Kernel; - typedef CGAL::Arr_segment_traits_2 Traits_2; - typedef Traits_2::Point_2 Point_2; - typedef Traits_2::X_monotone_curve_2 Segment_2; - typedef CGAL::Arrangement_2 Arrangement_2; - - - - std::cout<<"Kernel Cartesian"<(arr_in, input); - CGAL::create_arrangement_from_file(arr_out, ans_input); - - CGAL::Visibility_2::Naive_visibility_2 visibility; - - - } - - - assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); - - - // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases - assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); - assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); - - - typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel_b; - typedef CGAL::Arr_segment_traits_2 Traits_2_b; - typedef Traits_2::Point_2 Point_2_b; - typedef Traits_2::X_monotone_curve_2 Segment_2_b; - typedef CGAL::Arrangement_2 Arrangement_2_b; - - - // First read arrangement - Arrangement_2 arr; - - - std::ifstream input("./data/simple_polygon_test_case_1.in"); - CGAL::create_arrangement_from_file(arr, input); - - assert(false == (CGAL::test_is_attached >(visibility))); - visibility.attach(arr); - assert(true == (CGAL::test_is_attached >(visibility))); - visibility.detach(); - assert(false == (CGAL::test_is_attached >(visibility))); - visibility.attach(arr); - assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); - - // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases - assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); - assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); - - return 0; -} diff --git a/Visibility_2/test/test_naive_visibility.cpp b/Visibility_2/test/test_naive_visibility.cpp new file mode 100644 index 00000000000..011d3220484 --- /dev/null +++ b/Visibility_2/test/test_naive_visibility.cpp @@ -0,0 +1,76 @@ +/* + * Author: Kan Huang + * E-mail: huangkandiy@gmail.com + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include +#include +#include + +int main() { + int case_number = 5; + //test kernel Cartesian + { + typedef CGAL::Gmpq Number_type; + typedef CGAL::Cartesian Kernel; + typedef CGAL::Arr_segment_traits_2 Traits_2; + typedef Traits_2::Point_2 Point_2; + typedef Traits_2::X_monotone_curve_2 Segment_2; + typedef CGAL::Arrangement_2 Arrangement_2; + + std::cout<<"Kernel: Cartesian"<(arr_in, input); + CGAL::create_arrangement_from_file(arr_out, ans_input); + + CGAL::Visibility_2::Naive_visibility_2 vb(arr_in); + vb.visibility_region(Point_2(0, 0), face, arr_vb); + assert(true == (CGAL::test_are_equal(arr_out, arr_vb))); + } + } + //test kernel Exact_predicates_exact_constructions_kernel + { + typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel; + typedef CGAL::Arr_segment_traits_2 Traits_2; + typedef Traits_2::Point_2 Point_2; + typedef Traits_2::X_monotone_curve_2 Segment_2; + typedef CGAL::Arrangement_2 Arrangement_2; + + std::cout<<"Kernel: Exact_predicates_exact_constructions"<(arr_in, input); + CGAL::create_arrangement_from_file(arr_out, ans_input); + + CGAL::Visibility_2::Naive_visibility_2 vb(arr_in); + vb.visibility_region(Point_2(0, 0), face, arr_vb); + assert(true == (CGAL::test_are_equal(arr_out, arr_vb))); + } + } + return 0; +} From 852d42fb8d4632d15131737284d727a3c041fb35 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Sun, 14 Jul 2013 21:40:34 -0400 Subject: [PATCH 46/66] fix bugs in test_naive_visibility.cpp --- Visibility_2/test/test_naive_visibility.cpp | 26 +++++++-------------- 1 file changed, 8 insertions(+), 18 deletions(-) diff --git a/Visibility_2/test/test_naive_visibility.cpp b/Visibility_2/test/test_naive_visibility.cpp index 011d3220484..24b4d81d4ea 100644 --- a/Visibility_2/test/test_naive_visibility.cpp +++ b/Visibility_2/test/test_naive_visibility.cpp @@ -34,10 +34,14 @@ int main() { for (int i=1; i <= case_number; i++) { std::cout<<"Test "<> input_arr_file; + std::stringstream ss2("data/Arrangement_Test/non_regular_out"); + ss2 << i; + ss2 >> ans_file; + std::ifstream input(input_arr_file.c_str()); + std::ifstream ans_input(ans_file.c_str()); Arrangement_2 arr_in, arr_out, arr_vb; CGAL::create_arrangement_from_file(arr_in, input); CGAL::create_arrangement_from_file(arr_out, ans_input); @@ -56,21 +60,7 @@ int main() { typedef CGAL::Arrangement_2 Arrangement_2; std::cout<<"Kernel: Exact_predicates_exact_constructions"<(arr_in, input); - CGAL::create_arrangement_from_file(arr_out, ans_input); - CGAL::Visibility_2::Naive_visibility_2 vb(arr_in); - vb.visibility_region(Point_2(0, 0), face, arr_vb); - assert(true == (CGAL::test_are_equal(arr_out, arr_vb))); - } } return 0; } From 1888cfc93dbdccc51f0d8e7f5e5bebc6474a27f2 Mon Sep 17 00:00:00 2001 From: Francisc Date: Mon, 15 Jul 2013 19:22:09 +0300 Subject: [PATCH 47/66] testing progress --- .../include/CGAL/Simple_visibility_2.h | 245 ++++++++++++------ .../test/data/simple_polygon_test_case_3.in | 20 ++ .../test/data/simple_polygon_test_case_3.out | 17 ++ .../test/data/simple_polygon_test_case_4.in | 20 ++ .../test/data/simple_polygon_test_case_4.out | 19 ++ .../test/include/CGAL/test_simple_polygons.h | 109 +++++--- Visibility_2/test/test_simple_visibility.cpp | 15 +- 7 files changed, 319 insertions(+), 126 deletions(-) create mode 100644 Visibility_2/test/data/simple_polygon_test_case_3.in create mode 100644 Visibility_2/test/data/simple_polygon_test_case_3.out create mode 100644 Visibility_2/test/data/simple_polygon_test_case_4.in create mode 100644 Visibility_2/test/data/simple_polygon_test_case_4.out diff --git a/Visibility_2/include/CGAL/Simple_visibility_2.h b/Visibility_2/include/CGAL/Simple_visibility_2.h index 3ac9ea806a4..e2a6ae165b0 100644 --- a/Visibility_2/include/CGAL/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Simple_visibility_2.h @@ -51,15 +51,10 @@ public: Output_Arrangement_2 &out_arr ) { - int i = 0; - bool ccw = false; - typename Input_Arrangement_2::Ccb_halfedge_const_circulator circ = face->outer_ccb(); typename Input_Arrangement_2::Ccb_halfedge_const_circulator curr = circ; typename Input_Arrangement_2::Halfedge_const_handle he = curr; - int parity = 0; - std::vector temp_vertices; int index_v0 = 0; int index = 0; @@ -92,6 +87,83 @@ public: std::cout << vertices[k] << std::endl; } + visibility_region_impl(q, out_arr); + } + + void visibility_region(const Point_2 &q, + const Halfedge_const_handle he, + Output_Arrangement_2 &out_arr + ) { + + std::vector temp_vertices; + bool query_point_on_source = false; + + if (q != he->source()->point()) { + if (q != he->target()->point()) { + vertices.push_back(q); + vertices.push_back(he->target()->point()); + } + else { + vertices.push_back(q); + } + } + else { + query_point_on_source = true; + vertices.push_back(q); + vertices.push_back(he->target()->point()); + } + + typename Input_Arrangement_2::Face_const_handle face = he->face(); + typename Input_Arrangement_2::Ccb_halfedge_const_circulator circ = face->outer_ccb(); + typename Input_Arrangement_2::Ccb_halfedge_const_circulator curr = circ; + typename Input_Arrangement_2::Halfedge_const_handle he_handle = curr; + + while (he_handle != he) { + he_handle = curr; + curr++; + } + + do { + he_handle = curr; + Point_2 curr_vertex = he->target()->point(); + temp_vertices.push_back(curr_vertex); + + } while (++curr != circ); + + if (!query_point_on_source) { + vertices.push_back(he->source()->point()); + } + + std::cout << "Vertices:" << std::endl; + for (unsigned int i = 0 ; i < vertices.size() ; i++) { + std::cout << vertices[i] << std::endl; + } + std::cout << " end" << std::endl; + // visibility_region_impl(q, out_arr); + } +protected: + const Input_Arrangement_2 *p_arr; + std::stack s; + std::vector vertices; + enum {LEFT, RIGHT, SCANA, SCANB, SCANC, SCAND, FINISH} upcase; + + bool do_overlap(const Point_2 &a, const Point_2 &b, const Point_2 &c) { + if (collinear(a, b, c)) { + std::cout << a << " " << b << " " << c << " are collinear" << std::endl; + Segment_2 s1(a, b); + Segment_2 s2(a, c); + const Segment_2 *seg_overlap; + CGAL::Object result = CGAL::intersection(s1, s2); + if (seg_overlap = CGAL::object_cast(&result)) { + return true; + } + } + return false; + } + + void visibility_region_impl(Point_2 &q, Output_Arrangement_2 &out_arr) { + + int i = 0; Point_2 w; if (orientation(q, vertices[0], vertices[1]) == CGAL::LEFT_TURN) { @@ -114,9 +186,7 @@ public: std::cout << "CASE: " << upcase << std::endl; switch(upcase) { case LEFT: - std::cout << "before entering left" << std::endl; left(i, w, q); - std::cout << "after exiting left" << std::endl; break; case RIGHT: right(i, w, q); @@ -167,9 +237,8 @@ public: s.push(s_t); } } - std::cout << "gets out" << std::endl; - if (counter == 2) { - // exit(0); + if (counter == 8) { + // exit(0); } counter++; } while(upcase != FINISH); @@ -192,34 +261,8 @@ public: CGAL::insert(out_arr, segments.begin(), segments.end()); } - void visibility_region(const Point_2 &q, - const Halfedge_const_handle he, - Output_Arrangement_2 &out_arr - ) { - - } -protected: - const Input_Arrangement_2 *p_arr; - std::stack s; - std::vector vertices; - enum {LEFT, RIGHT, SCANA, SCANB, SCANC, SCAND, FINISH} upcase; - - bool do_overlap(const Point_2 &a, const Point_2 &b, const Point_2 &c) { - if (collinear(a, b, c)) { - std::cout << a << " " << b << " " << c << " are collinear" << std::endl; - Segment_2 s1(a, b); - Segment_2 s2(a, c); - const Segment_2 *seg_overlap; - CGAL::Object result = CGAL::intersection(s1, s2); - if (seg_overlap = CGAL::object_cast(&result)) { - return true; - } - } - return false; - } - void left(int &i, Point_2 &w, const Point_2 &query_pt) { - std::cout << "begin with i = " << i << std::endl; + std::cout << "begin left with i = " << i << std::endl; if (i == vertices.size() - 1) { std::cout << "done" << std::endl; upcase = FINISH; @@ -227,28 +270,41 @@ protected: else if (orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::LEFT_TURN) { std::cout << "left::left turn with i =" << i << std::endl; upcase = LEFT; + std::cout << "left::pushing1 " << vertices[i+1] << std::endl; s.push(vertices[i+1]); w = vertices[i+1]; i++; } else if (orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { + std::cout << "left::right turn with i = " << i << std::endl; Point_2 s_t = s.top(); + std::cout << "left:: s_t = " << s_t << std::endl; s.pop(); Point_2 s_t_prev = s.top(); + std::cout << "left:: s_t-i = " << s_t_prev << std::endl; s.pop(); if (orientation(s_t_prev, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { + std::cout << "left::switched to scana" << std::endl; upcase = SCANA; + w = vertices[i+1]; + i++; + } // Both conditions have to be met to move on. Thus same else branch as below + else { + std::cout << "left::switching to right mode branch1" << std::endl; + upcase = RIGHT; + w = vertices[i]; i++; } s.push(s_t_prev); s.push(s_t); - w = vertices[i+1]; } else { + std::cout << "left::switching to right mode" << std::endl; upcase = RIGHT; i++; w = vertices[i]; } + std::cout << "leaving left with i = " << i << std::endl; } void right(int &i, Point_2 &w, const Point_2 &query_pt) { @@ -256,58 +312,80 @@ protected: // (a) (z, s_j, v_i) is a right turn and (z, s_j-1, v_i) is a left turn, or // (b) (z, s_j-1, s_j) is a forward move and (v_i-1, v_i) intersects (s_j-1, s_j) bool found = false; - - while(!found) { - Point_2 s_j = s.top(); - if (!s.empty()) { + std::cout << "entered right with i = " << i << std::endl; + while(!found && !s.empty()) { + Point_2 s_j = s.top(); + std::cout << "right:: considering s_j = " << s_j << std::endl; s.pop(); - Point_2 s_j_prev = s.top(); + if (!s.empty()) { + Point_2 s_j_prev = s.top(); + std::cout << "right:: s_j-1 = " << s_j_prev << std::endl; - // Check condition (a) - if ((orientation(query_pt, s_j, vertices[i]) == CGAL::RIGHT_TURN) - && (orientation(query_pt, s_j_prev, vertices[i]) == CGAL::LEFT_TURN)) { - found = true; - Segment_2 s1(s_j_prev, s_j); - Segment_2 s2(query_pt, vertices[i]); - CGAL::Object result = intersection(s1, s2); - if (const Point_2 *ipoint = CGAL::object_cast(&result)) { - s_j = *ipoint; + // Check condition (a) + if ((orientation(query_pt, s_j, vertices[i]) == CGAL::RIGHT_TURN) + && (orientation(query_pt, s_j_prev, vertices[i]) == CGAL::LEFT_TURN)) { + std::cout << "right:: case A" << std::endl; + found = true; + Segment_2 s1(s_j_prev, s_j); + Ray_2 s2(query_pt, vertices[i]); + CGAL::Object result = intersection(s1, s2); + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + std::cout << "s_j is now = " << *ipoint << std::endl; + s_j = *ipoint; + } + + if (orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { + std::cout << "case a1" << std::endl; + upcase = RIGHT; + s.push(s_j); + w = vertices[i]; + i++; + } + else if ((orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::LEFT_TURN) + && (orientation(vertices[i-1], vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN)) { + std::cout << "case a2: right::switch to left" << std::endl; + upcase = LEFT; + s.push(s_j); + s.push(vertices[i]); + s.push(vertices[i+1]); + w = vertices[i+1]; + i++; + } + else { + std::cout << "case a3" << std::endl; + upcase = SCANC; + s.push(s_j); + w = vertices[i]; + i++; + } } - - if (orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { - upcase = RIGHT; - s.push(s_j); - i++; - w = vertices[i]; + else if (do_overlap(query_pt, s_j_prev, s_j)) { // Case (b) + // Check if v_i-1, v_i intersects (s_j-1, s_j) + Segment_2 s1(s_j_prev, s_j); + Segment_2 s2(vertices[i-1], vertices[i]); + CGAL::Object result = intersection(s1, s2); + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + // Keep s_j off the stack + std::cout << "right:: case B" << std::endl; + found = true; + upcase = SCAND; + w = *ipoint; + } } - else if ((orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::LEFT_TURN) - && (orientation(vertices[i-1], vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN)) { + else if ((orientation(query_pt, s_j, vertices[i]) == CGAL::RIGHT_TURN) + && (orientation(query_pt, s_j_prev, vertices[i]) == CGAL::COLLINEAR)) { + found = true; upcase = LEFT; - i++; - s.push(s_j); s.push(vertices[i]); s.push(vertices[i+1]); w = vertices[i+1]; - } - else { - upcase = SCANC; i++; - s.push(s_j); } + std::cout << "right::FOUND? = " << found << std::endl; } - else { // Case (b) - Segment_2 s1(s_j_prev, s_j); - Segment_2 s2(vertices[i-1], vertices[i]); - CGAL::Object result = intersection(s1, s2); - if (const Point_2 *ipoint = CGAL::object_cast(&result)) { - // Keep s_j off the stack - upcase = SCAND; - w = *ipoint; - } - } - } } + std::cout << "leaving right with i = " << i << std::endl; } void scana(int &i, Point_2 &w, const Point_2 &query_pt) { @@ -315,7 +393,7 @@ protected: bool found = false; int k = i; Point_2 intersection_pt; - while (k+1 < vertices.size()-1) { + while (k+1 < vertices.size()) { std::cout << "Considering edge: " << vertices[k] << " " << vertices[k+1] << std::endl; Segment_2 s1(vertices[k], vertices[k+1]); std::cout << "With edge: " << query_pt << " " << s.top() << std::endl; @@ -367,7 +445,7 @@ protected: int k = i; bool found = false; Point_2 intersection_pt; - while (k+1 < vertices.size()-1) { + while (k+1 < vertices.size()) { Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(s_t, vertices[vertices.size()-1]); CGAL::Object result = intersection(s1, s2); @@ -394,16 +472,20 @@ protected: void scanc(int &i,Point_2 &w, const Point_2 &query_pt) { // Scan v_i, v_i+1, ..., v_n-1, v_n for the first edge to intersect (s_t, w) + std::cout << "entered scanc with i = " << i << std::endl; Point_2 s_t = s.top(); int k = i; bool found = false; Point_2 intersection_pt; - while (k+1 < vertices.size()-1) { + std::cout << "size: " << vertices.size() << std::endl; + while (k+1 < vertices.size()) { + std::cout << "doesn't get here" << std::endl; Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(s_t, w); CGAL::Object result = intersection(s1, s2); if (const Point_2 *ipoint = CGAL::object_cast(&result)) { found = true; + std::cout << "scanc::found" << std::endl; intersection_pt = *ipoint; break; } @@ -414,6 +496,7 @@ protected: i = k+1; w = intersection_pt; } + std::cout << "leaving scanc" << std::endl; } void scand(int &i, Point_2 &w, const Point_2 &query_pt) { @@ -422,7 +505,7 @@ protected: int k = i; bool found = false; Point_2 intersection_pt; - while (k+1 < vertices.size()-1) { + while (k+1 < vertices.size()) { Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(s_t, w); CGAL::Object result = intersection(s1, s2); diff --git a/Visibility_2/test/data/simple_polygon_test_case_3.in b/Visibility_2/test/data/simple_polygon_test_case_3.in new file mode 100644 index 00000000000..af54c28320a --- /dev/null +++ b/Visibility_2/test/data/simple_polygon_test_case_3.in @@ -0,0 +1,20 @@ +# Test case 2 for simple polygons. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +8 +0 0 +13 0 +13 4 +11 2 +9 4 +7 2 +4 2 +0 5 +8 +0 1 +1 2 +2 3 +3 4 +4 5 +5 6 +6 7 +7 0 +2 2 \ No newline at end of file diff --git a/Visibility_2/test/data/simple_polygon_test_case_3.out b/Visibility_2/test/data/simple_polygon_test_case_3.out new file mode 100644 index 00000000000..b297b5aa35b --- /dev/null +++ b/Visibility_2/test/data/simple_polygon_test_case_3.out @@ -0,0 +1,17 @@ +# Test case 2 for simple polygons. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +7 +0 0 +13 0 +13 2 +11 2 +7 2 +4 2 +0 5 +7 +0 1 +1 2 +2 3 +3 4 +4 5 +5 6 +6 0 \ No newline at end of file diff --git a/Visibility_2/test/data/simple_polygon_test_case_4.in b/Visibility_2/test/data/simple_polygon_test_case_4.in new file mode 100644 index 00000000000..0a6d3b4e5e0 --- /dev/null +++ b/Visibility_2/test/data/simple_polygon_test_case_4.in @@ -0,0 +1,20 @@ +# Test case 4 for simple polygons. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +8 +0 0 +4 0 +8 3 +12 0 +12 3 +8 6 +4 3 +0 3 +8 +0 1 +1 2 +2 3 +3 4 +4 5 +5 6 +6 7 +7 0 +2 3 \ No newline at end of file diff --git a/Visibility_2/test/data/simple_polygon_test_case_4.out b/Visibility_2/test/data/simple_polygon_test_case_4.out new file mode 100644 index 00000000000..f03ae70ac76 --- /dev/null +++ b/Visibility_2/test/data/simple_polygon_test_case_4.out @@ -0,0 +1,19 @@ +# Test case 4 for simple polygons. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases +8 +0 0 +4 0 +8 3 +12 0 +12 3 +4 3 +2 3 +0 3 +8 +0 1 +1 2 +2 3 +3 4 +4 2 +2 5 +5 6 +6 0 \ No newline at end of file diff --git a/Visibility_2/test/include/CGAL/test_simple_polygons.h b/Visibility_2/test/include/CGAL/test_simple_polygons.h index af2eb2390e5..ee7a200fd9a 100644 --- a/Visibility_2/test/include/CGAL/test_simple_polygons.h +++ b/Visibility_2/test/include/CGAL/test_simple_polygons.h @@ -9,41 +9,7 @@ namespace CGAL { template < class _Visibility_2, class _Arrangement_2 > -bool simple_polygon_test_case_1() { - - typedef _Visibility_2 Visibility_2; - typedef _Arrangement_2 Arrangement_2; - typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; - typedef typename Geometry_traits_2::Point_2 Point_2; - - Visibility_2 visibility; - - // First read arrangement - Arrangement_2 arr, out_arr, correct_out_arr; - std::ifstream input("./data/simple_polygon_test_case_1.in"); - CGAL::create_arrangement_from_file(arr, input); - - // Read query point from file - double x, y; - input >> x >> y; - Point_2 query_pt(x, y); - - std::ifstream correct_output("./data/simple_polygon_test_case_1.out"); - CGAL::create_arrangement_from_file(correct_out_arr, correct_output); - - typename Arrangement_2::Face_const_iterator fit; - - for (fit = arr.faces_begin(); fit != arr.faces_end(); ++fit) { - if (!fit->is_unbounded()) { - visibility.visibility_region(query_pt, fit, out_arr); - } - } - - return CGAL::test_are_equal(correct_out_arr, out_arr); -} - -template < class _Visibility_2, class _Arrangement_2 > -bool simple_polygon_test_case_2() { +bool simple_polygon_face_test_case(std::ifstream &input, std::ifstream &correct_output) { typedef _Visibility_2 Visibility_2; typedef _Arrangement_2 Arrangement_2; @@ -54,7 +20,7 @@ bool simple_polygon_test_case_2() { // First read arrangement Arrangement_2 arr, out_arr, correct_out_arr; - std::ifstream input("./data/simple_polygon_test_case_2.in"); + CGAL::create_arrangement_from_file(arr, input); // Read query point from file @@ -62,7 +28,6 @@ bool simple_polygon_test_case_2() { input >> x >> y; Point_2 query_pt(x, y); - std::ifstream correct_output("./data/simple_polygon_test_case_2.out"); CGAL::create_arrangement_from_file(correct_out_arr, correct_output); typename Arrangement_2::Face_const_iterator fit; @@ -73,10 +38,76 @@ bool simple_polygon_test_case_2() { } } - return CGAL::test_are_equal(correct_out_arr, out_arr); - + return CGAL::test_are_equal(correct_out_arr, out_arr); } +template < class _Visibility_2, class _Arrangement_2 > +bool simple_polygon_halfedge_test_case(std::ifstream &input, std::ifstream &correct_output) { + + typedef _Visibility_2 Visibility_2; + typedef _Arrangement_2 Arrangement_2; + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + typedef typename Geometry_traits_2::Point_2 Point_2; + typedef typename Geometry_traits_2::Segment_2 Segment_2; + + Visibility_2 visibility; + + // First read arrangement + Arrangement_2 arr, out_arr, correct_out_arr; + + CGAL::create_arrangement_from_file(arr, input); + + // Read query point from file + double x, y; + input >> x >> y; + Point_2 query_pt(x, y); + + CGAL::create_arrangement_from_file(correct_out_arr, correct_output); + + typename Arrangement_2::Halfedge_const_iterator hit; + + for (hit = arr.halfedges_begin(); hit != arr.halfedges_end(); ++hit) { + Segment_2 curr_seg(hit->source()->point(), hit->target()->point()); + if (curr_seg.has_on(query_pt)) { + visibility.visibility_region(query_pt, hit, out_arr); + } + } + return true; +// return CGAL::test_are_equal(correct_out_arr, out_arr); +} + +template < class _Visibility_2, class _Arrangement_2 > +bool simple_polygon_test_case_1() { + + std::ifstream input("./data/simple_polygon_test_case_1.in"); + std::ifstream correct_output("./data/simple_polygon_test_case_1.out"); + return simple_polygon_face_test_case<_Visibility_2, _Arrangement_2>(input, correct_output); +} + +template < class _Visibility_2, class _Arrangement_2 > +bool simple_polygon_test_case_2() { + + std::ifstream input("./data/simple_polygon_test_case_2.in"); + std::ifstream correct_output("./data/simple_polygon_test_case_2.out"); + return simple_polygon_face_test_case<_Visibility_2, _Arrangement_2>(input, correct_output); +} + +template < class _Visibility_2, class _Arrangement_2 > +bool simple_polygon_test_case_3() { + std::ifstream input("./data/simple_polygon_test_case_3.in"); + std::ifstream correct_output("./data/simple_polygon_test_case_3.out"); + return simple_polygon_face_test_case<_Visibility_2, _Arrangement_2>(input, correct_output); +} + +template < class _Visibility_2, class _Arrangement_2 > +bool simple_polygon_test_case_4() { + std::ifstream input("./data/simple_polygon_test_case_4.in"); + std::ifstream correct_output("./data/simple_polygon_test_case_4.out"); + return simple_polygon_halfedge_test_case<_Visibility_2, _Arrangement_2>(input, correct_output); +} + + + } // end namespace CGAL #endif \ No newline at end of file diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp index b4e513c0f6f..442df1e288a 100644 --- a/Visibility_2/test/test_simple_visibility.cpp +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -28,7 +28,7 @@ int main() { typedef CGAL::Arrangement_2 Arrangement_2; // First read arrangement - Arrangement_2 arr; + /* Arrangement_2 arr; std::ifstream input("./data/simple_polygon_test_case_1.in"); CGAL::create_arrangement_from_file(arr, input); CGAL::Visibility_2::Simple_visibility_2 visibility; @@ -39,10 +39,12 @@ int main() { assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); - +*/ // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases - assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); +/* assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ()));*/ + assert(true == (CGAL::simple_polygon_test_case_4, Arrangement_2> ())); } { typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel; @@ -52,7 +54,7 @@ int main() { typedef CGAL::Arrangement_2 Arrangement_2; // First read arrangement - Arrangement_2 arr; +/* Arrangement_2 arr; std::ifstream input("./data/simple_polygon_test_case_1.in"); CGAL::create_arrangement_from_file(arr, input); CGAL::Visibility_2::Simple_visibility_2 visibility; @@ -63,10 +65,11 @@ int main() { assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); - +*/ // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases - assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); +/* assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ()));*/ } return 0; } \ No newline at end of file From 538e5ca1ee9e1ee942c5915c1d4819244bc711ad Mon Sep 17 00:00:00 2001 From: Francisc Date: Tue, 16 Jul 2013 15:11:04 +0300 Subject: [PATCH 48/66] progress with needle test cases --- .../include/CGAL/Simple_visibility_2.h | 80 ++++++++++++------- .../test/include/CGAL/test_simple_polygons.h | 2 + Visibility_2/test/include/CGAL/test_utils.h | 6 +- Visibility_2/test/test_simple_visibility.cpp | 16 ++-- 4 files changed, 64 insertions(+), 40 deletions(-) diff --git a/Visibility_2/include/CGAL/Simple_visibility_2.h b/Visibility_2/include/CGAL/Simple_visibility_2.h index e2a6ae165b0..04767c995b9 100644 --- a/Visibility_2/include/CGAL/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Simple_visibility_2.h @@ -95,12 +95,10 @@ public: Output_Arrangement_2 &out_arr ) { - std::vector temp_vertices; - bool query_point_on_source = false; - if (q != he->source()->point()) { if (q != he->target()->point()) { - vertices.push_back(q); + s.push(q); + // vertices.push_back(q); vertices.push_back(he->target()->point()); } else { @@ -108,38 +106,45 @@ public: } } else { - query_point_on_source = true; vertices.push_back(q); vertices.push_back(he->target()->point()); } typename Input_Arrangement_2::Face_const_handle face = he->face(); typename Input_Arrangement_2::Ccb_halfedge_const_circulator circ = face->outer_ccb(); - typename Input_Arrangement_2::Ccb_halfedge_const_circulator curr = circ; - typename Input_Arrangement_2::Halfedge_const_handle he_handle = curr; + typename Input_Arrangement_2::Ccb_halfedge_const_circulator curr; + typename Input_Arrangement_2::Halfedge_const_handle he_handle = circ; while (he_handle != he) { + he_handle = circ; + circ++; + } + + curr = circ; + curr++; + + he_handle = curr; + vertices.push_back(Point_2(he_handle->source()->point())); + + typename Input_Arrangement_2::Ccb_halfedge_const_circulator next; + next = curr; + next++; + + while (curr != circ) { he_handle = curr; + Point_2 curr_vertex = he_handle->target()->point(); + vertices.push_back(curr_vertex); curr++; + next = curr; + next++; } - - do { - he_handle = curr; - Point_2 curr_vertex = he->target()->point(); - temp_vertices.push_back(curr_vertex); - - } while (++curr != circ); - - if (!query_point_on_source) { - vertices.push_back(he->source()->point()); - } - + vertices.push_back(q); std::cout << "Vertices:" << std::endl; for (unsigned int i = 0 ; i < vertices.size() ; i++) { std::cout << vertices[i] << std::endl; } - std::cout << " end" << std::endl; - // visibility_region_impl(q, out_arr); + + visibility_region_impl(q, out_arr); } protected: const Input_Arrangement_2 *p_arr; @@ -161,7 +166,7 @@ protected: return false; } - void visibility_region_impl(Point_2 &q, Output_Arrangement_2 &out_arr) { + void visibility_region_impl(const Point_2 &q, Output_Arrangement_2 &out_arr) { int i = 0; Point_2 w; @@ -181,7 +186,7 @@ protected: w = vertices[1]; s.push(vertices[0]); } - int counter = 0; + do { std::cout << "CASE: " << upcase << std::endl; switch(upcase) { @@ -222,6 +227,7 @@ protected: if ((*vertex_new) != (s_t_prev) && (*vertex_new != s_t)) { std::cout << "switch to scanb" << std::endl; upcase = SCANB; + std::cout << "pushing " << *vertex_new << std::endl; s.push(*vertex_new); } else { // Do not alter stack if it doesn't intersect - push back s_t @@ -237,10 +243,9 @@ protected: s.push(s_t); } } - if (counter == 8) { - // exit(0); + if (i == 9) { +// exit(0); } - counter++; } while(upcase != FINISH); std::cout << "RESULT: " << std::endl; @@ -374,9 +379,11 @@ protected: } else if ((orientation(query_pt, s_j, vertices[i]) == CGAL::RIGHT_TURN) && (orientation(query_pt, s_j_prev, vertices[i]) == CGAL::COLLINEAR)) { - + std::cout << "we're here in collinear" << std::endl; found = true; upcase = LEFT; + std::cout << "right::pushing " << vertices[i] << std::endl; + std::cout << "right::pushing " << vertices[i+1] << std::endl; s.push(vertices[i]); s.push(vertices[i+1]); w = vertices[i+1]; @@ -429,7 +436,11 @@ protected: upcase = LEFT; i = k+1; s.push(intersection_pt); - s.push(vertices[k+1]); + std::cout << "scana::pushing " << intersection_pt << std::endl; + if (intersection_pt != vertices[k+1]) { + std::cout << "scana::pushing " << vertices[k+1] << std::endl; + s.push(vertices[k+1]); + } w = vertices[k+1]; } else { @@ -450,14 +461,17 @@ protected: Segment_2 s2(s_t, vertices[vertices.size()-1]); CGAL::Object result = intersection(s1, s2); if (const Point_2 *ipoint = CGAL::object_cast(&result)) { - intersection_pt = *ipoint; - found = true; - break; + if (*ipoint != s_t) { + intersection_pt = *ipoint; + found = true; + break; + } } k++; } if (found) { if ((intersection_pt == vertices[k+1]) && (intersection_pt == vertices[vertices.size()-1])) { + std::cout << "scanb::done\n"; upcase = FINISH; w = vertices[vertices.size()-1]; s.push(vertices[vertices.size()-1]); @@ -468,6 +482,10 @@ protected: w = intersection_pt; } } + else { + upcase = LEFT; + i++; + } } void scanc(int &i,Point_2 &w, const Point_2 &query_pt) { diff --git a/Visibility_2/test/include/CGAL/test_simple_polygons.h b/Visibility_2/test/include/CGAL/test_simple_polygons.h index ee7a200fd9a..69cb21af4c0 100644 --- a/Visibility_2/test/include/CGAL/test_simple_polygons.h +++ b/Visibility_2/test/include/CGAL/test_simple_polygons.h @@ -70,8 +70,10 @@ bool simple_polygon_halfedge_test_case(std::ifstream &input, std::ifstream &corr Segment_2 curr_seg(hit->source()->point(), hit->target()->point()); if (curr_seg.has_on(query_pt)) { visibility.visibility_region(query_pt, hit, out_arr); + break; } } + std::cout << "exited" << std::endl; return true; // return CGAL::test_are_equal(correct_out_arr, out_arr); } diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index 33f151cfdcc..04f1f5951d8 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -88,13 +88,17 @@ bool test_are_equal(const _Arrangement_2 &arr1, const _Arrangement_2 &arr2) { } eit_fst_mid = eit_fst; eit_snd_mid = eit_snd; + // Now we know where to start the edge comparisons from for (eit_fst, eit_snd ; eit_fst != arr1.edges_end(), eit_snd != arr2.edges_end() ; ++eit_fst, ++eit_snd) { Segment_2 seg_fst = eit_fst->curve(); Segment_2 seg_snd = eit_snd->curve(); - if (seg_fst != seg_snd) { + std::cout << seg_fst << std::endl; + std::cout << seg_snd << std::endl; + if ((seg_fst.source() != seg_snd.source() || seg_fst.target() != seg_snd.target()) && + (seg_fst.source() != seg_snd.target() || seg_fst.target() != seg_snd.source())) { return false; } } diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp index 442df1e288a..abffa7591d7 100644 --- a/Visibility_2/test/test_simple_visibility.cpp +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -28,7 +28,7 @@ int main() { typedef CGAL::Arrangement_2 Arrangement_2; // First read arrangement - /* Arrangement_2 arr; + Arrangement_2 arr; std::ifstream input("./data/simple_polygon_test_case_1.in"); CGAL::create_arrangement_from_file(arr, input); CGAL::Visibility_2::Simple_visibility_2 visibility; @@ -39,11 +39,11 @@ int main() { assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); -*/ + // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases -/* assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); - assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ()));*/ + assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ())); assert(true == (CGAL::simple_polygon_test_case_4, Arrangement_2> ())); } { @@ -54,7 +54,7 @@ int main() { typedef CGAL::Arrangement_2 Arrangement_2; // First read arrangement -/* Arrangement_2 arr; + Arrangement_2 arr; std::ifstream input("./data/simple_polygon_test_case_1.in"); CGAL::create_arrangement_from_file(arr, input); CGAL::Visibility_2::Simple_visibility_2 visibility; @@ -65,11 +65,11 @@ int main() { assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); -*/ + // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases -/* assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); - assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ()));*/ + assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ())); } return 0; } \ No newline at end of file From 6f916cd4d196ee9205f2d19eb1449621de26aa3f Mon Sep 17 00:00:00 2001 From: kanhuang Date: Tue, 16 Jul 2013 19:23:31 -0400 Subject: [PATCH 49/66] fix a bug Naive_visibility_2.h --- .../include/CGAL/Naive_visibility_2.h | 28 ++++--- .../data/Arrangement_Test/non_regular_out4 | 4 +- Visibility_2/test/test_naive_visibility.cpp | 73 ++++++++++++++----- 3 files changed, 69 insertions(+), 36 deletions(-) diff --git a/Visibility_2/include/CGAL/Naive_visibility_2.h b/Visibility_2/include/CGAL/Naive_visibility_2.h index d48afdc4b2a..fe6ebaac405 100644 --- a/Visibility_2/include/CGAL/Naive_visibility_2.h +++ b/Visibility_2/include/CGAL/Naive_visibility_2.h @@ -23,10 +23,10 @@ void print(std::vector ps){ std::cout<point().x()<<","<point().y()< -void print_point(const Point_2& p) { - std::cout<<"["< +//void print_point(const Point_2& p) { +// std::cout<<"["< @@ -179,7 +179,6 @@ public: std::vector edges, active_edges; //edges stores all halfedges of the face; and active_edges stores all halfedges that is currently intersected by the view ray. //preprocess the face input_face(fh, vertices, edges, query); - print(vertices); //initiation of vision ray Vector_2 dir; if (Direction_2(-1, 0) < Direction_2(Vector_2(query, (*vertices.rbegin())->point()))) @@ -530,9 +529,6 @@ private: add_edge(*begin_it, edges, r); } while (++begin_it != end_it); - //debug - std::cout<<"after adding"<& edges, Ray_2& r, std::vector& collinear_vertices) { typename std::vector::iterator curr = edges.begin(); // Point_2 p = r.source(), end1, end2; - Vertex_const_handle vertex1, vertex2; + Vertex_const_handle vertex1; //flag shows whether the left side or right side of needle is blocked. bool block_left, block_right; do { Point_2 cross = intersection_point(r, *curr); - print_point(cross); if (cross != (*curr)->source()->point() && cross != (*curr)->target()->point()) { collinear_vertices.push_back(cross); return INNER; } - if (cross == (*curr)->source()->point()) { - vertex1 = (*curr)->source(); - vertex2 = (*curr)->target(); + if (CGAL::orientation(r.source(), (*curr)->source()->point(), (*curr)->target()->point()) == CGAL::COLLINEAR) { + vertex1 = (*curr)->target(); } else { - vertex1 = (*curr)->target(); - vertex2 = (*curr)->source(); + if (cross == (*curr)->source()->point()) { + vertex1 = (*curr)->source(); + } + else { + vertex1 = (*curr)->target(); + } } if (collinear_vertices.empty() || vertex1->point() != collinear_vertices.back()) { collinear_vertices.push_back(vertex1->point()); diff --git a/Visibility_2/test/data/Arrangement_Test/non_regular_out4 b/Visibility_2/test/data/Arrangement_Test/non_regular_out4 index a4b6e2671d1..0eb09835e36 100644 --- a/Visibility_2/test/data/Arrangement_Test/non_regular_out4 +++ b/Visibility_2/test/data/Arrangement_Test/non_regular_out4 @@ -1,5 +1,5 @@ # Non-regularized visibility result of Test case 4 for arbitrary arrangement. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases -12 +14 0 2 0 3 -1 3 @@ -12,6 +12,8 @@ 5 0 7 0 10 0 +3 3 +1 1 14 0 1 1 2 diff --git a/Visibility_2/test/test_naive_visibility.cpp b/Visibility_2/test/test_naive_visibility.cpp index 24b4d81d4ea..a8fb7b16076 100644 --- a/Visibility_2/test/test_naive_visibility.cpp +++ b/Visibility_2/test/test_naive_visibility.cpp @@ -19,8 +19,15 @@ #include #include +template +std::string number2string(T n) { + std::stringstream ss; + ss << n; + return ss.str(); +} + int main() { - int case_number = 5; + int case_number = 1; //test kernel Cartesian { typedef CGAL::Gmpq Number_type; @@ -33,34 +40,60 @@ int main() { std::cout<<"Kernel: Cartesian"<> input_arr_file; - std::stringstream ss2("data/Arrangement_Test/non_regular_out"); - ss2 << i; - ss2 >> ans_file; + std::string input_arr_file("data/Arrangement_Test/in"); + input_arr_file += number2string(i); + std::string ans_file("data/Arrangement_Test/non_regular_out"); + ans_file += number2string(i); + std::ifstream input(input_arr_file.c_str()); +// std::cout<<"read file over\n"; std::ifstream ans_input(ans_file.c_str()); - Arrangement_2 arr_in, arr_out, arr_vb; +// std::cout<<"read another file\n"; + Arrangement_2 arr_in, arr_ans, arr_vb; CGAL::create_arrangement_from_file(arr_in, input); - CGAL::create_arrangement_from_file(arr_out, ans_input); + CGAL::create_arrangement_from_file(arr_ans, ans_input); CGAL::Visibility_2::Naive_visibility_2 vb(arr_in); - vb.visibility_region(Point_2(0, 0), face, arr_vb); - assert(true == (CGAL::test_are_equal(arr_out, arr_vb))); + typename Arrangement_2::Face_const_handle fit = arr_in.faces_begin(); + do { + if (!fit->is_unbounded()) break; + } while (++fit != arr_in.faces_end()); + vb.visibility_region(Point_2(0, 0), fit, arr_vb); +// CGAL::Visibility_2::print_arrangement(arr_vb); +// CGAL::Visibility_2::print_arrangement(arr_ans); + std::cout<<(true == (CGAL::test_are_equal(arr_ans, arr_vb)))< Traits_2; - typedef Traits_2::Point_2 Point_2; - typedef Traits_2::X_monotone_curve_2 Segment_2; - typedef CGAL::Arrangement_2 Arrangement_2; +// { +// typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel; +// typedef CGAL::Arr_segment_traits_2 Traits_2; +// typedef Traits_2::Point_2 Point_2; +// typedef Traits_2::X_monotone_curve_2 Segment_2; +// typedef CGAL::Arrangement_2 Arrangement_2; - std::cout<<"Kernel: Exact_predicates_exact_constructions"<(arr_in, input); +// CGAL::create_arrangement_from_file(arr_ans, ans_input); + +// CGAL::Visibility_2::Naive_visibility_2 vb(arr_in); +// typename Arrangement_2::Face_const_handle fit = arr_in.faces_begin(); +// do { +// if (!fit->is_unbounded()) break; +// } while (++fit != arr_in.faces_end()); +// vb.visibility_region(Point_2(0, 0), fit, arr_vb); +// std::cout<<(true == (CGAL::test_are_equal(arr_ans, arr_vb)))< Date: Wed, 17 Jul 2013 01:48:28 -0400 Subject: [PATCH 50/66] add some function to test_utils.h --- Visibility_2/test/include/CGAL/test_utils.h | 50 ++++++++++++++++++++- Visibility_2/test/test_naive_visibility.cpp | 1 + 2 files changed, 50 insertions(+), 1 deletion(-) diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index 04f1f5951d8..4a042ba604a 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -14,7 +14,7 @@ #include #include #include - +#include namespace CGAL { @@ -140,6 +140,12 @@ Number_type string2num(const std::string& s) { } } +template +std::string num2string(Number_type& n) { + std::stringstream ss; + ss< void create_arrangement_from_file(_Arrangement_2 &arr, std::ifstream& input) { typedef _Arrangement_2 Arrangement_2; @@ -223,6 +229,48 @@ void create_polygons_from_file(_Arrangement_2 &arr, std::ifstream& input) { } +template +bool compare_arr_by_edges(const Arrangement_2& arr1, const Arrangement_2& arr2) { + std::set s1; + typedef typename Arrangement_2::Edge_const_iterator Edge_const_iterator; + for (Edge_const_iterator eit = arr1.edges_begin(); eit != arr1.edges_end(); ++eit) { + s1.insert(edge2string(eit->target()->point(), eit->source()->point())); + } + std::set s2; + for (Edge_const_iterator eit = arr2.edges_begin(); eit != arr2.edges_end(); ++eit) { + s2.insert(edge2string(eit->target()->point(), eit->source()->point())); + } + return s1==s2; +} + +template +bool is_ahead(Point_2& p1, Point_2& p2) { + if (p1.x() > p2.x()) { + return true; + } + if (p1.x() == p2.x() && p1.y() > p2.y()) { + return true; + } + return false; +} + + +template +std::string edge2string(const Point_2& p1, const Point_2& p2) { + Point_2 q1, q2; + if (is_ahead(p1, p2)) { + q1 = p1; + q2 = p2; + } + else { + q1 = p2; + q2 = p1; + } + return num2string(q1.x()) + num2string(q1.y()) + num2string(q2.x()) + num2string(q2.y()); +} + + + } // end namespace CGAL #endif diff --git a/Visibility_2/test/test_naive_visibility.cpp b/Visibility_2/test/test_naive_visibility.cpp index a8fb7b16076..47b2b31d20e 100644 --- a/Visibility_2/test/test_naive_visibility.cpp +++ b/Visibility_2/test/test_naive_visibility.cpp @@ -62,6 +62,7 @@ int main() { // CGAL::Visibility_2::print_arrangement(arr_vb); // CGAL::Visibility_2::print_arrangement(arr_ans); std::cout<<(true == (CGAL::test_are_equal(arr_ans, arr_vb)))< Date: Wed, 17 Jul 2013 18:16:34 +0300 Subject: [PATCH 51/66] progress with needles --- .../include/CGAL/Simple_visibility_2.h | 59 +++++++++++++++---- Visibility_2/test/test_simple_visibility.cpp | 8 +-- 2 files changed, 51 insertions(+), 16 deletions(-) diff --git a/Visibility_2/include/CGAL/Simple_visibility_2.h b/Visibility_2/include/CGAL/Simple_visibility_2.h index 04767c995b9..2646097bd97 100644 --- a/Visibility_2/include/CGAL/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Simple_visibility_2.h @@ -24,6 +24,9 @@ public: typedef typename Geometry_traits_2::Point_2 Point_2; typedef typename Geometry_traits_2::Ray_2 Ray_2; typedef typename Geometry_traits_2::Segment_2 Segment_2; + typedef typename Geometry_traits_2::Vector_2 Vector_2; + typedef typename Geometry_traits_2::FT Number_type; + Simple_visibility_2() : p_arr(NULL) {}; @@ -56,31 +59,42 @@ public: typename Input_Arrangement_2::Halfedge_const_handle he = curr; std::vector temp_vertices; - int index_v0 = 0; - int index = 0; - Point_2 curr_min = he->source()->point(); + Point_2 intersect_pt; + Point_2 min_intersect_pt; - // Push all vertices + Segment_2 curr_edge(he->source()->point(), he->target()->point()); + Point_2 curr_vertex = he->source()->point(); + temp_vertices.push_back(curr_vertex); + Number_type min_dist = dist_point_to_segment(q, curr_edge, intersect_pt); + + int min_dist_index = 0; + int index = 1; + + // Push all vertices and determine edge minimum in terms of squared distance to query point do { he = curr; - Point_2 curr_vertex = he->target()->point(); - if (curr_vertex.x() < curr_min.x() && (curr_vertex.x() > q.x())) { - curr_min = curr_vertex; - index_v0 = index; + curr_edge = Segment_2(he->source()->point(), he->target()->point()); + curr_vertex = Point_2(he->target()->point()); + + Number_type curr_dist = dist_point_to_segment(q, curr_edge, intersect_pt); + if (curr_dist < min_dist) { + min_dist = curr_dist; + min_dist_index = index; + min_intersect_pt = intersect_pt; } temp_vertices.push_back(curr_vertex); index++; } while (++curr != circ); - // Now create vector so that first vertex v0 has the smallest positive x-coordinate (thus - visible from the query point) - for (unsigned int k = index_v0 ; k < temp_vertices.size() ; k++) { + // Now create vector so that first vertex v0 is visible + for (unsigned int k = min_dist_index ; k < temp_vertices.size() ; k++) { vertices.push_back(temp_vertices[k]); } - for (unsigned int k = 0 ; k < index_v0 ; k++) { + for (unsigned int k = 0 ; k < min_dist_index ; k++) { vertices.push_back(temp_vertices[k]); } // Push first vertex again to fulfill algo precondition - vertices.push_back(vertices[0]); + // vertices.push_back(vertices[0]); std::cout << "Vertices:\n"; for (unsigned int k = 0 ; k < vertices.size() ; k++) { @@ -152,6 +166,27 @@ protected: std::vector vertices; enum {LEFT, RIGHT, SCANA, SCANB, SCANC, SCAND, FINISH} upcase; + Number_type dist_point_to_segment(const Point_2 &p, const Segment_2 &seg, Point_2 &intersect_pt) { + + Vector_2 v(seg); + Vector_2 w(seg.source(), p); + Number_type c1 = w*v; + if (c1 <= 0) { + intersect_pt = seg.source(); + return squared_distance(p, seg.source()); + } + + Number_type c2 = v*v; + if (c2 <= c1) { + intersect_pt = seg.target(); + return squared_distance(p, seg.target()); + } + + Number_type b = c1/c2; + intersect_pt = Point_2(seg.source() + b*v); + return squared_distance(p, intersect_pt); + } + bool do_overlap(const Point_2 &a, const Point_2 &b, const Point_2 &c) { if (collinear(a, b, c)) { std::cout << a << " " << b << " " << c << " are collinear" << std::endl; diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp index abffa7591d7..930473285ae 100644 --- a/Visibility_2/test/test_simple_visibility.cpp +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -41,11 +41,11 @@ int main() { assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases - assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); + /* assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ())); - assert(true == (CGAL::simple_polygon_test_case_4, Arrangement_2> ())); -} + assert(true == (CGAL::simple_polygon_test_case_4, Arrangement_2> ()));*/ +}/* { typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel; typedef CGAL::Arr_segment_traits_2 Traits_2; @@ -70,6 +70,6 @@ int main() { assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ())); -} +}*/ return 0; } \ No newline at end of file From 46c9c48dec24f544d54c566fa15192a4be615d28 Mon Sep 17 00:00:00 2001 From: Francisc Date: Wed, 17 Jul 2013 18:18:50 +0300 Subject: [PATCH 52/66] progress with needles --- .../test/data/simple_polygon_test_case_4.out | 12 ++++---- .../test/include/CGAL/test_model_methods.h | 24 +++++++++++++--- .../test/include/CGAL/test_simple_polygons.h | 28 ++++++++++++++----- Visibility_2/test/test_simple_visibility.cpp | 24 +++++++++++++--- 4 files changed, 66 insertions(+), 22 deletions(-) diff --git a/Visibility_2/test/data/simple_polygon_test_case_4.out b/Visibility_2/test/data/simple_polygon_test_case_4.out index f03ae70ac76..4399c931640 100644 --- a/Visibility_2/test/data/simple_polygon_test_case_4.out +++ b/Visibility_2/test/data/simple_polygon_test_case_4.out @@ -1,19 +1,17 @@ # Test case 4 for simple polygons. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases -8 +7 0 0 4 0 8 3 -12 0 12 3 4 3 2 3 0 3 -8 +7 0 1 1 2 2 3 -3 4 -4 2 -2 5 +2 4 +4 5 5 6 -6 0 \ No newline at end of file +6 0 diff --git a/Visibility_2/test/include/CGAL/test_model_methods.h b/Visibility_2/test/include/CGAL/test_model_methods.h index 4110e302765..6ecc9da2c9d 100644 --- a/Visibility_2/test/include/CGAL/test_model_methods.h +++ b/Visibility_2/test/include/CGAL/test_model_methods.h @@ -1,7 +1,23 @@ -/* - * Author: Francisc Bungiu - * E-mail: fbungiu@gmail.com - */ +// Copyright (c) 2013 Technical University Braunschweig (Germany). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org). +// You can redistribute it and/or modify it under the terms of the GNU +// General Public License as published by the Free Software Foundation, +// either version 3 of the License, or (at your option) any later version. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s): Francisc Bungiu +// Michael Hemmer #ifndef CGAL_TEST_MODEL_METHODS_H #define CGAL_TEST_MODEL_METHODS_H diff --git a/Visibility_2/test/include/CGAL/test_simple_polygons.h b/Visibility_2/test/include/CGAL/test_simple_polygons.h index 69cb21af4c0..a6168e0d499 100644 --- a/Visibility_2/test/include/CGAL/test_simple_polygons.h +++ b/Visibility_2/test/include/CGAL/test_simple_polygons.h @@ -1,7 +1,23 @@ -/* - * Author: Francisc Bungiu - * E-mail: fbungiu@gmail.com - */ +// Copyright (c) 2013 Technical University Braunschweig (Germany). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org). +// You can redistribute it and/or modify it under the terms of the GNU +// General Public License as published by the Free Software Foundation, +// either version 3 of the License, or (at your option) any later version. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s): Francisc Bungiu +// Michael Hemmer #ifndef CGAL_TEST_SIMPLE_POLYGONS_H #define CGAL_TEST_SIMPLE_POLYGONS_H @@ -73,9 +89,7 @@ bool simple_polygon_halfedge_test_case(std::ifstream &input, std::ifstream &corr break; } } - std::cout << "exited" << std::endl; - return true; -// return CGAL::test_are_equal(correct_out_arr, out_arr); + return CGAL::test_are_equal(correct_out_arr, out_arr); } template < class _Visibility_2, class _Arrangement_2 > diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp index 930473285ae..d7e8fa94bf8 100644 --- a/Visibility_2/test/test_simple_visibility.cpp +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -1,7 +1,23 @@ -/* - * Author: Francisc Bungiu - * E-mail: fbungiu@gmail.com - */ +// Copyright (c) 2013 Technical University Braunschweig (Germany). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org). +// You can redistribute it and/or modify it under the terms of the GNU +// General Public License as published by the Free Software Foundation, +// either version 3 of the License, or (at your option) any later version. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s): Francisc Bungiu +// Michael Hemmer #include #include From f2d0fbb7c5ac107ae30c96e448e43c580b7be72e Mon Sep 17 00:00:00 2001 From: Francisc Date: Wed, 17 Jul 2013 18:19:06 +0300 Subject: [PATCH 53/66] progress with needles --- .../include/CGAL/Simple_visibility_2.h | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/Visibility_2/include/CGAL/Simple_visibility_2.h b/Visibility_2/include/CGAL/Simple_visibility_2.h index 2646097bd97..889bc03bbda 100644 --- a/Visibility_2/include/CGAL/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Simple_visibility_2.h @@ -1,3 +1,24 @@ +// Copyright (c) 2013 Technical University Braunschweig (Germany). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org). +// You can redistribute it and/or modify it under the terms of the GNU +// General Public License as published by the Free Software Foundation, +// either version 3 of the License, or (at your option) any later version. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s): Francisc Bungiu +// Michael Hemmer + #ifndef CGAL_SIMPLE_VISIBILITY_2_H #define CGAL_SIMPLE_VISIBILITY_2_H From a3187158679450c10a943ab8e17b3b0fa9d0fc94 Mon Sep 17 00:00:00 2001 From: Francisc Date: Wed, 17 Jul 2013 20:00:57 +0300 Subject: [PATCH 54/66] corrected arrangement comparison function --- Visibility_2/test/include/CGAL/test_utils.h | 92 ++++++--------------- 1 file changed, 27 insertions(+), 65 deletions(-) diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index 4a042ba604a..7c260d3bcbc 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -29,9 +29,11 @@ bool test_are_equal(const _Arrangement_2 &arr1, const _Arrangement_2 &arr2) { typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; typedef typename Arrangement_2::Vertex_const_iterator Vertex_const_iterator; typedef typename Arrangement_2::Edge_const_iterator Edge_const_iterator; + typedef typename Arrangement_2::Halfedge Halfedge; typedef typename Geometry_traits_2::Segment_2 Segment_2; typedef typename Geometry_traits_2::Point_2 Point_2; + // First make sure they have the same size if (arr1.number_of_vertices() != arr2.number_of_vertices()) { return false; @@ -39,76 +41,36 @@ bool test_are_equal(const _Arrangement_2 &arr1, const _Arrangement_2 &arr2) { if (arr1.number_of_edges() != arr2.number_of_edges()) { return false; } - - Vertex_const_iterator vit_fst, vit_snd; - vit_fst = arr1.vertices_begin(); - vit_snd = arr2.vertices_begin(); - - Point_2 min_fst = vit_fst->point(); - Point_2 min_snd = vit_snd->point(); - vit_fst++; - vit_snd++; - - for (vit_fst ; vit_fst != arr1.vertices_end(); ++vit_fst) { - if (vit_fst->point().y() < min_fst.y()) { - min_fst = vit_fst->point(); - } - else if (vit_fst->point().y() == min_fst.y() && - vit_fst->point().x() < min_fst.x()) { - min_fst = vit_fst->point(); - } + if (arr1.number_of_isolated_vertices() != arr2.number_of_isolated_vertices()) { + return false; + } + if (arr1.number_of_faces() != arr2.number_of_faces()) { + return false; } - for (vit_snd ; vit_snd != arr2.vertices_end() ; ++vit_snd) { - if (vit_snd->point().y() < min_snd.y()) { - min_snd = vit_snd->point(); - } - else if (vit_snd->point().y() == min_snd.y() && - vit_snd->point().x() < min_snd.y()) { - min_snd = vit_snd->point(); - } + Edge_const_iterator eit_fst, eit_snd; + std::vector halfedges_fst, halfedges_snd; + + for (eit_fst = arr1.edges_begin(), eit_snd = arr2.edges_begin() ; + eit_fst != arr1.edges_end(), eit_snd != arr2.edges_end() ; + ++eit_fst, ++eit_snd) { + + halfedges_fst.push_back(*eit_fst); + halfedges_snd.push_back(*eit_snd); } - // Determine from which edge to start from - // (the one that contains the minimum vertex) - Edge_const_iterator eit_fst, eit_snd, eit_fst_mid, eit_snd_mid; - - for (eit_fst = arr1.edges_begin(); eit_fst != arr1.edges_end(); ++eit_fst) { - Segment_2 curr = eit_fst->curve(); - if (curr.source() == min_fst || curr.target() == min_fst) { - break; + // Compare the two vectors + for (unsigned int i = 0 ; i < halfedges_fst.size() ; i++) { + Halfedge he_curr = halfedges_fst[i]; + bool found = false; + for (unsigned int j = 0 ; j < halfedges_snd.size() ; j++) { + if (he_curr.source()->point() == halfedges_snd[j].source()->point() && + he_curr.target()->point() == halfedges_snd[j].target()->point()) { + found = true; + break; + } } - } - - for (eit_snd = arr2.edges_begin() ; eit_snd != arr2.edges_end(); ++eit_snd){ - Segment_2 curr = eit_snd->curve(); - if (curr.source() == min_snd || curr.target() == min_snd) { - break; - } - } - eit_fst_mid = eit_fst; - eit_snd_mid = eit_snd; - - // Now we know where to start the edge comparisons from - for (eit_fst, eit_snd ; eit_fst != arr1.edges_end(), - eit_snd != arr2.edges_end() ; ++eit_fst, ++eit_snd) { - - Segment_2 seg_fst = eit_fst->curve(); - Segment_2 seg_snd = eit_snd->curve(); - std::cout << seg_fst << std::endl; - std::cout << seg_snd << std::endl; - if ((seg_fst.source() != seg_snd.source() || seg_fst.target() != seg_snd.target()) && - (seg_fst.source() != seg_snd.target() || seg_fst.target() != seg_snd.source())) { - return false; - } - } - // Check first edges as well - for (eit_fst = arr1.edges_begin(), eit_snd = arr2.edges_begin() ; - eit_fst != eit_fst_mid, eit_snd != eit_snd_mid ; ++eit_fst, ++eit_snd){ - - Segment_2 seg_fst = eit_fst->curve(); - Segment_2 seg_snd = eit_snd->curve(); - if (seg_fst != seg_snd) { + if (found == false) { return false; } } From 2335d99341ffb053677870b409f11cbd9b6af4e2 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Wed, 17 Jul 2013 20:59:26 -0400 Subject: [PATCH 55/66] save before openning the test branch --- .../include/CGAL/Naive_visibility_2.h | 20 +++++++++---------- Visibility_2/test/test_naive_visibility.cpp | 4 ++-- 2 files changed, 11 insertions(+), 13 deletions(-) diff --git a/Visibility_2/include/CGAL/Naive_visibility_2.h b/Visibility_2/include/CGAL/Naive_visibility_2.h index fe6ebaac405..89ca4a32207 100644 --- a/Visibility_2/include/CGAL/Naive_visibility_2.h +++ b/Visibility_2/include/CGAL/Naive_visibility_2.h @@ -31,20 +31,18 @@ void print(std::vector ps){ template class Naive_visibility_2 { - typedef typename Arrangement_2::Traits_2 Traits_2; - typedef typename Traits_2::Kernel Kernel; - typedef typename Traits_2::Point_2 Point_2; - typedef typename CGAL::Segment_2 Segment_2; + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + typedef typename Geometry_traits_2::Point_2 Point_2; + typedef typename Geometry_traits_2::Ray_2 Ray_2; + typedef typename Geometry_traits_2::Segment_2 Segment_2; + typedef typename Geometry_traits_2::Vector_2 Vector_2; + typedef typename Geometry_traits_2::Direction_2 Direction_2; typedef typename Arrangement_2::Halfedge Halfedge; typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle; typedef typename Arrangement_2::Vertex_const_handle Vertex_const_handle; typedef typename Arrangement_2::Face_const_handle Face_const_handle; - typedef typename CGAL::Vector_2 Vector_2; - typedef typename CGAL::Direction_2 Direction_2; - typedef typename CGAL::Ray_2 Ray_2; - enum Intersection_type { UNBOUNDED, CORNER, INNER }; public: @@ -170,7 +168,7 @@ public: vit = end_it; } if (!is_init_empty) { - CGAL::insert_curve(out_arr, Segment_2(polygon[0], polygon.back())); + CGAL::insert(out_arr, Segment_2(polygon[0], polygon.back())); } } @@ -296,7 +294,7 @@ public: vit = end_it; } if (!is_init_empty) { - CGAL::insert_curve(out_arr, Segment_2(polygon.front(),polygon.back())); + CGAL::insert(out_arr, Segment_2(polygon.front(),polygon.back())); } } @@ -492,7 +490,7 @@ private: else { if (polygon.back() != p){ - CGAL::insert_curve(arr, Segment_2(polygon.back(), p)); + CGAL::insert(arr, Segment_2(polygon.back(), p)); polygon.push_back(p); } } diff --git a/Visibility_2/test/test_naive_visibility.cpp b/Visibility_2/test/test_naive_visibility.cpp index 47b2b31d20e..aa0acbc8f28 100644 --- a/Visibility_2/test/test_naive_visibility.cpp +++ b/Visibility_2/test/test_naive_visibility.cpp @@ -27,7 +27,7 @@ std::string number2string(T n) { } int main() { - int case_number = 1; + int case_number = 5; //test kernel Cartesian { typedef CGAL::Gmpq Number_type; @@ -62,7 +62,7 @@ int main() { // CGAL::Visibility_2::print_arrangement(arr_vb); // CGAL::Visibility_2::print_arrangement(arr_ans); std::cout<<(true == (CGAL::test_are_equal(arr_ans, arr_vb)))< Date: Wed, 17 Jul 2013 23:12:26 -0400 Subject: [PATCH 56/66] no insertion of same edge twice --- .../include/CGAL/Naive_visibility_2.h | 22 +++++++++++-------- Visibility_2/test/test_naive_visibility.cpp | 6 ++--- 2 files changed, 16 insertions(+), 12 deletions(-) diff --git a/Visibility_2/include/CGAL/Naive_visibility_2.h b/Visibility_2/include/CGAL/Naive_visibility_2.h index 89ca4a32207..6204f43b379 100644 --- a/Visibility_2/include/CGAL/Naive_visibility_2.h +++ b/Visibility_2/include/CGAL/Naive_visibility_2.h @@ -256,6 +256,7 @@ public: Intersection_type i_type = needle(active_edges, curr_vision_ray, collinear_vertices); switch (i_type) { case UNBOUNDED : + //todo:this part is not finished. //remove right and collinear; remove_edges(active_edges, curr_vision_ray); update_visibility(right_p, polygon, out_arr); @@ -271,10 +272,10 @@ public: remove_edges(active_edges, curr_vision_ray); left_p = intersection_point(curr_vision_ray, active_edges[0]); update_visibility(right_p, polygon, out_arr); - - update_visibility(collinear_vertices, polygon, out_arr); + insert_needle(collinear_vertices, polygon, out_arr); // update_visibility(mid_p, polygon, out_arr); - update_visibility(left_p, polygon, out_arr); +// update_visibility(left_p, polygon, out_arr); + polygon.push_back(left_p); break; case INNER : //remove right and collinear; @@ -285,8 +286,9 @@ public: else { left_p = intersection_point(curr_vision_ray, active_edges[0]); update_visibility(right_p, polygon, out_arr); - update_visibility(collinear_vertices, polygon, out_arr); - update_visibility(left_p, polygon, out_arr); + insert_needle(collinear_vertices, polygon, out_arr); +// update_visibility(left_p, polygon, out_arr); + polygon.push_back(left_p); } break; } @@ -294,7 +296,7 @@ public: vit = end_it; } if (!is_init_empty) { - CGAL::insert(out_arr, Segment_2(polygon.front(),polygon.back())); + CGAL::insert(out_arr, Segment_2(polygon.back(),polygon.front())); } } @@ -496,9 +498,11 @@ private: } } - void update_visibility(const std::vector& points, std::vector& polygon, Arrangement_2 &arr){ - for (int i = 0; i != points.size(); i++) { - update_visibility(points[i], polygon, arr); + void insert_needle(const std::vector& points, std::vector& polygon, Arrangement_2 &arr){ + if (points.size() > 1) { + for (int i = 0; i != points.size()-1; i++) { + CGAL::insert(arr, Segment_2(points[i], points[i+1])); + } } } diff --git a/Visibility_2/test/test_naive_visibility.cpp b/Visibility_2/test/test_naive_visibility.cpp index aa0acbc8f28..a0c8186bc92 100644 --- a/Visibility_2/test/test_naive_visibility.cpp +++ b/Visibility_2/test/test_naive_visibility.cpp @@ -27,7 +27,7 @@ std::string number2string(T n) { } int main() { - int case_number = 5; + int case_number = 1; //test kernel Cartesian { typedef CGAL::Gmpq Number_type; @@ -59,8 +59,8 @@ int main() { if (!fit->is_unbounded()) break; } while (++fit != arr_in.faces_end()); vb.visibility_region(Point_2(0, 0), fit, arr_vb); -// CGAL::Visibility_2::print_arrangement(arr_vb); -// CGAL::Visibility_2::print_arrangement(arr_ans); + CGAL::Visibility_2::print_arrangement(arr_vb); + CGAL::Visibility_2::print_arrangement(arr_ans); std::cout<<(true == (CGAL::test_are_equal(arr_ans, arr_vb)))< Date: Thu, 18 Jul 2013 12:55:02 +0300 Subject: [PATCH 57/66] modified equality function for arrs --- Visibility_2/test/include/CGAL/test_utils.h | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index 7c260d3bcbc..4bdbd40a56e 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -74,6 +74,21 @@ bool test_are_equal(const _Arrangement_2 &arr1, const _Arrangement_2 &arr2) { return false; } } + + for (unsigned int i = 0 ; i < halfedges_snd.size() ; i++) { + Halfedge he_curr = halfedges_snd[i]; + bool found = false; + for (unsigned int j = 0 ; j < halfedges_fst.size() ; j++) { + if (he_curr.source()->point() == halfedges_fst[j].source()->point() && + he_curr.target()->point() == halfedges_fst[j].target()->point()) { + found = true; + break; + } + } + if (found == false) { + return false; + } + } return true; } From 4132418a7607d283dc63f4b3e0f4f4d318d2286f Mon Sep 17 00:00:00 2001 From: Francisc Date: Thu, 18 Jul 2013 14:34:41 +0300 Subject: [PATCH 58/66] corrected choice of first vertex in algorithm --- .../include/CGAL/Simple_visibility_2.h | 74 +++++++++++++------ Visibility_2/test/test_simple_visibility.cpp | 16 ++-- 2 files changed, 60 insertions(+), 30 deletions(-) diff --git a/Visibility_2/include/CGAL/Simple_visibility_2.h b/Visibility_2/include/CGAL/Simple_visibility_2.h index 889bc03bbda..33c7a726c21 100644 --- a/Visibility_2/include/CGAL/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Simple_visibility_2.h @@ -24,6 +24,7 @@ #include #include +#include namespace CGAL { @@ -85,17 +86,15 @@ public: Segment_2 curr_edge(he->source()->point(), he->target()->point()); Point_2 curr_vertex = he->source()->point(); - temp_vertices.push_back(curr_vertex); Number_type min_dist = dist_point_to_segment(q, curr_edge, intersect_pt); int min_dist_index = 0; - int index = 1; + int index = 0; // Push all vertices and determine edge minimum in terms of squared distance to query point do { he = curr; curr_edge = Segment_2(he->source()->point(), he->target()->point()); - curr_vertex = Point_2(he->target()->point()); Number_type curr_dist = dist_point_to_segment(q, curr_edge, intersect_pt); if (curr_dist < min_dist) { @@ -103,19 +102,24 @@ public: min_dist_index = index; min_intersect_pt = intersect_pt; } - temp_vertices.push_back(curr_vertex); + temp_vertices.push_back(he->source()->point()); index++; } while (++curr != circ); + std::cout << "min_index = " << min_dist_index << std::endl; + + vertices.push_back(intersect_pt); // Now create vector so that first vertex v0 is visible for (unsigned int k = min_dist_index ; k < temp_vertices.size() ; k++) { + std::cout << "Pushing " << temp_vertices[k] << std::endl; vertices.push_back(temp_vertices[k]); } for (unsigned int k = 0 ; k < min_dist_index ; k++) { + std::cout << "Pushing " << temp_vertices[k] << std::endl; vertices.push_back(temp_vertices[k]); } // Push first vertex again to fulfill algo precondition - // vertices.push_back(vertices[0]); + vertices.push_back(intersect_pt); std::cout << "Vertices:\n"; for (unsigned int k = 0 ; k < vertices.size() ; k++) { @@ -123,6 +127,49 @@ public: } visibility_region_impl(q, out_arr); + + std::cout << "RESULT: " << std::endl; + typename std::deque segments; + if (!s.empty()) { + Point_2 prev_pt = s.top(); + std::cout << "prev: " << prev_pt << std::endl; + if (prev_pt == intersect_pt) { + s.pop(); + if (!s.empty()) { + prev_pt = s.top(); + } + } + if (!s.empty()) { + s.pop(); + } + while(!s.empty()) { + Point_2 curr_pt = s.top(); + std::cout << "curr: " << curr_pt << std::endl; + if (curr_pt == intersect_pt) { + s.pop(); + } + else { + segments.push_front(Segment_2(curr_pt, prev_pt)); + prev_pt = curr_pt; + s.pop(); + } + } + } + + std::cout << "initial\n"; + for (typename std::deque::iterator it = segments.begin(); it != segments.end(); it++) { + std::cout << it->source() << " " << it->target() << std::endl; + } + + // Close the loop + std::cout << "src: " << segments[0].source() << std::endl; + std::cout << "trg: " << segments[segments.size()-1].target() << std::endl; + segments.push_back(Segment_2(segments[segments.size()-1].target(), segments[0].source())); + + for (typename std::deque::iterator it = segments.begin(); it != segments.end(); it++) { + std::cout << it->source() << " " << it->target() << std::endl; + } + CGAL::insert(out_arr, segments.begin(), segments.end()); } void visibility_region(const Point_2 &q, @@ -303,23 +350,6 @@ protected: // exit(0); } } while(upcase != FINISH); - - std::cout << "RESULT: " << std::endl; - typename std::list segments; - if (!s.empty()) { - Point_2 prev_pt = s.top(); - s.pop(); - while(!s.empty()) { - Point_2 curr_pt = s.top(); - segments.push_front(Segment_2(curr_pt, prev_pt)); - prev_pt = curr_pt; - s.pop(); - } - } - for (typename std::list::iterator it = segments.begin(); it != segments.end(); it++) { - std::cout << it->source() << " " << it->target() << std::endl; - } - CGAL::insert(out_arr, segments.begin(), segments.end()); } void left(int &i, Point_2 &w, const Point_2 &query_pt) { diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp index d7e8fa94bf8..901f94f3ce3 100644 --- a/Visibility_2/test/test_simple_visibility.cpp +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -57,11 +57,11 @@ int main() { assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases - /* assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); - assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); - assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ())); - assert(true == (CGAL::simple_polygon_test_case_4, Arrangement_2> ()));*/ -}/* + assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); +// assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); + // assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ())); + // assert(true == (CGAL::simple_polygon_test_case_4, Arrangement_2> ())); +} { typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel; typedef CGAL::Arr_segment_traits_2 Traits_2; @@ -84,8 +84,8 @@ int main() { // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); - assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); - assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ())); -}*/ + /* assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ()));*/ +} return 0; } \ No newline at end of file From c49dac584e87d166844c7a79c53b525dc84ae613 Mon Sep 17 00:00:00 2001 From: Michael Hemmer Date: Thu, 18 Jul 2013 16:38:20 +0200 Subject: [PATCH 59/66] compare visibility regions starting at smallest vertex in each --- Visibility_2/test/include/CGAL/test_utils.h | 438 ++++++++++++-------- 1 file changed, 263 insertions(+), 175 deletions(-) diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/include/CGAL/test_utils.h index 4bdbd40a56e..240b55d7106 100644 --- a/Visibility_2/test/include/CGAL/test_utils.h +++ b/Visibility_2/test/include/CGAL/test_utils.h @@ -18,6 +18,45 @@ namespace CGAL { +template +typename Arrangement_2::Halfedge_handle get_initial_halfedge(const Arrangement_2 &arr) { + + typedef typename Arrangement_2::Vertex Vertex; + typedef typename Arrangement_2::Vertex_handle Vertex_handle; + typedef typename Arrangement_2::Vertex_const_iterator Vertex_const_iterator; + typedef typename Arrangement_2::Halfedge Halfedge; + typedef typename Arrangement_2::Halfedge_handle Halfedge_handle; + + // find the min vertex + Vertex v = *arr.vertices_begin(); + for(Vertex_const_iterator vit = arr.vertices_begin(); vit != arr.vertices_end(); vit++){ + if(arr.traits()->compare_xy_2_object()((*vit).point(),v.point()) == CGAL::SMALLER){ + v = *vit; + } + } + + // take the edge with the smallest source + Halfedge_handle he_final = v.incident_halfedges(); + Halfedge_handle he1 = v.incident_halfedges(); + he1=he1->next()->twin(); + + while(he1 != v.incident_halfedges()){ + if(arr.traits()->compare_xy_2_object()( + he1->source()->point(), + he_final->source()->point()) == CGAL::SMALLER){ + he_final = he1; + } + he1=he1->next()->twin(); + } + + // as this may be on a needle, continue until faces on both sides differ + while(he_final->face() == he_final->twin()->face()) + he_final = he_final->next(); + + return he_final; + +} + /* * Function to compare two arrangements; first determines lowest vertex * from each arrangements, then it walks the edges and compares them @@ -25,225 +64,274 @@ namespace CGAL { template bool test_are_equal(const _Arrangement_2 &arr1, const _Arrangement_2 &arr2) { - typedef _Arrangement_2 Arrangement_2; - typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; - typedef typename Arrangement_2::Vertex_const_iterator Vertex_const_iterator; - typedef typename Arrangement_2::Edge_const_iterator Edge_const_iterator; - typedef typename Arrangement_2::Halfedge Halfedge; - typedef typename Geometry_traits_2::Segment_2 Segment_2; - typedef typename Geometry_traits_2::Point_2 Point_2; + typedef _Arrangement_2 Arrangement_2; + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + typedef typename Arrangement_2::Vertex_const_iterator Vertex_const_iterator; + typedef typename Arrangement_2::Edge_const_iterator Edge_const_iterator; + typedef typename Arrangement_2::Halfedge Halfedge; + typedef typename Arrangement_2::Halfedge_handle Halfedge_handle; + typedef typename Geometry_traits_2::Segment_2 Segment_2; + typedef typename Geometry_traits_2::Point_2 Point_2; - // First make sure they have the same size - if (arr1.number_of_vertices() != arr2.number_of_vertices()) { - return false; - } - if (arr1.number_of_edges() != arr2.number_of_edges()) { - return false; - } - if (arr1.number_of_isolated_vertices() != arr2.number_of_isolated_vertices()) { - return false; - } - if (arr1.number_of_faces() != arr2.number_of_faces()) { - return false; - } + // First make sure they have the same size + if (arr1.number_of_vertices() != arr2.number_of_vertices()) { + return false; + } + if (arr1.number_of_edges() != arr2.number_of_edges()) { + return false; + } + if (arr1.number_of_isolated_vertices() != arr2.number_of_isolated_vertices()) { + return false; + } + if (arr1.number_of_faces() != arr2.number_of_faces()) { + return false; + } + + // currently checking for closed for visibility region + assert(arr1.number_of_faces() == 2); + assert(arr2.number_of_faces() == 2); - Edge_const_iterator eit_fst, eit_snd; - std::vector halfedges_fst, halfedges_snd; - for (eit_fst = arr1.edges_begin(), eit_snd = arr2.edges_begin() ; - eit_fst != arr1.edges_end(), eit_snd != arr2.edges_end() ; - ++eit_fst, ++eit_snd) { + // get unique halfedge + Halfedge_handle he_start_1 = get_initial_halfedge(arr1); + Halfedge_handle he_start_2 = get_initial_halfedge(arr2); + + // run on first loop and compare sources + assert(arr1.traits()->compare_xy_2_object()( + he_start_1->source()->point(), + he_start_2->source()->point()) == CGAL::EQUAL); - halfedges_fst.push_back(*eit_fst); - halfedges_snd.push_back(*eit_snd); - } + Halfedge_handle he_run_1 = he_start_1->next(); + Halfedge_handle he_run_2 = he_start_2->next(); - // Compare the two vectors - for (unsigned int i = 0 ; i < halfedges_fst.size() ; i++) { - Halfedge he_curr = halfedges_fst[i]; - bool found = false; - for (unsigned int j = 0 ; j < halfedges_snd.size() ; j++) { - if (he_curr.source()->point() == halfedges_snd[j].source()->point() && - he_curr.target()->point() == halfedges_snd[j].target()->point()) { - found = true; - break; - } - } - if (found == false) { - return false; - } - } + while(he_run_1 != he_start_1){ + + assert(arr1.traits()->compare_xy_2_object()( + he_run_1->source()->point(), + he_run_2->source()->point()) == CGAL::EQUAL); + + he_run_1 = he_run_1->next(); + he_run_2 = he_run_2->next(); + } + assert(he_run_2 == he_start_2); - for (unsigned int i = 0 ; i < halfedges_snd.size() ; i++) { - Halfedge he_curr = halfedges_snd[i]; - bool found = false; - for (unsigned int j = 0 ; j < halfedges_fst.size() ; j++) { - if (he_curr.source()->point() == halfedges_fst[j].source()->point() && - he_curr.target()->point() == halfedges_fst[j].target()->point()) { - found = true; - break; - } - } - if (found == false) { - return false; - } - } - return true; + + // run on second loop and compare sources. + he_start_1 = he_start_1->twin(); + he_start_2 = he_start_2->twin(); + he_run_1 = he_start_1->next(); + he_run_2 = he_start_2->next(); + while(he_run_1 != he_start_1){ + + assert(arr1.traits()->compare_xy_2_object()( + he_run_1->source()->point(), + he_run_2->source()->point()) == CGAL::EQUAL); + + he_run_1 = he_run_1->next(); + he_run_2 = he_run_2->next(); + } + assert(he_run_2 == he_start_2); + + + return true; + +// Edge_const_iterator eit_fst, eit_snd; +// std::vector halfedges_fst, halfedges_snd; + +// for (eit_fst = arr1.edges_begin(), eit_snd = arr2.edges_begin() ; +// eit_fst != arr1.edges_end(), eit_snd != arr2.edges_end() ; +// ++eit_fst, ++eit_snd) { + +// halfedges_fst.push_back(*eit_fst); +// halfedges_snd.push_back(*eit_snd); +// } + +// // Compare the two vectors +// for (unsigned int i = 0 ; i < halfedges_fst.size() ; i++) { +// Halfedge he_curr = halfedges_fst[i]; +// bool found = false; +// for (unsigned int j = 0 ; j < halfedges_snd.size() ; j++) { +// if (he_curr.source()->point() == halfedges_snd[j].source()->point() && +// he_curr.target()->point() == halfedges_snd[j].target()->point()) { +// found = true; +// break; +// } +// } +// if (found == false) { +// return false; +// } +// } + +// for (unsigned int i = 0 ; i < halfedges_snd.size() ; i++) { +// Halfedge he_curr = halfedges_snd[i]; +// bool found = false; +// for (unsigned int j = 0 ; j < halfedges_fst.size() ; j++) { +// if (he_curr.source()->point() == halfedges_fst[j].source()->point() && +// he_curr.target()->point() == halfedges_fst[j].target()->point()) { +// found = true; +// break; +// } +// } +// if (found == false) { +// return false; +// } +// } +// return true; } template Number_type string2num(const std::string& s) { - int i; - if (s.find("/") != std::string::npos) { - i = s.find("/"); - std::string p = s.substr(0, i); - std::string q = s.substr(i+1); - std::stringstream convert(p); - int n, d; - convert >> n; - std::stringstream convert2(q); - convert2 >> d; - return Number_type(n)/Number_type(d); + int i; + if (s.find("/") != std::string::npos) { + i = s.find("/"); + std::string p = s.substr(0, i); + std::string q = s.substr(i+1); + std::stringstream convert(p); + int n, d; + convert >> n; + std::stringstream convert2(q); + convert2 >> d; + return Number_type(n)/Number_type(d); - } - else { - std::stringstream convert(s); - double n; - convert >> n; - return Number_type(n); - } + } + else { + std::stringstream convert(s); + double n; + convert >> n; + return Number_type(n); + } } template std::string num2string(Number_type& n) { - std::stringstream ss; - ss< void create_arrangement_from_file(_Arrangement_2 &arr, std::ifstream& input) { - typedef _Arrangement_2 Arrangement_2; - typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; - typedef typename Geometry_traits_2::Segment_2 Segment_2; - typedef typename Geometry_traits_2::Point_2 Point_2; - typedef typename Geometry_traits_2::FT Number_type; - if (input) { - std::string line; - while (std::getline(input, line)) { - if (line[0] != '#' && line[0] != '/') - break; - } - std::vector points; - std::vector segments; - std::stringstream convert(line); - int number_of_points; - convert >> number_of_points; + typedef _Arrangement_2 Arrangement_2; + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + typedef typename Geometry_traits_2::Segment_2 Segment_2; + typedef typename Geometry_traits_2::Point_2 Point_2; + typedef typename Geometry_traits_2::FT Number_type; + if (input) { + std::string line; + while (std::getline(input, line)) { + if (line[0] != '#' && line[0] != '/') + break; + } + std::vector points; + std::vector segments; + std::stringstream convert(line); + int number_of_points; + convert >> number_of_points; - for (int i = 0; i != number_of_points; i++) { - std::getline(input, line); - std::string n1, n2; - std::istringstream iss(line); - iss>> n1 >> n2; - points.push_back(Point_2(string2num(n1), string2num(n2))); - } - int number_of_edges; - input >> number_of_edges; - for (int i = 0; i != number_of_edges; i++) { - unsigned i1,i2; - input >> i1 >> i2; - segments.push_back(Segment_2(points[i1], points[i2])); - } - CGAL::insert(arr, segments.begin(), segments.end()); + for (int i = 0; i != number_of_points; i++) { + std::getline(input, line); + std::string n1, n2; + std::istringstream iss(line); + iss>> n1 >> n2; + points.push_back(Point_2(string2num(n1), string2num(n2))); } - else { - std::cout<<"Can't open the file. Check the file name."; + int number_of_edges; + input >> number_of_edges; + for (int i = 0; i != number_of_edges; i++) { + unsigned i1,i2; + input >> i1 >> i2; + segments.push_back(Segment_2(points[i1], points[i2])); } + CGAL::insert(arr, segments.begin(), segments.end()); + } + else { + std::cout<<"Can't open the file. Check the file name."; + } } template void create_polygons_from_file(_Arrangement_2 &arr, std::ifstream& input) { - typedef _Arrangement_2 Arrangement_2; - typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; - typedef typename Geometry_traits_2::Segment_2 Segment_2; - typedef typename Geometry_traits_2::Point_2 Point_2; - typedef typename Geometry_traits_2::FT Number_type; - if (input) { - std::string line; - while (std::getline(input, line)) { - if (line[0] != '#' && line[0] != '/') - break; - } - std::stringstream convert(line); - int number_of_polygons; - convert >> number_of_polygons; - for (int i = 0; i != number_of_polygons; i++) { - std::vector points; - std::vector segments; - int number_of_vertex; - input >> number_of_vertex; - for (int j = 0; j != number_of_vertex-1; j++) { - std::getline(input, line); - std::string n1, n2; - std::istringstream iss(line); - iss >> n1 >> n2; - points.push_back(Point_2(string2num(n1), string2num(n2))); - } - for (int j = 0; j != number_of_vertex-1; j++) { - - segments.push_back(Segment_2(points[j], points[j+1])); - } - segments.push_back(Segment_2(points.front(), points.back())); - CGAL::insert(arr, segments.begin(), segments.end()); - } - + typedef _Arrangement_2 Arrangement_2; + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + typedef typename Geometry_traits_2::Segment_2 Segment_2; + typedef typename Geometry_traits_2::Point_2 Point_2; + typedef typename Geometry_traits_2::FT Number_type; + if (input) { + std::string line; + while (std::getline(input, line)) { + if (line[0] != '#' && line[0] != '/') + break; } - else { - std::cout<<"Can't open the file. Check the file name."; + std::stringstream convert(line); + int number_of_polygons; + convert >> number_of_polygons; + for (int i = 0; i != number_of_polygons; i++) { + std::vector points; + std::vector segments; + int number_of_vertex; + input >> number_of_vertex; + for (int j = 0; j != number_of_vertex-1; j++) { + std::getline(input, line); + std::string n1, n2; + std::istringstream iss(line); + iss >> n1 >> n2; + points.push_back(Point_2(string2num(n1), string2num(n2))); + } + for (int j = 0; j != number_of_vertex-1; j++) { + + segments.push_back(Segment_2(points[j], points[j+1])); + } + segments.push_back(Segment_2(points.front(), points.back())); + CGAL::insert(arr, segments.begin(), segments.end()); } + } + else { + std::cout<<"Can't open the file. Check the file name."; + } + } template bool compare_arr_by_edges(const Arrangement_2& arr1, const Arrangement_2& arr2) { - std::set s1; - typedef typename Arrangement_2::Edge_const_iterator Edge_const_iterator; - for (Edge_const_iterator eit = arr1.edges_begin(); eit != arr1.edges_end(); ++eit) { - s1.insert(edge2string(eit->target()->point(), eit->source()->point())); - } - std::set s2; - for (Edge_const_iterator eit = arr2.edges_begin(); eit != arr2.edges_end(); ++eit) { - s2.insert(edge2string(eit->target()->point(), eit->source()->point())); - } - return s1==s2; + std::set s1; + typedef typename Arrangement_2::Edge_const_iterator Edge_const_iterator; + for (Edge_const_iterator eit = arr1.edges_begin(); eit != arr1.edges_end(); ++eit) { + s1.insert(edge2string(eit->target()->point(), eit->source()->point())); + } + std::set s2; + for (Edge_const_iterator eit = arr2.edges_begin(); eit != arr2.edges_end(); ++eit) { + s2.insert(edge2string(eit->target()->point(), eit->source()->point())); + } + return s1==s2; } template bool is_ahead(Point_2& p1, Point_2& p2) { - if (p1.x() > p2.x()) { - return true; - } - if (p1.x() == p2.x() && p1.y() > p2.y()) { - return true; - } - return false; + if (p1.x() > p2.x()) { + return true; + } + if (p1.x() == p2.x() && p1.y() > p2.y()) { + return true; + } + return false; } template std::string edge2string(const Point_2& p1, const Point_2& p2) { - Point_2 q1, q2; - if (is_ahead(p1, p2)) { - q1 = p1; - q2 = p2; - } - else { - q1 = p2; - q2 = p1; - } - return num2string(q1.x()) + num2string(q1.y()) + num2string(q2.x()) + num2string(q2.y()); + Point_2 q1, q2; + if (is_ahead(p1, p2)) { + q1 = p1; + q2 = p2; + } + else { + q1 = p2; + q2 = p1; + } + return num2string(q1.x()) + num2string(q1.y()) + num2string(q2.x()) + num2string(q2.y()); } From 96b29d5719d72b50d1b72819ffc6ea236d9ee1c9 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Fri, 19 Jul 2013 23:01:49 -0400 Subject: [PATCH 61/66] begin of preprocess algo --- .../include/CGAL/Naive_visibility_2.h | 20 +++++++++++++++++++ Visibility_2/test/test_naive_visibility.cpp | 1 + 2 files changed, 21 insertions(+) diff --git a/Visibility_2/include/CGAL/Naive_visibility_2.h b/Visibility_2/include/CGAL/Naive_visibility_2.h index 6204f43b379..ea9bfd38fa7 100644 --- a/Visibility_2/include/CGAL/Naive_visibility_2.h +++ b/Visibility_2/include/CGAL/Naive_visibility_2.h @@ -1,3 +1,23 @@ +// Copyright (c) 2013 Technical University Braunschweig (Germany). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org). +// You can redistribute it and/or modify it under the terms of the GNU +// General Public License as published by the Free Software Foundation, +// either version 3 of the License, or (at your option) any later version. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s): Kan Huang +// #ifndef CGAL_NAIVE_VISIBILITY_2_H #define CGAL_NAIVE_VISIBILITY_2_H diff --git a/Visibility_2/test/test_naive_visibility.cpp b/Visibility_2/test/test_naive_visibility.cpp index a0c8186bc92..c72055a984c 100644 --- a/Visibility_2/test/test_naive_visibility.cpp +++ b/Visibility_2/test/test_naive_visibility.cpp @@ -12,6 +12,7 @@ #include #include #include +#include From 122c0488a40e035b58c3505b3681ee907d88e233 Mon Sep 17 00:00:00 2001 From: kanhuang Date: Fri, 19 Jul 2013 23:02:20 -0400 Subject: [PATCH 62/66] begin of preprocess algo --- .../include/CGAL/Preprocessed_visibility_2.h | 109 ++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 Visibility_2/include/CGAL/Preprocessed_visibility_2.h diff --git a/Visibility_2/include/CGAL/Preprocessed_visibility_2.h b/Visibility_2/include/CGAL/Preprocessed_visibility_2.h new file mode 100644 index 00000000000..d3c52d566eb --- /dev/null +++ b/Visibility_2/include/CGAL/Preprocessed_visibility_2.h @@ -0,0 +1,109 @@ +// Copyright (c) 2013 Technical University Braunschweig (Germany). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org). +// You can redistribute it and/or modify it under the terms of the GNU +// General Public License as published by the Free Software Foundation, +// either version 3 of the License, or (at your option) any later version. +// +// Licensees holding a valid commercial license may use this file in +// accordance with the commercial license agreement provided with the software. +// +// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +// +// $URL$ +// $Id$ +// +// +// Author(s): Kan Huang +// + +#ifndef CGAL_PREPROCESSED_VISIBILITY_2_H +#define CGAL_PREPROCESSED_VISIBILITY_2_H + +#include +#include +#include +#include + +namespace CGAL { + +namespace Visibility_2 { + +template +class Preprocessed_visibility_2 { + +public: + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + // Currently only consider with same type for both + typedef Arrangement_2 Input_Arrangement_2; + typedef Arrangement_2 Output_Arrangement_2; + + typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle; + typedef typename Arrangement_2::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; + typedef typename Arrangement_2::Face_const_handle Face_const_handle; + typedef typename Arrangement_2::Kernel Kernel; + typedef typename CGAL::Arr_linear_traits_2 Linear_traits_2; + + typedef typename Geometry_traits_2::Point_2 Point_2; + typedef typename Geometry_traits_2::Ray_2 Ray_2; + typedef typename Geometry_traits_2::Segment_2 Segment_2; + typedef typename Geometry_traits_2::Line_2 Line_2; + typedef typename Geometry_traits_2::Vector_2 Vector_2; + typedef typename Geometry_traits_2::FT Number_type; + + typedef typename CGAL::Arrangement_2 Line_Arrangement_2; + + Preprocessed_visibility_2() : p_arr(NULL) {}; + + /*! Constructor given an arrangement and the Regularization tag. */ + Preprocessed_visibility_2(const Input_Arrangement_2 &arr/*, Regularization_tag r_t*/): p_arr(&arr) {}; + + bool is_attached() { + return (p_arr != NULL); + } + + void attach(const Input_Arrangement_2 &arr) { + p_arr = &arr; + } + + void detach() { + p_arr = NULL; + } + + Input_Arrangement_2 arr() { + return *p_arr; + } + + void visibility_region(Point_2 &q, + const Face_const_handle face, + Output_Arrangement_2 &out_arr + ) { + + } + + void visibility_region(const Point_2 &q, + const Halfedge_const_handle he, + Output_Arrangement_2 &out_arr + ) { + +} + +private: + Input_Arrangement_2* arr; + Line_Arrangement_2 line_arr; + void preprocess() { + + } + + Line_2 dual_line(const Point_2& p) { + return Line_2(p.x(), -1, -p.y()); + } + +}; + +} // namespace Visibility_2 +} // namespace CGAL + +#endif From 88e50661542639a761309f1ba893e3ef2dd78fb3 Mon Sep 17 00:00:00 2001 From: Francisc Date: Mon, 22 Jul 2013 13:19:40 +0300 Subject: [PATCH 63/66] implemented treatment of needles --- .../include/CGAL/Simple_visibility_2.h | 1196 +++++++++-------- .../test/data/simple_polygon_test_case_4.out | 8 +- Visibility_2/test/test_simple_visibility.cpp | 31 +- 3 files changed, 671 insertions(+), 564 deletions(-) diff --git a/Visibility_2/include/CGAL/Simple_visibility_2.h b/Visibility_2/include/CGAL/Simple_visibility_2.h index 33c7a726c21..189501acf09 100644 --- a/Visibility_2/include/CGAL/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Simple_visibility_2.h @@ -24,610 +24,718 @@ #include #include -#include namespace CGAL { namespace Visibility_2 { -template +template class Simple_visibility_2 { public: - typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; - // Currently only consider with same type for both - typedef Arrangement_2 Input_Arrangement_2; - typedef Arrangement_2 Output_Arrangement_2; + typedef typename Arrangement_2::Geometry_traits_2 Geometry_traits_2; + // Currently only consider with same type for both + typedef Arrangement_2 Input_Arrangement_2; + typedef Arrangement_2 Output_Arrangement_2; - typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle; - typedef typename Arrangement_2::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; - typedef typename Arrangement_2::Face_const_handle Face_const_handle; + typedef typename Arrangement_2::Halfedge_const_handle Halfedge_const_handle; + typedef typename Arrangement_2::Ccb_halfedge_const_circulator + Ccb_halfedge_const_circulator; + typedef typename Arrangement_2::Face_const_handle Face_const_handle; - typedef typename Geometry_traits_2::Point_2 Point_2; - typedef typename Geometry_traits_2::Ray_2 Ray_2; - typedef typename Geometry_traits_2::Segment_2 Segment_2; - typedef typename Geometry_traits_2::Vector_2 Vector_2; - typedef typename Geometry_traits_2::FT Number_type; + typedef typename Geometry_traits_2::Point_2 Point_2; + typedef typename Geometry_traits_2::Ray_2 Ray_2; + typedef typename Geometry_traits_2::Segment_2 Segment_2; + typedef typename Geometry_traits_2::Line_2 Line_2; + typedef typename Geometry_traits_2::Vector_2 Vector_2; + typedef typename Geometry_traits_2::Direction_2 Direction_2; + typedef typename Geometry_traits_2::FT Number_type; + Simple_visibility_2() : p_arr(NULL), geom_traits(NULL) {}; - Simple_visibility_2() : p_arr(NULL) {}; + /*! Constructor given an arrangement and the Regularization tag. */ + Simple_visibility_2(const Input_Arrangement_2 &arr): + p_arr(&arr) { + geom_traits = p_arr->geometry_traits(); + }; - /*! Constructor given an arrangement and the Regularization tag. */ - Simple_visibility_2(const Input_Arrangement_2 &arr/*, Regularization_tag r_t*/): p_arr(&arr) {}; + bool is_attached() { + return (p_arr != NULL); + } - bool is_attached() { - return (p_arr != NULL); - } + void attach(const Input_Arrangement_2 &arr) { + p_arr = &arr; + geom_traits = p_arr->geometry_traits(); + } - void attach(const Input_Arrangement_2 &arr) { - p_arr = &arr; - } + void detach() { + p_arr = NULL; + geom_traits = NULL; + } - void detach() { - p_arr = NULL; - } + Input_Arrangement_2 arr() { + return *p_arr; + } - Input_Arrangement_2 arr() { - return *p_arr; - } + void visibility_region(Point_2 &q, const Face_const_handle face, + Output_Arrangement_2 &out_arr) { - void visibility_region(Point_2 &q, - const Face_const_handle face, - Output_Arrangement_2 &out_arr - ) { + typename Input_Arrangement_2::Ccb_halfedge_const_circulator circ = + face->outer_ccb(); + typename Input_Arrangement_2::Ccb_halfedge_const_circulator curr = circ; + typename Input_Arrangement_2::Halfedge_const_handle he = curr; - typename Input_Arrangement_2::Ccb_halfedge_const_circulator circ = face->outer_ccb(); - typename Input_Arrangement_2::Ccb_halfedge_const_circulator curr = circ; - typename Input_Arrangement_2::Halfedge_const_handle he = curr; + std::vector temp_vertices; + Point_2 min_intersect_pt; + bool intersect_on_endpoint = false; - std::vector temp_vertices; - Point_2 intersect_pt; - Point_2 min_intersect_pt; + Segment_2 curr_edge(he->source()->point(), he->target()->point()); + Segment_2 curr_min_edge(he->source()->point(), he->target()->point()); + Point_2 curr_vertex = he->target()->point(); + min_intersect_pt = + Construct_projected_point_2(curr_min_edge.supporting_line(), q); - Segment_2 curr_edge(he->source()->point(), he->target()->point()); - Point_2 curr_vertex = he->source()->point(); - Number_type min_dist = dist_point_to_segment(q, curr_edge, intersect_pt); + temp_vertices.push_back(curr_vertex); + Number_type min_dist = Compute_squared_distance_2(q, curr_edge); - int min_dist_index = 0; - int index = 0; + int min_dist_index = 0; + int index = 1; - // Push all vertices and determine edge minimum in terms of squared distance to query point - do { - he = curr; - curr_edge = Segment_2(he->source()->point(), he->target()->point()); + curr++; + // Push all vertices and determine edge minimum in terms + // of squared distance to query point + do { + he = curr; + curr_edge = Segment_2(he->source()->point(), he->target()->point()); + Number_type curr_dist = Compute_squared_distance_2(q, curr_edge); + + if (curr_dist < min_dist) { + min_dist = curr_dist; + min_dist_index = index; + curr_min_edge = curr_edge; + } + temp_vertices.push_back(he->target()->point()); + index++; + } while (++curr != circ); - Number_type curr_dist = dist_point_to_segment(q, curr_edge, intersect_pt); - if (curr_dist < min_dist) { - min_dist = curr_dist; - min_dist_index = index; - min_intersect_pt = intersect_pt; - } - temp_vertices.push_back(he->source()->point()); - index++; - } while (++curr != circ); + // Only now compute the intersection point + min_intersect_pt = + Construct_projected_point_2(curr_min_edge.supporting_line(), q); - std::cout << "min_index = " << min_dist_index << std::endl; + if (min_intersect_pt != curr_min_edge.source() && + min_intersect_pt != curr_min_edge.target()) { + vertices.push_back(min_intersect_pt); + } - vertices.push_back(intersect_pt); - // Now create vector so that first vertex v0 is visible - for (unsigned int k = min_dist_index ; k < temp_vertices.size() ; k++) { - std::cout << "Pushing " << temp_vertices[k] << std::endl; - vertices.push_back(temp_vertices[k]); - } - for (unsigned int k = 0 ; k < min_dist_index ; k++) { - std::cout << "Pushing " << temp_vertices[k] << std::endl; - vertices.push_back(temp_vertices[k]); - } - // Push first vertex again to fulfill algo precondition - vertices.push_back(intersect_pt); + // Now create vector so that first vertex v0 is visible + for (unsigned int k = min_dist_index ; k < temp_vertices.size() ; k++) { + vertices.push_back(temp_vertices[k]); + } + for (unsigned int k = 0 ; k < min_dist_index ; k++) { + vertices.push_back(temp_vertices[k]); + } - std::cout << "Vertices:\n"; - for (unsigned int k = 0 ; k < vertices.size() ; k++) { - std::cout << vertices[k] << std::endl; - } + // Push first vertex again to fulfill algo precondition + if (min_intersect_pt != curr_min_edge.source() && + min_intersect_pt != curr_min_edge.target()) { + vertices.push_back(min_intersect_pt); + } + else { + vertices.push_back(vertices[0]); + } - visibility_region_impl(q, out_arr); + visibility_region_impl(q); - std::cout << "RESULT: " << std::endl; - typename std::deque segments; - if (!s.empty()) { - Point_2 prev_pt = s.top(); - std::cout << "prev: " << prev_pt << std::endl; - if (prev_pt == intersect_pt) { - s.pop(); - if (!s.empty()) { - prev_pt = s.top(); - } - } - if (!s.empty()) { - s.pop(); - } - while(!s.empty()) { - Point_2 curr_pt = s.top(); - std::cout << "curr: " << curr_pt << std::endl; - if (curr_pt == intersect_pt) { - s.pop(); - } - else { - segments.push_front(Segment_2(curr_pt, prev_pt)); - prev_pt = curr_pt; - s.pop(); - } - } - } + typename std::vector points; + if (!s.empty()) { + Point_2 prev_pt = s.top(); + if (prev_pt == min_intersect_pt) { + s.pop(); + if (!s.empty()) { + prev_pt = s.top(); + points.push_back(prev_pt); + } + } + if (!s.empty()) { + s.pop(); + } + while(!s.empty()) { + Point_2 curr_pt = s.top(); + if (curr_pt == min_intersect_pt) { + s.pop(); + } + else { + points.push_back(curr_pt); + prev_pt = curr_pt; + s.pop(); + } + } + } - std::cout << "initial\n"; - for (typename std::deque::iterator it = segments.begin(); it != segments.end(); it++) { - std::cout << it->source() << " " << it->target() << std::endl; - } + std::reverse(points.begin(), points.end()); + std::vector segments; + treat_needles(q, points, segments); + CGAL::insert_non_intersecting_curves(out_arr, + segments.begin(), + segments.end()); + } - // Close the loop - std::cout << "src: " << segments[0].source() << std::endl; - std::cout << "trg: " << segments[segments.size()-1].target() << std::endl; - segments.push_back(Segment_2(segments[segments.size()-1].target(), segments[0].source())); + void visibility_region(const Point_2 &q, const Halfedge_const_handle he, + Output_Arrangement_2 &out_arr ) { - for (typename std::deque::iterator it = segments.begin(); it != segments.end(); it++) { - std::cout << it->source() << " " << it->target() << std::endl; - } - CGAL::insert(out_arr, segments.begin(), segments.end()); - } + if (q != he->source()->point()) { + if (q != he->target()->point()) { + s.push(q); + vertices.push_back(he->target()->point()); + } + else { + vertices.push_back(q); + } + } + else { + vertices.push_back(q); + vertices.push_back(he->target()->point()); + } - void visibility_region(const Point_2 &q, - const Halfedge_const_handle he, - Output_Arrangement_2 &out_arr - ) { + typename Input_Arrangement_2::Face_const_handle face = he->face(); + typename Input_Arrangement_2::Ccb_halfedge_const_circulator circ = + face->outer_ccb(); + typename Input_Arrangement_2::Ccb_halfedge_const_circulator curr; + typename Input_Arrangement_2::Halfedge_const_handle he_handle = circ; - if (q != he->source()->point()) { - if (q != he->target()->point()) { - s.push(q); - // vertices.push_back(q); - vertices.push_back(he->target()->point()); - } - else { - vertices.push_back(q); - } - } - else { - vertices.push_back(q); - vertices.push_back(he->target()->point()); - } + while (he_handle != he) { + he_handle = circ; + circ++; + } - typename Input_Arrangement_2::Face_const_handle face = he->face(); - typename Input_Arrangement_2::Ccb_halfedge_const_circulator circ = face->outer_ccb(); - typename Input_Arrangement_2::Ccb_halfedge_const_circulator curr; - typename Input_Arrangement_2::Halfedge_const_handle he_handle = circ; + curr = circ; + curr++; - while (he_handle != he) { - he_handle = circ; - circ++; - } + he_handle = curr; + vertices.push_back(Point_2(he_handle->source()->point())); - curr = circ; - curr++; + while (curr != circ) { + he_handle = curr; + Point_2 curr_vertex = he_handle->target()->point(); + vertices.push_back(curr_vertex); + curr++; + } + vertices.push_back(q); - he_handle = curr; - vertices.push_back(Point_2(he_handle->source()->point())); + visibility_region_impl(q); + + typename std::vector points; + if (!s.empty()) { + Point_2 prev_pt = s.top(); + if (prev_pt != q) { + points.push_back(prev_pt); + } + if (!s.empty()) { + s.pop(); + } + while(!s.empty()) { + Point_2 curr_pt = s.top(); + if (curr_pt != q) { + points.push_back(curr_pt); + } + s.pop(); + } + } - typename Input_Arrangement_2::Ccb_halfedge_const_circulator next; - next = curr; - next++; + std::reverse(points.begin(), points.end()); + std::vector segments; + treat_needles(q, points, segments); + CGAL::insert_non_intersecting_curves(out_arr, segments.begin(), segments.end()); + } - while (curr != circ) { - he_handle = curr; - Point_2 curr_vertex = he_handle->target()->point(); - vertices.push_back(curr_vertex); - curr++; - next = curr; - next++; - } - vertices.push_back(q); - std::cout << "Vertices:" << std::endl; - for (unsigned int i = 0 ; i < vertices.size() ; i++) { - std::cout << vertices[i] << std::endl; - } + void print_arrangement(const Arrangement_2 &arr) { + typedef typename Arrangement_2::Edge_const_iterator Edge_const_iterator; + Edge_const_iterator eit; + std::cout << arr.number_of_edges() << " edges:" << std::endl; + for (eit = arr.edges_begin(); eit != arr.edges_end(); ++eit) + std::cout << "[" << eit->curve() << "]" << std::endl; + } - visibility_region_impl(q, out_arr); - } protected: - const Input_Arrangement_2 *p_arr; - std::stack s; - std::vector vertices; - enum {LEFT, RIGHT, SCANA, SCANB, SCANC, SCAND, FINISH} upcase; + const Input_Arrangement_2 *p_arr; + const Geometry_traits_2 *geom_traits; + std::stack s; + std::vector vertices; + enum {LEFT, RIGHT, SCANA, SCANB, SCANC, SCAND, FINISH} upcase; - Number_type dist_point_to_segment(const Point_2 &p, const Segment_2 &seg, Point_2 &intersect_pt) { + typedef Arr_traits_basic_adaptor_2 Traits_adaptor_2; - Vector_2 v(seg); - Vector_2 w(seg.source(), p); - Number_type c1 = w*v; - if (c1 <= 0) { - intersect_pt = seg.source(); - return squared_distance(p, seg.source()); - } + bool LessDistanceToPoint_2(const Point_2 &p, const Point_2 &q, + const Point_2 &r) const { + typename Geometry_traits_2::Less_distance_to_point_2 less_dist = + geom_traits->less_distance_to_point_2_object(); + return less_dist(p, q, r); + } - Number_type c2 = v*v; - if (c2 <= c1) { - intersect_pt = seg.target(); - return squared_distance(p, seg.target()); - } + bool Collinear(const Point_2 &p, const Point_2 &q, + const Point_2 &r) const { + typename Geometry_traits_2::Collinear_2 collinear_fnct = + geom_traits->collinear_2_object(); + return collinear_fnct(p, q, r); + } +/* + Object_2 Intersect_2(const Segment_2 &s1, const Segment_2 &s2) { + typename Geometry_traits_2::Intersect_2 intersect_fnct = + geom_traits->intersect_2_object(); + return intersect_fnct(s1, s2); + } +*/ + Orientation Orientation_2(const Point_2 &p, const Point_2 &q, + const Point_2 &r) { + typename Geometry_traits_2::Orientation_2 orient = + geom_traits->orientation_2_object(); + return orient(p, q, r); + } - Number_type b = c1/c2; - intersect_pt = Point_2(seg.source() + b*v); - return squared_distance(p, intersect_pt); - } + Point_2 Construct_projected_point_2(const Line_2 &l, const Point_2 &p) { + typename Geometry_traits_2::Construct_projected_point_2 construct_proj = + geom_traits->construct_projected_point_2_object(); + return construct_proj(l, p); + } - bool do_overlap(const Point_2 &a, const Point_2 &b, const Point_2 &c) { - if (collinear(a, b, c)) { - std::cout << a << " " << b << " " << c << " are collinear" << std::endl; - Segment_2 s1(a, b); - Segment_2 s2(a, c); - const Segment_2 *seg_overlap; - CGAL::Object result = CGAL::intersection(s1, s2); - if (seg_overlap = CGAL::object_cast(&result)) { - return true; - } - } - return false; - } + Number_type Compute_squared_distance_2(const Point_2 &p, + const Segment_2 &seg) { + typename Geometry_traits_2::Compute_squared_distance_2 compute_dist = + geom_traits->compute_squared_distance_2_object(); + return compute_dist(p, seg); + } - void visibility_region_impl(const Point_2 &q, Output_Arrangement_2 &out_arr) { + bool do_overlap(const Point_2 &a, const Point_2 &b, const Point_2 &c) { + if (collinear(a, b, c)) { + Segment_2 s1(a, b); + Segment_2 s2(a, c); + const Segment_2 *seg_overlap; + CGAL::Object result = CGAL::intersection(s1, s2); + if (seg_overlap = CGAL::object_cast(&result)) { + return true; + } + } + return false; + } - int i = 0; - Point_2 w; + void treat_needles(const Point_2 &q, typename std::vector &points, + typename std::vector &segments) { - if (orientation(q, vertices[0], vertices[1]) == CGAL::LEFT_TURN) { - std::cout << "left" << std::endl; - upcase = LEFT; - i = 1; - w = vertices[1]; - s.push(vertices[0]); - s.push(vertices[1]); - } - else { - std::cout << "scana" << std::endl; - upcase = SCANA; - i = 1; - w = vertices[1]; - s.push(vertices[0]); - } + typename std::vector::size_type i = 0; - do { - std::cout << "CASE: " << upcase << std::endl; - switch(upcase) { - case LEFT: - left(i, w, q); - break; - case RIGHT: - right(i, w, q); - break; - case SCANA: - scana(i, w, q); - break; - case SCANB: - scanb(i, w, q); - break; - case SCANC: - scanc(i, w, q); - break; - case SCAND: - scand(i, w, q); - break; - } - if (upcase == LEFT) { - // Check if (s_t-1, s_t) intersects (q, vn) - Point_2 s_t = s.top(); - std::cout << "s_t= " << s_t << std::endl; - s.pop(); - Point_2 s_t_prev = s.top(); - std::cout << "s_t-1= " << s_t_prev << std::endl; - Segment_2 s1(s_t_prev, s_t); - Segment_2 s2(q, vertices[vertices.size()-1]); - CGAL::Object result = CGAL::intersection(s1, s2); + while (CGAL::collinear(points[i], points[points.size()-1], + points[points.size()-2]) || + CGAL::collinear(points[i], points[i+1], points[points.size()-1])) { - if (const Point_2 *ipoint = CGAL::object_cast(&result)) { - Segment_2 s3(s_t_prev, vertices[i]); - CGAL::Object result2 = CGAL::intersection(s3, s2); - if (const Point_2 *vertex_new = CGAL::object_cast(&result2)) { - if ((*vertex_new) != (s_t_prev) && (*vertex_new != s_t)) { - std::cout << "switch to scanb" << std::endl; - upcase = SCANB; - std::cout << "pushing " << *vertex_new << std::endl; - s.push(*vertex_new); - } - else { // Do not alter stack if it doesn't intersect - push back s_t - std::cout << "skipping because it is endpoint" << std::endl; - s.push(s_t); - } - } - else { - s.push(s_t); - } - } - else { - s.push(s_t); - } - } - if (i == 9) { -// exit(0); - } - } while(upcase != FINISH); - } + points.push_back(points[i]); + i++; + } - void left(int &i, Point_2 &w, const Point_2 &query_pt) { - std::cout << "begin left with i = " << i << std::endl; - if (i == vertices.size() - 1) { - std::cout << "done" << std::endl; - upcase = FINISH; - } - else if (orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::LEFT_TURN) { - std::cout << "left::left turn with i =" << i << std::endl; - upcase = LEFT; - std::cout << "left::pushing1 " << vertices[i+1] << std::endl; - s.push(vertices[i+1]); - w = vertices[i+1]; - i++; - } - else if (orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { - std::cout << "left::right turn with i = " << i << std::endl; - Point_2 s_t = s.top(); - std::cout << "left:: s_t = " << s_t << std::endl; - s.pop(); - Point_2 s_t_prev = s.top(); - std::cout << "left:: s_t-i = " << s_t_prev << std::endl; - s.pop(); - if (orientation(s_t_prev, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { - std::cout << "left::switched to scana" << std::endl; - upcase = SCANA; - w = vertices[i+1]; - i++; - } // Both conditions have to be met to move on. Thus same else branch as below - else { - std::cout << "left::switching to right mode branch1" << std::endl; - upcase = RIGHT; - w = vertices[i]; - i++; - } - s.push(s_t_prev); - s.push(s_t); - } - else { - std::cout << "left::switching to right mode" << std::endl; - upcase = RIGHT; - i++; - w = vertices[i]; - } - std::cout << "leaving left with i = " << i << std::endl; - } + points.push_back(points[i]); - void right(int &i, Point_2 &w, const Point_2 &query_pt) { - // Scan s_t, s_t-1, ..., s_1, s_0 for the first edge (s_j, s_j-1) such that - // (a) (z, s_j, v_i) is a right turn and (z, s_j-1, v_i) is a left turn, or - // (b) (z, s_j-1, s_j) is a forward move and (v_i-1, v_i) intersects (s_j-1, s_j) - bool found = false; - std::cout << "entered right with i = " << i << std::endl; - while(!found && !s.empty()) { - Point_2 s_j = s.top(); - std::cout << "right:: considering s_j = " << s_j << std::endl; - s.pop(); - if (!s.empty()) { - Point_2 s_j_prev = s.top(); - std::cout << "right:: s_j-1 = " << s_j_prev << std::endl; + std::vector forward_needle; + std::vector backward_needle; - // Check condition (a) - if ((orientation(query_pt, s_j, vertices[i]) == CGAL::RIGHT_TURN) - && (orientation(query_pt, s_j_prev, vertices[i]) == CGAL::LEFT_TURN)) { - std::cout << "right:: case A" << std::endl; - found = true; - Segment_2 s1(s_j_prev, s_j); - Ray_2 s2(query_pt, vertices[i]); - CGAL::Object result = intersection(s1, s2); - if (const Point_2 *ipoint = CGAL::object_cast(&result)) { - std::cout << "s_j is now = " << *ipoint << std::endl; - s_j = *ipoint; - } + while (i+1 < points.size()) { + if ((i+2 < points.size()) && + (Orientation_2(points[i], + points[i+1], + points[i+2]) == CGAL::COLLINEAR)) { + + Point_2 needle_start = points[i]; + Direction_2 forward_dir(Segment_2(points[i], points[i+1])); + forward_needle.push_back(points[i]); + forward_needle.push_back(points[i+1]); - if (orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN) { - std::cout << "case a1" << std::endl; - upcase = RIGHT; - s.push(s_j); - w = vertices[i]; - i++; - } - else if ((orientation(query_pt, vertices[i], vertices[i+1]) == CGAL::LEFT_TURN) - && (orientation(vertices[i-1], vertices[i], vertices[i+1]) == CGAL::RIGHT_TURN)) { - std::cout << "case a2: right::switch to left" << std::endl; - upcase = LEFT; - s.push(s_j); - s.push(vertices[i]); - s.push(vertices[i+1]); - w = vertices[i+1]; - i++; - } - else { - std::cout << "case a3" << std::endl; - upcase = SCANC; - s.push(s_j); - w = vertices[i]; - i++; - } - } - else if (do_overlap(query_pt, s_j_prev, s_j)) { // Case (b) - // Check if v_i-1, v_i intersects (s_j-1, s_j) - Segment_2 s1(s_j_prev, s_j); - Segment_2 s2(vertices[i-1], vertices[i]); - CGAL::Object result = intersection(s1, s2); - if (const Point_2 *ipoint = CGAL::object_cast(&result)) { - // Keep s_j off the stack - std::cout << "right:: case B" << std::endl; - found = true; - upcase = SCAND; - w = *ipoint; - } - } - else if ((orientation(query_pt, s_j, vertices[i]) == CGAL::RIGHT_TURN) - && (orientation(query_pt, s_j_prev, vertices[i]) == CGAL::COLLINEAR)) { - std::cout << "we're here in collinear" << std::endl; - found = true; - upcase = LEFT; - std::cout << "right::pushing " << vertices[i] << std::endl; - std::cout << "right::pushing " << vertices[i+1] << std::endl; - s.push(vertices[i]); - s.push(vertices[i+1]); - w = vertices[i+1]; - i++; - } - std::cout << "right::FOUND? = " << found << std::endl; - } - } - std::cout << "leaving right with i = " << i << std::endl; - } + while ((i+2 < points.size()) && + (Orientation_2(points[i], + points[i+1], + points[i+2]) == CGAL::COLLINEAR)) { - void scana(int &i, Point_2 &w, const Point_2 &query_pt) { - // Scan v_i, v_i+1, ..., v_n for the first edge to intersect (z, s_t) - bool found = false; - int k = i; - Point_2 intersection_pt; - while (k+1 < vertices.size()) { - std::cout << "Considering edge: " << vertices[k] << " " << vertices[k+1] << std::endl; - Segment_2 s1(vertices[k], vertices[k+1]); - std::cout << "With edge: " << query_pt << " " << s.top() << std::endl; - Ray_2 s2(query_pt, s.top()); - CGAL::Object result = intersection(s1, s2); - if (const Point_2 *ipoint = CGAL::object_cast(&result)) { - found = true; - std::cout << " found edge!" << std::endl; - intersection_pt = *ipoint; - std::cout << intersection_pt << std::endl; - break; - } - k++; - } - if (found) { - if ((orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::RIGHT_TURN) - && (!do_overlap(query_pt, s.top(), intersection_pt))) { - std::cout << "if1" << std::endl; - upcase = RIGHT; - i = k+1; - w = intersection_pt; - } - else if ((orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::RIGHT_TURN) - && (do_overlap(query_pt, s.top(), intersection_pt))) { - std::cout << "elseif1" << std::endl; - upcase = SCAND; - i = k+1; - w = intersection_pt; - } - else if ((orientation(query_pt, vertices[k], vertices[k+1]) == CGAL::LEFT_TURN) - && (do_overlap(query_pt, s.top(), intersection_pt))) { - std::cout << "elseif2" << std::endl; - upcase = LEFT; - i = k+1; - s.push(intersection_pt); - std::cout << "scana::pushing " << intersection_pt << std::endl; - if (intersection_pt != vertices[k+1]) { - std::cout << "scana::pushing " << vertices[k+1] << std::endl; - s.push(vertices[k+1]); - } - w = vertices[k+1]; - } - else { - std::cout << "should never occur" << std::endl; - // This case never occurs - } - } - } + Direction_2 check_dir(Segment_2(points[i+1], points[i+2])); + if (forward_dir == check_dir) { + forward_needle.push_back(points[i+2]); + } + else if (check_dir == -forward_dir) { + backward_needle.push_back(points[i+2]); + } + i++; + } + std::reverse(backward_needle.begin(), backward_needle.end()); - void scanb(int &i, Point_2 &w, const Point_2 &query_pt) { - // Scan v_i, v_i+1, ..., v_n-1, v_n for the first edge to intersect (s_t, v_n] - Point_2 s_t = s.top(); - int k = i; - bool found = false; - Point_2 intersection_pt; - while (k+1 < vertices.size()) { - Segment_2 s1(vertices[k], vertices[k+1]); - Segment_2 s2(s_t, vertices[vertices.size()-1]); - CGAL::Object result = intersection(s1, s2); - if (const Point_2 *ipoint = CGAL::object_cast(&result)) { - if (*ipoint != s_t) { - intersection_pt = *ipoint; - found = true; - break; - } - } - k++; - } - if (found) { - if ((intersection_pt == vertices[k+1]) && (intersection_pt == vertices[vertices.size()-1])) { - std::cout << "scanb::done\n"; - upcase = FINISH; - w = vertices[vertices.size()-1]; - s.push(vertices[vertices.size()-1]); - } - else { - upcase = RIGHT; - i = k+1; - w = intersection_pt; - } - } - else { - upcase = LEFT; - i++; - } - } + std::vector merged_needle; - void scanc(int &i,Point_2 &w, const Point_2 &query_pt) { - // Scan v_i, v_i+1, ..., v_n-1, v_n for the first edge to intersect (s_t, w) - std::cout << "entered scanc with i = " << i << std::endl; - Point_2 s_t = s.top(); - int k = i; - bool found = false; - Point_2 intersection_pt; - std::cout << "size: " << vertices.size() << std::endl; - while (k+1 < vertices.size()) { - std::cout << "doesn't get here" << std::endl; - Segment_2 s1(vertices[k], vertices[k+1]); - Segment_2 s2(s_t, w); - CGAL::Object result = intersection(s1, s2); - if (const Point_2 *ipoint = CGAL::object_cast(&result)) { - found = true; - std::cout << "scanc::found" << std::endl; - intersection_pt = *ipoint; - break; - } - k++; - } - if (found) { - upcase = RIGHT; - i = k+1; - w = intersection_pt; - } - std::cout << "leaving scanc" << std::endl; - } + // Now merge the two vectors + unsigned int itr_fst = 0, itr_snd = 0; + while (itr_fst < forward_needle.size() && + itr_snd < backward_needle.size()) { - void scand(int &i, Point_2 &w, const Point_2 &query_pt) { - // Scan v_i, v_i+1, v_n-1, v_n for the fist edge to intersect (s_t, w) - Point_2 s_t = s.top(); - int k = i; - bool found = false; - Point_2 intersection_pt; - while (k+1 < vertices.size()) { - Segment_2 s1(vertices[k], vertices[k+1]); - Segment_2 s2(s_t, w); - CGAL::Object result = intersection(s1, s2); - if (const Point_2 *ipoint = CGAL::object_cast(&result)) { - found = true; - intersection_pt = *ipoint; - break; - } - k++; - } - if (found) { - upcase = LEFT; - i = k+1; - s.push(intersection_pt); - s.push(vertices[k+1]); - w = vertices[k+1]; - } - } + if (LessDistanceToPoint_2(q, forward_needle[itr_fst], + backward_needle[itr_snd])) { + merged_needle.push_back(forward_needle[itr_fst]); + itr_fst++; + } + else { + merged_needle.push_back(backward_needle[itr_snd]); + itr_snd++; + } + } + while (itr_fst < forward_needle.size()) { + merged_needle.push_back(forward_needle[itr_fst]); + itr_fst++; + } + while (itr_snd < backward_needle.size()) { + merged_needle.push_back(backward_needle[itr_snd]); + itr_snd++; + } + for (unsigned int p = 0 ; p+1 < merged_needle.size() ; p++) { + segments.push_back(Segment_2(merged_needle[p], merged_needle[p+1])); + } + } + else { + segments.push_back(Segment_2(points[i], points[i+1])); + } + i++; + } + } + + void visibility_region_impl(const Point_2 &q) { + + int i = 0; + Point_2 w; + + if (Orientation_2(q, vertices[0], vertices[1]) == CGAL::LEFT_TURN) { + upcase = LEFT; + i = 1; + w = vertices[1]; + s.push(vertices[0]); + s.push(vertices[1]); + } + else { + upcase = SCANA; + i = 1; + w = vertices[1]; + s.push(vertices[0]); + } + + do { + switch(upcase) { + case LEFT: + left(i, w, q); + break; + case RIGHT: + right(i, w, q); + break; + case SCANA: + scana(i, w, q); + break; + case SCANB: + scanb(i, w, q); + break; + case SCANC: + scanc(i, w, q); + break; + case SCAND: + scand(i, w, q); + break; + } + if (upcase == LEFT) { + // Check if (s_t-1, s_t) intersects (q, vn) + Point_2 s_t = s.top(); + s.pop(); + Point_2 s_t_prev = s.top(); + Segment_2 s1(s_t_prev, s_t); + Segment_2 s2(q, vertices[vertices.size()-1]); + CGAL::Object result = CGAL::intersection(s1, s2); + + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + Segment_2 s3(s_t_prev, vertices[i]); + CGAL::Object result2 = CGAL::intersection(s3, s2); + if (const Point_2 *vertex_new = CGAL::object_cast(&result2)){ + if ((*vertex_new) != (s_t_prev) && (*vertex_new != s_t)) { + upcase = SCANB; + s.push(*vertex_new); + } + else { // Do not alter stack if it doesn't intersect - push back s_t + s.push(s_t); + } + } + else { + s.push(s_t); + } + } + else { + s.push(s_t); + } + } + } while(upcase != FINISH); + } + + void left(int &i, Point_2 &w, const Point_2 &query_pt) { + if (i == vertices.size() - 1) { + upcase = FINISH; + } + else if (Orientation_2(query_pt, + vertices[i], + vertices[i+1]) == CGAL::LEFT_TURN) { + upcase = LEFT; + s.push(vertices[i+1]); + w = vertices[i+1]; + i++; + } + else if (Orientation_2(query_pt, + vertices[i], + vertices[i+1]) == CGAL::RIGHT_TURN) { + Point_2 s_t = s.top(); + s.pop(); + Point_2 s_t_prev = s.top(); + s.pop(); + if (Orientation_2(s_t_prev, + vertices[i], + vertices[i+1]) == CGAL::RIGHT_TURN) { + upcase = SCANA; + w = vertices[i+1]; + i++; + } // Both conditions have to be met to move on. Thus same else branch as below + else { + upcase = RIGHT; + w = vertices[i]; + i++; + } + s.push(s_t_prev); + s.push(s_t); + } + else { + upcase = RIGHT; + i++; + w = vertices[i]; + } + } + + void right(int &i, Point_2 &w, const Point_2 &query_pt) { + // Scan s_t, s_t-1, ..., s_1, s_0 for the first edge (s_j, s_j-1) such that + // (a) (z, s_j, v_i) is a right turn and (z, s_j-1, v_i) is a left turn, or + // (b) (z, s_j-1, s_j) is a forward move and (v_i-1, v_i) intersects (s_j-1, s_j) + bool found = false; + while(!found && !s.empty()) { + Point_2 s_j = s.top(); + s.pop(); + if (!s.empty()) { + Point_2 s_j_prev = s.top(); + // Check condition (a) + if ((Orientation_2(query_pt, + s_j, + vertices[i]) == CGAL::RIGHT_TURN) && + (Orientation_2(query_pt, + s_j_prev, + vertices[i]) == CGAL::LEFT_TURN)) { + found = true; + Segment_2 s1(s_j_prev, s_j); + Ray_2 s2(query_pt, vertices[i]); + CGAL::Object result = CGAL::intersection(s1, s2); + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + s_j = *ipoint; + } + + if (Orientation_2(query_pt, + vertices[i], + vertices[i+1]) == CGAL::RIGHT_TURN) { + upcase = RIGHT; + s.push(s_j); + w = vertices[i]; + i++; + } + else if ((Orientation_2(query_pt, + vertices[i], + vertices[i+1]) == CGAL::LEFT_TURN) && + (Orientation_2(vertices[i-1], + vertices[i], + vertices[i+1]) == CGAL::RIGHT_TURN)) { + upcase = LEFT; + s.push(s_j); + s.push(vertices[i]); + s.push(vertices[i+1]); + w = vertices[i+1]; + i++; + } + else { + upcase = SCANC; + s.push(s_j); + w = vertices[i]; + i++; + } + } + else if (do_overlap(query_pt, s_j_prev, s_j)) { // Case (b) + // Check if v_i-1, v_i intersects (s_j-1, s_j) + Segment_2 s1(s_j_prev, s_j); + Segment_2 s2(vertices[i-1], vertices[i]); + CGAL::Object result = CGAL::intersection(s1, s2); + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + // Keep s_j off the stack + found = true; + upcase = SCAND; + w = *ipoint; + } + } + else if ((Orientation_2(query_pt, + s_j, + vertices[i]) == CGAL::RIGHT_TURN) && + (Orientation_2(query_pt, + s_j_prev, + vertices[i]) == CGAL::COLLINEAR)) { + found = true; + upcase = LEFT; + s.push(vertices[i]); + s.push(vertices[i+1]); + w = vertices[i+1]; + i++; + } + } + } + } + + void scana(int &i, Point_2 &w, const Point_2 &query_pt) { + // Scan v_i, v_i+1, ..., v_n for the first edge to intersect (z, s_t) + bool found = false; + int k = i; + Point_2 intersection_pt; + while (k+1 < vertices.size()) { + Segment_2 s1(vertices[k], vertices[k+1]); + Ray_2 s2(query_pt, s.top()); + CGAL::Object result = intersection(s1, s2); + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + found = true; + intersection_pt = *ipoint; + break; + } + k++; + } + if (found) { + if ((Orientation_2(query_pt, + vertices[k], + vertices[k+1]) == CGAL::RIGHT_TURN) && + (!do_overlap(query_pt, s.top(), intersection_pt))) { + + upcase = RIGHT; + i = k+1; + w = intersection_pt; + } + else if ((Orientation_2(query_pt, + vertices[k], + vertices[k+1]) == CGAL::RIGHT_TURN) && + (do_overlap(query_pt, s.top(), intersection_pt))) { + + upcase = SCAND; + i = k+1; + w = intersection_pt; + } + else if ((Orientation_2(query_pt, + vertices[k], + vertices[k+1]) == CGAL::LEFT_TURN) && + (do_overlap(query_pt, s.top(), intersection_pt))) { + + upcase = LEFT; + i = k+1; + s.push(intersection_pt); + if (intersection_pt != vertices[k+1]) { + s.push(vertices[k+1]); + } + w = vertices[k+1]; + } + else { + // This case never occurs + } + } + } + + void scanb(int &i, Point_2 &w, const Point_2 &query_pt) { + // Scan v_i, v_i+1, ..., v_n-1, v_n for the first edge to intersect (s_t, v_n] + Point_2 s_t = s.top(); + int k = i; + bool found = false; + Point_2 intersection_pt; + while (k+1 < vertices.size()) { + Segment_2 s1(vertices[k], vertices[k+1]); + Segment_2 s2(s_t, vertices[vertices.size()-1]); + CGAL::Object result = CGAL::intersection(s1, s2); + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + if (*ipoint != s_t) { + intersection_pt = *ipoint; + found = true; + break; + } + } + k++; + } + if (found) { + if ((intersection_pt == vertices[k+1]) && + (intersection_pt == vertices[vertices.size()-1])) { + + upcase = FINISH; + w = vertices[vertices.size()-1]; + s.push(vertices[vertices.size()-1]); + } + else { + upcase = RIGHT; + i = k+1; + w = intersection_pt; + } + } + else { + upcase = LEFT; + i++; + } + } + + void scanc(int &i,Point_2 &w, const Point_2 &query_pt) { + // Scan v_i, v_i+1, ..., v_n-1, v_n for the first edge to intersect (s_t, w) + Point_2 s_t = s.top(); + int k = i; + bool found = false; + Point_2 intersection_pt; + while (k+1 < vertices.size()) { + Segment_2 s1(vertices[k], vertices[k+1]); + Segment_2 s2(s_t, w); + CGAL::Object result = CGAL::intersection(s1, s2); + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + found = true; + intersection_pt = *ipoint; + break; + } + k++; + } + if (found) { + upcase = RIGHT; + i = k+1; + w = intersection_pt; + } + } + + void scand(int &i, Point_2 &w, const Point_2 &query_pt) { + // Scan v_i, v_i+1, v_n-1, v_n for the fist edge to intersect (s_t, w) + Point_2 s_t = s.top(); + int k = i; + bool found = false; + Point_2 intersection_pt; + while (k+1 < vertices.size()) { + Segment_2 s1(vertices[k], vertices[k+1]); + Segment_2 s2(s_t, w); + CGAL::Object result = CGAL::intersection(s1, s2); + if (const Point_2 *ipoint = CGAL::object_cast(&result)) { + found = true; + intersection_pt = *ipoint; + break; + } + k++; + } + if (found) { + upcase = LEFT; + i = k+1; + s.push(intersection_pt); + s.push(vertices[k+1]); + w = vertices[k+1]; + } + } }; } // namespace Visibility_2 diff --git a/Visibility_2/test/data/simple_polygon_test_case_4.out b/Visibility_2/test/data/simple_polygon_test_case_4.out index 4399c931640..eb97ed629ba 100644 --- a/Visibility_2/test/data/simple_polygon_test_case_4.out +++ b/Visibility_2/test/data/simple_polygon_test_case_4.out @@ -1,17 +1,15 @@ # Test case 4 for simple polygons. See https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases -7 +6 0 0 4 0 8 3 12 3 4 3 -2 3 0 3 -7 +6 0 1 1 2 2 3 2 4 4 5 -5 6 -6 0 +5 0 \ No newline at end of file diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/test_simple_visibility.cpp index 901f94f3ce3..d67e89bac9d 100644 --- a/Visibility_2/test/test_simple_visibility.cpp +++ b/Visibility_2/test/test_simple_visibility.cpp @@ -47,20 +47,20 @@ int main() { Arrangement_2 arr; std::ifstream input("./data/simple_polygon_test_case_1.in"); CGAL::create_arrangement_from_file(arr, input); - CGAL::Visibility_2::Simple_visibility_2 visibility; - assert(false == (CGAL::test_is_attached >(visibility))); + CGAL::Visibility_2::Simple_visibility_2 visibility; + assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); - assert(true == (CGAL::test_is_attached >(visibility))); + assert(true == (CGAL::test_is_attached >(visibility))); visibility.detach(); - assert(false == (CGAL::test_is_attached >(visibility))); + assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases - assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); -// assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); - // assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ())); - // assert(true == (CGAL::simple_polygon_test_case_4, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_4, Arrangement_2> ())); } { typedef CGAL::Exact_predicates_exact_constructions_kernel Kernel; @@ -73,19 +73,20 @@ int main() { Arrangement_2 arr; std::ifstream input("./data/simple_polygon_test_case_1.in"); CGAL::create_arrangement_from_file(arr, input); - CGAL::Visibility_2::Simple_visibility_2 visibility; - assert(false == (CGAL::test_is_attached >(visibility))); + CGAL::Visibility_2::Simple_visibility_2 visibility; + assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); - assert(true == (CGAL::test_is_attached >(visibility))); + assert(true == (CGAL::test_is_attached >(visibility))); visibility.detach(); - assert(false == (CGAL::test_is_attached >(visibility))); + assert(false == (CGAL::test_is_attached >(visibility))); visibility.attach(arr); assert(true == (CGAL::test_are_equal(arr, visibility.arr()))); // Run test cases from https://cgal.geometryfactory.com/CGAL/Members/wiki/Visibility/TestCases - assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); - /* assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); - assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ()));*/ + assert(true == (CGAL::simple_polygon_test_case_1, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_2, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_3, Arrangement_2> ())); + assert(true == (CGAL::simple_polygon_test_case_4, Arrangement_2> ())); } return 0; } \ No newline at end of file From c6e65acc514c5ceba688149847d12c30d54888cf Mon Sep 17 00:00:00 2001 From: Francisc Date: Mon, 22 Jul 2013 14:38:01 +0300 Subject: [PATCH 64/66] entirely switched to kernel constructions and predicates - global functions dropped --- .../include/CGAL/Simple_visibility_2.h | 34 +++++++++++-------- 1 file changed, 19 insertions(+), 15 deletions(-) diff --git a/Visibility_2/include/CGAL/Simple_visibility_2.h b/Visibility_2/include/CGAL/Simple_visibility_2.h index 189501acf09..5cd289532f5 100644 --- a/Visibility_2/include/CGAL/Simple_visibility_2.h +++ b/Visibility_2/include/CGAL/Simple_visibility_2.h @@ -50,6 +50,7 @@ public: typedef typename Geometry_traits_2::Vector_2 Vector_2; typedef typename Geometry_traits_2::Direction_2 Direction_2; typedef typename Geometry_traits_2::FT Number_type; + typedef typename Geometry_traits_2::Object_2 Object_2; Simple_visibility_2() : p_arr(NULL), geom_traits(NULL) {}; @@ -256,7 +257,7 @@ public: std::cout << "[" << eit->curve() << "]" << std::endl; } -protected: +private: const Input_Arrangement_2 *p_arr; const Geometry_traits_2 *geom_traits; std::stack s; @@ -278,13 +279,16 @@ protected: geom_traits->collinear_2_object(); return collinear_fnct(p, q, r); } -/* - Object_2 Intersect_2(const Segment_2 &s1, const Segment_2 &s2) { - typename Geometry_traits_2::Intersect_2 intersect_fnct = - geom_traits->intersect_2_object(); + + template < class _Curve_first, class _Curve_second > + Object_2 Intersect_2(const _Curve_first &s1, const _Curve_second &s2) { + typedef typename Geometry_traits_2::Kernel Kernel; + const Kernel *kernel = static_cast (geom_traits); + typename Kernel::Intersect_2 intersect_fnct = + kernel->intersect_2_object(); return intersect_fnct(s1, s2); } -*/ + Orientation Orientation_2(const Point_2 &p, const Point_2 &q, const Point_2 &r) { typename Geometry_traits_2::Orientation_2 orient = @@ -310,7 +314,7 @@ protected: Segment_2 s1(a, b); Segment_2 s2(a, c); const Segment_2 *seg_overlap; - CGAL::Object result = CGAL::intersection(s1, s2); + Object_2 result = Intersect_2(s1, s2); if (seg_overlap = CGAL::object_cast(&result)) { return true; } @@ -446,11 +450,11 @@ protected: Point_2 s_t_prev = s.top(); Segment_2 s1(s_t_prev, s_t); Segment_2 s2(q, vertices[vertices.size()-1]); - CGAL::Object result = CGAL::intersection(s1, s2); + Object_2 result = Intersect_2(s1, s2); if (const Point_2 *ipoint = CGAL::object_cast(&result)) { Segment_2 s3(s_t_prev, vertices[i]); - CGAL::Object result2 = CGAL::intersection(s3, s2); + Object_2 result2 = Intersect_2(s3, s2); if (const Point_2 *vertex_new = CGAL::object_cast(&result2)){ if ((*vertex_new) != (s_t_prev) && (*vertex_new != s_t)) { upcase = SCANB; @@ -532,7 +536,7 @@ protected: found = true; Segment_2 s1(s_j_prev, s_j); Ray_2 s2(query_pt, vertices[i]); - CGAL::Object result = CGAL::intersection(s1, s2); + Object_2 result = Intersect_2(s1, s2); if (const Point_2 *ipoint = CGAL::object_cast(&result)) { s_j = *ipoint; } @@ -569,7 +573,7 @@ protected: // Check if v_i-1, v_i intersects (s_j-1, s_j) Segment_2 s1(s_j_prev, s_j); Segment_2 s2(vertices[i-1], vertices[i]); - CGAL::Object result = CGAL::intersection(s1, s2); + Object_2 result = Intersect_2(s1, s2); if (const Point_2 *ipoint = CGAL::object_cast(&result)) { // Keep s_j off the stack found = true; @@ -602,7 +606,7 @@ protected: while (k+1 < vertices.size()) { Segment_2 s1(vertices[k], vertices[k+1]); Ray_2 s2(query_pt, s.top()); - CGAL::Object result = intersection(s1, s2); + Object_2 result = Intersect_2(s1, s2); if (const Point_2 *ipoint = CGAL::object_cast(&result)) { found = true; intersection_pt = *ipoint; @@ -657,7 +661,7 @@ protected: while (k+1 < vertices.size()) { Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(s_t, vertices[vertices.size()-1]); - CGAL::Object result = CGAL::intersection(s1, s2); + Object_2 result = Intersect_2(s1, s2); if (const Point_2 *ipoint = CGAL::object_cast(&result)) { if (*ipoint != s_t) { intersection_pt = *ipoint; @@ -696,7 +700,7 @@ protected: while (k+1 < vertices.size()) { Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(s_t, w); - CGAL::Object result = CGAL::intersection(s1, s2); + Object_2 result = Intersect_2(s1, s2); if (const Point_2 *ipoint = CGAL::object_cast(&result)) { found = true; intersection_pt = *ipoint; @@ -720,7 +724,7 @@ protected: while (k+1 < vertices.size()) { Segment_2 s1(vertices[k], vertices[k+1]); Segment_2 s2(s_t, w); - CGAL::Object result = CGAL::intersection(s1, s2); + Object_2 result = Intersect_2(s1, s2); if (const Point_2 *ipoint = CGAL::object_cast(&result)) { found = true; intersection_pt = *ipoint; From 741b937aded3ada20b51ef1679411bb0f5728fdb Mon Sep 17 00:00:00 2001 From: Francisc Date: Mon, 22 Jul 2013 14:38:54 +0300 Subject: [PATCH 65/66] added details about algorithm to documentation and removed extended traits --- .../Visibility_2/CGAL/Simple_visibility_2.h | 74 +++++++++++++------ .../doc/Visibility_2/Concepts/Visibility_2.h | 43 ++++++----- 2 files changed, 74 insertions(+), 43 deletions(-) diff --git a/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h b/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h index bd4c50b9a1e..2f7c6a42093 100644 --- a/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h +++ b/Visibility_2/doc/Visibility_2/CGAL/Simple_visibility_2.h @@ -3,35 +3,48 @@ namespace CGAL { \ingroup PkgVisibility_2Classes This class is a model of the concept `Visibility_2` offers visibility queries within -a simple polygon with no holes. Uses the algorithm of B.Joe and R.B.Simpson \cite bjrb-clvpa-87 to obtain -the visibility polygon, based on a scan of the boundary of the polygon and the notion of angular -displacement as a control variable. The time complexity is O(n) in the number of the vertices -of the polygon. +a simple polygon with no holes. Uses the algorithm of B.Joe and R.B.Simpson \cite bjrb-clvpa-87 to +obtain the visibility polygon, based on a scan of the boundary of the polygon and the notion +of angular displacement as a control variable. The algorithm is a modification and extension +of the linear time algorithm of Lee \cite TODO. It computes the visibility polygon from a +viewpoint that is in the interior or on the boundary of the polygon. + +The algorithm uses a stack to manipulate the vertices, and ultimately yields the visibility +polygon. For each scanned edge, at most 2 points are pushed on the stack. Overall, it +will have at most 2n points pushed and popped, thus the time and space complexities of the +algorithm are O(n), where n is the number of the vertices of the polygon. Degenerate cases +such as needles require a post-processing step, which is linear in the number of vertices +forming the needles. In such cases, the overall time complexity is O(n*m), where n is the +number of vertices of the polygon, and m is the number of vertices forming the largest needle +in the output. + +The class also supports a regularization tag which allows the user to obtain an output +with all the isolated vertices and edges that have the same face on both sides removed. \cgalModels `Visibility_2` \sa 'CGAL::Visibility_2' -\sa `CGAL::Naive_visibility_2` -\sa `CGAL::Preprocessed_visibility_2` +\sa `CGAL::Naive_visibility_2` +\sa `CGAL::Preprocessed_visibility_2` */ -template +template class Simple_visibility_2 { public: /// \name Types /// @{ - typedef ArrExtensionTraits_2 Arr_extension_traits_2; + typedef ArrTraits_2 Arr_traits_2; /*! The Arrangement type is used for input. */ - typedef Arr_extension_traits_2::Input_Arrangement_2 Input_Arrangement_2; + typedef Arr_traits_2::Input_Arrangement_2 Input_Arrangement_2; /*! *The Arrangement type is used for output. */ - typedef Arr_extension_traits_2::Output_Arrangement_2 Output_Arrangement_2; + typedef Arr_traits_2::Output_Arrangement_2 Output_Arrangement_2; /*! The Point_2 type which is used for queries. @@ -44,6 +57,11 @@ public: /// \name Constructors /// @{ +/*! +Default constructor creates an empty `Visibility_2` object +*/ +Simple_visibility_2(); + /*! Constructs a `Visibility_2` object from a given `Input_Arrangement_2` */ @@ -56,31 +74,45 @@ Simple_visibility_2(const Input_Arrangement_2& arr); /// @{ /*! +Returns whether an arrangement is attached to the visibility object +*/ + bool is_attached (); +/*! +Attaches the given arrangement to the visibility object +*/ + void attach (const Input_Arrangement_2 &arr); + +/*! +Detaches the arrangement from the visibility object it is currently attached to +*/ + void detach(); + +/*! +Access to the attached arrangement +*/ + Input_Arrangement_2 arr(); + +/*! Computes the visibility region for the given query point q. \pre face is a face of this->arr() with no holes \pre p is in the interior of face \pre out_arr is the output arrangement - +\return a face handle to the bounded face of the output */ - void visibility_region(const Point_2& q, const Face& face, Output_Arrangement_2& out_arr); + Face_handle visibility_region(const Point_2& q, const Face& face, Output_Arrangement_2& out_arr); /*! Computes for the given query point q the visibility region that is on the side of the given halfedge. -\pre half_edge is a half edge of this->arr() -\pre p is on halfedge +\pre half_edge is a half edge of this->arr() +\pre p is located on the halfedge \pre out_arr is the output arrangement - +\return a face handle to the bounded face of the output */ - void visibility_region(const Point_2& q, const Halfedge& halfedge, Output_Arrangement_2& out_arr); + Face_handle visibility_region(const Point_2& q, const Halfedge& halfedge, Output_Arrangement_2& out_arr); /// @} }; /* end Visibility_2 */ - -/*! -[1] B. Joe, R. B. Simpson, "Corrections to Lee's visibility polygon algorithm", BIT Numerical Mathematics -Volume 27, Issue 4 , pp 458-473 -*/ } diff --git a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h index ba8b571de6c..609fa42f20e 100644 --- a/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h +++ b/Visibility_2/doc/Visibility_2/Concepts/Visibility_2.h @@ -6,13 +6,13 @@ A model of the concept `Visibility_2` offers visibility queries within an Arrangement. -\cgalHasModel `CGAL::Simple_visibility_2` -\cgalHasModel `CGAL::Naive_visibility_2` -\cgalHasModel `CGAL::Preprocessed_visibility_2` +\cgalHasModel `CGAL::Simple_visibility_2` +\cgalHasModel `CGAL::Naive_visibility_2` +\cgalHasModel `CGAL::Preprocessed_visibility_2` -\sa `CGAL::Simple_visibility_2` -\sa `CGAL::Naive_visibility_2` -\sa `CGAL::Preprocessed_visibility_2` +\sa `CGAL::Simple_visibility_2` +\sa `CGAL::Naive_visibility_2` +\sa `CGAL::Preprocessed_visibility_2` */ class Visibility_2 { @@ -73,7 +73,7 @@ Visibility_2(); /*! Constructs a `Visibility_2` object from a given `Arrangement_2` and a given Regularization tag. */ -Visibility_2(const Input_Arrangement_2& arr); +Visibility_2(const Input_Arrangement_2 &arr); /// @} @@ -81,47 +81,46 @@ Visibility_2(const Input_Arrangement_2& arr); /// \name functions /// @{ - - /*! -Return whether the object is attachted to an arrangement. +Returns whether an arrangement is attached to the visibility object */ bool is_attached (); /*! -Attaches visibility object to the given arrangement arr. +Attaches the given arrangement to the visibility object. */ - void attach ( Input_Arrangement_2 arr); + void attach (const Input_Arrangement_2 &arr); /*! -Detaches the object from the arrangement it is currently attached to. +Detaches the arrangement from the visibility object it is currently attached to */ - void detach (); + void detach(); /*! -Access to the attached Arrangement_2. +Access to the attached arrangement */ Input_Arrangement_2 arr(); /*! Computes the visibility region for the given query point q. Visibility polygon of q and its face will be saved to out_arr and out_face. \pre face is a face of this->arr() -\pre p is in the interior of face - +\pre p is in the interior of face +\pre out_arr is the output arrangement +\return a face handle to the bounded face of the output */ - void visibility_region(const Point_2& q, const Face_handle& face, Output_Arrangement_2& out_arr, const Out_face_handle& out_face); + Face_handle visibility_region(const Point_2& q, const Face_handle& face, Output_Arrangement_2& out_arr); /*! Computes for the given query point q the visibility region that is on the side of the given halfedge. Visibility polygon of q and its face will be saved to out_arr and out_face. \pre half_edge is a half edge of this->arr() -\pre p is on halfedge - +\pre p is on halfedge +\pre out_arr is the output arrangement +\return a face handle to the bounded face of the output */ - void visibility_region(const Point_2& q, const Halfedge_handle& halfedge, Output_Arrangement_2& out_arr, const Out_face_handle& out_face); + Face_handle visibility_region(const Point_2& q, const Halfedge_handle& halfedge, Output_Arrangement_2& out_arr); /// @} - }; /* end Visibility_2 */ From 1446df9ce968011cf05a59539e781817bdfa77d3 Mon Sep 17 00:00:00 2001 From: Francisc Date: Mon, 22 Jul 2013 18:23:43 +0300 Subject: [PATCH 66/66] moved files in test/Visibility_2 folder --- Documentation/biblio/cgal_manual.bib | 19 + Documentation/biblio/how_to_cite.html | 3260 ++++++++++++---- Documentation/biblio/how_to_cite_cgal.txt | 3444 +++++++++++++---- .../data/Arrangement_Test/in1 | 0 .../data/Arrangement_Test/in2 | 0 .../data/Arrangement_Test/in3 | 0 .../data/Arrangement_Test/in4 | 0 .../data/Arrangement_Test/in5 | 0 .../data/Arrangement_Test/non_regular_out1 | 0 .../data/Arrangement_Test/non_regular_out2 | 0 .../data/Arrangement_Test/non_regular_out3 | 0 .../data/Arrangement_Test/non_regular_out4 | 0 .../data/Arrangement_Test/non_regular_out5 | 0 .../data/simple_polygon_test_case_1.in | 0 .../data/simple_polygon_test_case_1.out | 0 .../data/simple_polygon_test_case_2.in | 0 .../data/simple_polygon_test_case_2.out | 0 .../data/simple_polygon_test_case_3.in | 0 .../data/simple_polygon_test_case_3.out | 0 .../data/simple_polygon_test_case_4.in | 0 .../data/simple_polygon_test_case_4.out | 0 .../include/CGAL/test_model_methods.h | 0 .../include/CGAL/test_simple_polygons.h | 0 .../include/CGAL/test_utils.h | 0 .../test/{ => Visibility_2}/run_tests.sh | 0 .../test_naive_visibility.cpp | 0 .../test_simple_visibility.cpp | 0 27 files changed, 5304 insertions(+), 1419 deletions(-) rename Visibility_2/test/{ => Visibility_2}/data/Arrangement_Test/in1 (100%) rename Visibility_2/test/{ => Visibility_2}/data/Arrangement_Test/in2 (100%) rename Visibility_2/test/{ => Visibility_2}/data/Arrangement_Test/in3 (100%) rename Visibility_2/test/{ => Visibility_2}/data/Arrangement_Test/in4 (100%) rename Visibility_2/test/{ => Visibility_2}/data/Arrangement_Test/in5 (100%) rename Visibility_2/test/{ => Visibility_2}/data/Arrangement_Test/non_regular_out1 (100%) rename Visibility_2/test/{ => Visibility_2}/data/Arrangement_Test/non_regular_out2 (100%) rename Visibility_2/test/{ => Visibility_2}/data/Arrangement_Test/non_regular_out3 (100%) rename Visibility_2/test/{ => Visibility_2}/data/Arrangement_Test/non_regular_out4 (100%) rename Visibility_2/test/{ => Visibility_2}/data/Arrangement_Test/non_regular_out5 (100%) rename Visibility_2/test/{ => Visibility_2}/data/simple_polygon_test_case_1.in (100%) rename Visibility_2/test/{ => Visibility_2}/data/simple_polygon_test_case_1.out (100%) rename Visibility_2/test/{ => Visibility_2}/data/simple_polygon_test_case_2.in (100%) rename Visibility_2/test/{ => Visibility_2}/data/simple_polygon_test_case_2.out (100%) rename Visibility_2/test/{ => Visibility_2}/data/simple_polygon_test_case_3.in (100%) rename Visibility_2/test/{ => Visibility_2}/data/simple_polygon_test_case_3.out (100%) rename Visibility_2/test/{ => Visibility_2}/data/simple_polygon_test_case_4.in (100%) rename Visibility_2/test/{ => Visibility_2}/data/simple_polygon_test_case_4.out (100%) rename Visibility_2/test/{ => Visibility_2}/include/CGAL/test_model_methods.h (100%) rename Visibility_2/test/{ => Visibility_2}/include/CGAL/test_simple_polygons.h (100%) rename Visibility_2/test/{ => Visibility_2}/include/CGAL/test_utils.h (100%) rename Visibility_2/test/{ => Visibility_2}/run_tests.sh (100%) rename Visibility_2/test/{ => Visibility_2}/test_naive_visibility.cpp (100%) rename Visibility_2/test/{ => Visibility_2}/test_simple_visibility.cpp (100%) diff --git a/Documentation/biblio/cgal_manual.bib b/Documentation/biblio/cgal_manual.bib index 1fe8cc83edd..6a477b637b9 100644 --- a/Documentation/biblio/cgal_manual.bib +++ b/Documentation/biblio/cgal_manual.bib @@ -2336,6 +2336,25 @@ ADDRESS = "Saarbr{\"u}cken, Germany" series = {Texts and Monographs in Symbolic Computation} } +@article{cgal:ta-aeafvpprh-85 + ,author = {T. Asano} + ,title = {An Efficient Algorithm for Finding the Visibility Polygon for a Polygonal Region with Holes} + ,journal = {IEICE Transactions (1976-1990)} + ,year = 1985 + ,volume = E68 + ,number = 9 + ,pages = {557--559} +} + +@article{cgal:bjrb-clvpa-87, +author = "B. Joe and R.B. Simpson", +title = "Corrections to Lee's visibility polygon algorithm", +journal = "BIT", +volume = 27, +year = 1987, +pages = "458--473" +} + % ---------------------------------------------------------------------------- % END OF BIBFILE % ---------------------------------------------------------------------------- diff --git a/Documentation/biblio/how_to_cite.html b/Documentation/biblio/how_to_cite.html index 538d449be6a..4268b35657b 100644 --- a/Documentation/biblio/how_to_cite.html +++ b/Documentation/biblio/how_to_cite.html @@ -1,962 +1,2754 @@ -

manual-4.2.bib

-@book{cgal:eb-12b,
-  title = {{CGAL} User and Reference Manual},
-  author = {{The CGAL Project}},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  year = 2013,
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html}
+
cgal_manual.bib
+@article{cgal:afh-pdecm-02,
+  author = {P. K. Agarwal and E. Flato and D. Halperin},
+  title = {Polygon Decomposition for Efficient Construction of {Minkowski} Sums},
+  journal = {Computational Geometry: Theory and Applications},
+  volume = 21,
+  year = 2002,
+  pages = {39--61}
 }
 

 
-
-@incollection{cgal:h-af-12b,
-  author = {Michael Hemmer},
-  title = {Algebraic Foundations},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgAlgebraicFoundationsSummary},
-  year = 2013
+
+@manual{cgal:a-cclga-94,
+  author = {Avnaim, F.},
+  title = {{C}{\tt ++}{GAL}: {A} {C}{\tt ++} Library for Geometric
+                  Algorithms},
+  organization = {INRIA Sophia-Antipolis},
+  year = 1994,
+  update = {98.01 schirra}
 }
 

 
-
-@incollection{cgal:bht-ak-12b,
-  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.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgAlgebraicKerneldSummary},
-  year = 2013
+
+@incollection{cgal:a-cgs-97,
+  author = {N. Amenta},
+  title = {Computational Geometry Software},
+  booktitle = {Handbook of Discrete and Computational Geometry},
+  editors = {J. Goodman and J. O'Rourke},
+  publisher = {CRC Press},
+  year = {1997},
+  pages = {951--960},
+  update = {98.01 schirra}
 }
 

 
-
-@incollection{cgal:hhkps-nt-12b,
-  author = {Michael Hemmer and Susan Hert and Lutz Kettner and Sylvain Pion and Stefan Schirra},
-  title = {Number Types},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgNumberTypesSummary},
-  year = 2013
+
+@book{cgal:a-gps-98,
+  author = {Matthew H. Austern},
+  title = {Generic Programming and the {STL}},
+  publisher = {Addison-Wesley},
+  year = 1998,
+  update = {01.06 hoffmann}
 }
 

 
-
-@incollection{cgal:h-p-12b,
-  author = {Michael Hemmer},
-  title = {Polynomial},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgPolynomialSummary},
-  year = 2013
+
+@book{cgal:a-mcdgp-01,
+  author = {Andrei Alexandrescu},
+  title = {Modern {C++} Design: Generic Programming and Design
+                   Patterns Applied},
+  year = 2001,
+  publisher = {Addison-Wesley}
 }
 

 
-
-@incollection{cgal:h-ma-12b,
-  author = {Michael Hemmer},
-  title = {Modular Arithmetic},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgModularArithmeticSummary},
-  year = 2013
+
+@inproceedings{cgal:a-nqimr-67,
+  author = {Arthur Appel},
+  title = {The Notion of Quantitive Invisibility and the
+                  Machine Rendering of Solids},
+  booktitle = {Proc. ACM National Conf.},
+  year = 1967,
+  pages = {387--393},
+  annote = {Basis for the contour edge idea in hidden surface
+                   removal.},
+  update = {97.04 kettner}
 }
 

 
-
-@incollection{cgal:bfghhkps-lgk23-12b,
-  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.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgKernel23Summary},
-  year = 2013
+
+@article{cgal:acyd-vtm-05,
+  author = {Pierre Alliez and David Cohen-Steiner
+                 and Mariette Yvinec and Mathieu Desbrun},
+  title = {Variational tetrahedral meshing},
+  year = 2005,
+  journal = {ACM Transactions on Graphics},
+  pages = {617--625},
+  note = {SIGGRAPH '2005 Conference Proceedings},
+  volume = 24,
+  url = {http://hal.inria.fr/inria-00226418},
+  geombib = {not yet}
 }
 

 
-
-@incollection{cgal:s-gkd-12b,
-  author = {Michael Seel},
-  title = {{dD} Geometry Kernel},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgKernelDSummary},
-  year = 2013
+
+@misc{cgal:ansi-is14882-98,
+  key = {{C}{\tt ++}},
+  title = {International Standard {ISO/IEC} 14882:
+                 Programming languages -- {C{\tt ++}}},
+  howpublished = {American National Standards Institute, 11 West 42nd
+                 Street, New York 10036},
+  year = 1998,
+  url = {\path|http://webstore.ansi.org/|},
+  update = {04.03 kettner, 01.06 hoffmann}
 }
 

 
-
-@incollection{cgal:cpt-cgk2-12b,
-  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.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgCircularKernel2Summary},
-  year = 2013
+
+@inproceedings{cgal:b-digph-01,
+  author = {Herv{\'e} Br{\"o}nnimann},
+  title = {Designing and implementing a general purpose halfedge
+                   data structure},
+  booktitle = {Proc. 5th International Workshop on Algorithm
+                   Engineering (WAE)},
+  editors = {G. Brodal and D. Frigioni and A. Marchetti-Spaccamela},
+  publisher = {Springer LNCS 2141},
+  year = 2001,
+  pages = {51--66},
+  update = {04.04 kettner}
 }
 

 
-
-@incollection{cgal:cclt-sgk3-12b,
-  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.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgSphericalKernel3Summary},
-  year = 2013
+
+@article{cgal:bbp-iayed-01,
+  author = {H. Br{\"o}nnimann and C. Burnikel and S. Pion},
+  title = {Interval arithmetic yields efficient dynamic filters
+                   for computational geometry},
+  journal = {Discrete Applied Mathematics},
+  volume = 109,
+  year = 2001,
+  pages = {25--47},
+  succeeds = {bbp-iayed-98scg},
+  update = {04.03 pion}
 }
 

 
-
-@incollection{cgal:hs-chep2-12b,
-  author = {Susan Hert and Stefan Schirra},
-  title = {{2D} Convex Hulls and Extreme Points},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgConvexHull2Summary},
-  year = 2013
+
+@article{cgal:bdpty-tc-02,
+  author = {Jean-Daniel Boissonnat and Olivier Devillers and Sylvain
+Pion and Monique Teillaud and Mariette Yvinec},
+  title = {Triangulations in {CGAL}},
+  journal = {Comput. Geom. Theory Appl.},
+  volume = 22,
+  year = 2002,
+  pages = {5--19},
+  succeeds = {bdty-tcgal-00}
 }
 

 
-
-@incollection{cgal:hs-ch3-12b,
-  author = {Susan Hert and Stefan Schirra},
-  title = {{3D} Convex Hulls},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgConvexHull3Summary},
-  year = 2013
+
+@inproceedings{cgal:behhms-cbcab-02,
+  author = {Berberich, Eric and Eigenwillig, Arno and Hemmer, Michael
+                  and Hert, Susan and Mehlhorn, Kurt and Sch{\"o}mer, Elmar},
+  editor = {M{\"o}hring, Rolf and Raman, Rajeev},
+  title = {A Computational Basis for Conic Arcs and Boolean Operations
+                  on Conic Polygons},
+  booktitle = {Algorithms - ESA 2002: 10th Annual European Symposium},
+  address = {Rome, Italy},
+  publisher = {Springer},
+  month = sep,
+  series = {Lecture Notes in Computer Science},
+  volume = {2461},
+  year = {2002},
+  pages = {174--186},
+  abstract = {We give an exact geometry kernel for conic arcs, algorithms
+                  for exact computation with low-degree algebraic
+                  numbers, and an algorithm for computing the
+                  arrangement of conic arcs that immediately leads to
+                  a realization of regularized boolean operations on
+                  conic polygons. A conic polygon, or polygon for
+                  short, is anything that can be obtained from linear
+                  or conic halfspaces (= the set of points where a
+                  linear or quadratic function is non-negative) by
+                  regularized boolean operations. The algorithm and
+                  its implementation are complete (they can handle all
+                  cases), exact (they give the mathematically correct
+                  result), and efficient (they can handle inputs with
+                  several hundred primitives).}
 }
 

 
-
-@incollection{cgal:gw-p2-12b,
-  author = {Geert-Jan Giezeman and Wieger Wesselink},
-  title = {{2D} Polygons},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgPolygon2Summary},
-  year = 2013
+
+@inproceedings{cgal:bfh-mgedm-95,
+  author = {Heinzgerd Bendels and Dieter W. Fellner and Sven
+                   Havemann},
+  title = {Modellierung der Grundlagen: Erweiterbare
+                   Datenstrukturen zur Modellierung und Visualisierung
+                   polygonaler Welten},
+  booktitle = {Modeling -- Virtual Worlds -- Distributed Graphics},
+  year = 1995,
+  editor = {D. W. Fellner},
+  pages = {149--157},
+  address = {Bad Honnef / Bonn},
+  month = {27.--28. November},
+  annote = {A reference for the halfedge data structure and
+                  Euler operators (preserving the topological type).},
+  update = {97.04 kettner}
 }
 

 
-
-@incollection{cgal:h-pp2-12b,
-  author = {Susan Hert},
-  title = {{2D} Polygon Partitioning},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgPolygonPartitioning2Summary},
-  year = 2013
+
+@inproceedings{cgal:bgh-dsmd-97,
+  author = {Julien Basch and Leonidas Guibas and John Hershberger},
+  title = {Data Structures for Mobile Data},
+  booktitle = {Proceedings of the 8th Annual {ACM}-{SIAM} Symposium on
+                Discrete Algorithms},
+  year = {1997},
+  pages = {747--756}
 }
 

 
-
-@incollection{cgal:hs-chdt3-12b,
-  author = {Susan Hert and Michael Seel},
-  title = {{dD} Convex Hulls and {Delaunay} Triangulations},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgConvexHullDSummary},
-  year = 2013
+
+@inproceedings{cgal:bhksw-eceicpmqic-05,
+  author = {Eric Berberich and Michael Hemmer and Lutz Kettner and
+            Elmar Sch{\"o}mer and Nicola Wolpert},
+  title = {An Exact, Complete and Efficient Implementation for Computing
+           Planar Maps of Quadric Intersection Curves},
+  booktitle = {Proceedings of 21st Annual Symposium on Computational Geometry (SCG)},
+  year = 2005,
+  pages = {99--106}
 }
 

 
-
-@incollection{cgal:k-ps-12b,
-  author = {Lutz Kettner},
-  title = {{3D} Polyhedral Surfaces},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgPolyhedronSummary},
-  year = 2013
+
+@inproceedings{cgal:byb-mgmmi-09,
+  booktitle = {Medical Image Computing and Computer-Assisted Intervention},
+  nickname = {MICCAI 2009},
+  series = {Lecture Notes in Computer Science},
+  volume = 5762,
+  year = 2009,
+  author = {Dobrina Boltcheva and Mariette Yvinec and Jean-Daniel
+Boissonnat},
+  title = {Mesh Generation from 3D Multi-material Images},
+  pages = {283--290},
+  url = {http://hal.inria.fr/inria-00420228/},
+  x-international-audience = {yes},
+  x-proceedings = {yes}
 }
 

 
-
-@incollection{cgal:k-hds-12b,
-  author = {Lutz Kettner},
-  title = {Halfedge Data Structures},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgHDSSummary},
-  year = 2013
+
+@article{cgal:-byb-fpdmgmmi-09,
+  author = {Dobrina Boltcheva and Mariette Yvinec and Jean-Daniel Boissonnat},
+  title = {Feature preserving Delaunay mesh generation from 
+            3D multi- material images},
+  journal = {Computer Graphics Forum},
+  note = {special issue for EUROGRAPHICS Symposium on Geometry Processing},
+  pages = {1455-14645},
+  volume = 28,
+  year = 2009,
+  url = {http://hal.inria.fr/inria-00413248},
+  x-international-audience = {yes},
+  x-editorial-board = {yes}
 }
 

 
-
-@incollection{cgal:d-cm-12b,
-  author = {Guillaume Damiand},
-  title = {Combinatorial Maps},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgCombinatorialMapsSummary},
-  year = 2013
+
+@techreport{cgal:bhkt-risak-07,
+  author = {Berberich, Eric and Hemmer, Michael and
+                   Karavelas, Menelaos I. and Teillaud, Monique},
+  title = {Revision of the interface specification of algebraic kernel},
+  institution = {INRIA Sophia-Antipolis, Max Planck Institut f{\"u}r
+                   Informatik, National University of Athens},
+  year = {2007},
+  type = {Technical Report},
+  number = {ACS-TR-243301-01},
+  update = {09.12 penarand}
 }
 

 
-
-@incollection{cgal:d-lcc-12b,
-  author = {Guillaume Damiand},
-  title = {Linear Cell Complex},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgLinearCellComplexSummary},
-  year = 2013
+
+@book{cgal:bn-sec++-94,
+  author = {J. J. Barton and L. R. Nackman},
+  title = {Scientific and Engineering {C{\tt ++}}},
+  publisher = {Addison-Wesley, Reading, MA},
+  year = {1997},
+  update = {98.01 schirra}
 }
 

 
-
-@incollection{cgal:fwzh-rbso2-12b,
-  author = {Efi Fogel and  Ron Wein and  Baruch Zukerman and Dan Halperin},
-  title = {{2D} Regularized {Boolean} Set-Operations},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgBooleanSetOperations2Summary},
-  year = 2013
+
+@article{cgal:bo-pgsms-05,
+  author = {Jean-Daniel Boissonnat and Steve Oudot},
+  title = {Provably good sampling and meshing of surfaces},
+  journal = {Graphical Models},
+  volume = 67,
+  year = 2005,
+  pages = {405--451}
 }
 

 
-
-@incollection{cgal:w-rms2-12b,
-  author = {Ron Wein},
-  title = {{2D} {Minkowski} Sums},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgMinkowskiSum2Summary},
-  year = 2013
+
+@misc{cgal:bpp-vrml-95,
+  author = {Gavin Bell and Anthony Parisi and Mark Pesce},
+  title = {VRML The Virtual Reality Modeling Language:
+                     Version 1.0 Specification},
+  howpublished = {\path|http://www.web3d.org/x3d/specifications/vrml/VRML1.0/index.html|},
+  month = {May 26},
+  year = 1995,
+  update = {13.04 lrineau}
 }
 

 
-
-@incollection{cgal:s-bonp2-12b,
-  author = {Michael Seel},
-  title = {{2D} {Boolean} Operations on {Nef} Polygons},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgNef2Summary},
-  year = 2013
+
+@incollection{cgal:bv-sbc-96,
+  author = {G. Booch and M. Vilot},
+  title = {Simplifying the Booch Components},
+  booktitle = {{\CC\ }Gems},
+  publisher = {SIGS publications},
+  editor = {Lippman, S.},
+  year = {1996},
+  pages = {59--89},
+  update = {98.01 schirra}
 }
 

 
-
-@incollection{cgal:hk-bonpes2-12b,
-  author = {Peter Hachenberger and Lutz Kettner},
-  title = {{2D} {Boolean} Operations on {Nef} Polygons Embedded on the Sphere},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgNefS2Summary},
-  year = 2013
+
+@inproceedings{cgal::c-mssbo-04,
+  author = {Chen, L.},
+  title = {{Mesh Smoothing Schemes based on Optimal Delaunay Triangulations}},
+  booktitle = {Proceedings of 13th International Meshing Roundtable},
+  pages = {109--120},
+  year = {2004}
 }
 

 
-
-@incollection{cgal:hk-bonp3-12b,
-  author = {Peter Hachenberger and Lutz Kettner},
-  title = {{3D} {Boolean} Operations on {Nef} Polyhedra},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgNef3Summary},
-  year = 2013
+
+@phdthesis{cgal:c-tpsos-10,
+  author = {Manuel Caroli},
+  title = {Triangulating Point Sets in Orbit Spaces},
+  type = {Th\`{e}se de doctorat en sciences},
+  school = {Universit\'e de {Nice-Sophia Antipolis}},
+  address = {France},
+  year = 2010,
+  url = {http://tel.archives-ouvertes.fr/tel-00552215/}
 }
 

 
-
-@incollection{cgal:h-emspe-12b,
-  author = {Peter Hachenberger},
-  title = {Convex Decomposition of Polyhedra},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgConvexDecomposition3Summary},
-  year = 2013
+
+@article{cgal:cc-rgbss-78,
+  author = {E.~Catmull and J.~Clark},
+  title = {Recursively generated {B}-spline surfaces
+             on arbitrary topological meshes},
+  journal = {Computer Aided Design},
+  year = {1978},
+  volume = {10},
+  pages = {350--355}
 }
 

 
-
-@incollection{cgal:h-msp3-12b,
-  author = {Peter Hachenberger},
-  title = {{3D} {Minkowski} Sum of Polyhedra},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgMinkowskiSum3Summary},
-  year = 2013
+
+@article{cgal:cdeft-slive-00,
+  author = {Cheng, Siu-Wing and Dey, Tamal K. and Edelsbrunner, Herbert and Facello, Michael A. and Teng, Shang-Hua},
+  title = {Sliver exudation},
+  journal = {J. ACM},
+  volume = {47},
+  number = {5},
+  year = {2000},
+  issn = {0004-5411},
+  pages = {883--904},
+  doi = {http://doi.acm.org/10.1145/355483.355487},
+  publisher = {ACM},
+  address = {New York, NY, USA}
 }
 

 
-
-@incollection{cgal:c-sspo2-12b,
-  author = {Fernando Cacciola},
-  title = {{2D} Straight Skeleton and Polygon Offsetting},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgStraightSkeleton2Summary},
-  year = 2013
+
+@inproceedings{cgal:cdl-pdma-07,
+  author = {S.-W. Cheng and T. K. Dey and J. A. Levine},
+  title = { A practical Delaunay meshing algorithm for a large class of domains.},
+  booktitle = {Meshing Roundtable},
+  year = {2007},
+  pages = {477-494}
 }
 

 
-
-@incollection{cgal:wfzh-a2-12b,
-  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.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgArrangement2Summary},
-  year = 2013
+
+@inproceedings{cgal:cdr-drpsc-07,
+  author = {Siu-Wing Cheng and Tamal K. Dey and Edgar A. Ramos},
+  title = {Delaunay refinement for piecewise smooth complexes},
+  booktitle = {SODA},
+  year = {2007},
+  pages = {1096--1105},
+  address = {Philadelphia, PA, USA}
 }
 

 
-
-@incollection{cgal:wfz-ic2-12b,
-  author = {Baruch Zukerman and Ron Wein and Efi Fogel},
-  title = {{2D} Intersection of Curves},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgIntersectionOfCurves2Summary},
-  year = 2013
+
+@inproceedings{cgal:cl-vmbcm-96,
+  author = {Brian Curless and Marc Levoy},
+  title = {A Volumetric Method for Building Complex
+                   Models from Range Images},
+  booktitle = {Computer Graphics (Proc. SIGGRAPH '96)},
+  volume = 30,
+  year = 1996,
+  pages = {303--312},
+  update = {97.08 kettner}
 }
 

 
-
-@incollection{cgal:p-sr2-12b,
-  author = {Eli Packer},
-  title = {{2D} Snap Rounding},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgSnapRounding2Summary},
-  year = 2013
+
+@article{cgal:cp-edqpf-05,
+  author = {F. Cazals and M. Pouget},
+  title = {Estimating Differential Quantities using Polynomial fitting of Osculating Jets},
+  journal = {Computer Aided Geometric Design},
+  year = {2005},
+  volume = {22},
+  number = {2},
+  pages = {},
+  note = {Conference version: Symp. on Geometry Processing 2003}
 }
 

 
-
-@incollection{cgal:w-e2-12b,
-  author = {Ron Wein},
-  title = {{2D} Envelopes},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgEnvelope2Summary},
-  year = 2013
+
+@article{cgal:cp-ssulc-05,
+  author = {F. Cazals and M. Pouget},
+  title = {Smooth surfaces, umbilics, lines of curvatures, foliations, ridges and the medial axis: selected topics},
+  year = {2005},
+  volume = {15},
+  number = {5},
+  pages = {511--536},
+  journal = {Int. J. of Computational Geometry and Applications}
 }
 

 
-
-@incollection{cgal:mwz-e3-12b,
-  author = {Michal Meyerovitch and Ron Wein and Baruch Zukerman},
-  title = {{3D} Envelopes},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgEnvelope3Summary},
-  year = 2013
+
+@techreport{cgal:cp-tdare-05,
+  author = {F. Cazals and M. Pouget},
+  title = {Topology driven algorithms for ridge extraction on meshes},
+  number = {RR-5526},
+  institution = {INRIA},
+  year = {2005}
 }
 

 
-
-@incollection{cgal:y-t2-12b,
-  author = {Mariette Yvinec},
-  title = {{2D} Triangulations},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgTriangulation2Summary},
-  year = 2013
+
+@inproceedings{cgal:csm-rdtnc-03,
+  author = {D. Cohen-Steiner and J.-M. Morvan},
+  title = {Restricted Delaunay triangulations and normal cycle},
+  booktitle = {ACM Symposium on Computational Geometry},
+  address = {},
+  year = {2003},
+  pages = {}
 }
 

 
-
-@incollection{cgal:py-tds2-12b,
-  author = {Sylvain Pion and Mariette Yvinec},
-  title = {{2D} Triangulation Data Structure},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgTDS2Summary},
-  year = 2013
-}
-

-
-
-@incollection{cgal:pt-t3-12b,
-  author = {Sylvain Pion and Monique Teillaud},
-  title = {{3D} Triangulations},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgTriangulation3Summary},
-  year = 2013
-}
-

-
-
-@incollection{cgal:pt-tds3-12b,
-  author = {Sylvain Pion and Monique Teillaud},
-  title = {{3D} Triangulation Data Structure},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgTDS3Summary},
-  year = 2013
-}
-

-
-
-@incollection{cgal:ct-pt3-12b,
+
+@inproceedings{cgal:ct-c3pt-09,
+  title = {Computing {3D} Periodic Triangulations},
   author = {Manuel Caroli and Monique Teillaud},
-  title = {{3D} Periodic Triangulations},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgPeriodic3Triangulation3Summary},
-  year = 2013
+  booktitle = {Proceedings 17th European Symposium on Algorithms},
+  nickname = {ESA'09},
+  series = {Lecture Notes in Computer Science},
+  year = 2009,
+  volume = 5757,
+  pages = {37--48},
+  note = {Full version available as INRIA Research Report 6823 \path|http://hal.inria.fr/inria-00356871|}
 }
 

 
-
-@incollection{cgal:d-as2-12b,
-  author = {Tran Kai Frank Da},
-  title = {{2D} Alpha Shapes},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgAlphaShape2Summary},
-  year = 2013
+
+@inproceedings{cgal:cvmtwabw-se-96,
+  author = {Jonathan Cohen and Amitabh Varshney and Dinesh
+                   Manocha and Greg Turk and Hans Weber and Pankaj
+                   Agarwal and Frederick Brooks and William Wright},
+  title = {Simplification Envelopes},
+  booktitle = {Computer Graphics (Proc. SIGGRAPH '96)},
+  volume = 30,
+  year = 1996,
+  pages = {119--128},
+  note = {Examples and code in
+                   \path|http://www.cs.unc.edu/~geom/envelope.html|},
+  update = {97.08 kettner}
 }
 

 
-
-@incollection{cgal:dy-as3-12b,
-  author = {Tran Kai Frank Da and Mariette Yvinec},
-  title = {{3D} Alpha Shapes},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgAlphaShapes3Summary},
-  year = 2013
+
+@phdthesis{cgal:d-ccccg-10,
+  author = {Damiand, G.},
+  title = {Contributions aux Cartes Combinatoires et Cartes G\'en\'eralis\'ees : Simplification, Mod\`eles, Invariants Topologiques et Applications},
+  month = {Septembre},
+  year = {2010},
+  school = {Universit\'e Lyon 1},
+  type = {Habilitation \`a Diriger des Recherches}
 }
 

 
-
-@incollection{cgal:k-sdg2-12b,
-  author = {Menelaos Karavelas},
-  title = {{2D} Segment {Delaunay} Graphs},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgSegmentDelaunayGraph2Summary},
-  year = 2013
+
+@article{cgal:d-dh-02,
+  author = {Olivier Devillers},
+  title = {The {Delaunay} hierarchy},
+  journal = {Internat. J. Found. Comput. Sci.},
+  year = 2002,
+  volume = {13},
+  pages = {163--180},
+  anote = {special issue on triangulations},
+  succeeds = {d-iirdt-98}
 }
 

 
-
-@incollection{cgal:ky-ag2-12b,
-  author = {Menelaos Karavelas and Mariette Yvinec},
-  title = {{2D} {Apollonius} Graphs ({Delaunay} Graphs of Disks)},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgApolloniusGraph2Summary},
-  year = 2013
+
+@mastersthesis{cgal:d-grct-03,
+  author = {Wei Ding},
+  title = {Geometric Rounding without Changing the Topology},
+  school = {Fachbereich Informatik, Universit{\"a}t Saarbr{\"u}cken},
+  year = 2003,
+  address = {Saarbr{\"u}cken, Germany},
+  update = {04.04 kettner}
 }
 

 
-
-@incollection{cgal:k-vda2-12b,
-  author = {Menelaos Karavelas},
-  title = {{2D} {Voronoi} Diagram Adaptor},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgVoronoiDiagramAdaptor2Summary},
-  year = 2013
+
+@article{cgal:dds-scs-09,
+  author = {C. Dyken and M Daehlen and T. Sevaldrud},
+  title = {Simultaneous Curve Simplification},
+  journal = {Journal of Geographical Systems},
+  volume = 0,
+  pages = {0--0},
+  year = 2009
 }
 

 
-
-@incollection{cgal:r-ctm2-12b,
-  author = {Laurent Rineau},
-  title = {{2D} Conforming Triangulations and Meshes},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgMesh2Summary},
-  year = 2013
+
+@article{cgal:dfg-cvtaa-99t,
+  title = {{Centroidal Voronoi Tessellations: Applications and Algorithms}},
+  author = {Du, Q. and Faber, V. and Gunzburger, M.},
+  journal = {SIAM review},
+  volume = {41},
+  number = {4},
+  pages = {637--676},
+  year = {1999},
+  publisher = {Society for Industrial and Applied Mathematics}
 }
 

 
-
-@incollection{cgal:ry-smg-12b,
-  author = {Laurent Rineau and Mariette Yvinec},
-  title = {{3D} Surface Mesh Generation},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgSurfaceMesher3Summary},
-  year = 2013
+
+@inproceedings{cgal:dfmt-amafe-00,
+  author = {Olivier Devillers and Alexandra Fronville and Bernard Mourrain
+and Monique Teillaud},
+  title = {Algebraic methods and arithmetic filtering for exact predicates
+ on circle arcs},
+  booktitle = {Proc. 16th Annu. ACM Sympos. Comput. Geom.},
+  year = 2000,
+  pages = {139--147}
 }
 

 
-
-@incollection{cgal:asg-srps-12b,
-  author = {Pierre Alliez and Laurent Saboret and Gael Guennebaud},
-  title = {Surface Reconstruction from Point Sets},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgSurfaceReconstructionFromPointSetsSummary},
-  year = 2013
+
+@article{cgal:dfmt-amafe-02,
+  author = {Olivier Devillers and Alexandra Fronville and Bernard
+Mourrain and Monique Teillaud},
+  title = { Algebraic methods and arithmetic filtering
+                 for exact predicates on circle arcs},
+  journal = {Comput. Geom. Theory Appl.},
+  volume = 22,
+  year = 2002,
+  pages = {119--142},
+  succeeds = {dfmt-amafe-00}
 }
 

 
-
-@incollection{cgal:k-ssm3-12b,
-  author = {Nico Kruithof},
-  title = {{3D} Skin Surface Meshing},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgSkinSurface3Summary},
-  year = 2013
+
+@article{cgal:dh-pifch-96,
+  author = {J. H. Dul\'a and R. V. Helgason},
+  title = {A new procedure for identifying the frame of the convex hull of a finite collection of points in multidimensional space},
+  journal = {European Journal of Operational Research},
+  volume = {92},
+  number = {2},
+  pages = {352 - 367},
+  year = {1996},
+  issn = {0377-2217},
+  doi = {DOI: 10.1016/0377-2217(94)00366-1},
+  url = {http://www.sciencedirect.com/science/article/B6VCT-3VW8NPR-11/2/3cf4525c68d79c055676541418264043},
+  keywords = {Convex hull problem, Frame, Linear programming, Data envelopment analysis, Redundancy}
 }
 

 
-
-@incollection{cgal:rty-m3-12b,
-  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.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgMesh_3Summary},
-  year = 2013
+
+@unpublished{cgal:dl-cosfa-08,
+  author = {J.H. Dul\'a and F.J. L\'opez},
+  title = {Competing Output-Sensitive Frame Algorithms},
+  year = {2008},
+  note = {Draft (2008), available at
+\url{http://idisk.mac.com/jdula-Public/WORKINGPAPERS/PolyFrOttmann.pdf}},
+  keywords = {Extreme points, Convex hull, Linear programming, Computational Geometry, Redundancy identification}
 }
 

 
-
-@incollection{cgal:s-ssm2-12b,
-  author = {Le-Jeng Andy Shiue},
-  title = {{3D} Surface Subdivision Methods},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgSurfaceSubdivisionMethods3Summary},
-  year = 2013
+
+@article{cgal:dma-ipsm-02,
+  author = {Mathieu Desbrun and Mark Meyer and Pierre Alliez},
+  title = {Intrinsic Parameterizations of Surface Meshes},
+  journal = {Com{\-}pu{\-}ter Graphics Forum},
+  volume = {21},
+  number = {3},
+  pages = {209--218},
+  month = sep,
+  year = {2002}
 }
 

 
-
-@incollection{cgal:c-tsms-12b,
-  author = {Fernando Cacciola},
-  title = {Triangulated Surface Mesh Simplification},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgSurfaceMeshSimplificationSummary},
-  year = 2013
+
+@inproceedings{cgal:dp-eegpd-03,
+  author = {Olivier Devillers and Sylvain Pion},
+  title = {Efficient Exact Geometric Predicates for {Delaunay} Triangulations},
+  booktitle = {Proc. 5th Workshop Algorithm Eng. Exper.},
+  nickname = {ALENEX '03},
+  year = 2003,
+  pages = {37--44},
+  url = {http://hal.inria.fr/inria-00344517/}
 }
 

 
-
-@incollection{cgal:sal-pptsm2-12b,
-  author = {Laurent Saboret and Pierre Alliez and Bruno L\'evy},
-  title = {Planar Parameterization of Triangulated Surface Meshes},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgSurfaceParameterizationSummary},
-  year = 2013
+
+@article{cgal:dpt-wt-02,
+  author = {Olivier Devillers and Sylvain Pion and Monique
+Teillaud},
+  title = {Walking in a triangulation},
+  journal = {Internat. J. Found. Comput. Sci.},
+  year = 2002,
+  volume = {13},
+  pages = {181--199},
+  anote = {special issue on triangulations},
+  succeeds = {dpt-wt-01}
 }
 

 
-
-@incollection{cgal:b-ss2-12b,
-  author = {Matthias B{\"a}sken},
-  title = {{2D} Range and Neighbor Search},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgPointSet2Summary},
-  year = 2013
+
+@inproceedings{cgal:dt-pvr3d-03,
+  author = {Olivier Devillers and Monique Teillaud},
+  title = {Perturbations and Vertex Removal in a {3D Delaunay} Triangulation},
+  booktitle = {Proc. 14th ACM-SIAM Sympos. Discrete Algorithms (SODA)},
+  year = 2003,
+  pages = {313-319}
 }
 

 
-
-@incollection{cgal:n-rstd-12b,
-  author = {Gabriele Neyer},
-  title = {{dD} Range and Segment Trees},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgRangeSegmentTreesDSummary},
-  year = 2013
+
+@techreport{cgal:dt-pvrdr-06,
+  author = {Devillers, Olivier  and  Teillaud, Monique},
+  title = {Perturbations and Vertex Removal in {Delaunay} and Regular {3D} Triangulations},
+  year = {2006},
+  institution = {INRIA},
+  number = {5968},
+  type = {Research Report},
+  note = {\path|http://hal.inria.fr/inria-00090522|}
 }
 

 
-
-@incollection{cgal:f-isl-12b,
-  author = {Andreas Fabri},
-  title = {Interval Skip List},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgIntervalSkipListSummary},
-  year = 2013
+
+@article{cgal:dw-tmgob-02,
+  title = {{Tetrahedral mesh generation and optimization based on centroidal Voronoi tessellations}},
+  author = {Du, Q. and Wang, D.},
+  journal = {International Journal for Numerical Methods in Engineering},
+  volume = {56},
+  pages = {1355--1373},
+  year = {2002}
 }
 

 
-
-@incollection{cgal:tf-ssd-12b,
-  author = {Hans Tangelder and Andreas Fabri},
-  title = {{dD} Spatial Searching},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgSpatialSearchingDSummary},
-  year = 2013
+
+@article{cgal:e-dssd-99,
+  author = {H. Edelsbrunner},
+  title = {Deformable smooth surface design},
+  journal = {Discrete Comput. Geom.},
+  volume = 21,
+  pages = {87--115},
+  year = 1999
 }
 

 
-
-@incollection{cgal:kmz-isiobd-12b,
-  author = {Lutz Kettner and Andreas Meyer and Afra Zomorodian},
-  title = {Intersecting Sequences of {dD} Iso-oriented Boxes},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgBoxIntersectionDSummary},
-  year = 2013
+
+@inproceedings{cgal:eddhls-maam-95,
+  author = {Matthias Eck and Tony DeRose and Tom Duchamp and
+                  Hugues Hoppe and Michael Lounsbery and Werner Stuetzle},
+  title = {Multiresolution Analysis of Arbitrary Meshes},
+  booktitle = {Computer Graphics (Proc. SIGGRAPH '95)},
+  volume = 29,
+  year = 1995,
+  pages = {173--182},
+  note = {Examples in
+                   \path|ftp://ftp.cs.washington.edu/pub/graphics|},
+  update = {97.08 kettner}
 }
 

 
-
-@incollection{cgal:fghhs-bv-12b,
-  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.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgBoundingVolumesSummary},
-  year = 2013
+
+@proceedings{cgal:ek-sicad-99,
+  title = {Computer Aided Design},
+  note = {Special Issue  on Offsets, Sweeps and Minkowski Sums},
+  volume = 31,
+  editor = {G. Elber and M.-S. Kim},
+  year = 1999
 }
 

 
-
-@incollection{cgal:fgsw-lqps-12b,
-  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.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgQPSolverSummary},
-  year = 2013
+
+@inproceedings{cgal:ekptt-tock-04,
+  author = {Ioannis Z. Emiris and Athanasios Kakargias and Sylvain Pion and
+ Monique Teillaud and Elias P. Tsigaridas},
+  title = {Towards an Open Curved Kernel},
+  booktitle = {Proc. 20th Annu. ACM Sympos. Comput. Geom.},
+  year = 2004,
+  pages = {438--446}
 }
 

 
-
-@incollection{cgal:hp-ia-12b,
-  author = {Michael Hoffmann and Eli Packer},
-  title = {Inscribed Areas},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgInscribedAreasSummary},
-  year = 2013
-}
-

-
-
-@incollection{cgal:fghhs-od-12b,
-  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.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgOptimalDistancesSummary},
-  year = 2013
-}
-

-
-
-@incollection{cgal:f-i-12b,
+
+@phdthesis{cgal:f-csapc-03,
   author = {Julia Fl{\"o}totto},
-  title = {{2D} and Surface Function Interpolation},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgInterpolation2Summary},
-  year = 2013
+  title = {A coordinate system associated to a point cloud issued from
+                   a manifold: definition, properties and applications},
+  type = {Th\`{e}se de doctorat en sciences},
+  school = {Universit\'e de {Nice-Sophia Antipolis}},
+  address = {France},
+  year = 2003,
+  url = {http://www-sop.inria.fr/prisme/personnel/flototto/}
 }
 

 
-
-@incollection{cgal:ap-pcad-12b,
-  author = {Pierre Alliez and Sylvain Pion and Ankit Gupta},
-  title = {Principal Component Analysis},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgPrincipalComponentAnalysisDSummary},
-  year = 2013
+
+@book{cgal:f-sec-85,
+  author = {Richard Fairley},
+  title = {Software Engineering Concepts},
+  publisher = {McGraw-Hill},
+  year = 1985,
+  series = {McGraw-Hill Series in Software Engineering and Technology},
+  annote = {recommended software engineering reading.
+                   Topics from pre-object-oriented software engineering.},
+  update = {98.01 kettner}
 }
 

 
-
-@incollection{cgal:m-ps-12b,
-  author = {Abdelkrim Mebarki},
-  title = {{2D} Placement of Streamlines},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgPlacementOfStreamlines2Summary},
-  year = 2013
+
+@inproceedings{cgal:fh-oscps-95,
+  author = {Ulrich Finke and Klaus Hinrichs},
+  title = {Overlaying simply connected planar subdivisions in linear
+                   time},
+  booktitle = {Proc. 11th Annu. ACM Sympos. Comput. Geom.},
+  year = 1995,
+  pages = {119--126},
+  keywords = {red-blue segment intersection},
+  update = {95.09 mitchell}
 }
 

 
-
-@incollection{cgal:cp-arutsm-12b,
-  author = {Marc Pouget and Fr\'ed\'eric Cazals},
-  title = {Approximation of Ridges and Umbilics on Triangulated Surface Meshes},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgRidges_3Summary},
-  year = 2013
+
+@incollection{cgal:fh-survey-05,
+  author = {M. S. Floater and K. Hormann},
+  title = {Surface Parameterization: a Tutorial and Survey},
+  booktitle = {Advances in Multiresolution for Geometric Modelling},
+  pages = {157-186},
+  publisher = {Springer},
+  year = 2005,
+  editor = {N. A. Dodgson and M. S. Floater and M. A. Sabin},
+  series = {Mathematics and Visualization},
+  address = {Berlin, Heidelberg}
 }
 

 
-
-@incollection{cgal:pc-eldp-12b,
-  author = {Marc Pouget and Fr\'ed\'eric Cazals},
-  title = {Estimation of Local Differential Properties of Point-Sampled Surfaces},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgJet_fitting_3Summary},
-  year = 2013
+
+@article{cgal:f-mvc-03,
+  author = {Michael Floater},
+  title = {Mean Value Coordinates},
+  journal = {Computer Aided Design},
+  volume = {20},
+  number = {1},
+  pages = {19--27},
+  year = {2003}
 }
 

 
-
-@incollection{cgal:ass-psp-12b,
-  author = {Pierre Alliez and Laurent Saboret and Nader Salman},
-  title = {Point Set Processing},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgPointSetProcessingSummary},
-  year = 2013
+
+@inproceedings{cgal:g-frseb-99,
+  author = {B. G{\"a}rtner},
+  title = {Fast and robust smallest enclosing balls},
+  booktitle = {Proc. 7th annu. European Symposium on Algorithms (ESA)},
+  year = {1999},
+  series = {Lecture Notes in Computer Science},
+  volume = {1643},
+  publisher = {Springer-Verlag},
+  pages = {325--338}
 }
 

 
-
-@incollection{cgal:r-kds-12b,
-  author = {Daniel Russel},
-  title = {Kinetic Data Structures},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgKdsSummary},
-  year = 2013
+
+@manual{cgal:g-gmpal-96,
+  author = {T. Granlund},
+  title = {{GNU MP}, The {GNU} Multiple Precision Arithmetic Library,
+                   version 2.0.2},
+  month = jun,
+  year = 1996
 }
 

 
-
-@incollection{cgal:r-kdsf-12b,
-  author = {Daniel Russel},
-  title = {Kinetic Framework},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgKdsFrameworkSummary},
-  year = 2013
+
+@article{cgal:g-ieva-85,
+  author = {Ronald N. Goldman},
+  title = {Illicit Expressions in Vector Algebra},
+  journal = {ACM Transaction on Graphics},
+  year = 1985,
+  volume = 4,
+  number = 3,
+  month = jul,
+  pages = {223--243},
+  update = {98.01 kettner}
 }
 

 
-
-@incollection{cgal:cfw-cbgl-12b,
-  author = {Andreas Fabri and Fernando Cacciola and Ron Wein},
-  title = {{CGAL} and the {Boost} Graph Library},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgBGLSummary},
-  year = 2013
+
+@inproceedings{cgal:ghhkm-bosnc-03,
+  author = {Granados, Miguel and Hachenberger, Peter and Hert, Susan
+                  and Ketter, Lutz and Mehlhorn, Kurt and Seel, Michael},
+  editor = {Di Battista, Giuseppe and Zwick, Uri},
+  title = {Boolean Operations on 3D Selective Nef Complexes
+                  Data Structure, Algorithms, and Implementation},
+  booktitle = {Algorithms - ESA 2003: 11th Annual European Symposium},
+  address = {Budapest, Hugary},
+  publisher = {Springer},
+  month = sep,
+  series = {Lecture Notes in Computer Science},
+  volume = {2832},
+  year = {2003},
+  pages = {174--186},
+  abstract = {We describe a data structure for three-dimensional Nef
+                  complexes, algorithms for boolean operations on them,
+                  and our implementation of data structure and algorithms.
+                  Nef polyhedra were introduced by W. Nef in his seminal
+                  1978 book on polyhedra. They are the closure of half-spaces
+                  under boolean operations and can represent non-manifold
+                  situations, open and closed boundaries, and mixed
+                  dimensional complexes. Our focus lies on the generality of
+                  the data structure, the completeness of the algorithms,
+                  and the exactness and efficiency of the implementation.
+                  In particular, all degeneracies are handled.}
 }
 

 
-
-@incollection{cgal:fs-cbpm-12b,
-  author = {Andreas Fabri and Laurent Saboret},
-  title = {{CGAL} and  {Boost} Property Maps},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgProperty_mapSummary},
-  year = 2013
+
+@book{cgal:ghjv-dpero-95,
+  author = {E. Gamma and R. Helm and R. Johnson and J. Vlissides},
+  title = {Design Patterns -- Elements of Reusable
+                     Object-Oriented Software},
+  publisher = {Addison-Wesley},
+  year = 1995,
+  annote = {recommended OO reading.},
+  update = {97.04 kettner}
 }
 

 
-
-@incollection{cgal:dd-ss-12b,
-  author = {Christophe Delage and Olivier Devillers},
-  title = {Spatial Sorting},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgSpatialSortingSummary},
-  year = 2013
+
+@inproceedings{cgal:gkr-cfhm-04,
+  author = {Leonidas Guibas and Menelaos Karaveles and Daniel Russel},
+  title = {A Computational Framework for Handling Motion},
+  booktitle = {Proceedings of the Sixth Workshop on Algorithm Engineering and
+                Experiments},
+  year = {2004},
+  pages = {129--141}
 }
 

 
-
-@incollection{cgal:atw-aabb-12b,
-  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.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgAABB_treeSummary},
-  year = 2013
+
+@techreport{cgal:gs-seeeg-98,
+  author = {Bernd G{\"a}rtner and Sven Sch{\"o}nherr},
+  title = {Smallest Enclosing Ellipses -- An Exact and
+                   Generic Implementation in {C++}},
+  institution = {Freie Universit{\"a}t Berlin, Germany},
+  type = {Serie B -- Informatik},
+  number = {B 98-05},
+  year = 1998,
+  month = apr,
+  note = {URL \path|http://www.inf.fu-berlin.de/inst/pubs/tr-b-98-05.abstract.html|},
+  update = {98.06 schoenherr}
 }
 

 
-
-@incollection{cgal:h-msms-12b,
-  author = {Michael Hoffmann},
-  title = {Monotone and Sorted Matrix Search},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgMatrixSearchSummary},
-  year = 2013
+
+@techreport{cgal:gs-seceg-98,
+  author = {Bernd G{\"a}rtner and Sven Sch{\"o}nherr},
+  title = {Smallest Enclosing Circles -- An Exact and
+                   Generic Implementation in {C++}},
+  institution = {Freie Universit{\"a}t Berlin, Germany},
+  type = {Serie B -- Informatik},
+  number = {B 98-04},
+  year = 1998,
+  month = apr,
+  note = {URL \path|http://www.inf.fu-berlin.de/inst/pubs/tr-b-98-04.abstract.html|},
+  update = {98.06 schoenherr}
 }
 

 
-
-@incollection{cgal:hkpw-se-12b,
-  author = {Michael Hoffmann and  Lutz Kettner and Sylvain Pion and Ron Wein},
-  title = {STL Extensions for {CGAL}},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgStlExtensionSummary},
-  year = 2013
+
+@techreport{cgal:gs-seefe-97a,
+  author = {Bernd G{\"a}rtner and Sven Sch{\"o}nherr},
+  title = {Smallest Enclosing Ellipses -- Fast and Exact},
+  institution = {Freie Universit{\"a}t Berlin, Germany},
+  type = {Serie B -- Informatik},
+  number = {B 97-03},
+  year = 1997,
+  month = jun,
+  note = {URL \path|http://www.inf.fu-berlin.de/inst/pubs/tr-b-97-03.abstract.html|},
+  update = {97.06 schoenherr, 98.02 schoenherr, 98.06 schoenherr}
 }
 

 
-
-@incollection{cgal:dksy-hc-12b,
-  author = {Olivier Devillers and Lutz Kettner and Michael Seel and Mariette Yvinec},
-  title = {Handles and Circulators},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgHandlesAndCirculatorsSummary},
-  year = 2013
+
+@article{cgal:gt-dpasr-93,
+  author = {J. Gregor and M. G. Thomason},
+  title = {Dynamic Programming Alignment of Sequences representing cyclic patterns},
+  journal = {IEEE Trans. Pattern Anal. Machine Intell.},
+  year = 1993,
+  volume = 15,
+  number = 2,
+  pages = {129--135}
 }
 

 
-
-@incollection{cgal:dhhk-gog-12b,
-  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.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgGeneratorsSummary},
-  year = 2013
+
+@manual{cgal:gvw-gsc-98,
+  author = {Geert-Jan Giezeman and Remco Veltkamp and
+                   Wieger Wesselink},
+  title = {Getting Started with {CGAL}},
+  year = 1998,
+  note = {{CGAL} {R}1.0. \path|http://www.cs.ruu.nl/CGAL|.},
+  update = {98.01 schoenherr}
 }
 

 
-
-@incollection{cgal:kps-pthum-12b,
-  author = {Lutz Kettner and Sylvain Pion and Michael Seel},
-  title = {Profiling Tools Timers, Hash Map, Union-find, Modifiers},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgProfilingToolsSummary},
-  year = 2013
+
+@incollection{cgal:h-a-04,
+  author = {Dan Halperin},
+  title = {Arrangements},
+  chapter = 24,
+  editor = {Jacob E. Goodman and Joseph O'Rourke},
+  booktitle = {Handbook of Discrete and Computational Geometry},
+  publisher = {Chapman \& Hall/CRC},
+  edition = {2nd},
+  year = 2004,
+  pages = {529--562}
 }
 

 
-
-@incollection{cgal:fgk-ios-12b,
-  author = {Andreas Fabri and Geert-Jan Giezeman and Lutz Kettner},
-  title = {IO Streams},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgIOstreamsSummary},
-  year = 2013
+
+@manual{cgal:h-cln-99,
+  title = {{CLN}, The Class Library for Numbers},
+  author = {Haible, B.},
+  edition = {1.0.1},
+  month = {June},
+  year = {1999},
+  note = {\path|http://clisp.cons.org/~haible/packages-cln.html|},
+  update = {99.06 pion}
 }
 

 
-
-@incollection{cgal:fp-gv-12b,
-  author = {Andreas Fabri and Sylvain Pion},
-  title = {Geomview},
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgGeomviewSummary},
-  year = 2013
+
+@misc{cgal:hh-eplca-05,
+  author = {Idit Haran and Dan Halperin},
+  title = {Efficient Point Location in CGAL Arrangements using Landmarks},
+  year = {2005}
 }
 

 
-
-@incollection{cgal:fr-cqgvf-12b,
-  author = {Andreas Fabri and Laurent Rineau},
-  title = {{CGAL} and the Qt Graphics View Framework },
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgGraphicsViewSummary},
-  year = 2013
+
+@book{cgal:h-gsmi-89,
+  author = {Christoph M. Hoffmann},
+  title = {Geometric and Solid Modeling - An Introduction},
+  publisher = {Morgan Kaufmann},
+  year = 1989
 }
 

 
-
-@incollection{cgal:lp-gi-12b,
-  author = {S\'ebastien Loriot and Sylvain Pion},
-  title = {{CGAL} Ipelets },
-  publisher = {{CGAL Editorial Board}},
-  edition = {{4.2}},
-  booktitle = {{CGAL} User and Reference Manual},
-  url = {http://doc.cgal.org/4.2/CGAL.CGAL/html/packages.html#PkgCGALIpeletsSummary},
-  year = 2013
+
+@book{cgal:hgygm-ttdpf-99,
+  author = {P. W. Hallinan and G. Gordon and A.L. Yuille and P. Giblin and D. Mumford},
+  title = {Two-and Three-Dimensional Patterns of the Face},
+  publisher = {A.K.Peters},
+  year = {1999}
+}
+

+
+
+@inproceedings{cgal:h-pm-96,
+  author = {Hugues Hoppe},
+  title = {Progressive Meshes},
+  booktitle = {Computer Graphics (Proc. SIGGRAPH '96)},
+  volume = 30,
+  year = 1996,
+  pages = {99--108},
+  update = {97.08 kettner}
+}
+

+
+
+@mastersthesis{cgal:h-epmhd-10,
+  author = {Christian Helbling},
+  title = {Extreme Points in Medium and High Dimensions},
+  school = {ETH Zurich},
+  year = 2010,
+  address = {Zurich, Switzerland}
+}
+

+
+
+@inproceedings{cgal:h-slacr-99,
+  author = {M. Hoffmann},
+  title = {A Simple Linear Algorithm for Computing Rectangular
+                   Three-Centers},
+  booktitle = {Proc. 11th Canad. Conf. Comput. Geom.},
+  year = 1999,
+  pages = {72--75}
+}
+

+
+
+@phdthesis{cgal:h-srup-94,
+  author = {Hugues Hoppe},
+  title = {Surface reconstruction from unorganized points},
+  school = {University of Washington},
+  year = 1994,
+  update = {97.08 kettner}
+}
+

+
+
+@inproceedings{cgal:hddhjmss-pssr-94,
+  author = {Hugues Hoppe and Tony DeRose and Tom Duchamp and
+                  Mark Halstaed and Hubert Jin and John McDonald and
+                  Jean Schweitzer and Werner Stuetzle},
+  title = {Piecewise Smooth Surface Reconstruction},
+  booktitle = {Computer Graphics (Proc. SIGGRAPH '94)},
+  volume = 28,
+  year = 1994,
+  pages = {295--302},
+  note = {Examples and code in
+                   \path|ftp://ftp.cs.washington.edu/pub/graphics|},
+  update = {97.08 kettner}
+}
+

+
+
+@inproceedings{cgal:hddms-mo-93,
+  author = {Hugues Hoppe and Tony DeRose and Tom Duchamp and
+                  John McDonald and Werner Stuetzle},
+  title = {Mesh Optimization},
+  booktitle = {Computer Graphics (Proc. SIGGRAPH '93)},
+  volume = 27,
+  year = 1993,
+  pages = {19--26},
+  note = {Examples and code in
+                   \path|ftp://ftp.cs.washington.edu/pub/graphics|},
+  update = {97.08 kettner}
+}
+

+
+
+@inproceedings{cgal:hddms-srup-92,
+  author = {Hugues Hoppe and Tony DeRose and Tom Duchamp and
+                  John McDonald and Werner Stuetzle},
+  title = {Surface Reconstruction from Unorganized Points},
+  booktitle = {Computer Graphics (Proc. SIGGRAPH '90)},
+  volume = 26,
+  year = 1992,
+  pages = {71--77},
+  update = {97.08 kettner}
+}
+

+
+
+@inproceedings{cgal:hnp-gstds-95,
+  author = {J. M. Hellerstein and J. F. Naughton and A. Pfeffer},
+  title = {Generalized Search Trees for Database Systems},
+  editor = {Umeshwar Dayal and Peter M. D. Gray and Shojiro Nishio},
+  booktitle = {{VLDB} '95: proceedings of the 21st International
+                   Conference on Very Large Data Bases, Zurich,
+                   Switzerland, Sept. 11--15, 1995},
+  publisher = {Morgan Kaufmann Publishers},
+  address = {Los Altos, CA 94022, USA},
+  year = 1995,
+  pages = {562--573}
+}
+

+
+
+@article{cgal:hp-isr-02,
+  author = {D. Halperin and E. Packer},
+  title = {Iterated Snap Rounding},
+  journal = {Computational Geometry: Theory and Applications},
+  volume = 23,
+  number = 2,
+  year = 2002,
+  pages = {209--225}
+}
+

+
+
+@book{cgal:hw-vrml2h-96,
+  author = {Jed Hartman and Josie Wernecke},
+  title = {The {VRML} 2.0 Handbook: Building Moving Worlds on the
+                  Web},
+  publisher = {Addison-Wesley},
+  year = 1996,
+  annote = {The VRML 2.0 Introduction and Reference by
+                   Silicon Graphics.},
+  update = {98.02 kettner}
+}
+

+
+
+@incollection{cgal:ii-pacfa,
+  author = {H. Imai and M. Iri},
+  title = {Polygonal Approximation of a Curve -- Formulation and Algorithms},
+  booktitle = {Computational Morphology},
+  editor = {G.T. Toussaint},
+  year = {1988},
+  pages = {71--86}
+}
+

+
+
+@book{cgal:j-csl-99,
+  author = {Nicolai M. Josuttis},
+  title = {The {C}++ Standard Library, A Tutorial and Reference},
+  publisher = {Addison-Wesley},
+  year = 1999,
+  update = {01.06 hoffmann}
+}
+

+
+
+@incollection{cgal:k-dat-96,
+  author = {Keffer, T.},
+  title = {The Design and Architecture of {T}ools.h{\tt ++}},
+  booktitle = {{C{\tt ++}}~Gems},
+  publisher = {SIGS publications},
+  editor = {Lippman, S.},
+  year = {1996},
+  pages = {43--57},
+  update = {98.01 schirra}
+}
+

+
+
+@inproceedings{cgal:k-reisv-04,
+  author = {Menelaos I. Karavelas},
+  title = {A robust and efficient implementation for the segment
+                  {V}oronoi diagram},
+  booktitle = {Proc. Internat. Symp. on Voronoi diagrams in Science
+                  and Engineering (VD2004)},
+  pages = {51--62},
+  year = {2004}
+}
+

+
+
+@article{cgal:k-rprnm-96,
+  author = {Khachiyan, L.},
+  title = {Rounding of polytopes in the real number model of
+                    computation},
+  journal = {Mathematics of Operations Research},
+  volume = 21,
+  number = 2,
+  year = 1996,
+  pages = {307--320}
+}
+

+
+
+@inproceedings{cgal:l-nmdgp-05,
+  author = {Bruno Levy},
+  title = {Numerical Methods for Digital Geometry Processing},
+  booktitle = {Israel Korea Bi-National Conference - Invited talk, extended abstract
+               (full paper will be available shortly)},
+  year = {2005},
+  month = {November},
+  url = {http://www.loria.fr/~levy/php/article.php?pub=../publications/papers/2005/Numerics}
+}
+

+
+
+@article{cgal:l-tmbrc-91,
+  author = {Lienhardt, P.},
+  title = {Topological models for boundary representation: a
+              comparison with N-dimensional generalized maps},
+  journal = {Computer-Aided Design},
+  year = 1991,
+  volume = 23,
+  number = 1,
+  pages = {59--82},
+  annote = {map,generalized map}
+}
+

+
+
+@inproceedings{cgal:lt-fmeps-98,
+  author = {Peter Lindstrom and Greg Turk},
+  title = {Fast and memory efficient polygonal simplification},
+  booktitle = {{IEEE} Visualization},
+  pages = {279-286},
+  year = {1998},
+  url = {citeseer.ist.psu.edu/lindstrom98fast.html}
+}
+

+
+
+@article{cgal:lt-ems-99,
+  author = {P. Lindstrom and G. Turk},
+  title = {Evaluation of Memoryless Simplification},
+  journal = {IEEE Transactions on Visualization and Computer Graphics},
+  volume = {5},
+  number = {2},
+  month = {\slash},
+  pages = {98--115},
+  year = {1999},
+  url = {citeseer.ist.psu.edu/lindstrom99evaluation.html}
+}
+

+
+
+@article{cgal:k-lp-84,
+  author = {Donald E. Knuth},
+  title = {Literate Programming},
+  journal = {The Computer Journal},
+  year = 1984,
+  volume = 27,
+  number = 2,
+  pages = {97--111},
+  update = {98.01 kettner}
+}
+

+
+
+@inproceedings{cgal:k-s-00,
+  author = {Leif Kobbelt},
+  title = {$\sqrt{3}$-Subdivision},
+  booktitle = {Computer Graphics (Proc. SIGGRAPH '00)},
+  volume = 34,
+  year = 2000,
+  pages = {103--112},
+  update = {03.04 kettner}
+}
+

+
+
+@techreport{cgal:ke-ppawv-02,
+  author = {Menelaos I. Karavelas and Ioannis Z. Emiris},
+  title = {Predicates for the Planar Additively Weighted
+                   {V}oronoi Diagram},
+  institution = {INRIA Sophia-Antipolis},
+  year = 2002,
+  type = {Technical Report},
+  number = {ECG-TR-122201-01},
+  address = {Sophia-Antipolis},
+  month = may,
+  url = {ftp://ftp-sop.inria.fr/prisme/ECG/Reports/Month12/ECG-TR-122201-01.ps.gz}
+}
+

+
+
+@inproceedings{cgal:ke-rctac-03,
+  author = {Menelaos I. Karavelas and Ioannis Z. Emiris},
+  title = {Root comparison techniques applied to computing the additively
+weighted {V}oronoi diagram},
+  booktitle = {Proc. 14th ACM-SIAM Sympos. Discrete Algorithms (SODA)},
+  year = 2003,
+  pages = {320--329}
+}
+

+
+
+@manual{cgal:kl-cssd-94,
+  title = {The {CWEB} System of Structured Documentation},
+  author = {Donald E. Knuth and Silvio Levy},
+  edition = {Version 3.0},
+  year = 1994,
+  update = {98.01 kettner}
+}
+

+
+
+@article{cgal:kl-isc++l-96,
+  author = {K. Kreft and A. Langer},
+  title = {Iterators in the Standard {\CC\ }Library},
+  journal = {{C{\tt ++}}~Report},
+  volume = {8},
+  number = {10},
+  month = {Nov.-Dec.},
+  year = {1996},
+  pages = {27--32},
+  update = {98.01 schirra}
+}
+

+
+
+@book{cgal:km-st-76,
+  author = {Kuratowski, K. and Mostowski, A.},
+  title = {Set Theory},
+  publisher = {North-Holland Publishing Co.},
+  year = {1976}
+}
+

+
+
+@inproceedings{cgal:kv-mssct-05,
+  author = {N.G.H. Kruithof and G. Vegter},
+  title = {Meshing Skin Surfaces with Certified Topology},
+  booktitle = {Proceedings of the nineth International CAD\/Graphics conference},
+  pages = {to appear.},
+  year = 2005
+}
+

+
+
+@incollection{cgal:kw-ceapp-97,
+  author = {Lutz Kettner and Emo Welzl},
+  title = {Contour Edge Analysis for Polyhedron Projections},
+  booktitle = {Geometric Modeling: Theory and Practice},
+  year = 1997,
+  pages = {379--394},
+  publisher = {Springer Verlag},
+  editor = {Wolfgang Strasser and Reinhard Klein and Rene Rau},
+  update = {97.04 kettner, 97.08 kettner}
+}
+

+
+
+@techreport{cgal:kw-dat-96,
+  author = {Dietmar K{\"u}hl and Karsten Weihe},
+  title = {Data Access Templates},
+  institution = {Universit\"at Konstanz, Germany},
+  year = 1996,
+  type = {Konstanzer Schriften in Mathematik und Informatik},
+  number = {Nr. 9},
+  month = may,
+  note = {\path|http://www.informatik.uni-konstanz.de/Schriften|},
+  annote = {recommended C++ reading.},
+  update = {97.04 kettner}
+}
+

+
+
+@article{cgal:kw-dat-97,
+  author = {Dietmar K{\"u}hl and Karsten Weihe},
+  title = {Data Access Templates},
+  journal = {C++ Report},
+  year = 1997,
+  month = jun,
+  annote = {recommended C++ reading.},
+  update = {97.06 schoenherr}
+}
+

+
+
+@incollection{cgal:kw-osepg-98,
+  author = {Lutz Kettner and Emo Welzl},
+  title = {One Sided Error Predicates in Geometric Computing},
+  booktitle = {Proc. 15th IFIP World Computer Congress,
+                  Fundamentals - Foundations of Computer Science},
+  year = 1998,
+  pages = {13--26},
+  editor = {Kurt Mehlhorn},
+  update = {98.08 kettner}
+}
+

+
+
+@inproceedings{cgal:ky-dawvd-02,
+  author = {Menelaos Karavelas and Mariette Yvinec},
+  title = {Dynamic Additively Weighted Voronoi Diagrams in 2D},
+  year = 2002,
+  booktitle = {Proc.  10th European Symposium on Algorithms},
+  pages = { 586-598},
+  keywords = {Voronoi diagram, Appollonius diagram, additively weighted
+Voronoi diagram}
+}
+

+
+
+@book{cgal:l-icom-96,
+  author = {Stanley B. Lippman},
+  title = {Inside the {C{\tt ++}} Object Model},
+  publisher = {Addison-Wesley},
+  year = 1996,
+  annote = {Insides into C++ compiler implementations.
+                    Performance issues of various C++ features. },
+  update = {97.04 kettner}
+}
+

+
+
+@book{cgal:ll-cp-98,
+  author = {Stanley B. Lippman and Josee Lajoie},
+  title = {C++ Primer},
+  edition = {3rd},
+  publisher = {Addison-Wesley},
+  year = 1998,
+  update = {04.08 kettner}
+}
+

+
+
+@book{cgal:l-lscsd-96,
+  author = {John Lakos},
+  title = {Large Scale {C{\tt ++}} Software Design},
+  publisher = {Addison-Wesley},
+  year = 1996,
+  annote = {recommended OO reading.},
+  update = {97.04 kettner}
+}
+

+
+
+@inproceedings{cgal:lprm-lscm-02,
+  author = {Bruno L{\'e}vy and Sylvain Petitjean and Nicolas Ray
+                and J{\'e}rome Maillot},
+  title = {Least Squares Conformal Maps for Automatic Texture
+                Atlas Generation},
+  pages = {362--371},
+  issn = {0730-0301},
+  booktitle = {Proceedings of the 29th Conference on Computer
+                Graphics and Interactive Techniques SIGGRAPH},
+  series = {ACM Transactions on Graphics},
+  volume = {21(3)},
+  year = {2002}
+}
+

+
+
+@inproceedings{cgal:l-vgasa-96,
+  author = {D. T. Lee},
+  title = {Visualizing Geometric Algorithms -- State of the Art},
+  editor = {M. C. Lin and D. Manocha},
+  booktitle = {Applied Computational Geometry (Proc. WACG~'96)},
+  series = {Lecture Notes Comput. Sci.},
+  volume = 1148,
+  publisher = {Springer-Verlag},
+  year = 1996,
+  pages = {45--50},
+  update = {98.01 schirra}
+}
+

+
+
+@inproceedings{cgal:lazard04b,
+  author = {Lazard, Sylvain and  Pe{\~n}aranda, Luis and Petitjean, Sylvain},
+  title = {Intersecting Quadrics\,: An Efficient and Exact Implementation},
+  booktitle = {{ACM Symposium on Computational Geometry - SoCG'2004, Brooklyn, NY}},
+  year = { 2004},
+  month = { Jun},
+  url = {http://www.loria.fr/publications/2004/A04-R-021/A04-R-021.ps},
+  abstract = {We present the first complete, exact and efficient C++ implementation of a method for parameterizing the intersection of two implicit quadrics with integer coefficients of arbitrary size. It is based on the near-optimal algorithm recently introduced by Dupont et al.~\cite{dupont03a}. Unlike existing implementations, it correctly identifies and parameterizes all the connected components of the intersection in all the possible cases, returning parameterizations with rational functions whenever such parameterizations exist. In addition, the coefficient field of the parameterizations is either minimal or involves one possibly unneeded square root.}
+}
+

+
+
+@inproceedings{cgal:lpt-wea-09,
+  author = {Lazard, Sylvain and Pe{\~n}aranda, Luis and
+                   Tsigaridas, Elias},
+  title = {Univariate Algebraic Kernel and Application to
+                   Arrangements},
+  booktitle = {SEA},
+  year = {2009},
+  pages = {209-220},
+  ee = {http://dx.doi.org/10.1007/978-3-642-02011-7_20},
+  crossref = {cgal:v-ea-09},
+  bibsource = {DBLP, http://dblp.uni-trier.de},
+  update = {09.11 penarand}
+}
+

+
+
+@book{cgal:m-cst-93,
+  author = {Robert B. Murray},
+  title = {{C{\tt ++}} Strategies and Tactics},
+  publisher = {Addison-Wesley},
+  year = 1993,
+  annote = {recommended C++ reading},
+  update = {98.01 schirra}
+}
+

+
+
+@book{cgal:m-ec-92,
+  author = {Scott Meyers},
+  title = {Effective {C{\tt ++}}},
+  publisher = {Addison-Wesley},
+  year = 1992,
+  annote = {recommended C++ reading. 50 Specific Ways to
+                   Improve Your Programs and Designs},
+  update = {97.04 schoenherr}
+}
+

+
+
+@book{cgal:m-ec-97,
+  author = {Scott Meyers},
+  title = {Effective C++: 50 Specific Ways to Improve Your Programs and
+                  Designs},
+  edition = {2nd},
+  publisher = {Addison-Wesley},
+  year = {1997}
+}
+

+
+
+@book{cgal:m-mec-96,
+  author = {Scott Meyers},
+  title = {More Effective {C{\tt ++}}},
+  publisher = {Addison-Wesley},
+  year = 1996,
+  annote = {recommended C++ reading. 35 New Ways to
+                   Improve Your Programs and Designs},
+  update = {97.04 schoenherr}
+}
+

+
+
+@inproceedings{cgal:m-pppd-96,
+  author = {Kurt Mehlhorn},
+  title = {Position Paper for Panel Discussion},
+  editor = {M. C. Lin and D. Manocha},
+  booktitle = {Applied Computational Geometry (Proc. WACG~'96)},
+  series = {Lecture Notes Comput. Sci.},
+  volume = 1148,
+  publisher = {Springer-Verlag},
+  year = 1996,
+  pages = {51--52},
+  update = {98.01 schirra}
+}
+

+
+
+@article{cgal:m-tnutt-95,
+  author = {Nathan C. Myers},
+  title = {Traits: a New and Useful Template Technique},
+  journal = {{C{\tt ++}}~Report},
+  year = 1995,
+  month = jun,
+  annote = {recommended C++ reading. stream traits, iterator
+                   traits, typedef's.},
+  update = {97.04 kettner}
+}
+

+
+
+@book{cgal:m-wsc-93,
+  author = {Steve Maguire},
+  title = {Writing Solid Code},
+  publisher = {Microsoft Press},
+  year = 1993,
+  annote = {Microsoft's techniques for developing bug-free C programs},
+  update = {98.01 schirra}
+}
+

+
+
+@inproceedings{cgal:mad-fpsep-05,
+  author = {Abdelkrim Mebarki and Pierre Alliez and Olivier Devillers},
+  title = {Farthest Point Seeding for Efficient Placement of Streamlines},
+  year = 2005,
+  booktitle = {Proceeding of IEEE Visualization}
+}
+

+
+
+@inproceedings{cgal:mdsb-ddgot-02,
+  author = {M. Meyer and M. Desbrun and P. Schr{\"o}der and A. H. Barr},
+  title = {Discrete Differential-Geometry Operators for Triangulated 2-Manifolds},
+  booktitle = {VisMath},
+  address = {},
+  year = {2002},
+  pages = {}
+}
+

+
+
+@book{cgal:mg-uulp-06,
+  author = {J. Matou\v{s}ek and B. G{\"a}rtner},
+  title = {Understanding and Using Linear Programming},
+  publisher = {Springer-Verlag},
+  year = 2006
+}
+

+
+
+@manual{cgal:mnsu-lum,
+  author = {Mehlhorn, K. and N\"aher, S. and Seel, M. and Uhrig, C.},
+  title = {The {LEDA} {U}ser {M}anual},
+  organization = {Max-Planck-Insitut f\"ur Informatik},
+  address = {66123 Saarbr\"ucken, Germany},
+  note = {\path|http://www.mpi-sb.mpg.de/LEDA/leda.html|},
+  update = {99.05 schirra, 00.09 hert}
+}
+

+
+
+@inproceedings{cgal:mp-fcafg-05,
+  author = {Guillaume Melquiond and Sylvain Pion},
+  title = {Formal certification of arithmetic filters for geometric predicates},
+  booktitle = {Proc. 17th IMACS World Congress on Scientific, Applied Mathematics and Simulation},
+  year = 2005,
+  pages = {}
+}
+

+
+
+@article{cgal:ms-aogl-94,
+  author = {David R.~Musser and Alexander A.~Stepanov},
+  title = {Algorithm-oriented Generic Libraries},
+  journal = {Software -- Practice and Experience},
+  year = 1994,
+  volume = 24,
+  number = 7,
+  pages = {623--642},
+  month = jul
+}
+

+
+
+@inproceedings{cgal:ms-gp-89,
+  author = {David R.~Musser and Alexander A.~Stepanov},
+  title = {Generic Programming},
+  booktitle = {1st Intl.\ Joint Conf.\ of ISSAC-88 and AAEC-6},
+  year = 1989,
+  pages = {13--25},
+  publisher = {Springer LNCS 358}
+}
+

+
+
+@book{cgal:ms-strg-96,
+  author = {David R. Musser and Atul Saini},
+  title = {{STL} Tutorial and Reference Guide:
+                  {C{\tt ++}}~Programming with the Standard Template
+                   Library},
+  publisher = {Addison-Wesley},
+  year = 1996,
+  annote = {recommended C++ reading.},
+  update = {97.04 kettner}
+}
+

+
+
+@misc{cgal:mt-mpfr,
+  key = {MPFR},
+  title = {{MPFR} - The Multiple Precision Floating-Point Reliable
+                   Library},
+  howpublished = {The {MPFR} Team},
+  note = {\path|http://mpfr.org|},
+  update = {09.11 penarand}
+}
+

+
+
+@book{cgal:ndw-opgog-93,
+  author = {Jackie Neider and Tom Davis and Mason Woo},
+  title = {OpenGL Programming Guide: The Official Guide to
+                     Learning OpenGL, Release 1},
+  publisher = {Addison-Wesley},
+  year = 1993,
+  update = {97.04 kettner}
+}
+

+
+
+@inproceedings{cgal:o-dcgal-96,
+  author = {Mark H. Overmars},
+  title = {Designing the Computational Geometry Algorithms
+                     Library {CGAL}},
+  booktitle = {ACM Workshop on Applied Computational Geometry},
+  editor = {M. C. Lin and D. Manocha},
+  address = {Philadelphia, Pennsylvenia},
+  month = {May, 27--28},
+  year = 1996,
+  note = {Lecture Notes in Computer Science 1148},
+  update = {97.04 kettner}
+}
+

+
+
+@inproceedings{cgal:ory-mvbss-05,
+  author = {Steve Oudot and Laurent Rineau  and Mariette Yvinec},
+  title = {Meshing Volumes Bounded by Smooth Surfaces},
+  booktitle = {Proc.  14th International Meshing Roundtable},
+  year = 2005,
+  nickname = {IMRT05},
+  pages = {203-219}
+}
+

+
+
+@book{cgal:p-gd-01,
+  author = {I. Porteous},
+  title = {Geometric Differentiation (2nd Edition)},
+  publisher = {Cambridge University Press},
+  year = {2001}
+}
+

+
+
+@manual{cgal:p-gmgv16-96,
+  author = {Mark Phillips},
+  title = {Geomview Manual, Version 1.6.1 for Unix Workstations},
+  organization = {The Geometry Center},
+  address = {University of Minnesota},
+  year = 1996,
+  note = {\path|http://www.geom.umn.edu/software/download/geomview.html|},
+  annote = {Reference for object file format (OFF).},
+  update = {03.04 kettner}
+}
+

+
+
+@article{cgal:p-plcbd-93,
+  author = {B. Piper},
+  title = {Properties of Local Coordinates based on Dirichlet
+                   tesselations},
+  journal = {Computing Suppl.},
+  year = {1993},
+  volume = {8},
+  pages = {227-239}
+}
+

+
+
+@article{cgal:p-smrqt-01,
+  author = {S. Petitjean},
+  title = {A Survey of Methods for Recovering Quadrics in Triangle Meshes},
+  journal = {ACM Computing Surveys},
+  year = {2001},
+  volume = {34},
+  number = {2},
+  pages = {}
+}
+

+
+
+@techreport{cgal:pabl-cco-07,
+  author = {Poudret, M. and Arnould, A. and Bertrand, Y. and Lienhardt, P.},
+  title = {Cartes Combinatoires Ouvertes.},
+  institution = {Laboratoire SIC E.A. 4103},
+  number = {2007-1},
+  month = {October},
+  year = {2007},
+  address = {F-86962 Futuroscope Cedex, France},
+  type = {Research Notes},
+  keywords = {cartes combinatoires, demi-ar{\^e}te, ar{\^e}te radiale}
+}
+

+
+
+@article{cgal:pc-rdp-86,
+  author = {David L. Parnas and Paul C. Clements},
+  title = {A Rational Design Process: How and Why to Fake It},
+  journal = {IEEE Transactions on Software Engineering},
+  year = 1986,
+  volume = 12,
+  number = 2,
+  pages = {251-257},
+  update = {98.01 kettner}
+}
+

+
+
+@article{cgal:pp-cdmsc-93,
+  author = {U. Pinkall and K. Polthier},
+  title = {Computing discrete minimal surfaces and their conjugates},
+  journal = {Experimental Mathematics},
+  volume = {2},
+  number = {1},
+  pages = {15-36},
+  year = {1993}
+}
+

+
+
+@book{cgal:ptvf-nrcpp-02,
+  author = {W. Press and S. Teukolsky and W. Vetterling and B. Flannery},
+  title = {Numerical Recipes in {C}{\tt ++}},
+  edition = {2nd},
+  publisher = {Cambridge University Press},
+  year = 2002
+}
+

+
+
+@article{cgal:pv-opadc-94,
+  author = {J.C. Perez and E. Vidal},
+  title = {Optimum polygonal approximation of digitized curves},
+  journal = {Pattern Recognition Letters},
+  year = 1994,
+  number = 15,
+  pages = {743--750}
+}
+

+
+
+@article{cgal:r-lomom-94,
+  author = {James Rumbaugh},
+  title = {The Life of an Object Model: How the Object-Model
+                     Changes During Development},
+  journal = {Journal of Object-Oriented Programming},
+  year = 1994,
+  volume = 7,
+  number = 1,
+  pages = {24--32},
+  month = {March/April},
+  annote = {Object and class diagram notation as used in the
+                     book of design patterns ghjv-dpero-95.},
+  update = {97.04 kettner}
+}
+

+
+
+@misc{cgal:r-mpfi,
+  key = {MPFI},
+  title = {{MPFI} - The Multiple Precision Floating-Point Interval
+                   Library},
+  howpublished = {{R}evol, {N}athalie and {R}ouillier, {F}abrice},
+  note = {\path|http://perso.ens-lyon.fr/nathalie.revol/software.html|},
+  update = {09.11 penarand}
+}
+

+
+
+@article{cgal:r-rrstm-80,
+  author = {Requicha, Aristides G.},
+  title = {Representations for Rigid Solids: Theory, Methods,
+            and Systems},
+  journal = {ACM Computing Surveys},
+  volume = {12},
+  number = {4},
+  year = {1980},
+  issn = {0360-0300},
+  pages = {437--464},
+  publisher = {ACM Press}
+}
+

+
+
+@misc{cgal:r-rs,
+  key = {RS},
+  title = {{RS - A} Software for real solving of algebraic systems},
+  howpublished = {{R}ouillier, {F}abrice},
+  note = {\path|http://www.loria.fr/equipes/vegas/rs/|},
+  update = {09.11 penarand}
+}
+

+
+
+@book{cgal:rbpel-oomd-91,
+  author = {James Rumbaugh and Michael Blaha and William
+                     Premerlani and Frederick Eddy and William Lorenson},
+  title = {Object-Oriented Modeling and Design},
+  publisher = {Prentice Hall},
+  address = {Englewood Cliffs, NJ},
+  year = 1991,
+  annote = {Object and class diagram notation as used in the
+                     book of design patterns ghjv-dpero-95.},
+  update = {97.04 kettner}
+}
+

+
+
+@article{cgal:ry-gsddrm-06,
+  author = {Laurent Rineau and Mariette Yvinec},
+  title = {A Generic Software Design for {D}elaunay Refinement Meshing},
+  year = 2007,
+  journal = {Comput. Geom. Theory Appl.},
+  volume = 38,
+  pages = {100--110},
+  url = {http://dx.doi.org/10.1016/j.comgeo.2006.11.008},
+  publisher = {Elsevier Science Publishers B. V.},
+  update = {09.02 lrineau}
+}
+

+
+
+@article{cgal:rz-jcam-04,
+  author = {{R}ouillier, {F}abrice and {Z}immermann, {P}aul},
+  title = {{E}fficient isolation of polynomial's real roots},
+  journal = {Journal of Computational and Applied Mathematics},
+  volume = 162,
+  number = 1,
+  pages = {33-50},
+  year = 2004,
+  update = {09.11 penarand}
+}
+

+
+
+@inproceedings{cgal:s-cgehd-98,
+  author = {Jonathan R. Shewchuk},
+  title = {A Condition Guaranteeing the Existence of Higher-Dimensional
+                   Constrained Delaunay Triangulations},
+  booktitle = {Proc. 14th Annu. ACM Sympos. Comput. Geom.},
+  year = 1998,
+  pages = {76--85}
+}
+

+
+
+@book{cgal:s-cpl-91,
+  author = {Bjarne Stroustrup},
+  title = {The {C{\tt ++}}~Programming Language},
+  publisher = {Addison-Wesley},
+  year = 1991,
+  edition = {2nd},
+  annote = {recommended C++ reading.},
+  update = {97.04 kettner}
+}
+

+
+
+@book{cgal:s-cpl-97,
+  author = {Bjarne Stroustrup},
+  title = {The {C{\tt ++}}~Programming Language},
+  publisher = {Addison-Wesley},
+  year = 1997,
+  edition = {3rd},
+  annote = {recommended C++ reading.},
+  update = {97.12 kettner}
+}
+

+
+
+@misc{cgal:s-dcgal-96,
+  author = {S. Schirra},
+  title = {Designing a Computational Geometry Algorithms Library},
+  howpublished = {Lecture Notes for Advanced School on Algorithmic
+                   Foundations of Geographic Information Systems, CISM,
+                   Udine},
+  month = {September 16-20},
+  year = {1996},
+  update = {98.01 schirra}
+}
+

+
+
+@incollection{cgal:s-ixgpe-91a,
+  author = {Peter Schorn},
+  title = {Implementing the {XYZ} {GeoBench}: A programming
+                   environment for geometric algorithms},
+  booktitle = {Computational Geometry --- Methods, Algorithms and
+                   Applications: Proc. Internat. Workshop Comput.
+                   Geom. CG '91},
+  series = {Lecture Notes Comput. Sci.},
+  volume = 553,
+  publisher = {Springer-Verlag},
+  year = 1991,
+  pages = {187--202},
+  note = {\path|http://wwwjn.inf.ethz.ch/geobench/XYZGeoBench.html|},
+  update = {94.01 rote, 98.01 kettner}
+}
+

+
+
+@techreport{cgal:s-picpc-98,
+  author = {Schirra, Stefan},
+  title = {Parameterized Implementations of Classical Planar
+                   Convex Hull Algorithms and Extreme Point Computations},
+  type = {Research Report},
+  institution = {Max-Planck-Institut f{\"u}r Informatik},
+  address = {Im Stadtwald, D-66123 Saarbr{\"u}cken, Germany},
+  number = {MPI-I-98-1-003},
+  month = {January},
+  year = {1998},
+  issn = {0946-011X},
+  update = {98.01 schirra}
+}
+

+
+
+@incollection{cgal:s-prgc-97,
+  author = {S. Schirra},
+  title = {Precision and Robustness in Geometric Computations},
+  booktitle = {Algorithmic foundations of geographic information systems},
+  editor = {van Kreveld, Marc and Nievergelt, J{\"u}rg and Roos, Thomas and Widmayer, Peter},
+  publisher = {Springer-Verlag},
+  address = {Berlin},
+  year = {1997},
+  series = {Lecture Notes in Computer Science},
+  volume = {1340},
+  pages = {255--287},
+  update = {98.4 schirra}
+}
+

+
+
+@mastersthesis{cgal:s-zkm-96,
+  author = {Michael Schutte},
+  title = {Zuf{\"a}llige Konvexe Mengen},
+  school = {Freie Universit{\"a}t Berlin},
+  year = 1996,
+  address = {Germany}
+}
+

+
+
+@misc{cgal:sgcsi-stlpg-97,
+  author = {{Silicon Graphics Computer Systems{,} Inc.}},
+  title = {Standard Template Library Programmer's Guide},
+  howpublished = {\path|http://www.sgi.com/Technology/STL/|},
+  year = 1997,
+  annote = {Web reference to the STL from SGI.
+                   recommended C++ and STL reference material.},
+  update = {97.12 kettner}
+}
+

+
+
+@misc{cgal:sl-stl-95,
+  author = {Alexander Stepanov and Meng Lee},
+  title = {The Standard Template Library},
+  month = oct,
+  year = 1995,
+  annote = {recommended C++ reading. Short introduction to the
+                   STL. Precise requirements for the iterators and
+                   containers. Explanation of iterator tags (outdated).},
+  update = {97.04 kettner}
+}
+

+
+
+@techreport{cgal:sm-iftml-00,
+  author = {M. Seel and K. Mehlhorn},
+  title = {Infimaximal Frames: A Technique for Making Lines Look
+                   Like Segments},
+  type = {Research Report},
+  institution = {MPI f{\"u}r Informatik},
+  address = {Saarbr{\"u}cken, Germany},
+  number = {MPI-I-2000-1-005},
+  month = dec,
+  year = {2000},
+  issn = {0946-011X},
+  note = {\path|http://www.mpi-sb.mpg.de/~mehlhorn/ftp/InfiFrames.ps|}
+}
+

+
+
+@inproceedings{cgal:sp-mrbee-05,
+  title = {Mesh Refinement based on Euler Encoding},
+  author = {Le-Jeng Shiue and J{\"o}rg Peters},
+  pages = {343--348},
+  year = {2005},
+  booktitle = {Proceedings of the International Conference on
+                 Shape Modeling and Applications 2005}
+}
+

+
+
+@inproceedings{cgal:sp-mrlbg-05,
+  title = {A Mesh Refinement Library based on Generic Design},
+  author = {Le-Jeng Shiue and J{\"o}rg Peters},
+  pages = {1-104--1-108},
+  year = {2005},
+  booktitle = {Proceedings of the 43rd ACM Southeast Conference}
+}
+

+
+
+@book{cgal:sll-bgl-02,
+  author = {Jeremy G. Siek and Lie-Quan Lee and Andrew Lumsdaine},
+  title = {Boost Graph Library},
+  publisher = {Addison-Wesley},
+  year = 2002
+}
+

+
+
+@inproceedings{cgal:sry-mvbss-05,
+  author = {Steve Oudot and Laurent Rineau  and Mariette Yvinec},
+  title = {Meshing Volumes Bounded by Smooth Surfaces},
+  booktitle = {Proc.  14th International Meshing Roundtable},
+  year = 2005,
+  nickname = {IMRT05},
+  pages = {203-219}
+}
+

+
+
+@article{cgal:ss-ablp-91,
+  author = {Lisa M. C. Smith and Mansur H. Samadzadeh},
+  title = {An Annotated Bibliography of Literate Programming},
+  journal = {ACM SIGPLAN Notices},
+  year = 1991,
+  volume = 26,
+  number = 1,
+  pages = {14--20},
+  month = jan,
+  update = {98.01 kettner}
+}
+

+
+
+@phdthesis{cgal:t-om-09,
+  author = {Jane Tournois},
+  title = {Optimisation de maillages},
+  type = {Th{\`e}se de doctorat en sciences},
+  school = {Uni\-ver\-sit{\'e} Nice Sophia-Antipolis},
+  address = {Nice, France},
+  year = 2009,
+  flag = {_these}
+}
+

+
+
+@article{cgal:tpg-rmtiise-99,
+  author = {G.M. Treece and R.W. Prager and A.H. Gee},
+  title = {Regularised marching tetrahedra: improved iso-surface extraction},
+  journal = {Computers and Graphics},
+  volume = {23},
+  number = {4},
+  pages = {583--598},
+  year = {1999},
+  url = {http://citeseer.ist.psu.edu/treece98regularised.html}
+}
+

+
+
+@inproceedings{cgal:tsa-ps3dd-09,
+  author = {Jane TOURNOIS and Rahul SRINIVASAN and Pierre ALLIEZ},
+  title = {{Perturbing slivers in 3D Delaunay meshes}},
+  year = {2009},
+  month = {october},
+  booktitle = {Proceedings of the 18th International Meshing Roundtable},
+  location = {Salt Lake City, Utah, USA}
+}
+

+
+
+@article{cgal:twad-iropitmg-09,
+  author = {Jane Tournois and Camille Wormser and Pierre Alliez
+                      and Mathieu Desbrun},
+  title = {Interleaving {Delaunay} Refinement and Optimization for
+                      Practical Isotropic Tetrahedron Mesh Generation},
+  year = 2009,
+  journal = {ACM Transactions on Graphics},
+  pages = {75:1-75:9},
+  note = {SIGGRAPH '2009 Conference Proceedings},
+  volume = {28(3)},
+  url = {http://hal.inria.fr/inria-00359288},
+  geombib = {not yet},
+  x-editorial-board = {yes},
+  x-proceedings = {yes},
+  x-international-audience = {yes}
+}
+

+
+
+@proceedings{cgal:v-ea-09,
+  editor = {Jan Vahrenhold},
+  title = {Experimental Algorithms, 8th International Symposium, SEA
+                   2009, Dortmund, Germany, June 4-6, 2009. Proceedings},
+  booktitle = {SEA},
+  publisher = {Springer},
+  series = {Lecture Notes in Computer Science},
+  volume = {5526},
+  year = {2009},
+  isbn = {978-3-642-02010-0},
+  ee = {http://dx.doi.org/10.1007/978-3-642-02011-7},
+  bibsource = {DBLP, http://dblp.uni-trier.de},
+  update = {09.11 penarand}
+}
+

+
+
+@article{cgal:v-et-95,
+  author = {Todd Veldhuizen},
+  title = {Expressions Templates},
+  journal = {{C{\tt ++}}~Report},
+  year = 1995,
+  month = jun,
+  pages = {26--31},
+  annote = {Inlining vector expressions and parameter passing
+		     of expressions at compile time. Template Metaprograms.},
+  update = {98.01 kettner}
+}
+

+
+
+@inproceedings{cgal:v-gpc-97,
+  author = {R. C. Veltkamp},
+  title = {Generic Programming in {CGAL}, the Computational
+                   Geometry Algorithms Library},
+  booktitle = {Proceedings of the 6th Eurographics Workshop on
+                  Programming Paradigms in Graphics},
+  year = {1997},
+  update = {98.01 schirra}
+}
+

+
+
+@article{cgal:v-tm-95,
+  author = {Todd Veldhuizen},
+  title = {Template Metaprograms},
+  journal = {{C{\tt ++}}~Report},
+  year = 1995,
+  month = may,
+  pages = {36--43},
+  annote = {Prime numbers at compiler time, C++ programs at
+		     compile time, control structures, local variables.},
+  update = {98.01 kettner}
+}
+

+
+
+@book{cgal:vj-ctcg-03,
+  author = {David Vandevoorde and Nicolai M. Josuttis},
+  title = {{C}++ Templates: The Complete Guide},
+  publisher = {Addison-Wesley},
+  year = 2003,
+  update = {04.04 kettner}
+}
+

+
+
+@article{cgal:vp-lactm-96,
+  author = {Todd Veldhuizen and Kumaraswamy Ponnambalam},
+  title = {Linear Algebra with {C{\tt ++}} Template Metaprograms},
+  journal = {Dr. Dobb's Journal},
+  year = 1996,
+  month = aug,
+  annote = {Vector operations without temporary variables.},
+  update = {04.01, 98.01 kettner}
+}
+

+
+
+@misc{cgal:vrmls-97,
+  key = {VRML2},
+  title = {The Virtual Reality Modeling Language Specification:
+                  Version 2.0, {ISO}/{IEC} {CD} 14772},
+  howpublished = {\path|http://www.web3d.org/x3d/specifications/vrml/ISO-IEC-14772-VRML97/|},
+  month = {December},
+  year = 1997,
+  update = {13.04 lrineau}
+}
+

+
+
+@manual{cgal:w-fum-92,
+  title = {{FunnelWeb} User's Manual},
+  author = {Ross N. Williams},
+  edition = {{V1.0} for {FunnelWeb} {V3.0}},
+  year = 1992,
+  month = may,
+  update = {98.01 kettner}
+}
+

+
+
+@incollection{cgal:w-fvt-90,
+  author = {Bob Wallis},
+  title = {Forms, Vectors, and Transforms},
+  booktitle = {Graphics Gems},
+  publisher = {Academic Press},
+  year = 1990,
+  editor = {Andrew S. Glassner},
+  pages = {533--538},
+  annote = {Normal vectors under affine transformations,
+                  tensor algebra and differential geometry, triangular
+                  interpolants, subdeviding a parametric polynomial
+                  curve},
+  update = {98.01 kettner}
+}
+

+
+
+@book{cgal:w-impoo-94,
+  author = {Josie Wernicke},
+  title = {The Inventor Mentor: Programming Object-Oriented
+		     3D Graphics with Open Inventor, Release 2},
+  publisher = {Addison-Wesley},
+  year = 1994,
+  update = {97.04 kettner}
+}
+

+
+
+@book{cgal:ww-smgd-02,
+  author = {Joe Warren and Henrik Weimer},
+  title = {Subdivision Methods for Geometric Design},
+  address = {New York},
+  publisher = {Morgan Kaufmann Publishers},
+  year = {2002}
+}
+

+
+
+@inproceedings{cgal:ybs-frdcl-05,
+  author = {Shin Yoshizawa and Alexander Belyaev and Hans-Peter Seidel},
+  title = {Fast and robust detection of crest lines on meshes},
+  booktitle = {SPM '05: Proceedings of the 2005 ACM symposium on Solid and physical modeling},
+  year = {2005},
+  isbn = {1-59593-015-9},
+  pages = {227--232},
+  location = {Cambridge, Massachusetts},
+  doi = {http://doi.acm.org/10.1145/1060244.1060270},
+  publisher = {ACM Press},
+  address = {New York, NY, USA}
+}
+

+
+
+@article{cgal:ybs-rvlmi-04,
+  author = {Yutaka Ohtake and Alexander Belyaev and Hans-Peter Seidel},
+  title = {Ridge-valley lines on meshes via implicit surface fitting},
+  journal = {ACM Trans. Graph.},
+  volume = {23},
+  number = {3},
+  year = {2004},
+  issn = {0730-0301},
+  pages = {609--612},
+  doi = {http://doi.acm.org/10.1145/1015706.1015768},
+  publisher = {ACM Press},
+  address = {New York, NY, USA}
+}
+

+
+
+@article{cgal:ze-fsbi-02,
+  author = {Afra Zomorodian and Herbert Edelsbrunner},
+  title = {Fast Software for Box Intersection},
+  journal = {Int. J. Comput. Geom. Appl.},
+  year = 2002,
+  volume = 12,
+  pages = {143--172}
+}
+

+
+
+@incollection{cgal:h-sm-04,
+  author = {Christoph M. Hoffmann},
+  title = {Solid Modeling},
+  chapter = 56,
+  editor = {Jacob E. Goodman and Joseph O'Rourke},
+  booktitle = {Handbook of Discrete and Computational Geometry},
+  publisher = {Chapman \& Hall/CRC},
+  edition = {2nd},
+  year = 2004,
+  pages = {1257--1278}
+}
+

+
+
+@inproceedings{cgal:fo-ss-98,
+  author = {Petr Felkel and St{\v{e}}p{\'{a}}n Obdr\v{z}{\'{a}}lek},
+  title = {Straight Skeleton Implementation},
+  booktitle = {14th Spring Conference on Computer Graphics
+              (SCCG'98)},
+  editor = {L{\'{a}}szl{\'{o}} Szirmay Kalos},
+  pages = {210--218},
+  year = {1998},
+  url = {citeseer.ist.psu.edu/article/felkel98straight.html}
+}
+

+
+
+@inproceedings{cgal:ee-rrccpp-98,
+  author = {David Eppstein and Jeff Erickson},
+  title = {Raising Roofs, Crashing Cycles, and Playing Pool: Applications of a Data Structure for Finding Pairwise Interactions},
+  booktitle = {Symposium on Computational Geometry},
+  pages = {58--67},
+  year = {1998},
+  url = {citeseer.ist.psu.edu/eppstein98raising.html}
+}
+

+
+
+@inproceedings{cgal:ld-agrm-03,
+  author = {R. G. Laycock and A. M. Day},
+  title = {Automatically Generating Roof Models from Building
+                Footprints},
+  booktitle = {The 11-th International Conference in Central Europe
+                on Computer Graphics, Visualization and Computer
+                Vision'2003. Journal of WSCG - FULL Papers },
+  year = 2003,
+  volume = 11,
+  issn = {ISSN 1213-6972},
+  url = {http://wscg.zcu.cz/wscg2003/Papers_2003/G67.pdf}
+}
+

+
+
+@inproceedings{cgal:k-vdc-06,
+  author = {Menelaos I. Karavelas},
+  title = {Voronoi diagrams in {\sc Cgal}},
+  booktitle = {22nd European Symposium on Computational Geometry},
+  pages = {229--232},
+  year = {2006},
+  address = {Delphi, Greece}
+}
+

+
+
+@techreport{cgal:f-ecsca-04,
+  author = {E. Fogel et al.},
+  title = {An empirical comparison of software for constructing arrangements of curved arcs},
+  type = {Technical {Report}},
+  number = {ECG-TR-361200-01},
+  institution = {Tel Aviv University},
+  year = 2004
+}
+

+
+
+@mastersthesis{cgal:m-rgece-06,
+  author = {Michal Meyerovitch},
+  title = {Robust, Generic, and Efficient Constructions of Envelopes of Surfaces in Three-Dimensional Space},
+  school = {Tel-Aviv University},
+  year = 2006,
+  address = {Israel}
+}
+

+
+
+@inproceedings{cgal:a-esgc-98,
+  author = {David Abrahams},
+  title = {Exception-Safety in Generic Components},
+  booktitle = {Generic Programming},
+  year = {1998},
+  pages = {69-79},
+  ee = {http://link.springer.de/link/service/series/0558/bibs/1766/17660069.htm},
+  crossref = {cgal:jlm-isgp-98},
+  bibsource = {DBLP, http://dblp.uni-trier.de},
+  url = {http://www.boost.org/more/generic_exception_safety.html}
+}
+

+
+
+@article{cgal:as-solri-92,
+  author = {F. Aurenhammer and O. Schwarzkopf},
+  title = {A simple on-line randomized incremental algorithm for computing higher order {Voronoi} diagrams},
+  journal = {Internat. J. Comput. Geom. Appl.},
+  volume = 2,
+  year = 1992,
+  pages = {363--381},
+  keywords = {Voronoi diagrams, geometric transforms, dynamization},
+  succeeds = {as-solri-91},
+  update = {93.09 aurenhammer, 93.05 schwarzkopf}
+}
+

+
+
+@inproceedings{cgal:fy-okvd-01,
+  author = {Julia Fl{\"o}totto and Mariette Yvinec},
+  title = {Order-$k$ {Voronoi} Diagrams},
+  booktitle = {Abstracts 17th European Workshop Comput. Geom.},
+  nickname = {CG 2001},
+  site = {Berlin},
+  publisher = {Freie Universit{\"a}t Berlin},
+  year = 2001,
+  pages = {109--112},
+  update = {01.04 icking}
+}
+

+
+
+@proceedings{cgal:jlm-isgp-98,
+  editor = {Mehdi Jazayeri and
+               R{\"u}diger Loos and
+               David R. Musser},
+  title = {Generic Programming, International Seminar on Generic Programming,
+               Dagstuhl Castle, Germany, April 27 - May 1, 1998, Selected Papers},
+  booktitle = {Generic Programming},
+  publisher = {Springer},
+  series = {Lecture Notes in Computer Science},
+  volume = {1766},
+  year = {2000},
+  isbn = {3-540-41090-2},
+  bibsource = {DBLP, http://dblp.uni-trier.de}
+}
+

+
+
+@inproceedings{Kazhdan06,
+  author = {Michael Kazhdan and M. Bolitho and Hugues Hoppe},
+  title = {{Poisson Surface Reconstruction}},
+  booktitle = {Symp. on Geometry Processing},
+  year = {2006},
+  pages = {61--70}
+}
+

+
+
+@article{BC02,
+  author = {Boissonnat and Cazals},
+  title = {Smooth Surface Reconstruction via Natural Neighbour
+         Interpolation of Distance Functions},
+  journal = {CGTA: Computational Geometry: Theory and
+         Applications},
+  volume = {22},
+  year = {2002}
+}
+

+
+
+@inproceedings{LC87,
+  author = {William E. Lorensen and Harvey E. Cline},
+  title = {Marching cubes: A high resolution 3D surface construction algorithm},
+  booktitle = {SIGGRAPH '87: Proceedings of the 14th annual conference on Computer graphics and interactive techniques},
+  year = {1987},
+  isbn = {0-89791-227-6},
+  pages = {163--169},
+  doi = {http://doi.acm.org/10.1145/37401.37422},
+  publisher = {ACM Press},
+  address = {New York, NY, USA}
+}
+

+
+
+@inproceedings{CBC01,
+  author = {J. C. Carr and R. K. Beatson and J. B. Cherrie and T. J. Mitchell and W. R. Fright and B. C. McCallum and T. R. Evans},
+  title = {Reconstruction and representation of 3D objects with radial basis functions},
+  booktitle = {SIGGRAPH '01: Proceedings of the 28th annual conference on Computer graphics and interactive techniques},
+  year = {2001},
+  isbn = {1-58113-374-X},
+  pages = {67--76},
+  doi = {http://doi.acm.org/10.1145/383259.383266},
+  publisher = {ACM Press},
+  address = {New York, NY, USA}
+}
+

+
+
+@inproceedings{ABK98,
+  author = {Nina Amenta and Marshall Bern and Manolis Kamvysselis},
+  title = {A new Voronoi-based surface reconstruction algorithm},
+  booktitle = {SIGGRAPH '98: Proceedings of the 25th annual conference on Computer graphics and interactive techniques},
+  year = {1998},
+  isbn = {0-89791-999-8},
+  pages = {415--421},
+  doi = {http://doi.acm.org/10.1145/280814.280947},
+  publisher = {ACM Press},
+  address = {New York, NY, USA}
+}
+

+
+
+@inproceedings{Guennebaud07,
+  author = {Ga\"{e}l Guennebaud and Markus Gross},
+  title = {Algebraic point set surfaces},
+  booktitle = {SIGGRAPH '07: ACM SIGGRAPH 2007 papers},
+  year = {2007},
+  pages = {23},
+  location = {San Diego, California},
+  doi = {http://doi.acm.org/10.1145/1275808.1276406},
+  publisher = {ACM},
+  address = {New York, NY, USA}
+}
+

+
+
+@article{cclt-dc3sk-08,
+  title = {Design of the {CGAL} 3{D} {Spherical Kernel} and application to arrangements of circles on a sphere},
+  journal = {Computational Geometry : Theory and Applications},
+  volume = {42},
+  number = {6-7},
+  pages = {536 - 550},
+  year = {2009},
+  note = {},
+  issn = {0925-7721},
+  doi = {DOI: 10.1016/j.comgeo.2008.10.003},
+  author = {Pedro M.M. de Castro and Frederic Cazals and Sebastien Loriot and Monique Teillaud}
+}
+

+
+
+@conference{schwarzkopf1995ede,
+  title = {{The extensible drawing editor Ipe}},
+  author = {Schwarzkopf, O.},
+  booktitle = {Proceedings of the eleventh annual symposium on Computational geometry},
+  pages = {410--411},
+  year = {1995},
+  organization = {ACM New York, NY, USA}
+}
+

+
+
+@manual{ipe:man-09,
+  title = {{IPE} manual and library documentation},
+  author = {Otfried Cheong},
+  edition = {6.0pre32},
+  year = {2009},
+  url = {http://tclab.kaist.ac.kr/ipe/}
+}
+

+
+
+@misc{cgal:t-ocdl-05,
+  key = {opcode},
+  author = {P. Terdiman},
+  title = {{{OPCODE 3D} Collision Detection library}},
+  note = {http://www.codercorner.com/Opcode.htm},
+  year = {2005}
+}
+

+
+
+@incollection{msri52:liu-snoeyink-05,
+  author = {Yuanxin Liu and Jack Snoeyink},
+  title = {A Comparison of Five Implementations of 3{D} Delaunay Tessellation},
+  booktitle = {Combinatorial and Computational Geometry},
+  editor = {Jacob E. Goodman, J\'anos Pach and Emo Welzl},
+  year = {2005},
+  pages = {439-458},
+  url = {http://www.msri.org/communications/books/Book52/files/23liu.pdf},
+  publisher = {MSRI Publications}
+}
+

+
+
+@article{cgta-kmpsy-08,
+  author = {Lutz Kettner and Kurt Mehlhorn and Sylvain Pion and Stefan Schirra and Chee Yap},
+  title = {Classroom Examples of Robustness Problems in Geometric Computations},
+  journal = {Computational Geometry: Theory and Applications},
+  publisher = {Elsevier},
+  year = {2008},
+  month = {may},
+  volume = {40},
+  number = {1},
+  pages = {61-78},
+  url = {http://hal.inria.fr/inria-00344310/},
+  doi = {10.1016/j.comgeo.2007.06.003},
+  x-international-audience = {yes},
+  x-editorial-board = {yes}
+}
+

+
+
+@inproceedings{e-dpssdt-02,
+  author = {Jeff Erickson},
+  title = {Dense point sets have sparse {Delaunay} triangulations},
+  booktitle = {Proc. 13th ACM-SIAM Sympos. Discrete Algorithms (SODA)},
+  year = 2002,
+  pages = {125-134}
+}
+

+
+
+@inproceedings{geometrica-5986i,
+  thanks = {barbados},
+  author = {Nina Amenta and Dominique Attali and Olivier Devillers},
+  title = {Complexity of {Delaunay} triangulation for points on lower-dimensional polyhedra},
+  booktitle = {Proc. 18th ACM-SIAM Sympos. Discrete Algorithms},
+  nickname = {SODA},
+  url = {http://hal.inria.fr/inria-00182835/},
+  year = 2007,
+  pages = {1106--1113}
+}
+

+
+
+@article{prisme-4453a,
+  author = {Dominique Attali and Jean-Daniel Boissonnat},
+  title = {Complexity of the {Delaunay} triangulation of points on polyhedral surfaces},
+  journal = {Discrete and Computational Geometry},
+  volume = 30,
+  number = 3,
+  pages = {437--452},
+  year = 2003
+}
+

+
+
+@inproceedings{prisme-abl-03,
+  geombib = {not yet},
+  author = {Dominique Attali and Jean-Daniel Boissonnat and Andr{\'e} Lieutier},
+  title = {Complexity of the {Delaunay} Triangulation of Points on Surfaces: The Smooth Case},
+  booktitle = {Proc. 19th Annual Symposium on Computational Geometry},
+  year = 2003,
+  pages = {237--246}
+}
+

+
+
+@phdthesis{eigenwillig-phd-08,
+  author = {Eigenwillig, Arno},
+  title = {Real Root Isolation for Exactand Approximate Polynomials Using Descartes ' Rule of Signs},
+  school = {Universit{\"a}t des Saarlandes},
+  year = {2008},
+  address = {Saarbr{\"u}cken, Germany}
+}
+

+
+
+@misc{abbott-qir-06,
+  author = {J. Abbott},
+  title = {Quadratic Interval Refinement for Real Roots},
+  url = {http://www.dima.unige.it/~abbott/},
+  note = {Poster presented at the 2006 Int.\ Symp.\ on Symb.\
+                 and Alg.\ Comp.\ (ISSAC 2006)}
+}
+

+
+
+@inproceedings{ek-exact-08,
+  author = {Arno Eigenwillig and Michael Kerber},
+  title = {Exact and Efficient 2D-Arrangements of Arbitrary Algebraic Curves},
+  booktitle = {Proceedings of the Nineteenth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA08)},
+  year = 2008,
+  note = {122--131}
+}
+

+
+
+@inproceedings{ekw-fast-07,
+  author = {Arno Eigenwillig and Michael Kerber and Nicola Wolpert},
+  title = {Fast and Exact Geometric Analysis of Real Algebraic Plane Curves},
+  booktitle = {Proocedings of the 2007 International Symposium on Symbolic and Algebraic Computation (ISSAC 2007)},
+  year = 2007,
+  editor = {Christopher W. Brown},
+  pages = {151--158}
+}
+

+
+
+@phdthesis{kerber-phd-09,
+  author = {Kerber, Michael},
+  title = {Geometric Algorithms for Algebraic Curves and Surfaces},
+  school = {Universit{\"a}t des Saarlandes},
+  year = 2009,
+  address = {Saarbr{\"u}cken, Germany}
+}
+

+
+
+@incollection{grlr-sturm-habicht-98,
+  author = {L.~Gonzalez-Vega and T.~Recio and H.~Lombardi and M.-F.~Roy},
+  title = {Sturm-Habicht Sequences, Determinants and Real Roots of Univariate Polynomials},
+  booktitle = {Quantifier Elimination and Cylindrical Algebraic Decomposition},
+  pages = {300--316},
+  publisher = {Springer},
+  year = 1998,
+  editor = {B.F.~Caviness and J.R.~Johnson},
+  series = {Texts and Monographs in Symbolic Computation}
+}
+

+
+
+@article{cgal:ta-aeafvpprh-85,
+  author = {T. Asano},
+  title = {An Efficient Algorithm for Finding the Visibility Polygon for a Polygonal Region with Holes},
+  journal = {IEICE Transactions (1976-1990)},
+  year = 1985,
+  volume = e68,
+  number = 9,
+  pages = {557--559}
+}
+

+
+
+@article{cgal:bjrb-clvpa-87,
+  author = {B. Joe and R.B. Simpson},
+  title = {Corrections to Lee's visibility polygon algorithm},
+  journal = {BIT},
+  volume = 27,
+  year = 1987,
+  pages = {458--473}
 }
 

 
 
This file was generated by
-bibtex2html 1.97.

+bibtex2html 1.96.

diff --git a/Documentation/biblio/how_to_cite_cgal.txt b/Documentation/biblio/how_to_cite_cgal.txt
index ca28b570921..52b5457521d 100644
--- a/Documentation/biblio/how_to_cite_cgal.txt
+++ b/Documentation/biblio/how_to_cite_cgal.txt
@@ -35,24 +35,24 @@ If you want to refer to %CGAL manual, please cite the appropriate
   entry from the bibliographic entries for individual chapters listed
   in the table below.
 
-
+     /usr/bin/bibtex2html -nodoc cgal_manual.bib  -->
 
 
 
@@ -60,15 +60,14 @@ The %CGAL Project.
 
 
@@ -76,16 +75,14 @@ Michael Hemmer.
 
 
@@ -93,15 +90,13 @@ Eric Berberich, Michael Hemmer, Michael Kerber, Sylvain Lazard, Luis
 
 
@@ -109,15 +104,14 @@ Michael Hemmer, Susan Hert, Lutz Kettner, Sylvain Pion, and Stefan Schirra.
 
 
@@ -125,15 +119,14 @@ Michael Hemmer.
 
 
@@ -141,16 +134,15 @@ Michael Hemmer.
 
 
@@ -158,15 +150,14 @@ Hervé Brönnimann, Andreas Fabri, Geert-Jan Giezeman, Susan Hert,
 
 
@@ -174,15 +165,14 @@ Michael Seel.
 
 
@@ -190,16 +180,14 @@ Pedro Machado Manh aes de Castro, Sylvain Pion, and Monique Teillaud.
 
 
@@ -207,15 +195,14 @@ Pedro Machado Manh aes de Castro, Frédéric Cazals, S&eac
 
 
@@ -223,15 +210,50 @@ Susan Hert and Stefan Schirra.
 
 
+
+
+
+
+
+
@@ -239,15 +261,14 @@ Susan Hert and Stefan Schirra.
 
 
@@ -255,15 +276,16 @@ Geert-Jan Giezeman and Wieger Wesselink.
 
 
@@ -271,15 +293,15 @@ Susan Hert.
 
 
@@ -287,15 +309,16 @@ Susan Hert and Michael Seel.
 
 
@@ -303,15 +326,14 @@ Lutz Kettner.
 
 
@@ -319,15 +341,13 @@ Lutz Kettner.
 
 
@@ -335,15 +355,13 @@ Guillaume Damiand.
 
 
@@ -351,15 +369,16 @@ Guillaume Damiand.
 
 
@@ -367,15 +386,14 @@ Efi Fogel, Ron Wein, Baruch Zukerman, and Dan Halperin.
 
 
@@ -383,15 +401,14 @@ Ron Wein.
 
 
@@ -399,15 +416,15 @@ Michael Seel.
 
 
@@ -415,15 +432,14 @@ Peter Hachenberger and Lutz Kettner.
 
 
@@ -431,15 +447,15 @@ Peter Hachenberger and Lutz Kettner.
 
 
@@ -447,15 +463,13 @@ Peter Hachenberger.
 
 
@@ -463,15 +477,13 @@ Peter Hachenberger.
 
 
@@ -479,16 +491,14 @@ Fernando Cacciola.
 
 
@@ -496,15 +506,15 @@ Ron Wein, Eric Berberich, Efi Fogel, Dan Halperin, Michael Hemmer, Oren
 
 
@@ -512,15 +522,15 @@ Baruch Zukerman, Ron Wein, and Efi Fogel.
 
 
@@ -528,15 +538,13 @@ Eli Packer.
 
 
@@ -544,15 +552,13 @@ Ron Wein.
 
 
@@ -560,79 +566,16 @@ Michal Meyerovitch, Ron Wein, and Baruch Zukerman.
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -640,15 +583,17 @@ Manuel Caroli and Monique Teillaud.
 
 
@@ -656,15 +601,16 @@ Tran Kai Frank Da.
 
 
@@ -672,15 +618,13 @@ Tran Kai Frank Da and Mariette Yvinec.
 
 
@@ -688,15 +632,14 @@ Menelaos Karavelas.
 
 
@@ -704,15 +647,13 @@ Menelaos Karavelas and Mariette Yvinec.
 
 
@@ -720,15 +661,13 @@ Menelaos Karavelas.
 
 
@@ -736,15 +675,15 @@ Laurent Rineau.
 
 
@@ -752,15 +691,14 @@ Laurent Rineau and Mariette Yvinec.
 
 
@@ -768,15 +706,20 @@ Pierre Alliez, Laurent Saboret, and Gael Guennebaud.
 
 
@@ -784,16 +727,18 @@ Nico Kruithof.
 
 
@@ -801,15 +746,14 @@ Pierre Alliez, Laurent Rineau, Stéphane Tayeb, Jane Tournois, and Mariett
 
 
@@ -817,15 +761,15 @@ Le-Jeng Andy Shiue.
 
 
@@ -833,15 +777,13 @@ Fernando Cacciola.
 
 
@@ -849,15 +791,14 @@ Laurent Saboret, Pierre Alliez, and Bruno Lévy.
 
 
@@ -865,15 +806,15 @@ Matthias Bäsken.
 
 
@@ -881,15 +822,15 @@ Gabriele Neyer.
 
 
@@ -897,15 +838,13 @@ Andreas Fabri.
 
 
@@ -913,15 +852,16 @@ Hans Tangelder and Andreas Fabri.
 
 
@@ -929,16 +869,13 @@ Lutz Kettner, Andreas Meyer, and Afra Zomorodian.
 
 
@@ -946,15 +883,15 @@ Kaspar Fischer, Bernd Gärtner, Thomas Herrmann, Michael Hoffmann, and Sven
 
 
@@ -962,48 +899,16 @@ Kaspar Fischer, Bernd Gärtner, Sven Schönherr, and Frans Wessendorp.
 
 
-
-
-
-
-
-
-
-
-
-
-
-
@@ -1011,15 +916,14 @@ Julia Flötotto.
 
 
@@ -1027,15 +931,17 @@ Pierre Alliez, Sylvain Pion, and Ankit Gupta.
 
 
@@ -1043,15 +949,15 @@ Abdelkrim Mebarki.
 
 
@@ -1059,16 +965,2301 @@ Marc Pouget and Frédéric Cazals.
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -1076,15 +3267,15 @@ Marc Pouget and Frédéric Cazals.
 
 
@@ -1092,15 +3283,15 @@ Pierre Alliez, Laurent Saboret, and Nader Salman.
 
 
@@ -1108,15 +3299,14 @@ Daniel Russel.
 
 
@@ -1124,15 +3314,15 @@ Daniel Russel.
 
 
@@ -1140,15 +3330,15 @@ Andreas Fabri, Fernando Cacciola, and Ron Wein.
 
 
@@ -1156,15 +3346,14 @@ Andreas Fabri and Laurent Saboret.
 
 
@@ -1172,15 +3361,16 @@ Christophe Delage and Olivier Devillers.
 
 
@@ -1188,15 +3378,14 @@ Pierre Alliez, Stéphane Tayeb, and Camille Wormser.
 
 
@@ -1204,131 +3393,16 @@ Michael Hoffmann.
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

 
 

 
-[1]
+[1]
 
 
-The %CGAL Project.
- %CGAL User and Reference Manual.
- %CGAL Editorial Board, 4.2 edition, 2013.
-[ bib | 
-.html ]
+P. K. Agarwal, E. Flato, and D. Halperin.
+ Polygon decomposition for efficient construction of Minkowski sums.
+ Computational Geometry: Theory and Applications, 21:39-61,
+  2002.
+[ bib ]
 
 
 

 
-[2]
+[2]
 
 
-Michael Hemmer.
- Algebraic foundations.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+F. Avnaim.
+ C++GAL: A C++ Library for Geometric
+  Algorithms.
+ INRIA Sophia-Antipolis, 1994.
+[ bib ]
 
 
 

 
-[3]
+[3]
 
 
-Eric Berberich, Michael Hemmer, Michael Kerber, Sylvain Lazard, Luis
-  Peñaranda, and Monique Teillaud.
- Algebraic kernel.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+N. Amenta.
+ Computational geometry software.
+ In Handbook of Discrete and Computational Geometry, pages
+  951-960. CRC Press, 1997.
+[ bib ]
 
 
 

 
-[4]
+[4]
 
 
-Michael Hemmer, Susan Hert, Lutz Kettner, Sylvain Pion, and Stefan Schirra.
- Number types.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Matthew H. Austern.
+ Generic Programming and the STL.
+ Addison-Wesley, 1998.
+[ bib ]
 
 
 

 
-[5]
+[5]
 
 
-Michael Hemmer.
- Polynomial.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Andrei Alexandrescu.
+ Modern C++ Design: Generic Programming and Design Patterns
+  Applied.
+ Addison-Wesley, 2001.
+[ bib ]
 
 
 

 
-[6]
+[6]
 
 
-Michael Hemmer.
- Modular arithmetic.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Arthur Appel.
+ The notion of quantitive invisibility and the machine rendering of
+  solids.
+ In Proc. ACM National Conf., pages 387-393, 1967.
+[ bib ]
 
 
 

 
-[7]
+[7]
 
 
-Hervé Brönnimann, Andreas Fabri, Geert-Jan Giezeman, Susan Hert,
-  Michael Hoffmann, Lutz Kettner, Sylvain Pion, and Stefan Schirra.
- 2D and 3D geometry kernel.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Pierre Alliez, David Cohen-Steiner, Mariette Yvinec, and Mathieu Desbrun.
+ Variational tetrahedral meshing.
+ ACM Transactions on Graphics, 24:617-625, 2005.
+ SIGGRAPH '2005 Conference Proceedings.
+[ bib | 
+http ]
 
 
 

 
-[8]
+[8]
 
 
-Michael Seel.
- dD geometry kernel.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+International standard ISO/IEC 14882: Programming languages - C++.
+ American National Standards Institute, 11 West 42nd Street, New York
+  10036, 1998.
+[ bib | 
+www: ]
 
 
 

 
-[9]
+[9]
 
 
-Pedro Machado Manh aes de Castro, Sylvain Pion, and Monique Teillaud.
- 2D circular geometry kernel.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Hervé Brönnimann.
+ Designing and implementing a general purpose halfedge data structure.
+ In Proc. 5th International Workshop on Algorithm Engineering
+  (WAE), pages 51-66. Springer LNCS 2141, 2001.
+[ bib ]
 
 
 

 
-[10]
+[10]
 
 
-Pedro Machado Manh aes de Castro, Frédéric Cazals, Sébastien
-  Loriot, and Monique Teillaud.
- 3D spherical geometry kernel.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+H. Brönnimann, C. Burnikel, and S. Pion.
+ Interval arithmetic yields efficient dynamic filters for
+  computational geometry.
+ Discrete Applied Mathematics, 109:25-47, 2001.
+[ bib ]
 
 
 

 
-[11]
+[11]
 
 
-Susan Hert and Stefan Schirra.
- 2D convex hulls and extreme points.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Jean-Daniel Boissonnat, Olivier Devillers, Sylvain Pion, Monique Teillaud, and
+  Mariette Yvinec.
+ Triangulations in %CGAL.
+ Comput. Geom. Theory Appl., 22:5-19, 2002.
+[ bib ]
 
 
 

 
-[12]
+[12]
 
 
-Susan Hert and Stefan Schirra.
- 3D convex hulls.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Eric Berberich, Arno Eigenwillig, Michael Hemmer, Susan Hert, Kurt Mehlhorn,
+  and Elmar Schömer.
+ A computational basis for conic arcs and boolean operations on conic
+  polygons.
+ In Rolf Möhring and Rajeev Raman, editors, Algorithms - ESA
+  2002: 10th Annual European Symposium, volume 2461 of Lecture Notes in
+  Computer Science, pages 174-186, Rome, Italy, September 2002. Springer.
+[ bib ]
+

+We give an exact geometry kernel for conic arcs, algorithms
+                  for exact computation with low-degree algebraic
+                  numbers, and an algorithm for computing the
+                  arrangement of conic arcs that immediately leads to
+                  a realization of regularized boolean operations on
+                  conic polygons. A conic polygon, or polygon for
+                  short, is anything that can be obtained from linear
+                  or conic halfspaces (= the set of points where a
+                  linear or quadratic function is non-negative) by
+                  regularized boolean operations. The algorithm and
+                  its implementation are complete (they can handle all
+                  cases), exact (they give the mathematically correct
+                  result), and efficient (they can handle inputs with
+                  several hundred primitives).
+

+

+

+[13]
+
+Heinzgerd Bendels, Dieter W. Fellner, and Sven Havemann.
+ Modellierung der grundlagen: Erweiterbare datenstrukturen zur
+  modellierung und visualisierung polygonaler welten.
+ In D. W. Fellner, editor, Modeling - Virtual Worlds -
+  Distributed Graphics, pages 149-157, Bad Honnef / Bonn, 27.-28. November
+  1995.
+[ bib ]
 
 
 

 
-[13]
+[14]
 
 
-Geert-Jan Giezeman and Wieger Wesselink.
- 2D polygons.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Julien Basch, Leonidas Guibas, and John Hershberger.
+ Data structures for mobile data.
+ In Proceedings of the 8th Annual ACM-SIAM Symposium on
+  Discrete Algorithms, pages 747-756, 1997.
+[ bib ]
 
 
 

 
-[14]
+[15]
 
 
-Susan Hert.
- 2D polygon partitioning.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Eric Berberich, Michael Hemmer, Lutz Kettner, Elmar Schömer, and Nicola
+  Wolpert.
+ An exact, complete and efficient implementation for computing planar
+  maps of quadric intersection curves.
+ In Proceedings of 21st Annual Symposium on Computational
+  Geometry (SCG), pages 99-106, 2005.
+[ bib ]
 
 
 

 
-[15]
+[16]
 
 
-Susan Hert and Michael Seel.
- dD convex hulls and Delaunay triangulations.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Dobrina Boltcheva, Mariette Yvinec, and Jean-Daniel Boissonnat.
+ Mesh generation from 3d multi-material images.
+ In Medical Image Computing and Computer-Assisted Intervention,
+  volume 5762 of Lecture Notes in Computer Science, pages 283-290, 2009.
+[ bib | 
+http ]
 
 
 

 
-[16]
+[17]
 
 
-Lutz Kettner.
- 3D polyhedral surfaces.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Dobrina Boltcheva, Mariette Yvinec, and Jean-Daniel Boissonnat.
+ Feature preserving delaunay mesh generation from 3d multi- material
+  images.
+ Computer Graphics Forum, 28:1455-14645, 2009.
+ special issue for EUROGRAPHICS Symposium on Geometry Processing.
+[ bib | 
+http ]
 
 
 

 
-[17]
+[18]
 
 
-Lutz Kettner.
- Halfedge data structures.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Eric Berberich, Michael Hemmer, Menelaos I. Karavelas, and Monique Teillaud.
+ Revision of the interface specification of algebraic kernel.
+ Technical Report ACS-TR-243301-01, INRIA Sophia-Antipolis, Max Planck
+  Institut für Informatik, National University of Athens, 2007.
+[ bib ]
 
 
 

 
-[18]
+[19]
 
 
-Guillaume Damiand.
- Combinatorial maps.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+J. J. Barton and L. R. Nackman.
+ Scientific and Engineering C++.
+ Addison-Wesley, Reading, MA, 1997.
+[ bib ]
 
 
 

 
-[19]
+[20]
 
 
-Guillaume Damiand.
- Linear cell complex.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Jean-Daniel Boissonnat and Steve Oudot.
+ Provably good sampling and meshing of surfaces.
+ Graphical Models, 67:405-451, 2005.
+[ bib ]
 
 
 

 
-[20]
+[21]
 
 
-Efi Fogel, Ron Wein, Baruch Zukerman, and Dan Halperin.
- 2D regularized Boolean set-operations.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Gavin Bell, Anthony Parisi, and Mark Pesce.
+ Vrml the virtual reality modeling language: Version 1.0
+  specification.
+ 
+  http://www.web3d.org/x3d/specifications/vrml/VRML1.0/index.html, May
+  26 1995.
+[ bib ]
 
 
 

 
-[21]
+[22]
 
 
-Ron Wein.
- 2D Minkowski sums.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+G. Booch and M. Vilot.
+ Simplifying the booch components.
+ In S. Lippman, editor,  Gems, pages 59-89. SIGS
+  publications, 1996.
+[ bib ]
 
 
 

 
-[22]
+[23]
 
 
-Michael Seel.
- 2D Boolean operations on Nef polygons.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+L. Chen.
+ Mesh Smoothing Schemes based on Optimal Delaunay Triangulations.
+ In Proceedings of 13th International Meshing Roundtable, pages
+  109-120, 2004.
+[ bib ]
 
 
 

 
-[23]
+[24]
 
 
-Peter Hachenberger and Lutz Kettner.
- 2D Boolean operations on Nef polygons embedded on the sphere.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Manuel Caroli.
+ Triangulating Point Sets in Orbit Spaces.
+ Thèse de doctorat en sciences, Université de Nice-Sophia
+  Antipolis, France, 2010.
+[ bib | 
+http ]
 
 
 

 
-[24]
+[25]
 
 
-Peter Hachenberger and Lutz Kettner.
- 3D Boolean operations on Nef polyhedra.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+E. Catmull and J. Clark.
+ Recursively generated B-spline surfaces on arbitrary topological
+  meshes.
+ Computer Aided Design, 10:350-355, 1978.
+[ bib ]
 
 
 

 
-[25]
+[26]
 
 
-Peter Hachenberger.
- Convex decomposition of polyhedra.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Siu-Wing Cheng, Tamal K. Dey, Herbert Edelsbrunner, Michael A. Facello, and
+  Shang-Hua Teng.
+ Sliver exudation.
+ J. ACM, 47(5):883-904, 2000.
+[ bib | 
+DOI ]
 
 
 

 
-[26]
+[27]
 
 
-Peter Hachenberger.
- 3D Minkowski sum of polyhedra.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+S.-W. Cheng, T. K. Dey, and J. A. Levine.
+ A practical delaunay meshing algorithm for a large class of domains.
+ In Meshing Roundtable, pages 477-494, 2007.
+[ bib ]
 
 
 

 
-[27]
+[28]
 
 
-Fernando Cacciola.
- 2D straight skeleton and polygon offsetting.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Siu-Wing Cheng, Tamal K. Dey, and Edgar A. Ramos.
+ Delaunay refinement for piecewise smooth complexes.
+ In SODA, pages 1096-1105, Philadelphia, PA, USA, 2007.
+[ bib ]
 
 
 

 
-[28]
+[29]
 
 
-Ron Wein, Eric Berberich, Efi Fogel, Dan Halperin, Michael Hemmer, Oren
-  Salzman, and Baruch Zukerman.
- 2D arrangements.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Brian Curless and Marc Levoy.
+ A volumetric method for building complex models from range images.
+ In Computer Graphics (Proc. SIGGRAPH '96), volume 30, pages
+  303-312, 1996.
+[ bib ]
 
 
 

 
-[29]
+[30]
 
 
-Baruch Zukerman, Ron Wein, and Efi Fogel.
- 2D intersection of curves.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+F. Cazals and M. Pouget.
+ Estimating differential quantities using polynomial fitting of
+  osculating jets.
+ Computer Aided Geometric Design, 22(2), 2005.
+ Conference version: Symp. on Geometry Processing 2003.
+[ bib ]
 
 
 

 
-[30]
+[31]
 
 
-Eli Packer.
- 2D snap rounding.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+F. Cazals and M. Pouget.
+ Smooth surfaces, umbilics, lines of curvatures, foliations, ridges
+  and the medial axis: selected topics.
+ Int. J. of Computational Geometry and Applications,
+  15(5):511-536, 2005.
+[ bib ]
 
 
 

 
-[31]
+[32]
 
 
-Ron Wein.
- 2D envelopes.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+F. Cazals and M. Pouget.
+ Topology driven algorithms for ridge extraction on meshes.
+ Technical Report RR-5526, INRIA, 2005.
+[ bib ]
 
 
 

 
-[32]
+[33]
 
 
-Michal Meyerovitch, Ron Wein, and Baruch Zukerman.
- 3D envelopes.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+D. Cohen-Steiner and J.-M. Morvan.
+ Restricted delaunay triangulations and normal cycle.
+ In ACM Symposium on Computational Geometry, 2003.
+[ bib ]
 
 
 

 
-[33]
-
-Mariette Yvinec.
- 2D triangulations.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[34]
-
-Sylvain Pion and Mariette Yvinec.
- 2D triangulation data structure.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[35]
-
-Sylvain Pion and Monique Teillaud.
- 3D triangulations.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[36]
-
-Sylvain Pion and Monique Teillaud.
- 3D triangulation data structure.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[37]
+[34]
 
 
 Manuel Caroli and Monique Teillaud.
- 3D periodic triangulations.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+ Computing 3D periodic triangulations.
+ In Proceedings 17th European Symposium on Algorithms, volume
+  5757 of Lecture Notes in Computer Science, pages 37-48, 2009.
+ Full version available as INRIA Research Report 6823
+  http://hal.inria.fr/inria-00356871.
+[ bib ]
 
 
 

 
-[38]
+[35]
 
 
-Tran Kai Frank Da.
- 2D alpha shapes.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Jonathan Cohen, Amitabh Varshney, Dinesh Manocha, Greg Turk, Hans Weber, Pankaj
+  Agarwal, Frederick Brooks, and William Wright.
+ Simplification envelopes.
+ In Computer Graphics (Proc. SIGGRAPH '96), volume 30, pages
+  119-128, 1996.
+ Examples and code in
+  http://www.cs.unc.edu/~geom/envelope.html.
+[ bib ]
 
 
 

 
-[39]
+[36]
 
 
-Tran Kai Frank Da and Mariette Yvinec.
- 3D alpha shapes.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+G. Damiand.
+ Contributions aux Cartes Combinatoires et Cartes
+  Généralisées : Simplification, Modèles, Invariants Topologiques et
+  Applications.
+ Habilitation à diriger des recherches, Université Lyon 1,
+  Septembre 2010.
+[ bib ]
 
 
 

 
-[40]
+[37]
 
 
-Menelaos Karavelas.
- 2D segment Delaunay graphs.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Olivier Devillers.
+ The Delaunay hierarchy.
+ Internat. J. Found. Comput. Sci., 13:163-180, 2002.
+[ bib ]
 
 
 

 
-[41]
+[38]
 
 
-Menelaos Karavelas and Mariette Yvinec.
- 2D Apollonius graphs (Delaunay graphs of disks).
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Wei Ding.
+ Geometric rounding without changing the topology.
+ Master's thesis, Fachbereich Informatik, Universität
+  Saarbrücken, Saarbrücken, Germany, 2003.
+[ bib ]
 
 
 

 
-[42]
+[39]
 
 
-Menelaos Karavelas.
- 2D Voronoi diagram adaptor.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+C. Dyken, M Daehlen, and T. Sevaldrud.
+ Simultaneous curve simplification.
+ Journal of Geographical Systems, 0:0-0, 2009.
+[ bib ]
 
 
 

 
-[43]
+[40]
 
 
-Laurent Rineau.
- 2D conforming triangulations and meshes.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Q. Du, V. Faber, and M. Gunzburger.
+ Centroidal Voronoi Tessellations: Applications and Algorithms.
+ SIAM review, 41(4):637-676, 1999.
+[ bib ]
 
 
 

 
-[44]
+[41]
 
 
-Laurent Rineau and Mariette Yvinec.
- 3D surface mesh generation.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Olivier Devillers, Alexandra Fronville, Bernard Mourrain, and Monique Teillaud.
+ Algebraic methods and arithmetic filtering for exact predicates on
+  circle arcs.
+ In Proc. 16th Annu. ACM Sympos. Comput. Geom., pages 139-147,
+  2000.
+[ bib ]
 
 
 

 
-[45]
+[42]
 
 
-Pierre Alliez, Laurent Saboret, and Gael Guennebaud.
- Surface reconstruction from point sets.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Olivier Devillers, Alexandra Fronville, Bernard Mourrain, and Monique Teillaud.
+ Algebraic methods and arithmetic filtering for exact predicates on
+  circle arcs.
+ Comput. Geom. Theory Appl., 22:119-142, 2002.
+[ bib ]
 
 
 

 
-[46]
+[43]
 
 
-Nico Kruithof.
- 3D skin surface meshing.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+J. H. Dulá and R. V. Helgason.
+ A new procedure for identifying the frame of the convex hull of a
+  finite collection of points in multidimensional space.
+ European Journal of Operational Research, 92(2):352 - 367,
+  1996.
+[ bib | 
+DOI | 
+http ]
+

+Keywords: Convex hull problem, Frame, Linear programming, Data envelopment analysis, Redundancy
+

 
 		
 

 
-[47]
+[44]
 
 
-Pierre Alliez, Laurent Rineau, Stéphane Tayeb, Jane Tournois, and Mariette
-  Yvinec.
- 3D mesh generation.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+J.H. Dulá and F.J. López.
+ Competing output-sensitive frame algorithms.
+ Draft (2008), available at
+  http://idisk.mac.com/jdula-Public/WORKINGPAPERS/PolyFrOttmann.pdf,
+  2008.
+[ bib ]
+

+Keywords: Extreme points, Convex hull, Linear programming, Computational Geometry, Redundancy identification
+

 
 		
 

 
-[48]
+[45]
 
 
-Le-Jeng Andy Shiue.
- 3D surface subdivision methods.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Mathieu Desbrun, Mark Meyer, and Pierre Alliez.
+ Intrinsic parameterizations of surface meshes.
+ Computer Graphics Forum, 21(3):209-218, September
+  2002.
+[ bib ]
 
 
 

 
-[49]
+[46]
 
 
-Fernando Cacciola.
- Triangulated surface mesh simplification.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Olivier Devillers and Sylvain Pion.
+ Efficient exact geometric predicates for Delaunay triangulations.
+ In Proc. 5th Workshop Algorithm Eng. Exper., pages 37-44,
+  2003.
+[ bib | 
+http ]
 
 
 

 
-[50]
+[47]
 
 
-Laurent Saboret, Pierre Alliez, and Bruno Lévy.
- Planar parameterization of triangulated surface meshes.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Olivier Devillers, Sylvain Pion, and Monique Teillaud.
+ Walking in a triangulation.
+ Internat. J. Found. Comput. Sci., 13:181-199, 2002.
+[ bib ]
 
 
 

 
-[51]
+[48]
 
 
-Matthias Bäsken.
- 2D range and neighbor search.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Olivier Devillers and Monique Teillaud.
+ Perturbations and vertex removal in a 3D Delaunay triangulation.
+ In Proc. 14th ACM-SIAM Sympos. Discrete Algorithms (SODA),
+  pages 313-319, 2003.
+[ bib ]
 
 
 

 
-[52]
+[49]
 
 
-Gabriele Neyer.
- dD range and segment trees.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Olivier Devillers and Monique Teillaud.
+ Perturbations and vertex removal in Delaunay and regular 3D
+  triangulations.
+ Research Report 5968, INRIA, 2006.
+ http://hal.inria.fr/inria-00090522.
+[ bib ]
 
 
 

 
-[53]
+[50]
 
 
-Andreas Fabri.
- Interval skip list.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Q. Du and D. Wang.
+ Tetrahedral mesh generation and optimization based on centroidal
+  Voronoi tessellations.
+ International Journal for Numerical Methods in Engineering,
+  56:1355-1373, 2002.
+[ bib ]
 
 
 

 
-[54]
+[51]
 
 
-Hans Tangelder and Andreas Fabri.
- dD spatial searching.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+H. Edelsbrunner.
+ Deformable smooth surface design.
+ Discrete Comput. Geom., 21:87-115, 1999.
+[ bib ]
 
 
 

 
-[55]
+[52]
 
 
-Lutz Kettner, Andreas Meyer, and Afra Zomorodian.
- Intersecting sequences of dD iso-oriented boxes.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Matthias Eck, Tony DeRose, Tom Duchamp, Hugues Hoppe, Michael Lounsbery, and
+  Werner Stuetzle.
+ Multiresolution analysis of arbitrary meshes.
+ In Computer Graphics (Proc. SIGGRAPH '95), volume 29, pages
+  173-182, 1995.
+ Examples in ftp://ftp.cs.washington.edu/pub/graphics.
+[ bib ]
 
 
 

 
-[56]
+[53]
 
 
-Kaspar Fischer, Bernd Gärtner, Thomas Herrmann, Michael Hoffmann, and Sven
-  Schönherr.
- Bounding volumes.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+G. Elber and M.-S. Kim, editors.
+ Computer Aided Design, volume 31, 1999.
+ Special Issue on Offsets, Sweeps and Minkowski Sums.
+[ bib ]
 
 
 

 
-[57]
+[54]
 
 
-Kaspar Fischer, Bernd Gärtner, Sven Schönherr, and Frans Wessendorp.
- Linear and quadratic programming solver.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Ioannis Z. Emiris, Athanasios Kakargias, Sylvain Pion, Monique Teillaud, and
+  Elias P. Tsigaridas.
+ Towards an open curved kernel.
+ In Proc. 20th Annu. ACM Sympos. Comput. Geom., pages 438-446,
+  2004.
+[ bib ]
 
 
 

 
-[58]
-
-Michael Hoffmann and Eli Packer.
- Inscribed areas.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[59]
-
-Kaspar Fischer, Bernd Gärtner, Thomas Herrmann, Michael Hoffmann, and Sven
-  Schönherr.
- Optimal distances.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[60]
+[55]
 
 
 Julia Flötotto.
- 2D and surface function interpolation.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+ A coordinate system associated to a point cloud issued from a
+  manifold: definition, properties and applications.
+ Thèse de doctorat en sciences, Université de Nice-Sophia
+  Antipolis, France, 2003.
+[ bib | 
+http ]
 
 
 

 
-[61]
+[56]
 
 
-Pierre Alliez, Sylvain Pion, and Ankit Gupta.
- Principal component analysis.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Richard Fairley.
+ Software Engineering Concepts.
+ McGraw-Hill Series in Software Engineering and Technology.
+  McGraw-Hill, 1985.
+[ bib ]
 
 
 

 
-[62]
+[57]
 
 
-Abdelkrim Mebarki.
- 2D placement of streamlines.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Ulrich Finke and Klaus Hinrichs.
+ Overlaying simply connected planar subdivisions in linear time.
+ In Proc. 11th Annu. ACM Sympos. Comput. Geom., pages 119-126,
+  1995.
+[ bib ]
+

+Keywords: red-blue segment intersection
+

 
 		
 

 
-[63]
+[58]
 
 
-Marc Pouget and Frédéric Cazals.
- Approximation of ridges and umbilics on triangulated surface meshes.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+M. S. Floater and K. Hormann.
+ Surface parameterization: a tutorial and survey.
+ In N. A. Dodgson, M. S. Floater, and M. A. Sabin, editors, 
+  Advances in Multiresolution for Geometric Modelling, Mathematics and
+  Visualization, pages 157-186. Springer, Berlin, Heidelberg, 2005.
+[ bib ]
 
 
 

 
-[64]
+[59]
 
 
-Marc Pouget and Frédéric Cazals.
- Estimation of local differential properties of point-sampled
+Michael Floater.
+ Mean value coordinates.
+ Computer Aided Design, 20(1):19-27, 2003.
+[ bib ]
+
+

+[60]
+
+B. Gärtner.
+ Fast and robust smallest enclosing balls.
+ In Proc. 7th annu. European Symposium on Algorithms (ESA),
+  volume 1643 of Lecture Notes in Computer Science, pages 325-338.
+  Springer-Verlag, 1999.
+[ bib ]
+
+

+[61]
+
+T. Granlund.
+ GNU MP, The GNU Multiple Precision Arithmetic Library,
+  version 2.0.2, June 1996.
+[ bib ]
+
+

+[62]
+
+Ronald N. Goldman.
+ Illicit expressions in vector algebra.
+ ACM Transaction on Graphics, 4(3):223-243, July 1985.
+[ bib ]
+
+

+[63]
+
+Miguel Granados, Peter Hachenberger, Susan Hert, Lutz Ketter, Kurt Mehlhorn,
+  and Michael Seel.
+ Boolean operations on 3d selective nef complexes data structure,
+  algorithms, and implementation.
+ In Giuseppe Di Battista and Uri Zwick, editors, Algorithms - ESA
+  2003: 11th Annual European Symposium, volume 2832 of Lecture Notes in
+  Computer Science, pages 174-186, Budapest, Hugary, September 2003.
+  Springer.
+[ bib ]
+

+We describe a data structure for three-dimensional Nef
+                  complexes, algorithms for boolean operations on them,
+                  and our implementation of data structure and algorithms.
+                  Nef polyhedra were introduced by W. Nef in his seminal
+                  1978 book on polyhedra. They are the closure of half-spaces
+                  under boolean operations and can represent non-manifold
+                  situations, open and closed boundaries, and mixed
+                  dimensional complexes. Our focus lies on the generality of
+                  the data structure, the completeness of the algorithms,
+                  and the exactness and efficiency of the implementation.
+                  In particular, all degeneracies are handled.
+

+

+

+[64]
+
+E. Gamma, R. Helm, R. Johnson, and J. Vlissides.
+ Design Patterns - Elements of Reusable Object-Oriented
+  Software.
+ Addison-Wesley, 1995.
+[ bib ]
+
+

+[65]
+
+Leonidas Guibas, Menelaos Karaveles, and Daniel Russel.
+ A computational framework for handling motion.
+ In Proceedings of the Sixth Workshop on Algorithm Engineering
+  and Experiments, pages 129-141, 2004.
+[ bib ]
+
+

+[66]
+
+Bernd Gärtner and Sven Schönherr.
+ Smallest enclosing ellipses - an exact and generic implementation in
+  C++.
+ Serie B - Informatik B 98-05, Freie Universität Berlin, Germany,
+  April 1998.
+ URL
+  http://www.inf.fu-berlin.de/inst/pubs/tr-b-98-05.abstract.html.
+[ bib ]
+
+

+[67]
+
+Bernd Gärtner and Sven Schönherr.
+ Smallest enclosing circles - an exact and generic implementation in
+  C++.
+ Serie B - Informatik B 98-04, Freie Universität Berlin, Germany,
+  April 1998.
+ URL
+  http://www.inf.fu-berlin.de/inst/pubs/tr-b-98-04.abstract.html.
+[ bib ]
+
+

+[68]
+
+Bernd Gärtner and Sven Schönherr.
+ Smallest enclosing ellipses - fast and exact.
+ Serie B - Informatik B 97-03, Freie Universität Berlin, Germany,
+  June 1997.
+ URL
+  http://www.inf.fu-berlin.de/inst/pubs/tr-b-97-03.abstract.html.
+[ bib ]
+
+

+[69]
+
+J. Gregor and M. G. Thomason.
+ Dynamic programming alignment of sequences representing cyclic
+  patterns.
+ IEEE Trans. Pattern Anal. Machine Intell., 15(2):129-135,
+  1993.
+[ bib ]
+
+

+[70]
+
+Geert-Jan Giezeman, Remco Veltkamp, and Wieger Wesselink.
+ Getting Started with %CGAL, 1998.
+ %CGAL R1.0. http://www.cs.ruu.nl/CGAL.
+[ bib ]
+
+

+[71]
+
+Dan Halperin.
+ Arrangements.
+ In Jacob E. Goodman and Joseph O'Rourke, editors, Handbook of
+  Discrete and Computational Geometry, chapter 24, pages 529-562. Chapman &
+  Hall/CRC, 2nd edition, 2004.
+[ bib ]
+
+

+[72]
+
+B. Haible.
+ CLN, The Class Library for Numbers, 1.0.1 edition, June 1999.
+ http://clisp.cons.org/~haible/packages-cln.html.
+[ bib ]
+
+

+[73]
+
+Idit Haran and Dan Halperin.
+ Efficient point location in cgal arrangements using landmarks, 2005.
+[ bib ]
+
+

+[74]
+
+Christoph M. Hoffmann.
+ Geometric and Solid Modeling - An Introduction.
+ Morgan Kaufmann, 1989.
+[ bib ]
+
+

+[75]
+
+P. W. Hallinan, G. Gordon, A.L. Yuille, P. Giblin, and D. Mumford.
+ Two-and Three-Dimensional Patterns of the Face.
+ A.K.Peters, 1999.
+[ bib ]
+
+

+[76]
+
+Hugues Hoppe.
+ Progressive meshes.
+ In Computer Graphics (Proc. SIGGRAPH '96), volume 30, pages
+  99-108, 1996.
+[ bib ]
+
+

+[77]
+
+Christian Helbling.
+ Extreme points in medium and high dimensions.
+ Master's thesis, ETH Zurich, Zurich, Switzerland, 2010.
+[ bib ]
+
+

+[78]
+
+M. Hoffmann.
+ A simple linear algorithm for computing rectangular three-centers.
+ In Proc. 11th Canad. Conf. Comput. Geom., pages 72-75, 1999.
+[ bib ]
+
+

+[79]
+
+Hugues Hoppe.
+ Surface reconstruction from unorganized points.
+ PhD thesis, University of Washington, 1994.
+[ bib ]
+
+

+[80]
+
+Hugues Hoppe, Tony DeRose, Tom Duchamp, Mark Halstaed, Hubert Jin, John
+  McDonald, Jean Schweitzer, and Werner Stuetzle.
+ Piecewise smooth surface reconstruction.
+ In Computer Graphics (Proc. SIGGRAPH '94), volume 28, pages
+  295-302, 1994.
+ Examples and code in ftp://ftp.cs.washington.edu/pub/graphics.
+[ bib ]
+
+

+[81]
+
+Hugues Hoppe, Tony DeRose, Tom Duchamp, John McDonald, and Werner Stuetzle.
+ Mesh optimization.
+ In Computer Graphics (Proc. SIGGRAPH '93), volume 27, pages
+  19-26, 1993.
+ Examples and code in ftp://ftp.cs.washington.edu/pub/graphics.
+[ bib ]
+
+

+[82]
+
+Hugues Hoppe, Tony DeRose, Tom Duchamp, John McDonald, and Werner Stuetzle.
+ Surface reconstruction from unorganized points.
+ In Computer Graphics (Proc. SIGGRAPH '90), volume 26, pages
+  71-77, 1992.
+[ bib ]
+
+

+[83]
+
+J. M. Hellerstein, J. F. Naughton, and A. Pfeffer.
+ Generalized search trees for database systems.
+ In Umeshwar Dayal, Peter M. D. Gray, and Shojiro Nishio, editors,
+  VLDB '95: proceedings of the 21st International Conference on Very
+  Large Data Bases, Zurich, Switzerland, Sept. 11-15, 1995, pages 562-573,
+  Los Altos, CA 94022, USA, 1995. Morgan Kaufmann Publishers.
+[ bib ]
+
+

+[84]
+
+D. Halperin and E. Packer.
+ Iterated snap rounding.
+ Computational Geometry: Theory and Applications,
+  23(2):209-225, 2002.
+[ bib ]
+
+

+[85]
+
+Jed Hartman and Josie Wernecke.
+ The VRML 2.0 Handbook: Building Moving Worlds on the Web.
+ Addison-Wesley, 1996.
+[ bib ]
+
+

+[86]
+
+H. Imai and M. Iri.
+ Polygonal approximation of a curve - formulation and algorithms.
+ In G.T. Toussaint, editor, Computational Morphology, pages
+  71-86. 1988.
+[ bib ]
+
+

+[87]
+
+Nicolai M. Josuttis.
+ The C++ Standard Library, A Tutorial and Reference.
+ Addison-Wesley, 1999.
+[ bib ]
+
+

+[88]
+
+T. Keffer.
+ The design and architecture of Tools.h++.
+ In S. Lippman, editor, C++ Gems, pages 43-57. SIGS
+  publications, 1996.
+[ bib ]
+
+

+[89]
+
+Menelaos I. Karavelas.
+ A robust and efficient implementation for the segment Voronoi
+  diagram.
+ In Proc. Internat. Symp. on Voronoi diagrams in Science and
+  Engineering (VD2004), pages 51-62, 2004.
+[ bib ]
+
+

+[90]
+
+L. Khachiyan.
+ Rounding of polytopes in the real number model of computation.
+ Mathematics of Operations Research, 21(2):307-320, 1996.
+[ bib ]
+
+

+[91]
+
+Bruno Levy.
+ Numerical methods for digital geometry processing.
+ In Israel Korea Bi-National Conference - Invited talk, extended
+  abstract (full paper will be available shortly), November 2005.
+[ bib | 
+http ]
+
+

+[92]
+
+P. Lienhardt.
+ Topological models for boundary representation: a comparison with
+  n-dimensional generalized maps.
+ Computer-Aided Design, 23(1):59-82, 1991.
+[ bib ]
+
+

+[93]
+
+Peter Lindstrom and Greg Turk.
+ Fast and memory efficient polygonal simplification.
+ In IEEE Visualization, pages 279-286, 1998.
+[ bib | 
+.html ]
+
+

+[94]
+
+P. Lindstrom and G. Turk.
+ Evaluation of memoryless simplification.
+ IEEE Transactions on Visualization and Computer Graphics,
+  5(2):98-115, /1999.
+[ bib | 
+.html ]
+
+

+[95]
+
+Donald E. Knuth.
+ Literate programming.
+ The Computer Journal, 27(2):97-111, 1984.
+[ bib ]
+
+

+[96]
+
+Leif Kobbelt.
+ sqrt(3)-subdivision.
+ In Computer Graphics (Proc. SIGGRAPH '00), volume 34, pages
+  103-112, 2000.
+[ bib ]
+
+

+[97]
+
+Menelaos I. Karavelas and Ioannis Z. Emiris.
+ Predicates for the planar additively weighted Voronoi diagram.
+ Technical Report ECG-TR-122201-01, INRIA Sophia-Antipolis,
+  Sophia-Antipolis, May 2002.
+[ bib | 
+.ps.gz ]
+
+

+[98]
+
+Menelaos I. Karavelas and Ioannis Z. Emiris.
+ Root comparison techniques applied to computing the additively
+  weighted Voronoi diagram.
+ In Proc. 14th ACM-SIAM Sympos. Discrete Algorithms (SODA),
+  pages 320-329, 2003.
+[ bib ]
+
+

+[99]
+
+Donald E. Knuth and Silvio Levy.
+ The CWEB System of Structured Documentation, version 3.0
+  edition, 1994.
+[ bib ]
+
+

+[100]
+
+K. Kreft and A. Langer.
+ Iterators in the standard  library.
+ C++ Report, 8(10):27-32, Nov.-Dec. 1996.
+[ bib ]
+
+

+[101]
+
+K. Kuratowski and A. Mostowski.
+ Set Theory.
+ North-Holland Publishing Co., 1976.
+[ bib ]
+
+

+[102]
+
+N.G.H. Kruithof and G. Vegter.
+ Meshing skin surfaces with certified topology.
+ In Proceedings of the nineth International CADGraphics
+  conference, page to appear., 2005.
+[ bib ]
+
+

+[103]
+
+Lutz Kettner and Emo Welzl.
+ Contour edge analysis for polyhedron projections.
+ In Wolfgang Strasser, Reinhard Klein, and Rene Rau, editors, 
+  Geometric Modeling: Theory and Practice, pages 379-394. Springer Verlag,
+  1997.
+[ bib ]
+
+

+[104]
+
+Dietmar Kühl and Karsten Weihe.
+ Data access templates.
+ Konstanzer Schriften in Mathematik und Informatik Nr. 9,
+  Universität Konstanz, Germany, May 1996.
+ http://www.informatik.uni-konstanz.de/Schriften.
+[ bib ]
+
+

+[105]
+
+Dietmar Kühl and Karsten Weihe.
+ Data access templates.
+ C++ Report, June 1997.
+[ bib ]
+
+

+[106]
+
+Lutz Kettner and Emo Welzl.
+ One sided error predicates in geometric computing.
+ In Kurt Mehlhorn, editor, Proc. 15th IFIP World Computer
+  Congress, Fundamentals - Foundations of Computer Science, pages 13-26.
+  1998.
+[ bib ]
+
+

+[107]
+
+Menelaos Karavelas and Mariette Yvinec.
+ Dynamic additively weighted voronoi diagrams in 2d.
+ In Proc. 10th European Symposium on Algorithms, pages 586-598,
+  2002.
+[ bib ]
+

+Keywords: Voronoi diagram, Appollonius diagram, additively weighted
+Voronoi diagram
+

+
+

+[108]
+
+Stanley B. Lippman.
+ Inside the C++ Object Model.
+ Addison-Wesley, 1996.
+[ bib ]
+
+

+[109]
+
+Stanley B. Lippman and Josee Lajoie.
+ C++ Primer.
+ Addison-Wesley, 3rd edition, 1998.
+[ bib ]
+
+

+[110]
+
+John Lakos.
+ Large Scale C++ Software Design.
+ Addison-Wesley, 1996.
+[ bib ]
+
+

+[111]
+
+Bruno Lévy, Sylvain Petitjean, Nicolas Ray, and Jérome Maillot.
+ Least squares conformal maps for automatic texture atlas generation.
+ In Proceedings of the 29th Conference on Computer Graphics and
+  Interactive Techniques SIGGRAPH, volume 21(3) of ACM Transactions on
+  Graphics, pages 362-371, 2002.
+[ bib ]
+
+

+[112]
+
+D. T. Lee.
+ Visualizing geometric algorithms - state of the art.
+ In M. C. Lin and D. Manocha, editors, Applied Computational
+  Geometry (Proc. WACG '96), volume 1148 of Lecture Notes Comput. Sci.,
+  pages 45-50. Springer-Verlag, 1996.
+[ bib ]
+
+

+[113]
+
+Sylvain Lazard, Luis Peñaranda, and Sylvain Petitjean.
+ Intersecting quadrics: An efficient and exact implementation.
+ In ACM Symposium on Computational Geometry - SoCG'2004,
+  Brooklyn, NY, Jun 2004.
+[ bib | 
+.ps ]
+

+We present the first complete, exact and efficient C++ implementation of a method for parameterizing the intersection of two implicit quadrics with integer coefficients of arbitrary size. It is based on the near-optimal algorithm recently introduced by Dupont et al. [?]. Unlike existing implementations, it correctly identifies and parameterizes all the connected components of the intersection in all the possible cases, returning parameterizations with rational functions whenever such parameterizations exist. In addition, the coefficient field of the parameterizations is either minimal or involves one possibly unneeded square root.
+

+

+

+[114]
+
+Sylvain Lazard, Luis Peñaranda, and Elias Tsigaridas.
+ Univariate algebraic kernel and application to arrangements.
+ In Vahrenhold [170], pages 209-220.
+[ bib ]
+
+

+[115]
+
+Robert B. Murray.
+ C++ Strategies and Tactics.
+ Addison-Wesley, 1993.
+[ bib ]
+
+

+[116]
+
+Scott Meyers.
+ Effective C++.
+ Addison-Wesley, 1992.
+[ bib ]
+
+

+[117]
+
+Scott Meyers.
+ Effective C++: 50 Specific Ways to Improve Your Programs and
+  Designs.
+ Addison-Wesley, 2nd edition, 1997.
+[ bib ]
+
+

+[118]
+
+Scott Meyers.
+ More Effective C++.
+ Addison-Wesley, 1996.
+[ bib ]
+
+

+[119]
+
+Kurt Mehlhorn.
+ Position paper for panel discussion.
+ In M. C. Lin and D. Manocha, editors, Applied Computational
+  Geometry (Proc. WACG '96), volume 1148 of Lecture Notes Comput. Sci.,
+  pages 51-52. Springer-Verlag, 1996.
+[ bib ]
+
+

+[120]
+
+Nathan C. Myers.
+ Traits: a new and useful template technique.
+ C++ Report, June 1995.
+[ bib ]
+
+

+[121]
+
+Steve Maguire.
+ Writing Solid Code.
+ Microsoft Press, 1993.
+[ bib ]
+
+

+[122]
+
+Abdelkrim Mebarki, Pierre Alliez, and Olivier Devillers.
+ Farthest point seeding for efficient placement of streamlines.
+ In Proceeding of IEEE Visualization, 2005.
+[ bib ]
+
+

+[123]
+
+M. Meyer, M. Desbrun, P. Schröder, and A. H. Barr.
+ Discrete differential-geometry operators for triangulated
+  2-manifolds.
+ In VisMath, 2002.
+[ bib ]
+
+

+[124]
+
+J. Matoušek and B. Gärtner.
+ Understanding and Using Linear Programming.
+ Springer-Verlag, 2006.
+[ bib ]
+
+

+[125]
+
+K. Mehlhorn, S. Näher, M. Seel, and C. Uhrig.
+ The LEDA User Manual.
+ Max-Planck-Insitut für Informatik, 66123 Saarbrücken, Germany.
+ http://www.mpi-sb.mpg.de/LEDA/leda.html.
+[ bib ]
+
+

+[126]
+
+Guillaume Melquiond and Sylvain Pion.
+ Formal certification of arithmetic filters for geometric predicates.
+ In Proc. 17th IMACS World Congress on Scientific, Applied
+  Mathematics and Simulation, 2005.
+[ bib ]
+
+

+[127]
+
+David R. Musser and Alexander A. Stepanov.
+ Algorithm-oriented generic libraries.
+ Software - Practice and Experience, 24(7):623-642, July 1994.
+[ bib ]
+
+

+[128]
+
+David R. Musser and Alexander A. Stepanov.
+ Generic programming.
+ In 1st Intl. Joint Conf. of ISSAC-88 and AAEC-6, pages
+  13-25. Springer LNCS 358, 1989.
+[ bib ]
+
+

+[129]
+
+David R. Musser and Atul Saini.
+ STL Tutorial and Reference Guide: C++ Programming with
+  the Standard Template Library.
+ Addison-Wesley, 1996.
+[ bib ]
+
+

+[130]
+
+MPFR - the multiple precision floating-point reliable library.
+ The MPFR Team.
+ http://mpfr.org.
+[ bib ]
+
+

+[131]
+
+Jackie Neider, Tom Davis, and Mason Woo.
+ OpenGL Programming Guide: The Official Guide to Learning OpenGL,
+  Release 1.
+ Addison-Wesley, 1993.
+[ bib ]
+
+

+[132]
+
+Mark H. Overmars.
+ Designing the computational geometry algorithms library %CGAL.
+ In M. C. Lin and D. Manocha, editors, ACM Workshop on Applied
+  Computational Geometry, Philadelphia, Pennsylvenia, May, 27-28 1996.
+ Lecture Notes in Computer Science 1148.
+[ bib ]
+
+

+[133]
+
+Steve Oudot, Laurent Rineau, and Mariette Yvinec.
+ Meshing volumes bounded by smooth surfaces.
+ In Proc. 14th International Meshing Roundtable, pages 203-219,
+  2005.
+[ bib ]
+
+

+[134]
+
+I. Porteous.
+ Geometric Differentiation (2nd Edition).
+ Cambridge University Press, 2001.
+[ bib ]
+
+

+[135]
+
+Mark Phillips.
+ Geomview Manual, Version 1.6.1 for Unix Workstations.
+ The Geometry Center, University of Minnesota, 1996.
+ http://www.geom.umn.edu/software/download/geomview.html.
+[ bib ]
+
+

+[136]
+
+B. Piper.
+ Properties of local coordinates based on dirichlet tesselations.
+ Computing Suppl., 8:227-239, 1993.
+[ bib ]
+
+

+[137]
+
+S. Petitjean.
+ A survey of methods for recovering quadrics in triangle meshes.
+ ACM Computing Surveys, 34(2), 2001.
+[ bib ]
+
+

+[138]
+
+M. Poudret, A. Arnould, Y. Bertrand, and P. Lienhardt.
+ Cartes combinatoires ouvertes.
+ Research Notes 2007-1, Laboratoire SIC E.A. 4103, F-86962 Futuroscope
+  Cedex, France, October 2007.
+[ bib ]
+

+Keywords: cartes combinatoires, demi-arête, arête radiale
+

+
+

+[139]
+
+David L. Parnas and Paul C. Clements.
+ A rational design process: How and why to fake it.
+ IEEE Transactions on Software Engineering, 12(2):251-257,
+  1986.
+[ bib ]
+
+

+[140]
+
+U. Pinkall and K. Polthier.
+ Computing discrete minimal surfaces and their conjugates.
+ Experimental Mathematics, 2(1):15-36, 1993.
+[ bib ]
+
+

+[141]
+
+W. Press, S. Teukolsky, W. Vetterling, and B. Flannery.
+ Numerical Recipes in C++.
+ Cambridge University Press, 2nd edition, 2002.
+[ bib ]
+
+

+[142]
+
+J.C. Perez and E. Vidal.
+ Optimum polygonal approximation of digitized curves.
+ Pattern Recognition Letters, (15):743-750, 1994.
+[ bib ]
+
+

+[143]
+
+James Rumbaugh.
+ The life of an object model: How the object-model changes during
+  development.
+ Journal of Object-Oriented Programming, 7(1):24-32,
+  March/April 1994.
+[ bib ]
+
+

+[144]
+
+MPFI - the multiple precision floating-point interval library.
+ Revol, Nathalie and Rouillier, Fabrice.
+ http://perso.ens-lyon.fr/nathalie.revol/software.html.
+[ bib ]
+
+

+[145]
+
+Aristides G. Requicha.
+ Representations for rigid solids: Theory, methods, and systems.
+ ACM Computing Surveys, 12(4):437-464, 1980.
+[ bib ]
+
+

+[146]
+
+RS - A software for real solving of algebraic systems.
+ Rouillier, Fabrice.
+ http://www.loria.fr/equipes/vegas/rs/.
+[ bib ]
+
+

+[147]
+
+James Rumbaugh, Michael Blaha, William Premerlani, Frederick Eddy, and William
+  Lorenson.
+ Object-Oriented Modeling and Design.
+ Prentice Hall, Englewood Cliffs, NJ, 1991.
+[ bib ]
+
+

+[148]
+
+Laurent Rineau and Mariette Yvinec.
+ A generic software design for Delaunay refinement meshing.
+ Comput. Geom. Theory Appl., 38:100-110, 2007.
+[ bib | 
+http ]
+
+

+[149]
+
+Fabrice Rouillier and Paul Zimmermann.
+ Efficient isolation of polynomial's real roots.
+ Journal of Computational and Applied Mathematics,
+  162(1):33-50, 2004.
+[ bib ]
+
+

+[150]
+
+Jonathan R. Shewchuk.
+ A condition guaranteeing the existence of higher-dimensional
+  constrained delaunay triangulations.
+ In Proc. 14th Annu. ACM Sympos. Comput. Geom., pages 76-85,
+  1998.
+[ bib ]
+
+

+[151]
+
+Bjarne Stroustrup.
+ The C++ Programming Language.
+ Addison-Wesley, 2nd edition, 1991.
+[ bib ]
+
+

+[152]
+
+Bjarne Stroustrup.
+ The C++ Programming Language.
+ Addison-Wesley, 3rd edition, 1997.
+[ bib ]
+
+

+[153]
+
+S. Schirra.
+ Designing a computational geometry algorithms library.
+ Lecture Notes for Advanced School on Algorithmic Foundations of
+  Geographic Information Systems, CISM, Udine, September 16-20 1996.
+[ bib ]
+
+

+[154]
+
+Peter Schorn.
+ Implementing the XYZ GeoBench: A programming environment for
+  geometric algorithms.
+ In Computational Geometry - Methods, Algorithms and
+  Applications: Proc. Internat. Workshop Comput. Geom. CG '91, volume 553 of
+  Lecture Notes Comput. Sci., pages 187-202. Springer-Verlag, 1991.
+ http://wwwjn.inf.ethz.ch/geobench/XYZGeoBench.html.
+[ bib ]
+
+

+[155]
+
+Stefan Schirra.
+ Parameterized implementations of classical planar convex hull
+  algorithms and extreme point computations.
+ Research Report MPI-I-98-1-003, Max-Planck-Institut für
+  Informatik, Im Stadtwald, D-66123 Saarbrücken, Germany, January 1998.
+[ bib ]
+
+

+[156]
+
+S. Schirra.
+ Precision and robustness in geometric computations.
+ In Marc van Kreveld, Jürg Nievergelt, Thomas Roos, and Peter
+  Widmayer, editors, Algorithmic foundations of geographic information
+  systems, volume 1340 of Lecture Notes in Computer Science, pages
+  255-287. Springer-Verlag, Berlin, 1997.
+[ bib ]
+
+

+[157]
+
+Michael Schutte.
+ Zufällige konvexe mengen.
+ Master's thesis, Freie Universität Berlin, Germany, 1996.
+[ bib ]
+
+

+[158]
+
+Silicon Graphics Computer Systems, Inc.
+ Standard template library programmer's guide.
+ http://www.sgi.com/Technology/STL/, 1997.
+[ bib ]
+
+

+[159]
+
+Alexander Stepanov and Meng Lee.
+ The standard template library, October 1995.
+[ bib ]
+
+

+[160]
+
+M. Seel and K. Mehlhorn.
+ Infimaximal frames: A technique for making lines look like segments.
+ Research Report MPI-I-2000-1-005, MPI für Informatik,
+  Saarbrücken, Germany, December 2000.
+ http://www.mpi-sb.mpg.de/~mehlhorn/ftp/InfiFrames.ps.
+[ bib ]
+
+

+[161]
+
+Le-Jeng Shiue and Jörg Peters.
+ Mesh refinement based on euler encoding.
+ In Proceedings of the International Conference on Shape Modeling
+  and Applications 2005, pages 343-348, 2005.
+[ bib ]
+
+

+[162]
+
+Le-Jeng Shiue and Jörg Peters.
+ A mesh refinement library based on generic design.
+ In Proceedings of the 43rd ACM Southeast Conference, pages
+  1-104-1-108, 2005.
+[ bib ]
+
+

+[163]
+
+Jeremy G. Siek, Lie-Quan Lee, and Andrew Lumsdaine.
+ Boost Graph Library.
+ Addison-Wesley, 2002.
+[ bib ]
+
+

+[164]
+
+Steve Oudot, Laurent Rineau, and Mariette Yvinec.
+ Meshing volumes bounded by smooth surfaces.
+ In Proc. 14th International Meshing Roundtable, pages 203-219,
+  2005.
+[ bib ]
+
+

+[165]
+
+Lisa M. C. Smith and Mansur H. Samadzadeh.
+ An annotated bibliography of literate programming.
+ ACM SIGPLAN Notices, 26(1):14-20, January 1991.
+[ bib ]
+
+

+[166]
+
+Jane Tournois.
+ Optimisation de maillages.
+ Thèse de doctorat en sciences, Université Nice
+  Sophia-Antipolis, Nice, France, 2009.
+[ bib ]
+
+

+[167]
+
+G.M. Treece, R.W. Prager, and A.H. Gee.
+ Regularised marching tetrahedra: improved iso-surface extraction.
+ Computers and Graphics, 23(4):583-598, 1999.
+[ bib | 
+.html ]
+
+

+[168]
+
+Jane TOURNOIS, Rahul SRINIVASAN, and Pierre ALLIEZ.
+ Perturbing slivers in 3D Delaunay meshes.
+ In Proceedings of the 18th International Meshing Roundtable,
+  october 2009.
+[ bib ]
+
+

+[169]
+
+Jane Tournois, Camille Wormser, Pierre Alliez, and Mathieu Desbrun.
+ Interleaving Delaunay refinement and optimization for practical
+  isotropic tetrahedron mesh generation.
+ ACM Transactions on Graphics, 28(3):75:1-75:9, 2009.
+ SIGGRAPH '2009 Conference Proceedings.
+[ bib | 
+http ]
+
+

+[170]
+
+Jan Vahrenhold, editor.
+ Experimental Algorithms, 8th International Symposium, SEA 2009,
+  Dortmund, Germany, June 4-6, 2009. Proceedings, volume 5526 of Lecture
+  Notes in Computer Science. Springer, 2009.
+[ bib ]
+
+

+[171]
+
+Todd Veldhuizen.
+ Expressions templates.
+ C++ Report, pages 26-31, June 1995.
+[ bib ]
+
+

+[172]
+
+R. C. Veltkamp.
+ Generic programming in %CGAL, the computational geometry algorithms
+  library.
+ In Proceedings of the 6th Eurographics Workshop on Programming
+  Paradigms in Graphics, 1997.
+[ bib ]
+
+

+[173]
+
+Todd Veldhuizen.
+ Template metaprograms.
+ C++ Report, pages 36-43, May 1995.
+[ bib ]
+
+

+[174]
+
+David Vandevoorde and Nicolai M. Josuttis.
+ C++ Templates: The Complete Guide.
+ Addison-Wesley, 2003.
+[ bib ]
+
+

+[175]
+
+Todd Veldhuizen and Kumaraswamy Ponnambalam.
+ Linear algebra with C++ template metaprograms.
+ Dr. Dobb's Journal, August 1996.
+[ bib ]
+
+

+[176]
+
+The virtual reality modeling language specification: Version 2.0, ISO/IEC
+  CD 14772.
+ 
+  http://www.web3d.org/x3d/specifications/vrml/ISO-IEC-14772-VRML97/,
+  December 1997.
+[ bib ]
+
+

+[177]
+
+Ross N. Williams.
+ FunnelWeb User's Manual, V1.0 for FunnelWeb V3.0
+  edition, May 1992.
+[ bib ]
+
+

+[178]
+
+Bob Wallis.
+ Forms, vectors, and transforms.
+ In Andrew S. Glassner, editor, Graphics Gems, pages 533-538.
+  Academic Press, 1990.
+[ bib ]
+
+

+[179]
+
+Josie Wernicke.
+ The Inventor Mentor: Programming Object-Oriented 3D Graphics
+  with Open Inventor, Release 2.
+ Addison-Wesley, 1994.
+[ bib ]
+
+

+[180]
+
+Joe Warren and Henrik Weimer.
+ Subdivision Methods for Geometric Design.
+ Morgan Kaufmann Publishers, New York, 2002.
+[ bib ]
+
+

+[181]
+
+Shin Yoshizawa, Alexander Belyaev, and Hans-Peter Seidel.
+ Fast and robust detection of crest lines on meshes.
+ In SPM '05: Proceedings of the 2005 ACM symposium on Solid and
+  physical modeling, pages 227-232, New York, NY, USA, 2005. ACM Press.
+[ bib | 
+DOI ]
+
+

+[182]
+
+Yutaka Ohtake, Alexander Belyaev, and Hans-Peter Seidel.
+ Ridge-valley lines on meshes via implicit surface fitting.
+ ACM Trans. Graph., 23(3):609-612, 2004.
+[ bib | 
+DOI ]
+
+

+[183]
+
+Afra Zomorodian and Herbert Edelsbrunner.
+ Fast software for box intersection.
+ Int. J. Comput. Geom. Appl., 12:143-172, 2002.
+[ bib ]
+
+

+[184]
+
+Christoph M. Hoffmann.
+ Solid modeling.
+ In Jacob E. Goodman and Joseph O'Rourke, editors, Handbook of
+  Discrete and Computational Geometry, chapter 56, pages 1257-1278. Chapman
+  & Hall/CRC, 2nd edition, 2004.
+[ bib ]
+
+

+[185]
+
+Petr Felkel and Stěpán Obdržálek.
+ Straight skeleton implementation.
+ In László Szirmay Kalos, editor, 14th Spring
+  Conference on Computer Graphics (SCCG'98), pages 210-218, 1998.
+[ bib | 
+.html ]
+
+

+[186]
+
+David Eppstein and Jeff Erickson.
+ Raising roofs, crashing cycles, and playing pool: Applications of a
+  data structure for finding pairwise interactions.
+ In Symposium on Computational Geometry, pages 58-67, 1998.
+[ bib | 
+.html ]
+
+

+[187]
+
+R. G. Laycock and A. M. Day.
+ Automatically generating roof models from building footprints.
+ In The 11-th International Conference in Central Europe on
+  Computer Graphics, Visualization and Computer Vision'2003. Journal of WSCG -
+  FULL Papers, volume 11, 2003.
+[ bib | 
+.pdf ]
+
+

+[188]
+
+Menelaos I. Karavelas.
+ Voronoi diagrams in cgal.
+ In 22nd European Symposium on Computational Geometry, pages
+  229-232, Delphi, Greece, 2006.
+[ bib ]
+
+

+[189]
+
+E. Fogel et al.
+ An empirical comparison of software for constructing arrangements of
+  curved arcs.
+ Technical Report ECG-TR-361200-01, Tel Aviv University, 2004.
+[ bib ]
+
+

+[190]
+
+Michal Meyerovitch.
+ Robust, generic, and efficient constructions of envelopes of surfaces
+  in three-dimensional space.
+ Master's thesis, Tel-Aviv University, Israel, 2006.
+[ bib ]
+
+

+[191]
+
+David Abrahams.
+ Exception-safety in generic components.
+ In Jazayeri et al. [194], pages 69-79.
+[ bib | 
+.html ]
+
+

+[192]
+
+F. Aurenhammer and O. Schwarzkopf.
+ A simple on-line randomized incremental algorithm for computing
+  higher order Voronoi diagrams.
+ Internat. J. Comput. Geom. Appl., 2:363-381, 1992.
+[ bib ]
+

+Keywords: Voronoi diagrams, geometric transforms, dynamization
+

+
+

+[193]
+
+Julia Flötotto and Mariette Yvinec.
+ Order-k Voronoi diagrams.
+ In Abstracts 17th European Workshop Comput. Geom., pages
+  109-112. Freie Universität Berlin, 2001.
+[ bib ]
+
+

+[194]
+
+Mehdi Jazayeri, Rüdiger Loos, and David R. Musser, editors.
+ Generic Programming, International Seminar on Generic
+  Programming, Dagstuhl Castle, Germany, April 27 - May 1, 1998, Selected
+  Papers, volume 1766 of Lecture Notes in Computer Science. Springer,
+  2000.
+[ bib ]
+
+

+[195]
+
+Michael Kazhdan, M. Bolitho, and Hugues Hoppe.
+ Poisson Surface Reconstruction.
+ In Symp. on Geometry Processing, pages 61-70, 2006.
+[ bib ]
+
+

+[196]
+
+Boissonnat and Cazals.
+ Smooth surface reconstruction via natural neighbour interpolation of
+  distance functions.
+ CGTA: Computational Geometry: Theory and Applications, 22,
+  2002.
+[ bib ]
+
+

+[197]
+
+William E. Lorensen and Harvey E. Cline.
+ Marching cubes: A high resolution 3d surface construction algorithm.
+ In SIGGRAPH '87: Proceedings of the 14th annual conference on
+  Computer graphics and interactive techniques, pages 163-169, New York, NY,
+  USA, 1987. ACM Press.
+[ bib | 
+DOI ]
+
+

+[198]
+
+J. C. Carr, R. K. Beatson, J. B. Cherrie, T. J. Mitchell, W. R. Fright, B. C.
+  McCallum, and T. R. Evans.
+ Reconstruction and representation of 3d objects with radial basis
+  functions.
+ In SIGGRAPH '01: Proceedings of the 28th annual conference on
+  Computer graphics and interactive techniques, pages 67-76, New York, NY,
+  USA, 2001. ACM Press.
+[ bib | 
+DOI ]
+
+

+[199]
+
+Nina Amenta, Marshall Bern, and Manolis Kamvysselis.
+ A new voronoi-based surface reconstruction algorithm.
+ In SIGGRAPH '98: Proceedings of the 25th annual conference on
+  Computer graphics and interactive techniques, pages 415-421, New York, NY,
+  USA, 1998. ACM Press.
+[ bib | 
+DOI ]
+
+

+[200]
+
+Gaël Guennebaud and Markus Gross.
+ Algebraic point set surfaces.
+ In SIGGRAPH '07: ACM SIGGRAPH 2007 papers, page 23, New York,
+  NY, USA, 2007. ACM.
+[ bib | 
+DOI ]
+
+

+[201]
+
+Pedro M.M. de Castro, Frederic Cazals, Sebastien Loriot, and Monique Teillaud.
+ Design of the %CGAL 3D Spherical Kernel and application to
+  arrangements of circles on a sphere.
+ Computational Geometry : Theory and Applications, 42(6-7):536
+  - 550, 2009.
+[ bib | 
+DOI ]
+
+

+[202]
+
+O. Schwarzkopf.
+ The extensible drawing editor Ipe.
+ In Proceedings of the eleventh annual symposium on Computational
+  geometry, pages 410-411. ACM New York, NY, USA, 1995.
+[ bib ]
+
+

+[203]
+
+Otfried Cheong.
+ IPE manual and library documentation, 6.0pre32 edition, 2009.
+[ bib | 
+http ]
+
+

+[204]
+
+P. Terdiman.
+ OPCODE 3D Collision Detection library, 2005.
+ http://www.codercorner.com/Opcode.htm.
+[ bib ]
+
+

+[205]
+
+Yuanxin Liu and Jack Snoeyink.
+ A comparison of five implementations of 3D delaunay tessellation.
+ In János Pach Jacob E. Goodman and Emo Welzl, editors, 
+  Combinatorial and Computational Geometry, pages 439-458. MSRI Publications,
+  2005.
+[ bib | 
+.pdf ]
+
+

+[206]
+
+Lutz Kettner, Kurt Mehlhorn, Sylvain Pion, Stefan Schirra, and Chee Yap.
+ Classroom examples of robustness problems in geometric computations.
+ Computational Geometry: Theory and Applications, 40(1):61-78,
+  may 2008.
+[ bib | 
+DOI | 
+http ]
+
+

+[207]
+
+Jeff Erickson.
+ Dense point sets have sparse Delaunay triangulations.
+ In Proc. 13th ACM-SIAM Sympos. Discrete Algorithms (SODA),
+  pages 125-134, 2002.
+[ bib ]
+
+

+[208]
+
+Nina Amenta, Dominique Attali, and Olivier Devillers.
+ Complexity of Delaunay triangulation for points on
+  lower-dimensional polyhedra.
+ In Proc. 18th ACM-SIAM Sympos. Discrete Algorithms, pages
+  1106-1113, 2007.
+[ bib | 
+http ]
+
+

+[209]
+
+Dominique Attali and Jean-Daniel Boissonnat.
+ Complexity of the Delaunay triangulation of points on polyhedral
   surfaces.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+ Discrete and Computational Geometry, 30(3):437-452, 2003.
+[ bib ]
 
 
 

 
-[65]
+[210]
 
 
-Pierre Alliez, Laurent Saboret, and Nader Salman.
- Point set processing.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Dominique Attali, Jean-Daniel Boissonnat, and André Lieutier.
+ Complexity of the Delaunay triangulation of points on surfaces: The
+  smooth case.
+ In Proc. 19th Annual Symposium on Computational Geometry, pages
+  237-246, 2003.
+[ bib ]
 
 
 

 
-[66]
+[211]
 
 
-Daniel Russel.
- Kinetic data structures.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Arno Eigenwillig.
+ Real Root Isolation for Exactand Approximate Polynomials Using
+  Descartes ' Rule of Signs.
+ PhD thesis, Universität des Saarlandes, Saarbrücken, Germany,
+  2008.
+[ bib ]
 
 
 

 
-[67]
+[212]
 
 
-Daniel Russel.
- Kinetic framework.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+J. Abbott.
+ Quadratic interval refinement for real roots.
+ Poster presented at the 2006 Int. Symp. on Symb. and Alg. Comp.   (ISSAC 2006).
+[ bib | 
+http ]
 
 
 

 
-[68]
+[213]
 
 
-Andreas Fabri, Fernando Cacciola, and Ron Wein.
- %CGAL and the Boost graph library.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Arno Eigenwillig and Michael Kerber.
+ Exact and efficient 2d-arrangements of arbitrary algebraic curves.
+ In Proceedings of the Nineteenth Annual ACM-SIAM Symposium on
+  Discrete Algorithms (SODA08), 2008.
+ 122-131.
+[ bib ]
 
 
 

 
-[69]
+[214]
 
 
-Andreas Fabri and Laurent Saboret.
- %CGAL and Boost property maps.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Arno Eigenwillig, Michael Kerber, and Nicola Wolpert.
+ Fast and exact geometric analysis of real algebraic plane curves.
+ In Christopher W. Brown, editor, Proocedings of the 2007
+  International Symposium on Symbolic and Algebraic Computation (ISSAC 2007),
+  pages 151-158, 2007.
+[ bib ]
 
 
 

 
-[70]
+[215]
 
 
-Christophe Delage and Olivier Devillers.
- Spatial sorting.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+Michael Kerber.
+ Geometric Algorithms for Algebraic Curves and Surfaces.
+ PhD thesis, Universität des Saarlandes, Saarbrücken, Germany,
+  2009.
+[ bib ]
 
 
 

 
-[71]
+[216]
 
 
-Pierre Alliez, Stéphane Tayeb, and Camille Wormser.
- 3d fast intersection and distance computation (aabb tree).
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+L. Gonzalez-Vega, T. Recio, H. Lombardi, and M.-F. Roy.
+ Sturm-habicht sequences, determinants and real roots of univariate
+  polynomials.
+ In B.F. Caviness and J.R. Johnson, editors, Quantifier
+  Elimination and Cylindrical Algebraic Decomposition, Texts and Monographs in
+  Symbolic Computation, pages 300-316. Springer, 1998.
+[ bib ]
 
 
 

 
-[72]
+[217]
 
 
-Michael Hoffmann.
- Monotone and sorted matrix search.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+T. Asano.
+ An efficient algorithm for finding the visibility polygon for a
+  polygonal region with holes.
+ IEICE Transactions (1976-1990), (9):557-559, 1985.
+[ bib ]
 
 
 

 
-[73]
+[218]
 
 
-Michael Hoffmann, Lutz Kettner, Sylvain Pion, and Ron Wein.
- Stl extensions for %CGAL.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[74]
-
-Olivier Devillers, Lutz Kettner, Michael Seel, and Mariette Yvinec.
- Handles and circulators.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[75]
-
-Olivier Devillers, Susan Hert, Michael Hoffmann, Lutz Kettner, and Sven
-  Schönherr.
- Geometric object generators.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[76]
-
-Lutz Kettner, Sylvain Pion, and Michael Seel.
- Profiling tools timers, hash map, union-find, modifiers.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[77]
-
-Andreas Fabri, Geert-Jan Giezeman, and Lutz Kettner.
- Io streams.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[78]
-
-Andreas Fabri and Sylvain Pion.
- Geomview.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[79]
-
-Andreas Fabri and Laurent Rineau.
- %CGAL and the qt graphics view framework.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
-
-

-[80]
-
-Sébastien Loriot and Sylvain Pion.
- %CGAL ipelets.
- In %CGAL User and Reference Manual. %CGAL Editorial Board,
-  4.2 edition, 2013.
-[ bib | 
-http ]
+B. Joe and R.B. Simpson.
+ Corrections to lee's visibility polygon algorithm.
+ BIT, 27:458-473, 1987.
+[ bib ]
 
 
 

 
This file was generated by
-bibtex2html 1.97.

+bibtex2html 1.96.

 */
diff --git a/Visibility_2/test/data/Arrangement_Test/in1 b/Visibility_2/test/Visibility_2/data/Arrangement_Test/in1
similarity index 100%
rename from Visibility_2/test/data/Arrangement_Test/in1
rename to Visibility_2/test/Visibility_2/data/Arrangement_Test/in1
diff --git a/Visibility_2/test/data/Arrangement_Test/in2 b/Visibility_2/test/Visibility_2/data/Arrangement_Test/in2
similarity index 100%
rename from Visibility_2/test/data/Arrangement_Test/in2
rename to Visibility_2/test/Visibility_2/data/Arrangement_Test/in2
diff --git a/Visibility_2/test/data/Arrangement_Test/in3 b/Visibility_2/test/Visibility_2/data/Arrangement_Test/in3
similarity index 100%
rename from Visibility_2/test/data/Arrangement_Test/in3
rename to Visibility_2/test/Visibility_2/data/Arrangement_Test/in3
diff --git a/Visibility_2/test/data/Arrangement_Test/in4 b/Visibility_2/test/Visibility_2/data/Arrangement_Test/in4
similarity index 100%
rename from Visibility_2/test/data/Arrangement_Test/in4
rename to Visibility_2/test/Visibility_2/data/Arrangement_Test/in4
diff --git a/Visibility_2/test/data/Arrangement_Test/in5 b/Visibility_2/test/Visibility_2/data/Arrangement_Test/in5
similarity index 100%
rename from Visibility_2/test/data/Arrangement_Test/in5
rename to Visibility_2/test/Visibility_2/data/Arrangement_Test/in5
diff --git a/Visibility_2/test/data/Arrangement_Test/non_regular_out1 b/Visibility_2/test/Visibility_2/data/Arrangement_Test/non_regular_out1
similarity index 100%
rename from Visibility_2/test/data/Arrangement_Test/non_regular_out1
rename to Visibility_2/test/Visibility_2/data/Arrangement_Test/non_regular_out1
diff --git a/Visibility_2/test/data/Arrangement_Test/non_regular_out2 b/Visibility_2/test/Visibility_2/data/Arrangement_Test/non_regular_out2
similarity index 100%
rename from Visibility_2/test/data/Arrangement_Test/non_regular_out2
rename to Visibility_2/test/Visibility_2/data/Arrangement_Test/non_regular_out2
diff --git a/Visibility_2/test/data/Arrangement_Test/non_regular_out3 b/Visibility_2/test/Visibility_2/data/Arrangement_Test/non_regular_out3
similarity index 100%
rename from Visibility_2/test/data/Arrangement_Test/non_regular_out3
rename to Visibility_2/test/Visibility_2/data/Arrangement_Test/non_regular_out3
diff --git a/Visibility_2/test/data/Arrangement_Test/non_regular_out4 b/Visibility_2/test/Visibility_2/data/Arrangement_Test/non_regular_out4
similarity index 100%
rename from Visibility_2/test/data/Arrangement_Test/non_regular_out4
rename to Visibility_2/test/Visibility_2/data/Arrangement_Test/non_regular_out4
diff --git a/Visibility_2/test/data/Arrangement_Test/non_regular_out5 b/Visibility_2/test/Visibility_2/data/Arrangement_Test/non_regular_out5
similarity index 100%
rename from Visibility_2/test/data/Arrangement_Test/non_regular_out5
rename to Visibility_2/test/Visibility_2/data/Arrangement_Test/non_regular_out5
diff --git a/Visibility_2/test/data/simple_polygon_test_case_1.in b/Visibility_2/test/Visibility_2/data/simple_polygon_test_case_1.in
similarity index 100%
rename from Visibility_2/test/data/simple_polygon_test_case_1.in
rename to Visibility_2/test/Visibility_2/data/simple_polygon_test_case_1.in
diff --git a/Visibility_2/test/data/simple_polygon_test_case_1.out b/Visibility_2/test/Visibility_2/data/simple_polygon_test_case_1.out
similarity index 100%
rename from Visibility_2/test/data/simple_polygon_test_case_1.out
rename to Visibility_2/test/Visibility_2/data/simple_polygon_test_case_1.out
diff --git a/Visibility_2/test/data/simple_polygon_test_case_2.in b/Visibility_2/test/Visibility_2/data/simple_polygon_test_case_2.in
similarity index 100%
rename from Visibility_2/test/data/simple_polygon_test_case_2.in
rename to Visibility_2/test/Visibility_2/data/simple_polygon_test_case_2.in
diff --git a/Visibility_2/test/data/simple_polygon_test_case_2.out b/Visibility_2/test/Visibility_2/data/simple_polygon_test_case_2.out
similarity index 100%
rename from Visibility_2/test/data/simple_polygon_test_case_2.out
rename to Visibility_2/test/Visibility_2/data/simple_polygon_test_case_2.out
diff --git a/Visibility_2/test/data/simple_polygon_test_case_3.in b/Visibility_2/test/Visibility_2/data/simple_polygon_test_case_3.in
similarity index 100%
rename from Visibility_2/test/data/simple_polygon_test_case_3.in
rename to Visibility_2/test/Visibility_2/data/simple_polygon_test_case_3.in
diff --git a/Visibility_2/test/data/simple_polygon_test_case_3.out b/Visibility_2/test/Visibility_2/data/simple_polygon_test_case_3.out
similarity index 100%
rename from Visibility_2/test/data/simple_polygon_test_case_3.out
rename to Visibility_2/test/Visibility_2/data/simple_polygon_test_case_3.out
diff --git a/Visibility_2/test/data/simple_polygon_test_case_4.in b/Visibility_2/test/Visibility_2/data/simple_polygon_test_case_4.in
similarity index 100%
rename from Visibility_2/test/data/simple_polygon_test_case_4.in
rename to Visibility_2/test/Visibility_2/data/simple_polygon_test_case_4.in
diff --git a/Visibility_2/test/data/simple_polygon_test_case_4.out b/Visibility_2/test/Visibility_2/data/simple_polygon_test_case_4.out
similarity index 100%
rename from Visibility_2/test/data/simple_polygon_test_case_4.out
rename to Visibility_2/test/Visibility_2/data/simple_polygon_test_case_4.out
diff --git a/Visibility_2/test/include/CGAL/test_model_methods.h b/Visibility_2/test/Visibility_2/include/CGAL/test_model_methods.h
similarity index 100%
rename from Visibility_2/test/include/CGAL/test_model_methods.h
rename to Visibility_2/test/Visibility_2/include/CGAL/test_model_methods.h
diff --git a/Visibility_2/test/include/CGAL/test_simple_polygons.h b/Visibility_2/test/Visibility_2/include/CGAL/test_simple_polygons.h
similarity index 100%
rename from Visibility_2/test/include/CGAL/test_simple_polygons.h
rename to Visibility_2/test/Visibility_2/include/CGAL/test_simple_polygons.h
diff --git a/Visibility_2/test/include/CGAL/test_utils.h b/Visibility_2/test/Visibility_2/include/CGAL/test_utils.h
similarity index 100%
rename from Visibility_2/test/include/CGAL/test_utils.h
rename to Visibility_2/test/Visibility_2/include/CGAL/test_utils.h
diff --git a/Visibility_2/test/run_tests.sh b/Visibility_2/test/Visibility_2/run_tests.sh
similarity index 100%
rename from Visibility_2/test/run_tests.sh
rename to Visibility_2/test/Visibility_2/run_tests.sh
diff --git a/Visibility_2/test/test_naive_visibility.cpp b/Visibility_2/test/Visibility_2/test_naive_visibility.cpp
similarity index 100%
rename from Visibility_2/test/test_naive_visibility.cpp
rename to Visibility_2/test/Visibility_2/test_naive_visibility.cpp
diff --git a/Visibility_2/test/test_simple_visibility.cpp b/Visibility_2/test/Visibility_2/test_simple_visibility.cpp
similarity index 100%
rename from Visibility_2/test/test_simple_visibility.cpp
rename to Visibility_2/test/Visibility_2/test_simple_visibility.cpp