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

moved yet again

This commit is contained in:
Efi Fogel 2003-10-01 14:47:03 +00:00
parent cbf4922f02
commit 31f6d2a04d
19 changed files with 2906 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
Packages/Planar_map/demo/Planar_map/Leda_window/README Normal file
View File

@ -0,0 +1,72 @@
Planar Map Package Demo Program
-------------------------------
The directory contains a demo program (do "make demo" to compile)
and a utility program for generating input files for the demo program
(do "make helputil" to compile).
There is also a directory "input_files" which contains some input
files in the format needed for the demo program.
The demo program:
-----------------
The demo program can be run with a file in the format defined below,
or it can be run without arguments in which case the user builds a planar
map interactively using the mouse.
The left button starts (resp. ends) a new segment at the position of
the mouse. The middle button will start (resp. end) at the nearest existing
vertex. The right button removes the segment directly above it.
Pressing "finish" will end the interactive reading of the planar map.
After the planar map is read (from the file or interactively) the user can use
the mouse for queries (ray shooting and point location).
usage:
demo [filename]
The helputil program :
-------------------
The program handles input files for the demo program .
The Input file should be at the following format:
<n = number of points>
<x1> <y1>
...
<xn> <yn>
<k = number of curves>
<s1> <t1>
...
<sk> <tk>
Where xi, yi are the coordinates of point i and si,ti
are the indices (in the the above list of points)
of the source and the target of curve i.
The utilities given are creating a random file of (possibly
intersecting) segments, and splitting of segments in such a file into
a file of non-intersecting segments.
Do not run the demo on a randomly generated file without splitting
the segments via the 'i' parameter. The demo might crash or
disfunction.
Usages:
* The first parameter is always 'e' or 'f' indicates that
the input file is:
'e' --- exact calculations (leda_rationals).
'f' --- floating point (double).
1. Split line segments at intersection points:
**** helputil <e/f> i <input_file> <output_file>
2. Convert rationals file to doubles file (and vice versa)
**** helputil <e/f> c <input_file> <output_file>
3. Create random (not intersected) file with <num> segments
**** helputil <e/f> r <num> <output_file>

6
Packages/Planar_map/demo/Planar_map/Leda_window/configuration Normal file
View File

@ -0,0 +1,6 @@
//#define USE_NAIVE_POINT_LOCATION //for naive strategy
//#define USE_WALK_POINT_LOCATION //for naive strategy
//#define USE_RATIONAL //for leda_rational coordinates
//#define USE_LEDA_RAT_KERNEL //for rational kernel (rat_point,etc..)
//#define CGAL_PM_DEBUG // internal debug flag
//#define CGAL_PM_TIMER // internal timing flag

244
Packages/Planar_map/demo/Planar_map/Leda_window/demo.C Normal file
View File

@ -0,0 +1,244 @@
#include <iostream>
#ifndef CGAL_USE_LEDA
int main()
{
std::cout << "Sorry, this demo needs LEDA for visualisation.";
std::cout << std::endl;
return 0;
}
#else
#include "configuration"
#include <CGAL/basic.h>
#include <fstream>
#ifdef USE_NAIVE_POINT_LOCATION
#include <CGAL/Pm_naive_point_location.h>
#endif
#ifdef USE_WALK_POINT_LOCATION
#include <CGAL/Pm_walk_along_line_point_location.h>
#endif
#include "draw_map.h"
//typedef CGAL::Point_2<Rep> Point;
//typedef CGAL::Segment_2<Rep> Segment;
typedef CGAL::Window_stream Window_stream;
unsigned int delete_restriction=0;
void redraw(leda_window* wp, double x0, double y0, double x1, double y1)
{ wp->flush_buffer(x0,y0,x1,y1); }
#ifdef CGAL_PM_TIMER
CGAL::Timer t_total,t_construction,t_insert,t_remove,t_locate,t_vertical,t_split,t_merge;
int n_total=0,n_insert=0,n_remove=0,n_locate=0,n_vertical=0,n_split=0,n_merge=0;
#endif
int test(Planar_map& M,char* name,int argc,char** argv)
{
Window_stream W(400, 400);
W.button("finish",10);
W.set_redraw(redraw);
double x0=-1.1,x1=1.1 ,y0=-1.1;
W.init(x0,x1,y0); // logical window size
W.set_mode(leda_src_mode);
W.set_node_width(3);
W.display(leda_window::center,leda_window::center);
#ifdef CGAL_PM_TIMER
t_construction.reset();
t_insert.reset();
t_remove.reset();
t_locate.reset();
t_vertical.reset();
t_split.reset();
t_merge.reset();
n_total=0;n_insert=0;n_remove=0;n_locate=0;n_vertical=0,n_split=0,n_merge=0;
#endif
if (argc>1)
{
#ifdef CGAL_PM_TIMER
t_construction.start();
#endif
if (!Init(argv[1],M)) {std::cerr << "\nBad input file";return true;}
#ifdef CGAL_PM_TIMER
t_construction.stop();
#endif
win_border(x0,x1,y0,M); //rescale window
W.init(x0,x1,y0);
if (argc>2)
{
Planar_map::Locate_type lt;
std::ifstream in(argv[2]);
if (in.bad()) {std::cerr << "\nBad locate input file";return false;}
unsigned int i,n_pt; in >> n_pt;
// bool first=true;
Planar_map::Point* p=new Planar_map::Point[n_pt];
for (i=0;i<n_pt;i++)
{
number_type x,y;
in >> x >> y ;
p[i]=Planar_map::Point(x,y);
}
do
{
#ifdef CGAL_PM_TIMER
t_locate.start();
#endif
for(i=0;i<n_pt;i++)
M.locate(p[i],lt);
#ifdef CGAL_PM_TIMER
t_locate.stop();
unsigned int k=(unsigned int)((n_locate+n_pt)/BUNDLE)-(unsigned int)(n_locate/BUNDLE);
for (i=0;i<k;i++) std::cout << "x";
std::cout << std::flush;
n_locate+=n_pt;
#endif
}
#ifdef CGAL_PM_TIMER
while(t_locate.time()<WIDE_PRECISION*t_locate.precision());
#else
while(false); // don't repeat this loop
#endif
if (delete_restriction)
{
// Planar_map::Locate_type lt;
Planar_map::Halfedge_handle e;
unsigned int n = std::min(delete_restriction,M.number_of_halfedges()/2);
while (n--)
{
e=M.halfedges_begin();
#ifdef CGAL_PM_TIMER
t_remove.start();
#endif
M.remove_edge(e);
#ifdef CGAL_PM_TIMER
t_remove.stop();
if (!(n_remove%BUNDLE)) std::cout << ">" << std::flush;
n_remove++;
#endif
}
}
}
else
{
W.set_redraw(redraw);
W.set_mode(leda_src_mode);
W.set_node_width(3);
W.display(leda_window::center,leda_window::center);
draw_pm(M,W);
}
}
else
{
W << CGAL::GREEN;
window_input(M,W);
CGAL::Window_stream W2(400, 400);
W2.init(x0,x1,y0);
W2.set_mode(leda_src_mode);
W2.set_node_width(3);
W2.button("quit",10);
W2.display(leda_window::max,leda_window::center);
draw_pm(M,W2);
}
#ifdef CGAL_PM_TIMER
if (delete_restriction)
{
std::cout << "\n" << name << " " << t_construction.time() << " " <<
t_insert.time()/n_insert << " " <<
t_locate.time()/n_locate << " " <<
t_remove.time()/n_remove << " " <<
t_vertical.time()/n_vertical << " cilrv" ;
}
else if (argc>2)
{
std::cout << "\n" << name << " " << t_construction.time() << " " <<
t_insert.time()/n_insert << " " <<
t_locate.time()/n_locate << " " <<
t_vertical.time()/n_vertical << " cilv";
}
else // (argc>1)
{
std::cout << "\n" << name << t_construction.time() << " " <<
t_insert.time()/n_insert << " " <<
t_locate.time()/n_locate << " cil";
}
#endif
return true;
}
int main(int argc, char* argv[])
{
#ifdef CGAL_PM_TIMER
t_total.reset();
t_total.start();
t_construction.reset();
t_insert.reset();
t_remove.reset();
t_locate.reset();
t_vertical.reset();
#endif
#ifdef USE_NAIVE_POINT_LOCATION
#ifdef USE_DEFAULT_WITHOUT_REBUILD
#error USE one point location
#endif
#ifdef USE_WALK_POINT_LOCATION
#error USE one point location
#endif
CGAL::Pm_naive_point_location<Planar_map> naive_pl;
Planar_map M(&naive_pl);
test(M,"naive",argc,argv);
std::cout << std::endl;
#else
#if defined(USE_WALK_POINT_LOCATION)
#ifdef USE_NAIVE_POINT_LOCATION
#error USE one point location
#endif
#ifdef USE_DEFAULT_WITHOUT_REBUILD
#error USE one point location
#endif
CGAL::Pm_walk_along_line_point_location<Planar_map> pl;
Planar_map M(&pl);
test(M,"walk_along_line",argc,argv);
std::cout << std::endl;
#else
#if defined(USE_DEFAULT_WITHOUT_REBUILD)
#ifdef USE_NAIVE_POINT_LOCATION
#error USE one point location
#endif
#ifdef USE_WALK_POINT_LOCATION
#error USE one point location
#endif
CGAL::Pm_default_point_location<Planar_map> pl(false);
Planar_map M(&pl);
test(M,"default_without_rebuilding",argc,argv);
std::cout << std::endl;
#else
Planar_map M;
test(M,"default",argc,argv);
std::cout << std::endl;
#endif
#endif
#endif
return 0;
}
#endif // CGAL_USE_LEDA

533
Packages/Planar_map/demo/Planar_map/Leda_window/draw_map.C Normal file
View File

@ -0,0 +1,533 @@
#include <iostream>
// if LEDA is not installed, a message will be issued in runtime.
#ifdef CGAL_USE_LEDA
#include <CGAL/basic.h>
#include <fstream>
#include <list>
#include "draw_map.h"
#include "read_inp.h"
/*=========================================================================
* Start of Code
\*=========================================================================*/
void MarkCcb (const Ccb_halfedge_circulator & b, std::list<Pm_curve>& l)
{
Ccb_halfedge_circulator first = b, iter = b;
do
{
l.push_back(iter->curve());
iter++;
}
while (iter != first);
}
void draw_arrow(Pm_point p1, Pm_point p2, bool black, CGAL::Window_stream & W)
{
if (black)
W << CGAL::BLACK;
else
W << CGAL::WHITE;
//float
number_type ar_size=(W.xmax()-W.xmin())/20 ;
W << Pm_curve (p1, p2);
#ifndef USE_LEDA_RAT_KERNEL
W << Pm_curve(p2, Pm_point (p2.x () - ar_size , p2.y () - ar_size));
W << Pm_curve(p2, Pm_point (p2.x () + ar_size , p2.y () - ar_size));
#else
W << Pm_curve(p2, Pm_point (p2.xcoord () - ar_size, p2.ycoord () - ar_size));
W << Pm_curve(p2, Pm_point (p2.xcoord () + ar_size, p2.ycoord () - ar_size));
#endif
}
void Draw (CGAL::Window_stream & W , Planar_map & pm)
{
W.set_flush( 0 );
Vertex_iterator vi;
for (vi = pm.vertices_begin (); vi != pm.vertices_end (); vi++)
{
W << CGAL::GREEN;
W << (*vi).point();
}
Halfedge_iterator ei;
for (ei = pm.halfedges_begin (); ei != pm.halfedges_end (); ei++)
{
W << CGAL::BLUE;
W << ((*ei).curve());
}
W.set_flush( 1 );
W.flush();
}
bool VerticalRayShoot (Pm_point p, Pm_point & q, bool up , Planar_map &pm)
{
Halfedge_handle e;
Planar_map::Locate_type lt;
number_type y_min, y_max, y_arrow_tip;
#ifdef CGAL_PM_TIMER
t_vertical.start();
#endif
e=pm.vertical_ray_shoot (p,lt, up);
#ifdef CGAL_PM_TIMER
t_vertical.stop();
n_vertical++;
#endif
if (lt!=Planar_map::UNBOUNDED_FACE)
{
Pm_point p1 = e->source()->point();
Pm_point p2 = e->target()->point();
// make the arrow point upwards and touch the found segment:
#ifndef USE_LEDA_RAT_KERNEL
if (p1.x() == p2.x())
{
// the found segment is vertical
y_min = std::min (p1.y(), p2.y());
y_max = std::max (p1.y(), p2.y());
y_arrow_tip = (p.y() < y_min) ? y_min : y_max;
q = Pm_point(p.x(), y_arrow_tip);
}
else
{
y_arrow_tip = p2.y()-
((p2.x()-p.x())*(p2.y()-p1.y()))/(p2.x()-p1.x());
q = Pm_point(p.x(), y_arrow_tip);
}
#else
if (p1.xcoord() == p2.xcoord())
{
// the found segment is vertical
y_min = std::min (p1.ycoord(), p2.ycoord());
y_max = std::max (p1.ycoord(), p2.ycoord());
y_arrow_tip = (p.ycoord() < y_min) ? y_min : y_max;
q = Pm_point(p.xcoord(), y_arrow_tip);
}
else
{
y_arrow_tip = p2.ycoord()-
((p2.xcoord()-p.xcoord())*(p2.ycoord()-p1.ycoord()))/
(p2.xcoord()-p1.xcoord());
q = Pm_point(p.xcoord(), y_arrow_tip);
}
#endif
return true;
}
else
{
return false;
}
}
void FindFace (const Pm_point& p , Planar_map &pm, std::list<Pm_curve>& l)
{
Planar_map::Locate_type lt;
#ifdef CGAL_PM_TIMER
t_vertical.start();
#endif
Halfedge_handle e = pm.vertical_ray_shoot (p, lt, true);
#ifdef CGAL_PM_TIMER
t_vertical.stop();
n_vertical++;
#endif
Face_handle f;
if (lt!=Planar_map::UNBOUNDED_FACE)
{
f = e->face ();
}
else
{
f = pm.unbounded_face ();
}
Ccb_halfedge_circulator ccb_circ;
if (f->does_outer_ccb_exist ())
{
ccb_circ = f->halfedge_on_outer_ccb()->ccb();
MarkCcb (ccb_circ,l);
}
Planar_map::Holes_iterator iccbit;
for (iccbit = f->holes_begin (); iccbit != f->holes_end (); ++iccbit)
{
MarkCcb (*iccbit,l);
}
}
int draw_pm (Planar_map & pm , CGAL::Window_stream & W)
{
std::list<Pm_curve> l;
Pm_point pnt (20, 20);
Pm_point ar1, ar2;
int mbutton = 0;
double x, y;
std::cerr << "Drawing the map:" << std::endl;
Draw (W,pm);
std::cerr << "1.Left button: vertical ray shooting." << std::endl;
std::cerr << "2.Middle button: point location." << std::endl;
std::cerr << "3.Right button: exit" << std::endl;
while (mbutton != 3)
{
int b=W.read_mouse(x,y);
if (b==10) return 0;
mbutton = -b;
// pnt = Pm_point (x, y);
#ifndef USE_LEDA_RAT_KERNEL
pnt = Pm_point(Rep::FT(x),
Rep::FT(y));
#else
pnt = Pm_point(leda_rational(x),leda_rational(y));
#endif
draw_arrow (ar1, ar2, false,W);
if (mbutton == 1)
{
ar1 = pnt;
if (VerticalRayShoot (ar1, ar2, true,pm))
draw_arrow (ar1, ar2, true,W);
}
if (mbutton == 2)
{
FindFace (pnt,pm,l);
}
if (mbutton != 0)
{
Draw (W,pm);
W << CGAL::RED;
for (std::list<Pm_curve>::iterator lit=l.begin(); lit!=l.end(); ++lit)
W << *lit;
l.erase(l.begin(),l.end());
}
}
return 0;
}
//-------------------------------------------------------------------
bool ReadFile(char *filename, int &num_points, Pm_point* &pnts,
int &num_curves, Pm_curve* &cvs )
{
int j, k;
std::ifstream is(filename);
if (is.bad()) return false;
PM_input<Traits> inp;
is >> inp;
is.close();
num_points = inp.get_num_pnts();
num_curves = inp.get_num_cvs();
pnts = new Pm_point[num_points];
cvs = new Pm_curve[num_curves];
int i;
for(i = 0; i < num_points; i++)
{
inp.get(i, pnts[i]);
}
for(i = 0; i < inp.get_num_cvs(); i++)
{
inp.get(i, k, j);
cvs[i] = Pm_curve(pnts[k], pnts[j]);
}
return true;
}
//----------------------------------------------------------------
void win_border( double &x0 , double &x1 , double &y0 ,Planar_map &pm)
{
Vertex_iterator vit = pm.vertices_begin();
#ifndef USE_LEDA_RAT_KERNEL
x0=x1=CGAL::to_double(( vit->point() ).x());
y0=CGAL::to_double(( vit->point() ).y());
#else
x0=x1=vit->point().xcoordD();
y0=vit->point().ycoordD();
#endif
while (vit!=pm.vertices_end())
{
#ifndef USE_LEDA_RAT_KERNEL
if ( ((*vit).point() ).x() < x0 )
x0 = CGAL::to_double(( (*vit).point() ).x()) ;
if ( ( (*vit).point() ).x() > x1 )
x1 = CGAL::to_double(( (*vit).point() ).x()) ;
if ( ( (*vit).point() ).y() < y0 )
y0 = CGAL::to_double(( (*vit).point() ).y()) ;
#else
if ( vit->point().xcoordD() < x0 )
x0 = vit->point().xcoordD() ;
if ( vit->point().xcoordD() > x1 )
x1 = vit->point().xcoordD() ;
if ( vit->point().ycoordD() < y0 )
y0 = vit->point().ycoordD() ;
#endif
vit++;
}
x0=x0-(x1-x0)/2;
x1=x1+(x1-x0)/3;
y0=y0-(x1-x0)/4;
if (x1<=x0)
std::cerr << "\nIf you are trying to read an input file "
<< "(e.g. from input_files directory),"
<< "\nmake sure to define the "
<< "USE_RATIONAL flag whenever you are reading exact input "
<< "\n(i.e. *.e files), otherwise avoid using this flag."
<< "\nexample: demo input_files\\window.f\n";
// CGAL_postcondition(x1>x0);
}
//DEBUG
//bool Init (char *filename , Planar_map & pm, CGAL::Window_stream& W)
bool Init (char *filename , Planar_map & pm)
{
int num_points, num_curves, i;
Pm_point *pnts;
Pm_curve *cvs;
#ifdef CGAL_PM_TIMER
// ReadFile shouldn't be included in construction time.
t_construction.stop();
#endif
if (!ReadFile (filename, num_points, pnts, num_curves, cvs ))
return false;
#ifdef CGAL_PM_TIMER
t_construction.start();
#endif
for (i = 0; i < num_curves; i++)
{
#ifdef CGAL_PM_DEBUG
std::cout << "inserting curve: i\n";
std::cout << cvs[i] << std::endl;
// W << cvs[i] ;
#endif
#ifdef CGAL_PM_TIMER
t_insert.start();
#endif
pm.insert (cvs[i]);
#ifdef CGAL_PM_TIMER
t_insert.stop();
n_insert++;
#endif
}
delete[] cvs;
delete[] pnts;
return true;
}
///////////////////////////////////////////////////////////////////////
CGAL::Window_stream& operator<<(CGAL::Window_stream& os, Planar_map &M)
{
Halfedge_iterator it = M.halfedges_begin();
while(it != M.halfedges_end()){
os << (*it).curve();
++it;
}
return os;
}
//function needed for window input
Vertex_handle closest_vertex(Planar_map &M, const Pm_point& p)
{
Vertex_handle v;
Vertex_iterator vi = M.vertices_begin();
if (vi==M.vertices_end())
return vi;
else v=vi;
#ifndef USE_LEDA_RAT_KERNEL
Rep::FT d = CGAL::squared_distance(p, (*vi).point());
for (; vi!=M.vertices_end(); ++vi)
{
Rep::FT d2 = CGAL::squared_distance(p, (*vi).point());
if(d2 < d){
d = d2;
v = vi;
}
}
#else
for (; vi!=M.vertices_end(); ++vi)
if(p.cmp_dist(vi->point(),v->point())<0){v = vi;}
#endif
return v;
}
void window_input(Planar_map & M, CGAL::Window_stream &W )
{
std::cerr << "1.Left button: start or end edge at mouse position."
<< std::endl;
std::cerr << "2.Middle button: start or end edge at closest vertex \
from mouse position"
<< std::endl;
std::cerr << "3.Right button: remove the edge directly above the mouse \
position"
<< std::endl;
Pm_point p;
Pm_point first_point;
// Vertex_handle last_vertex;
bool start_flag = true;
while(1) {
double x, y;
int b = W.get_mouse(x,y);
if (b==10) break;
#ifndef USE_LEDA_RAT_KERNEL
p = Pm_point(Rep::FT(x), Rep::FT(y));
#else
p = Pm_point(leda_rational(x),leda_rational(y));
#endif
if (b == MOUSE_BUTTON(1))
{
if (start_flag)
{
first_point=p;
start_flag=false;
}
else
{
start_flag=true;
#ifdef CGAL_PM_TIMER
t_insert.start();
#endif
#ifdef CGAL_PM_DEBUG
Halfedge_handle e=
#endif
M.insert(Pm_curve(first_point,p));
#ifdef CGAL_PM_TIMER
t_insert.stop();
n_insert++;
#endif
#ifdef CGAL_PM_DEBUG
Traits_wrap traits=M.get_traits();
CGAL_postcondition(traits.point_equal(e->source()->point(),
first_point));
CGAL_postcondition(traits.point_equal(e->target()->point(),p));
#endif
}
W << M;
}
else
if (b==MOUSE_BUTTON(2))
{
if (M.number_of_vertices()==0) { //an empty map do nothing
start_flag=true;
}
else {
Vertex_handle v=closest_vertex(M,p);
if (start_flag) {
first_point=v->point();
start_flag=false;
}
else //insert fromfirst_point to nearest
{
#ifdef CGAL_PM_TIMER
t_insert.start();
#endif
#ifdef CGAL_PM_DEBUG
Halfedge_handle e=
#endif
M.insert(Pm_curve(first_point,v->point()));
#ifdef CGAL_PM_TIMER
t_insert.stop();
n_insert++;
#endif
#ifdef CGAL_PM_DEBUG
Traits_wrap traits=M.get_traits();
CGAL_postcondition(traits.point_equal(e->source()->point(),
first_point));
CGAL_postcondition(traits.point_equal(e->target()->point(),
v->point()));
#endif
start_flag=true;
}
}
W << M;
}
else if(b == MOUSE_BUTTON(3))
{
start_flag=true;
Planar_map::Locate_type l;
Halfedge_handle e;
#ifdef CGAL_PM_TIMER
t_vertical.start();
#endif
e=M.vertical_ray_shoot(p,l,true);
#ifdef CGAL_PM_TIMER
t_vertical.stop();
n_vertical++;
#endif
if (l!=Planar_map::UNBOUNDED_FACE)
{
#ifdef CGAL_PM_TIMER
t_remove.start();
#endif
M.remove_edge(e);
#ifdef CGAL_PM_TIMER
t_remove.stop();
n_remove++;
#endif
W.clear();
W << M;
#ifdef CGAL_PM_DEBUG
std::cout << "\nremove()" << std::flush;
M.debug();
#endif
}
}
if (!M.is_valid()) {
std::cerr << "map is not valid - aborting" << std::endl;
exit(1);
}
}
}
#endif

112
Packages/Planar_map/demo/Planar_map/Leda_window/draw_map.h Normal file
View File

@ -0,0 +1,112 @@
#ifndef __DRAW_MAP_H
#define __DRAW_MAP_H
#include <iostream>
// if LEDA is not installed, a message will be issued in runtime by demo.C.
#ifdef CGAL_USE_LEDA
#include "configuration"
#include <CGAL/Cartesian.h>
#include <CGAL/squared_distance_2.h>
#include <CGAL/Point_2.h>
#include <CGAL/predicates_on_points_2.h>
#include <CGAL/Segment_2.h>
#include <CGAL/Pm_segment_traits_2.h>
#ifdef USE_RATIONAL
#include <CGAL/leda_rational.h>
#else
#if defined (USE_LEDA_RAT_KERNEL)
#include <CEP/Leda_rat_kernel/leda_rat_kernel_traits.h>
#endif
#endif
#include <CGAL/Pm_default_dcel.h>
#include <CGAL/Planar_map_2.h>
#include <CGAL/IO/Window_stream.h>
//#define CGAL_PM_DEBUG
#ifdef CGAL_PM_DEBUG
#include <CGAL/IO/Planar_map_iostream.h>
#endif
#ifdef CGAL_PM_TIMER
#include <CGAL/Timer.h>
#endif
#define BUNDLE 100
#define WIDE_PRECISION 10
#if defined(USE_RATIONAL) || defined(USE_LEDA_RAT_KERNEL)
#if defined(USE_RATIONAL) && defined(USE_LEDA_RAT_KERNEL)
#error only one kernel should be defined
#endif
typedef leda_rational number_type;
#else
typedef double number_type;
#endif
#ifdef USE_LEDA_RAT_KERNEL
typedef CGAL::leda_rat_kernel_traits Rep;
#else
typedef CGAL::Cartesian<number_type> Rep;
#endif
typedef CGAL::Pm_segment_traits_2<Rep> Traits;
typedef CGAL::Pm_default_dcel<Traits> Dcel;
typedef CGAL::Planar_map_2<Dcel,Traits> Planar_map;
typedef Planar_map::Traits_wrap Traits_wrap;
typedef Planar_map::Vertex Vertex;
typedef Planar_map::Halfedge Halfedge;
typedef Planar_map::Face Face;
typedef Planar_map::Vertex_handle Vertex_handle;
typedef Planar_map::Halfedge_handle Halfedge_handle;
typedef Planar_map::Face_handle Face_handle;
typedef Planar_map::Vertex_iterator Vertex_iterator;
typedef Planar_map::Halfedge_iterator Halfedge_iterator;
typedef Planar_map::Ccb_halfedge_circulator Ccb_halfedge_circulator;
typedef Traits::Point Pm_point;
typedef Traits::X_curve Pm_curve;
extern int draw_pm (Planar_map & pm , CGAL::Window_stream & W);
extern bool Init (char *filename , Planar_map & pm) ;
extern void win_border( double &x0 , double &x1 , double &y0 ,
Planar_map &pm);
extern CGAL::Window_stream& operator<<(CGAL::Window_stream& os,
Planar_map &M);
extern void window_input(Planar_map & M, CGAL::Window_stream &W );
#ifdef CGAL_PM_TIMER
extern CGAL::Timer t_total,t_construction,t_insert,t_remove,t_locate,t_vertical;
extern int n_total,n_insert,n_remove,n_locate,n_vertical;
#endif
/* move to Eyals leda_rat ? */
#ifdef USE_LEDA_RAT_KERNEL
inline CGAL::Window_stream& operator<<(CGAL::Window_stream& os, const Pm_point& p){
return os << leda_point(p.xcoordD(),p.ycoordD());
}
inline CGAL::Window_stream& operator<<(CGAL::Window_stream& os, const Pm_curve& c){
leda_segment s(c.xcoord1D(),c.ycoord1D(),c.xcoord2D(),c.ycoord2D());
return os << s;
}
#endif
#endif // CGAL_USE_LEDA
#endif // __DRAW_MAP_H

428
Packages/Planar_map/demo/Planar_map/Leda_window/helputil.C Normal file
View File

@ -0,0 +1,428 @@
#include <iostream>
// if LEDA is not installed, a message will be issued in runtime.
#ifndef CGAL_USE_LEDA
int main()
{
std::cout << "Sorry, helputil needs LEDA..";
std::cout << std::endl;
return 0;
}
#else
#include <CGAL/basic.h>
#include <CGAL/Cartesian.h>
#include <CGAL/Point_2.h>
#include <CGAL/leda_rational.h>
#include <iostream>
#include <fstream>
#include <cassert>
#include <cstdlib>
#include <ctime>
#include "read_inp.h"
#include "inter.h"
typedef PM_input< CGAL::Cartesian<double> > pminpD;
typedef pminpD::Point pntD;
typedef PM_input< CGAL::Cartesian<leda_rational> > pminpR;
typedef pminpR::Point pntR;
void print_help()
{
std::cout << "Utilities program for CGAL Planar Map package" << std::endl;
std::cout << "---------------------------------------------" << std::endl;
std::cout << "The program handles input files for the Planar Map";
std::cout << std::endl;
std::cout << "example program dctest." << std::endl;
std::cout << "The Input file should be at the following format:";
std::cout << std::endl;
std::cout << " <n = number of points>" << std::endl;
std::cout << " <x1> <y1> " << std::endl;
std::cout << " ..." << std::endl;
std::cout << " <xn> <yn>" << std::endl;
std::cout << " <k = number of curves>" << std::endl;
std::cout << " <s1> <t1>" << std::endl;
std::cout << " ..." << std::endl;
std::cout << " <sk> <tk>" << std::endl;
std::cout << " Where xi, yi are the coordinates of point i (for ";
std::cout << std::endl;
std::cout << " rational version in rational format), and si, ti ";
std::cout << std::endl;
std::cout << " are the indices (in the the above list of points) ";
std::cout << std::endl;
std::cout << " of the source and the target of curve i." << std::endl;
std::cout << "" << std::endl;
std::cout << "Usages:" << std::endl;
std::cout << "* The first parameter is always 'e' or 'f' indicates that ";
std::cout << std::endl;
std::cout << " the input file is:" << std::endl;
std::cout << " 'e' --- exact calculations (leda_rationals)." << std::endl;
std::cout << " 'f' --- floating point (double)." << std::endl;
std::cout << "" << std::endl;
std::cout << "1. Intersect Line Segments:" << std::endl;
std::cout << " **** helputil <e/f> i <input_file> <output_file>";
std::cout << std::endl;
std::cout << " " << std::endl;
std::cout << "2. Convert rationals file to doubles file (and vice versa)";
std::cout << std::endl;
std::cout << " **** helputil <e/f> c <input_file> <output_file>";
std::cout << std::endl;
std::cout << "" << std::endl;
std::cout << "3. Create random (not intersected) file with <num> segments";
std::cout << std::endl;
std::cout << " **** helputil <e/f> r <num> <output_file>" << std::endl;
std::cin.get();
exit(1);
}
void convert(const pminpR &i1, pminpD &i2)
// convert from rationals to doubles
{
i2.alloc(i1.get_num_pnts(), i1.get_num_cvs());
pntD pD;
pntR pR;
int i,k, j;
for(i = 0; i < i1.get_num_pnts(); i++)
{
i1.get(i, pR);
pD = pntD(CGAL::to_double(pR.x()), CGAL::to_double(pR.y()));
i2.set(i, pD);
}
for(i = 0; i < i1.get_num_cvs(); i++)
{
i1.get(i, k, j);
i2.set(i, k, j);
}
}
void convert(const pminpD &i1, pminpR &i2)
// convert from rationals to doubles
{
i2.alloc(i1.get_num_pnts(), i1.get_num_cvs());
pntD pD;
pntR pR;
int i,k, j;
for(i = 0; i < i1.get_num_pnts(); i++)
{
i1.get(i, pD);
pR = pntR(leda_rational(pD.x()), leda_rational(pD.y()));
i2.set(i, pR);
}
for(i = 0; i < i1.get_num_cvs(); i++)
{
i1.get(i, k, j);
i2.set(i, k, j);
}
}
void intersect(const pminpD &in, pminpD &out)
{
pntD p;
int k, j;
Lines<double> l(1);
int nc, np;
int intr_nc, intr_np;
nc = in.get_num_cvs();
np = in.get_num_pnts();
Lines<double>::pmcurve *cvs = new Lines<double>::pmcurve[nc];
Lines<double>::pmpoint *pnts = new Lines<double>::pmpoint[np];
Lines<double>::pmcurve *intr_cvs;
Lines<double>::pmpoint *intr_pnts;
int i;
for(i = 0; i < in.get_num_pnts(); i++)
{
in.get(i, p);
pnts[i].x = p.x();
pnts[i].y = p.y();
pnts[i].n = i;
}
for(i = 0; i < in.get_num_cvs(); i++)
{
in.get(i, k, j);
cvs[i].s = pnts[k];
cvs[i].t = pnts[j];
}
l.Intersect(pnts, np, cvs, nc, intr_pnts, intr_np, intr_cvs, intr_nc);
out.alloc(intr_np, intr_nc);
for(i = 0; i < intr_np; i++)
{
p = pntD(intr_pnts[i].x, intr_pnts[i].y);
out.set(i, p);
}
for(i = 0; i < intr_nc; i++)
{
out.set(i, intr_cvs[i].s.n, intr_cvs[i].t.n);
}
if (cvs != NULL) delete[] cvs;
if (pnts != NULL) delete[] pnts;
if (intr_cvs != NULL) delete[] intr_cvs;
if (intr_pnts != NULL) delete[] intr_pnts;
}
void intersect(const pminpR &in, pminpR &out)
{
pntR p;
int k, j;
Lines<leda_rational> l(0);
int nc, np;
int intr_nc, intr_np;
nc = in.get_num_cvs();
np = in.get_num_pnts();
Lines<leda_rational>::pmcurve *cvs = new Lines<leda_rational>::pmcurve[nc];
Lines<leda_rational>::pmpoint *pnts = new Lines<leda_rational>::pmpoint[np];
Lines<leda_rational>::pmcurve *intr_cvs;
Lines<leda_rational>::pmpoint *intr_pnts;
int i;
for(i = 0; i < in.get_num_pnts(); i++)
{
in.get(i, p);
pnts[i].x = p.x();
pnts[i].y = p.y();
pnts[i].n = i;
}
for(i = 0; i < in.get_num_cvs(); i++)
{
in.get(i, k, j);
cvs[i].s = pnts[k];
cvs[i].t = pnts[j];
}
l.Intersect(pnts, np, cvs, nc, intr_pnts, intr_np, intr_cvs, intr_nc);
out.alloc(intr_np, intr_nc);
for(i = 0; i < intr_np; i++)
{
p = pntR(intr_pnts[i].x, intr_pnts[i].y);
out.set(i, p);
}
for(i = 0; i < intr_nc; i++)
{
out.set(i, intr_cvs[i].s.n, intr_cvs[i].t.n);
}
if (cvs != NULL) delete[] cvs;
if (pnts != NULL) delete[] pnts;
if (intr_cvs != NULL) delete[] intr_cvs;
if (intr_pnts != NULL) delete[] intr_pnts;
}
void random(int num, pminpD &out, int max = 200)
{
srand( (unsigned)time( NULL ) );
out.alloc(num*2, num);
pntD p;
int i;
for (i =0; i < num*2; i++)
{
p = pntD(rand() % max, rand() % max);
out.set(i, p);
}
for (i =0; i < num; i++)
{
out.set(i, i*2, i*2+1);
}
}
void random(int num, pminpR &out, int max = 200)
{
srand( (unsigned)time( NULL ) );
out.alloc(num*2, num);
pntR p;
int i;
for (i =0; i < num*2; i++)
{
p = pntR(leda_rational(rand() % max),
leda_rational(rand() % max));
out.set(i, p);
}
for (i =0; i < num; i++)
{
out.set(i, i*2, i*2+1);
}
}
int main(int argc, char *argv[])
{
if (argc < 3)
print_help();
bool use_rational;
switch (argv[1][0])
{
case 'e':
use_rational = true;
break;
case 'f':
use_rational = false;
break;
default:
print_help();
};
switch (argv[2][0])
{
case 'r': // generate random file argv[4] with argv[3] curves
if (argc < 5)
print_help();
if (use_rational)
{
std::cout << "Create random file using rationals with ";
std::cout << CGAL_CLIB_STD::atoi(argv[3])
<< "segments" << std::endl;
std::cout << "Attention: the segments might intersect.";
std::cout << std::endl;
std::cout << " Split them using the i parameter of "
"helputil before running the demo.";
std::cout << std::endl;
pminpR rnd;
random(CGAL_CLIB_STD::atoi(argv[3]), rnd);
std::ofstream f(argv[4]);
f << rnd;
f.close();
}
else
{
std::cout << "Create random file using doubles with ";
std::cout << CGAL_CLIB_STD::atoi(argv[3])
<< " segments" << std::endl;
std::cout << "Attention: the segments might intersect.";
std::cout << std::endl;
std::cout << "Split them using the i parameter of helputil "
"before running the demo";
std::cout << std::endl;
pminpD rnd;
random(CGAL_CLIB_STD::atoi(argv[3]), rnd);
std::ofstream f(argv[4]);
f << rnd;
f.close();
}
break;
case 'i': // intersect argv[3] to argv[4]
if (argc < 5)
print_help();
std::cout << "Intersect the segments in " << argv[3]
<< " and write the intersected segments in ";
std::cout << argv[4] << std::endl;
if (use_rational)
{
pminpR inpR1;
pminpR inpR2;
std::ifstream in(argv[3]);
in >> inpR1;
in.close();
intersect(inpR1, inpR2);
std::ofstream out(argv[4]);
out << inpR2;
out.close();
}
else
{
pminpD inpD1;
pminpD inpD2;
std::ifstream in(argv[3]);
in >> inpD1;
in.close();
intersect(inpD1, inpD2);
std::ofstream out(argv[4]);
out << inpD2;
out.close();
}
break;
case 'c': // convert argv[3] to argv[4] switching from rationals to doubles
if (argc < 5)
print_help();
std::cout << "Convert the numbers in " << argv[3]
<< " and write the new file " << argv[4] << std::endl;
if (use_rational)
{
pminpR inpR;
pminpD inpD;
std::ifstream in(argv[3]);
in >> inpR;
in.close();
convert(inpR, inpD);
std::ofstream out(argv[4]);
out << inpD;
out.close();
}
else
{
pminpR inpR;
pminpD inpD;
std::ifstream in(argv[3]);
in >> inpD;
in.close();
convert(inpD, inpR);
std::ofstream out(argv[4]);
out << inpR;
out.close();
}
break;
default:
print_help();
break;
};
return 0;
}
#endif // CGAL_USE_LEDA

64
Packages/Planar_map/demo/Planar_map/Leda_window/input_files/grid.e Normal file
View File

@ -0,0 +1,64 @@
24
10/1 10/1
50/1 10/1
90/1 10/1
130/1 10/1
170/1 10/1
210/1 10/1
10/1 50/1
50/1 50/1
90/1 50/1
130/1 50/1
170/1 50/1
210/1 50/1
10/1 90/1
50/1 90/1
90/1 90/1
130/1 90/1
170/1 90/1
210/1 90/1
10/1 130/1
50/1 130/1
90/1 130/1
130/1 130/1
170/1 130/1
210/1 130/1
38
20 21
1 7
13 14
3 9
4 10
6 12
21 22
11 17
3 4
12 18
16 22
0 6
22 23
9 15
9 10
15 21
1 2
19 20
2 3
8 14
10 16
7 8
7 13
16 17
14 15
2 8
13 19
14 20
6 7
10 11
17 23
18 19
0 1
5 11
12 13
8 9
4 5
15 16

64
Packages/Planar_map/demo/Planar_map/Leda_window/input_files/grid.f Normal file
View File

@ -0,0 +1,64 @@
24
10 10
50 10
90 10
130 10
170 10
210 10
10 50
50 50
90 50
130 50
170 50
210 50
10 90
50 90
90 90
130 90
170 90
210 90
10 130
50 130
90 130
130 130
170 130
210 130
38
20 21
1 7
13 14
3 9
4 10
6 12
21 22
11 17
3 4
12 18
16 22
0 6
22 23
9 15
9 10
15 21
1 2
19 20
2 3
8 14
10 16
7 8
7 13
16 17
14 15
2 8
13 19
14 20
6 7
10 11
17 23
18 19
0 1
5 11
12 13
8 9
4 5
15 16

41
Packages/Planar_map/demo/Planar_map/Leda_window/input_files/md.e Normal file
View File

@ -0,0 +1,41 @@
14
120/1 10/1
20/1 63/1
87/1 63/1
155/1 63/1
220/1 63/1
53/1 120/1
187/1 120/1
20/1 180/1
87/1 180/1
155/1 180/1
220/1 180/1
120/1 240/1
100/1 120/1
140/1 120/1
25
12 13
9 10
3 4
5 8
9 11
6 9
4 6
0 2
5 2
8 11
1 5
5 7
1 2
6 10
2 3
3 6
0 3
8 9
7 8
5 12
9 13
8 12
2 12
3 13
13 6

41
Packages/Planar_map/demo/Planar_map/Leda_window/input_files/md.f Normal file
View File

@ -0,0 +1,41 @@
14
120 10
20 63
87 63
155 63
220 63
53 120
187 120
20 180
87 180
155 180
220 180
120 240
100 120
140 120
25
12 13
9 10
3 4
5 8
9 11
6 9
4 6
0 2
5 2
8 11
1 5
5 7
1 2
6 10
2 3
3 6
0 3
8 9
7 8
5 12
9 13
8 12
2 12
3 13
13 6

116
Packages/Planar_map/demo/Planar_map/Leda_window/input_files/mess.e Normal file
View File

@ -0,0 +1,116 @@
41
10/1 100/1
200/1 140/1
200/1 180/1
80/1 250/1
80/1 15/1
200/1 60/1
10/1 60/1
10/1 220/1
160/1 2314762247538213/17592186044416
160/1 7154143929938477/35184372088832
160/1 250/1
160/1 45/1
160/1 5/1
598918937007725/8796093022208 7897413790315053/70368744177664
10/1 180/1
4716605815996285/35184372088832 4963853435538925/140737488355328
180/1 105/2
200/1 100/1
5840528361127517/70368744177664 2029575319572185/17592186044416
1212805305902039/8796093022208 2582891791915575/70368744177664
160/1 5518387287156589/35184372088832
4624246839263101/35184372088832 220/1
160/1 220/1
200/1 220/1
10/1 140/1
160/1 3018449689314853/17592186044416
686879867229805/17592186044416 642620565969961/4398046511104
1032063186481709/17592186044416 1321568996121641/8796093022208
4808542580264403/35184372088832 5864073742929363/35184372088832
160/1 2407353441127183/35184372088832
405783562323755/2199023255552 8902631300892983/140737488355328
3295709578249267/35184372088832 2898675049850051/35184372088832
7609324151651697/70368744177664 2791528081527931/35184372088832
3368819185012651/70368744177664 7597924415094915/70368744177664
2609160444117097/70368744177664 6635723317832791/70368744177664
4741973748272333/35184372088832 958985245653205/4398046511104
2086964548886279/35184372088832 8617778624461799/70368744177664
1218422490906021/17592186044416 1188017915765457/8796093022208
7374785127307543/70368744177664 6336107278873133/35184372088832
1508485972843561/17592186044416 1371724318534271/8796093022208
4796192865661223/35184372088832 220/1
73
0 33
2 9
4 15
6 0
0 24
8 1
9 35
10 22
9 25
11 16
8 29
11 12
13 18
14 7
14 26
15 19
13 31
15 12
5 12
16 5
17 30
16 12
18 8
7 27
19 11
18 32
19 12
20 8
1 20
20 28
21 3
22 9
23 22
22 40
21 7
24 14
25 20
2 25
26 36
27 37
28 38
25 28
28 39
27 26
26 24
5 17
17 1
29 11
30 16
5 30
30 29
31 15
32 19
29 32
32 31
31 34
33 13
34 0
6 34
34 33
35 21
36 13
33 36
37 18
36 37
38 7
39 27
37 39
39 38
38 35
40 21
35 40
40 10

116
Packages/Planar_map/demo/Planar_map/Leda_window/input_files/mess.f Normal file
View File

@ -0,0 +1,116 @@
41
10 100
200 140
200 180
80 250
80 15
200 60
10 60
10 220
160 131.579
160 203.333
160 250
160 45
160 5
68.0892 112.229
10 180
134.054 35.2703
180 52.5
200 100
82.9989 115.368
137.88 36.7051
160 156.842
131.429 220
160 220
200 220
10 140
160 171.579
39.0446 146.115
58.666 150.245
136.667 166.667
160 68.4211
184.529 63.257
93.6697 82.3853
108.135 79.34
47.8738 107.973
37.0784 94.2993
134.775 218.048
59.3151 122.466
69.2593 135.062
104.802 180.083
85.7475 155.947
136.316 220
73
0 33
2 9
4 15
6 0
0 24
8 1
9 35
10 22
9 25
11 16
8 29
11 12
13 18
14 7
14 26
15 19
13 31
15 12
5 12
16 5
17 30
16 12
18 8
7 27
19 11
18 32
19 12
20 8
1 20
20 28
21 3
22 9
23 22
22 40
21 7
24 14
25 20
2 25
26 36
27 37
28 38
25 28
28 39
27 26
26 24
5 17
17 1
29 11
30 16
5 30
30 29
31 15
32 19
29 32
32 31
31 34
33 13
34 0
6 34
34 33
35 21
36 13
33 36
37 18
36 37
38 7
39 27
37 39
39 38
38 35
40 21
35 40
40 10

23
Packages/Planar_map/demo/Planar_map/Leda_window/input_files/smallgrid.e Normal file
View File

@ -0,0 +1,23 @@
9
0/1 0/1
0/1 1/1
0/1 2/1
1/1 0/1
1/1 1/1
1/1 2/1
2/1 0/1
2/1 1/1
2/1 2/1
12
0 1
1 2
3 4
4 5
6 7
7 8
0 3
3 6
1 4
4 7
2 5
5 8

34
Packages/Planar_map/demo/Planar_map/Leda_window/input_files/window.e Normal file
View File

@ -0,0 +1,34 @@
15
10/1 10/1
100/1 10/1
200/1 10/1
10/1 200/1
100/1 200/1
200/1 200/1
30/1 30/1
70/1 30/1
30/1 70/1
70/1 70/1
150/1 100/1
120/1 160/1
180/1 160/1
20/1 160/1
80/1 160/1
17
0 1
1 2
2 5
5 4
4 3
3 0
6 7
7 9
9 8
8 6
10 12
12 11
11 10
4 1
8 13
13 14
14 9

34
Packages/Planar_map/demo/Planar_map/Leda_window/input_files/window.f Normal file
View File

@ -0,0 +1,34 @@
15
10 10
100 10
200 10
10 200
100 200
200 200
30 30
70 30
30 70
70 70
150 100
120 160
180 160
20 160
80 160
17
0 1
1 2
2 5
5 4
4 3
3 0
6 7
7 9
9 8
8 6
10 12
12 11
11 10
4 1
8 13
13 14
14 9

370
Packages/Planar_map/demo/Planar_map/Leda_window/inter.h Normal file
View File

@ -0,0 +1,370 @@
#ifndef _INTER_H
#define _INTER_H
#define EPSILON (0.000001)
template<class number_type>
class Lines
{
public:
class pmpoint;
class pmcurve;
Lines(int fp = 1)
{
use_fp = fp;
}
int use_fp;
void Intersect(pmpoint* pnts, int num_points,
pmcurve* cvs, int num_curves,
pmpoint* &intr_pnts, int &intr_np,
pmcurve* &intr_cvs, int &intr_nc)
{
int *cvs2 = new int[num_curves];
int i;
for (i = 0; i < num_curves; i++) // if cvs[i] is false then it was
cvs2[i] = 1; // merged with another curve - hence, should
// be ignored.
// upper boundary for the number of
// intersection points + endpoints.
int PNUM = num_points * (num_points + 1);
pmpoint * pnt_buff = new pmpoint[PNUM];
// initializing with the endpoints.
for (i = 0; i < num_points; i++)
{
pnt_buff[i] = pnts[i];
pnt_buff[i].n = i;
}
PNUM = num_points;
// upper boundary on the number of segments.
int CNUM = num_curves * num_curves;
pmcurve * crv_buff = new pmcurve[CNUM];
CNUM = 0;
int k, n;
// an auxilary points buffer for keeping the intersection
// points of one curve.
pmpoint * pnt_aux_buff = new pmpoint[num_curves];
for (i = 0; i < num_curves; i++)
{
// n = number of intersections of the line
// pnt_aux_buff will contain the n intersection points.
// Intersect is the only place where cvs2[i] can turn to false.
n = Intersect(i, num_curves, cvs, cvs2, pnt_aux_buff);
// sort the n points from source to target.
// if cvs[i] intersects two curves in one point-
// the sort process will eliminate one.
n = Sort(n, pnt_aux_buff, cvs[i]);
if (cvs2[i])
{
// adding the new segments
crv_buff[CNUM].s = cvs[i].s;
for (k = 0; k < n; k++)
{
// add the intersection points to the buffer
pnt_aux_buff[k].n = PNUM;
pnt_buff[PNUM] = pnt_aux_buff[k];
PNUM++;
crv_buff[CNUM].t = pnt_aux_buff[k];
CNUM++;
crv_buff[CNUM].s = pnt_aux_buff[k];
}
crv_buff[CNUM].t = cvs[i].t;
CNUM++;
}
}
intr_np = PNUM;
intr_nc = CNUM;
intr_pnts = pnt_buff;
intr_cvs = crv_buff;
}
int Intersect(int i, int num_curves, pmcurve * cvs,
int* cvs2, pmpoint *pnt_aux_buff)
{
int j, n = 0;
pmcurve cv;
pmpoint p;
for (j = 0; j < num_curves; j++) // checking intersection with every segment
{
if ((j != i) && (cvs2[j]))
{
if ( (!is_vertical(cvs[i])) &&
(!is_vertical(cvs[j])) &&
is_same(a(cvs[i]),a(cvs[j])) )
{
// case 1:the segments have the same derivitive
// (however they are not vertical)
if ( is_same(b(cvs[i]), b(cvs[j])))
// the segments are on the same line
if (is_in_x_range(cvs[i],cvs[j].s) ||
is_in_x_range(cvs[i],cvs[j].t) ||
is_in_x_range(cvs[j],cvs[i].s) )
{
// the segments overlap
if (j > i) // always true (?)
{
cv.s = leftmost( leftmost(cvs[i].s, cvs[j].s),
leftmost(cvs[i].t, cvs[j].t) );
cv.t = rightmost(rightmost(cvs[i].s, cvs[j].s),
rightmost(cvs[i].t, cvs[j].t));
cvs[j] = cv;
cvs2[i] = 0;
return 0;
}
}
// else - the segments don't intersect
// else - the segments don't intersect (parralel)
} // end of case 1.
else
{
if (is_vertical(cvs[i]) && is_vertical(cvs[j]))
{
// case 2: both of the segments are vertical
if ( is_same(cvs[i].s.x, cvs[j].s.x) &&
(is_in_y_range(cvs[i], cvs[j].s) ||
is_in_y_range(cvs[i], cvs[j].t) ||
is_in_y_range(cvs[j], cvs[i].s)) )
{
// the segments overlap
if (j > i) // always true (?)
{
cv.s = lowest( lowest(cvs[i].s, cvs[j].s),
lowest(cvs[i].t, cvs[j].t) );
cv.t = highest(highest(cvs[i].s, cvs[j].s),
highest(cvs[i].t, cvs[j].t));
cvs[j] = cv;
cvs2[i] = 0;
return 0;
}
}
// if the segments are parralel - do nothing
}
else
{
if (is_vertical(cvs[i]))
{
// case 3: cvs[i] is vertical but cvs[j] isn't
p.x = cvs[i].s.x;
p.y = a(cvs[j]) * p.x + b(cvs[j]);
}
else
if (is_vertical(cvs[j]))
{
// case 3: cvs[j] is vertical but cvs[i] isn't
p.x = cvs[j].s.x;
p.y = a(cvs[i]) * p.x + b(cvs[i]);
}
else
{
p.x = (b(cvs[i]) - b(cvs[j]))/(a(cvs[j]) - a(cvs[i]));
p.y = a(cvs[i]) * p.x + b(cvs[i]);
}
if (is_in_x_range(cvs[i],p) && is_in_x_range(cvs[j],p) &&
is_in_y_range(cvs[i],p) && is_in_y_range(cvs[j],p) &&
(!is_same(p,cvs[i].s)) && (!is_same(p,cvs[i].t)))
{
pnt_aux_buff[n] = p;
n++;
}
}
}
}
}
return n;
}
int Sort(int n, pmpoint* buff, pmcurve &cv)
{
if (n == 0) return 0;
int flag1, flag2;
flag1 = flag2 = 0;
if (is_same_x(cv.s, cv.t))
{
flag1 = 1; // indicates that we have to compare on the y-axes
if (is_higher(cv.s, cv.t))
flag2 = 1; // we have to sort from high to low
}
else
if (is_right(cv.s, cv.t))
flag2 = 1;
//cases: flag1 = 0: flag2 = 0 from left to right
// flag2 = 1 from right to left
// flag1 = 1: flag2 = 0 from low to up
// flag2 = 1 from up to low
pmpoint tmp;
int i, j;
for (i = 0; i < n - 1; i++) // buff[i] contains the min in the i+1'th iteration
for (j = i+1; j < n; j++)
{
if ( ((!flag1) && (!flag2) && (is_left(buff[j], buff[i]))) ||
((!flag1) && (flag2) && (is_right(buff[j], buff[i]))) ||
((flag1) && (!flag2) && (is_lower(buff[j], buff[i]))) ||
((flag1) && (flag2) && (is_higher(buff[j], buff[i]))) )
{
tmp = buff[i];
buff[i] = buff[j];
buff[j] = tmp;
}
}
int n2 = n;
for (i = n-1; i > 0; i--)
{
if (is_same(buff[i], buff[i-1]))
{
for (j = i; j < n2 - 1; j++)
buff[j] = buff[j+1];
n2--;
}
}
return n2;
}
class pmpoint
{
public:
number_type x;
number_type y;
int n;
};
int is_left(const pmpoint &p1, const pmpoint &p2)
{
return (p1.x < p2.x);
}
int is_right(const pmpoint &p1, const pmpoint &p2)
{
return (p1.x > p2.x);
}
int is_same_x(const pmpoint &p1, const pmpoint &p2)
{
return (p1.x == p2.x);
}
int is_lower(const pmpoint &p1, const pmpoint &p2)
{
return (p1.y < p2.y);
}
int is_higher(const pmpoint &p1, const pmpoint &p2)
{
return (p1.y > p2.y);
}
int is_same_y(const pmpoint &p1, const pmpoint &p2)
{
return (p1.y == p2.y);
}
int is_same(number_type d1, number_type d2)
{
return (d1 == d2);
}
int is_same(const pmpoint &p1, const pmpoint &p2)
{
if (!use_fp)
{
return is_same_x(p1,p2) && is_same_y(p1,p2);
}
else
{
number_type d = (p1.x - p2.x)*(p1.x - p2.x) +
(p1.y - p2.y)*(p1.y - p2.y);
if (d < EPSILON * EPSILON)
return 1;
else
return 0;
// return (check_left(p1,p2) == 0) && (check_lower(p1,p2) == 0);
}
}
pmpoint leftmost(const pmpoint &p1, const pmpoint &p2)
{ return (is_left(p1, p2) ? p1 : p2); }
pmpoint rightmost(const pmpoint &p1, const pmpoint &p2)
{ return (is_right(p1, p2) ? p1 : p2); }
pmpoint lowest(const pmpoint &p1, const pmpoint &p2)
{ return (is_lower(p1, p2) ? p1 : p2); }
pmpoint highest(const pmpoint &p1, const pmpoint &p2)
{ return (is_higher(p1, p2) ? p1 : p2); }
number_type a(pmcurve &c)
{
if (is_same_x(c.s ,c.t))
return 0;
return (c.t.y - c.s.y)/(c.t.x - c.s.x);
}
number_type b(pmcurve &c)
{
if (is_same_x(c.s ,c.t))
return 0;
return (c.t.y * c.s.x - c.s.y * c.t.x )/(c.s.x - c.t.x);
}
int is_vertical(pmcurve &c)
{
return (c.s.x == c.t.x);
}
class pmcurve
{
public:
pmpoint s;
pmpoint t;
};
int is_in_x_range(pmcurve &cv, pmpoint &q)
{
int r = !( is_right(q, rightmost(cv.t, cv.s)) ||
is_left(q, leftmost(cv.t, cv.s)) );
return r;
}
int is_in_y_range(pmcurve &cv, pmpoint &q)
{
int r = !( is_higher(q, highest(cv.t, cv.s)) ||
is_lower(q, lowest(cv.t, cv.s)) );
return r;
}
};
#endif

209
Packages/Planar_map/demo/Planar_map/Leda_window/makefile Normal file
View File

@ -0,0 +1,209 @@
# This is the makefile for compiling a CGAL application.
#---------------------------------------------------------------------#
# include platform specific settings
#---------------------------------------------------------------------#
# Choose the right include file from the <cgalroot>/make directory.
OBJ_EXT = .wrong_cgal_makefile
#CGAL_MAKEFILE = ENTER_YOUR_INCLUDE_MAKEFILE_HERE
include $(CGAL_MAKEFILE)
#---------------------------------------------------------------------#
# compiler flags
#---------------------------------------------------------------------#
CXXFLAGS = \
-I../../../include \
-I../../../../Trapezoidal_decomposition/include \
-I../../../../Sweep_line_2/include \
$(EXTRA_FLAGS) \
$(CGAL_CXXFLAGS) \
$(LONG_NAME_PROBLEM_CXXFLAGS) \
$(DEBUG_OPT)
#---------------------------------------------------------------------#
# linker flags
#---------------------------------------------------------------------#
LIBPATH = \
$(CGAL_WINDOW_LIBPATH)
LDFLAGS = \
$(LONG_NAME_PROBLEM_LDFLAGS) \
$(CGAL_WINDOW_LDFLAGS)
#---------------------------------------------------------------------#
# target entries
#---------------------------------------------------------------------#
demo$(EXE_EXT): demo$(OBJ_EXT) draw_map$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo demo$(OBJ_EXT) draw_map$(OBJ_EXT) $(LDFLAGS)
helputil$(EXE_EXT): helputil$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)helputil helputil$(OBJ_EXT) $(LDFLAGS)
###########################################################################
#The following lines compile the demo with different options, we use
#them for experiments only.
demo.all: \
demo.float.rebuild\
demo.rational.rebuild\
demo.leda.rational.rebuild\
demo.float.no-rebuild\
demo.rational.no-rebuild\
demo.leda.rational.no-rebuild\
demo.float.walk\
demo.rational.walk\
demo.leda.rational.walk\
demo.float.naive\
demo.rational.naive\
demo.leda.rational.naive
# executables ... default strategy
demo.float.rebuild$(EXE_EXT): demo.float.rebuild$(OBJ_EXT) draw_map.float.rebuild$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.float.rebuild demo.float.rebuild$(OBJ_EXT) draw_map.float.rebuild$(OBJ_EXT) $(LDFLAGS)
demo.rational.rebuild$(EXE_EXT): demo.rational.rebuild$(OBJ_EXT) draw_map.rational.rebuild$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.rational.rebuild demo.rational.rebuild$(OBJ_EXT) draw_map.rational.rebuild$(OBJ_EXT) $(LDFLAGS)
demo.leda.rational.rebuild$(EXE_EXT): demo.leda.rational.rebuild$(OBJ_EXT) draw_map.leda.rational.rebuild$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.leda.rational.rebuild demo.leda.rational.rebuild$(OBJ_EXT) draw_map.leda.rational.rebuild$(OBJ_EXT) $(LDFLAGS)
# executables ... default strategy without rebuilds
demo.float.no-rebuild$(EXE_EXT): demo.float.no-rebuild$(OBJ_EXT) draw_map.float.no-rebuild$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.float.no-rebuild demo.float.no-rebuild$(OBJ_EXT) draw_map.float.no-rebuild$(OBJ_EXT) $(LDFLAGS)
demo.rational.no-rebuild$(EXE_EXT): demo.rational.no-rebuild$(OBJ_EXT) draw_map.rational.no-rebuild$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.rational.no-rebuild demo.rational.no-rebuild$(OBJ_EXT) draw_map.rational.no-rebuild$(OBJ_EXT) $(LDFLAGS)
demo.leda.rational.no-rebuild$(EXE_EXT): demo.leda.rational.no-rebuild$(OBJ_EXT) draw_map.leda.rational.no-rebuild$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.leda.rational.no-rebuild demo.leda.rational.no-rebuild$(OBJ_EXT) draw_map.leda.rational.no-rebuild$(OBJ_EXT) $(LDFLAGS)
# executables ... walk strategy
demo.float.walk$(EXE_EXT): demo.float.walk$(OBJ_EXT) draw_map.float.walk$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.float.walk demo.float.walk$(OBJ_EXT) draw_map.float.walk$(OBJ_EXT) $(LDFLAGS)
demo.rational.walk$(EXE_EXT): demo.rational.walk$(OBJ_EXT) draw_map.rational.walk$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.rational.walk demo.rational.walk$(OBJ_EXT) draw_map.rational.walk$(OBJ_EXT) $(LDFLAGS)
demo.leda.rational.walk$(EXE_EXT): demo.leda.rational.walk$(OBJ_EXT) draw_map.leda.rational.walk$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.leda.rational.walk demo.leda.rational.walk$(OBJ_EXT) draw_map.leda.rational.walk$(OBJ_EXT) $(LDFLAGS)
# executables ... naive strategy
demo.float.naive$(EXE_EXT): demo.float.naive$(OBJ_EXT) draw_map.float.naive$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.float.naive demo.float.naive$(OBJ_EXT) draw_map.float.naive$(OBJ_EXT) $(LDFLAGS)
demo.rational.naive$(EXE_EXT): demo.rational.naive$(OBJ_EXT) draw_map.rational.naive$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.rational.naive demo.rational.naive$(OBJ_EXT) draw_map.rational.naive$(OBJ_EXT) $(LDFLAGS)
demo.leda.rational.naive$(EXE_EXT): demo.leda.rational.naive$(OBJ_EXT) draw_map.leda.rational.naive$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.leda.rational.naive demo.leda.rational.naive$(OBJ_EXT) draw_map.leda.rational.naive$(OBJ_EXT) $(LDFLAGS)
# demo object files
demo.float.rebuild$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) $(EXE_OPT)demo.float.rebuild$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.rational.rebuild$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_RATIONAL $(EXE_OPT)demo.rational.rebuild$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.leda.rational.rebuild$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)demo.leda.rational.rebuild$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.float.no-rebuild$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_DEFAULT_WITHOUT_REBUILD $(EXE_OPT)demo.float.no-rebuild$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.rational.no-rebuild$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_DEFAULT_WITHOUT_REBUILD -DUSE_RATIONAL $(EXE_OPT)demo.rational.no-rebuild$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.leda.rational.no-rebuild$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_DEFAULT_WITHOUT_REBUILD -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)demo.leda.rational.no-rebuild$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.float.walk$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_WALK_POINT_LOCATION $(EXE_OPT)demo.float.walk$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.rational.walk$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_WALK_POINT_LOCATION -DUSE_RATIONAL $(EXE_OPT)demo.rational.walk$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.leda.rational.walk$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_WALK_POINT_LOCATION -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)demo.leda.rational.walk$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.float.naive$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_NAIVE_POINT_LOCATION $(EXE_OPT)demo.float.naive$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.rational.naive$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_NAIVE_POINT_LOCATION -DUSE_RATIONAL $(EXE_OPT)demo.rational.naive$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.leda.rational.naive$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_NAIVE_POINT_LOCATION -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)demo.leda.rational.naive$(OBJ_EXT) $(OBJ_OPT) demo.C
#draw_map object file
draw_map.float.rebuild$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) $(EXE_OPT)draw_map.float.rebuild$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.rational.rebuild$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_RATIONAL $(EXE_OPT)draw_map.rational.rebuild$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.leda.rational.rebuild$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)draw_map.leda.rational.rebuild$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.float.no-rebuild$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_DEFAULT_WITHOUT_REBUILD $(EXE_OPT)draw_map.float.no-rebuild$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.rational.no-rebuild$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_DEFAULT_WITHOUT_REBUILD -DUSE_RATIONAL $(EXE_OPT)draw_map.rational.no-rebuild$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.leda.rational.no-rebuild$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_DEFAULT_WITHOUT_REBUILD -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)draw_map.leda.rational.no-rebuild$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.float.walk$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_WALK_POINT_LOCATION $(EXE_OPT)draw_map.float.walk$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.rational.walk$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_WALK_POINT_LOCATION -DUSE_RATIONAL $(EXE_OPT)draw_map.rational.walk$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.leda.rational.walk$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_WALK_POINT_LOCATION -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)draw_map.leda.rational.walk$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.float.naive$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_NAIVE_POINT_LOCATION $(EXE_OPT)draw_map.float.naive$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.rational.naive$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_NAIVE_POINT_LOCATION -DUSE_RATIONAL $(EXE_OPT)draw_map.rational.naive$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.leda.rational.naive$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_NAIVE_POINT_LOCATION -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)draw_map.leda.rational.naive$(OBJ_EXT) $(OBJ_OPT) draw_map.C
all: demo \
helputil
#---------------------------------------------------------------------#
# suffix rules
#---------------------------------------------------------------------#
.C$(OBJ_EXT):
$(CGAL_CXX) $(CXXFLAGS) $(OBJ_OPT) $<
clean:
rm -f -r *$(OBJ_EXT) demo$(EXE_EXT) \
demo.float.rebuild$(EXE_EXT) \
demo.rational.rebuild$(EXE_EXT) \
demo.leda.rational.rebuild$(EXE_EXT) \
demo.float.no-rebuild$(EXE_EXT) \
demo.rational.no-rebuild$(EXE_EXT) \
demo.leda.rational.no-rebuild$(EXE_EXT) \
demo.float.walk$(EXE_EXT) \
demo.rational.walk$(EXE_EXT) \
demo.leda.rational.walk$(EXE_EXT) \
demo.float.naive$(EXE_EXT) \
demo.rational.naive$(EXE_EXT) \
demo.leda.rational.naive$(EXE_EXT) \
helputil$(EXE_EXT) \
ii_files \
core
# note - we use many compile flag dependent executables for optimization

232
Packages/Planar_map/demo/Planar_map/Leda_window/makefile.ms Normal file
View File

@ -0,0 +1,232 @@
# This is the makefile for compiling a CGAL application.
#---------------------------------------------------------------------#
# include platform specific settings
#---------------------------------------------------------------------#
# Choose the right include file from the <cgalroot>/make directory.
OBJ_EXT = .wrong_cgal_makefile
#CGAL_MAKEFILE = ENTER_YOUR_INCLUDE_MAKEFILE_HERE
!include $(CGAL_MAKEFILE)
#---------------------------------------------------------------------#
# compiler flags
#---------------------------------------------------------------------#
CXXFLAGS = \
$(EXTRA_FLAGS) \
$(CGAL_CXXFLAGS) \
$(LONG_NAME_PROBLEM_CXXFLAGS) \
$(DEBUG_OPT)
#---------------------------------------------------------------------#
# linker flags
#---------------------------------------------------------------------#
LIBPATH = \
$(CGAL_WINDOW_LIBPATH)
LDFLAGS = \
$(LONG_NAME_PROBLEM_LDFLAGS) \
$(CGAL_WINDOW_LDFLAGS)
#---------------------------------------------------------------------#
# target entries
#---------------------------------------------------------------------#
demo: demo$(EXE_EXT)
demo$(EXE_EXT): demo$(OBJ_EXT) draw_map$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo demo$(OBJ_EXT) draw_map$(OBJ_EXT) $(LDFLAGS)
helputil: helputil$(EXE_EXT)
helputil$(EXE_EXT): helputil$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)helputil helputil$(OBJ_EXT) $(LDFLAGS)
###########################################################################
#The following lines compile the demo with different options, we use
#them for experiments only.
demo.all: \
demo.float.rebuild\
demo.rational.rebuild\
demo.leda.rational.rebuild\
demo.float.no-rebuild\
demo.rational.no-rebuild\
demo.leda.rational.no-rebuild\
demo.float.walk\
demo.rational.walk\
demo.leda.rational.walk\
demo.float.naive\
demo.rational.naive\
demo.leda.rational.naive
demo.float.rebuild: demo.float.rebuild$(EXE_EXT)
demo.rational.rebuild: demo.rational.rebuild$(EXE_EXT)
demo.leda.rational.rebuild: demo.leda.rational.rebuild$(EXE_EXT)
demo.float.no-rebuild: demo.float.no-rebuild$(EXE_EXT)
demo.rational.no-rebuild: demo.rational.no-rebuild$(EXE_EXT)
demo.leda.rational.no-rebuild: demo.leda.rational.no-rebuild$(EXE_EXT)
demo.float.walk: demo.float.walk$(EXE_EXT)
demo.rational.walk: demo.rational.walk$(EXE_EXT)
demo.leda.rational.walk: demo.leda.rational.walk$(EXE_EXT)
demo.float.naive: demo.float.naive$(EXE_EXT)
demo.rational.naive: demo.rational.naive$(EXE_EXT)
demo.leda.rational.naive: demo.leda.rational.naive$(EXE_EXT)
# executables ... default strategy
demo.float.rebuild$(EXE_EXT): demo.float.rebuild$(OBJ_EXT) draw_map.float.rebuild$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.float.rebuild demo.float.rebuild$(OBJ_EXT) draw_map.float.rebuild$(OBJ_EXT) $(LDFLAGS)
demo.rational.rebuild$(EXE_EXT): demo.rational.rebuild$(OBJ_EXT) draw_map.rational.rebuild$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.rational.rebuild demo.rational.rebuild$(OBJ_EXT) draw_map.rational.rebuild$(OBJ_EXT) $(LDFLAGS)
demo.leda.rational.rebuild$(EXE_EXT): demo.leda.rational.rebuild$(OBJ_EXT) draw_map.leda.rational.rebuild$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.leda.rational.rebuild demo.leda.rational.rebuild$(OBJ_EXT) draw_map.leda.rational.rebuild$(OBJ_EXT) $(LDFLAGS)
# executables ... default strategy without rebuilds
demo.float.no-rebuild$(EXE_EXT): demo.float.no-rebuild$(OBJ_EXT) draw_map.float.no-rebuild$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.float.no-rebuild demo.float.no-rebuild$(OBJ_EXT) draw_map.float.no-rebuild$(OBJ_EXT) $(LDFLAGS)
demo.rational.no-rebuild$(EXE_EXT): demo.rational.no-rebuild$(OBJ_EXT) draw_map.rational.no-rebuild$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.rational.no-rebuild demo.rational.no-rebuild$(OBJ_EXT) draw_map.rational.no-rebuild$(OBJ_EXT) $(LDFLAGS)
demo.leda.rational.no-rebuild$(EXE_EXT): demo.leda.rational.no-rebuild$(OBJ_EXT) draw_map.leda.rational.no-rebuild$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.leda.rational.no-rebuild demo.leda.rational.no-rebuild$(OBJ_EXT) draw_map.leda.rational.no-rebuild$(OBJ_EXT) $(LDFLAGS)
# executables ... walk strategy
demo.float.walk$(EXE_EXT): demo.float.walk$(OBJ_EXT) draw_map.float.walk$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.float.walk demo.float.walk$(OBJ_EXT) draw_map.float.walk$(OBJ_EXT) $(LDFLAGS)
demo.rational.walk$(EXE_EXT): demo.rational.walk$(OBJ_EXT) draw_map.rational.walk$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.rational.walk demo.rational.walk$(OBJ_EXT) draw_map.rational.walk$(OBJ_EXT) $(LDFLAGS)
demo.leda.rational.walk$(EXE_EXT): demo.leda.rational.walk$(OBJ_EXT) draw_map.leda.rational.walk$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.leda.rational.walk demo.leda.rational.walk$(OBJ_EXT) draw_map.leda.rational.walk$(OBJ_EXT) $(LDFLAGS)
# executables ... naive strategy
demo.float.naive$(EXE_EXT): demo.float.naive$(OBJ_EXT) draw_map.float.naive$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.float.naive demo.float.naive$(OBJ_EXT) draw_map.float.naive$(OBJ_EXT) $(LDFLAGS)
demo.rational.naive$(EXE_EXT): demo.rational.naive$(OBJ_EXT) draw_map.rational.naive$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.rational.naive demo.rational.naive$(OBJ_EXT) draw_map.rational.naive$(OBJ_EXT) $(LDFLAGS)
demo.leda.rational.naive$(EXE_EXT): demo.leda.rational.naive$(OBJ_EXT) draw_map.leda.rational.naive$(OBJ_EXT)
$(CGAL_CXX) $(LIBPATH) $(EXE_OPT)demo.leda.rational.naive demo.leda.rational.naive$(OBJ_EXT) draw_map.leda.rational.naive$(OBJ_EXT) $(LDFLAGS)
# demo object files
demo.float.rebuild$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) $(EXE_OPT)demo.float.rebuild$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.rational.rebuild$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_RATIONAL $(EXE_OPT)demo.rational.rebuild$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.leda.rational.rebuild$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)demo.leda.rational.rebuild$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.float.no-rebuild$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_DEFAULT_WITHOUT_REBUILD $(EXE_OPT)demo.float.no-rebuild$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.rational.no-rebuild$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_DEFAULT_WITHOUT_REBUILD -DUSE_RATIONAL $(EXE_OPT)demo.rational.no-rebuild$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.leda.rational.no-rebuild$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_DEFAULT_WITHOUT_REBUILD -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)demo.leda.rational.no-rebuild$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.float.walk$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_WALK_POINT_LOCATION $(EXE_OPT)demo.float.walk$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.rational.walk$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_WALK_POINT_LOCATION -DUSE_RATIONAL $(EXE_OPT)demo.rational.walk$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.leda.rational.walk$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_WALK_POINT_LOCATION -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)demo.leda.rational.walk$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.float.naive$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_NAIVE_POINT_LOCATION $(EXE_OPT)demo.float.naive$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.rational.naive$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_NAIVE_POINT_LOCATION -DUSE_RATIONAL $(EXE_OPT)demo.rational.naive$(OBJ_EXT) $(OBJ_OPT) demo.C
demo.leda.rational.naive$(OBJ_EXT): demo.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_NAIVE_POINT_LOCATION -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)demo.leda.rational.naive$(OBJ_EXT) $(OBJ_OPT) demo.C
#draw_map object file
draw_map.float.rebuild$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) $(EXE_OPT)draw_map.float.rebuild$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.rational.rebuild$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_RATIONAL $(EXE_OPT)draw_map.rational.rebuild$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.leda.rational.rebuild$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)draw_map.leda.rational.rebuild$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.float.no-rebuild$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_DEFAULT_WITHOUT_REBUILD $(EXE_OPT)draw_map.float.no-rebuild$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.rational.no-rebuild$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_DEFAULT_WITHOUT_REBUILD -DUSE_RATIONAL $(EXE_OPT)draw_map.rational.no-rebuild$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.leda.rational.no-rebuild$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_DEFAULT_WITHOUT_REBUILD -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)draw_map.leda.rational.no-rebuild$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.float.walk$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_WALK_POINT_LOCATION $(EXE_OPT)draw_map.float.walk$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.rational.walk$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_WALK_POINT_LOCATION -DUSE_RATIONAL $(EXE_OPT)draw_map.rational.walk$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.leda.rational.walk$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_WALK_POINT_LOCATION -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)draw_map.leda.rational.walk$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.float.naive$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_NAIVE_POINT_LOCATION $(EXE_OPT)draw_map.float.naive$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.rational.naive$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_NAIVE_POINT_LOCATION -DUSE_RATIONAL $(EXE_OPT)draw_map.rational.naive$(OBJ_EXT) $(OBJ_OPT) draw_map.C
draw_map.leda.rational.naive$(OBJ_EXT): draw_map.C draw_map.h makefile
$(CGAL_CXX) $(CXXFLAGS) -DUSE_NAIVE_POINT_LOCATION -DUSE_LEDA_RAT_KERNEL $(EXE_OPT)draw_map.leda.rational.naive$(OBJ_EXT) $(OBJ_OPT) draw_map.C
all: demo \
helputil
#---------------------------------------------------------------------#
# suffix rules
#---------------------------------------------------------------------#
.C$(OBJ_EXT):
$(CGAL_CXX) $(CXXFLAGS) $(OBJ_OPT) $<
clean:
$(RM) $(RMFLAGS) *$(OBJ_EXT) demo$(EXE_EXT) \
demo.float.rebuild$(EXE_EXT) \
demo.rational.rebuild$(EXE_EXT) \
demo.leda.rational.rebuild$(EXE_EXT) \
demo.float.no-rebuild$(EXE_EXT) \
demo.rational.no-rebuild$(EXE_EXT) \
demo.leda.rational.no-rebuild$(EXE_EXT) \
demo.float.walk$(EXE_EXT) \
demo.rational.walk$(EXE_EXT) \
demo.leda.rational.walk$(EXE_EXT) \
demo.float.naive$(EXE_EXT) \
demo.rational.naive$(EXE_EXT) \
demo.leda.rational.naive$(EXE_EXT) \
helputil$(EXE_EXT)
# note - we use many compile flag dependent executables for optimization

167
Packages/Planar_map/demo/Planar_map/Leda_window/read_inp.h Normal file
View File

@ -0,0 +1,167 @@
#ifndef READ_INP_H
#define READ_INP_H
#include <CGAL/basic.h>
#include <CGAL/assertions.h>
template <class Traits>
class PM_input
{
public:
typedef typename Traits::Point_2 Point;
typedef struct { int s, t; } Curve;
PM_input()
{
num_pnts = num_cvs = 0;
pnts = NULL;
cvs = NULL;
}
~PM_input()
{
delete_all();
}
void delete_all()
{
if (pnts != NULL)
delete[] pnts;
if (cvs != NULL)
delete[] cvs;
num_pnts = num_cvs = 0;
pnts = NULL;
cvs = NULL;
}
void alloc(int np, int nc)
{
delete_all();
pnts = new Point[np];
num_pnts = np;
cvs = new Curve[nc];
num_cvs = nc;
}
void set(int i, int source, int target)
{
if ((i < 0) || (i >= num_cvs))
return;
cvs[i].s = source;
cvs[i].t = target;
}
void set(int i, const Point &p)
{
if ((i < 0) || (i >= num_pnts))
return;
pnts[i] = p;
}
bool get(int i, int &source, int &target) const
{
if ((i < 0) || (i >= num_cvs))
return false;
source = cvs[i].s;
target = cvs[i].t;
return true;
}
bool get(int i, Point &p) const
{
if ((i < 0) || (i >= num_pnts))
return false;
p = pnts[i];
return true;
}
int curve_source(int i) const
{
if ((i < 0) || (i >= num_cvs))
return -1;
return cvs[i].s;
}
int curve_target(int i) const
{
if ((i < 0) || (i >= num_cvs))
return -1;
return cvs[i].t;
}
int get_num_pnts() const { return num_pnts; }
int get_num_cvs() const { return num_cvs; }
Point point(int i) const
{
if ((i < 0) || (i >= num_pnts))
return Point(0,0);
return pnts[i];
}
friend std::ostream &operator<<(std::ostream &os, const PM_input &pmi)
{
CGAL::set_ascii_mode(os);
os << pmi.num_pnts << std::endl;
int i;
for (i = 0; i < pmi.num_pnts; i++)
{
os << pmi.pnts[i] << std::endl;
}
os << pmi.num_cvs << std::endl;
for (i = 0; i < pmi.num_cvs; i++)
{
os << pmi.cvs[i].s << " " << pmi.cvs[i].t << std::endl;
}
return os;
}
friend std::istream &operator>>(std::istream &is, PM_input &pmi)
{
CGAL::set_ascii_mode(is);
pmi.delete_all();
Point p;
is >> pmi.num_pnts;
#ifdef CGAL_PM_READ_DEBUG
std::cerr << "pmi.num_pnts " << pmi.num_pnts << std::endl;
#endif
pmi.pnts = new Point[pmi.num_pnts];
CGAL_assertion(pmi.pnts != NULL);
int i;
#ifdef USE_LEDA_RAT_KERNEL
number_type x,y;
#endif
for (i = 0; i < pmi.num_pnts; i++)
{
#ifndef USE_LEDA_RAT_KERNEL
is >> pmi.pnts[i];
#else
is >> x >> y;
pmi.pnts[i]=Point(x,y);
#endif
}
is >> pmi.num_cvs;
#ifdef CGAL_PM_READ_DEBUG
std::cerr << "pmi.num_cvs " << pmi.num_cvs << std::endl;
#endif
pmi.cvs = new Curve[pmi.num_cvs];
CGAL_assertion(pmi.cvs != NULL);
for (i = 0; i < pmi.num_cvs; i++)
{
is >> pmi.cvs[i].s >> pmi.cvs[i].t;
}
return is;
}
private:
Point *pnts;
Curve *cvs;
int num_pnts;
int num_cvs;
};
#endif