#### Filter Results:

- Full text PDF available (20)

#### Publication Year

1982

2011

- This year (0)
- Last 5 years (0)
- Last 10 years (4)

#### Publication Type

#### Co-author

#### Journals and Conferences

#### Key Phrases

Learn More

- Frank Dehne, Andreas Fabri, Andrew Rau-Chaplin
- Symposium on Computational Geometry
- 1993

Parallel Computational Geometry is concerned with solving some given geometric problem of size n on a parallel computer with p processors (e.g., a PRAM, mesh, or hypercube multiprocessor) in time TPa~~l/~l. We call T the parallel solution optimal, if T“aralle~ = 0( ‘e~~ntz”~), where T~e~Uential is the sequential time complexity of the problem. Theoretical… (More)

- Andreas Fabri, Geert-Jan Giezeman, Lutz Kettner, Stefan Schirra, Sven Schönherr
- Softw., Pract. Exper.
- 2000

CGAL is a Computational Geometry Algorithms Library written in C++, which is being developed by research groups in Europe and Israel. The goal is to make the large body of geometric algorithms developed in the field of computational geometry available for industrial application. We discuss the major design goals for CGAL, which are correctness, flexibility,… (More)

- Frank Dehne, Andreas Fabri, Andrew Rau-Chaplin
- Int. J. Comput. Geometry Appl.
- 1996

We study scalable parallel computational geometry algorithms for the coarse grained multicomputermodel: p processors solving a problem on n data items, were each processor has O( p ) O(1) local memory and all processors are connected via some arbitrary interconnection network (e.g. mesh, hypercube, fat tree). We present O(sequential p + Ts(n; p)) time… (More)

A large part of the cgal-project is devoted to the development of a Computational Geometry Algorithms Library, written in C++. We discuss design issues concerning the cgal-kernel which is the basis for the library and hence for all geometric computation in cgal.

- Olivier Devillers, Andreas Fabri
- WADS
- 1993

We present output-sensitive scalable parallel algorithms for bichromatic line segment intersection problems for the coarse grained multicomputer model. Under the assumption that n p 2 , where n is the number of line segments and p the number of processors, we obtain an intersection counting algorithm with a time complexity of O(n log n log p p + T s (n log… (More)

- Andreas Fabri
- IMR
- 2001

The Cgal project (www.cgal.org) is a collaborative effort of several research institutes in Europe. The mission of the project is to make the most important of the solutions and methods developed in computational geometry available to users in industry and academia.

We present a randomized parallel algorithm for constructing the 3D convex hull on a generic p-processor coarse grained multicomputer with arbitrary interconnection network and n/p local memory per processor, where ~ z p’+’ (for some arbitrarily small c > O). For any given set of n points in 3-space, the algorithm computes the 3D convex hull, with high… (More)

- Frank Dehne, Claire Mathieu, Andreas Fabri
- SPDP
- 1994

1 Abstract We present parallel computational geometry algorithms that are scalable, architecture independent, easy to implement, and have, with high probability, an optimal time complexity for uniformly distributed random input data. Our methods apply to multicomputers with arbitrary interconnection network or bus system. The following problems are studied… (More)

- Pierre Alliez, Andreas Fabri
- SIGGRAPH Courses
- 2009

This course provides an overview of CGAL geometric algorithms and data structures. We start with a presentation the objectives and scope of the CGAL open source project. The three next parts cover SIGGRAPH topics: (1) CGAL for point set processing, including denoising, outlier removal, smoothing, resampling, curvature estimation, shape detection and surface… (More)

- Sylvain Pion, Andreas Fabri
- Sci. Comput. Program.
- 2011

We present a generic C++ design to perform efficient and exact geometric computations using lazy evaluations. Exact geometric computations are critical for the robustness of geometric algorithms. Their efficiency is also critical for most applications, hence the need for delaying the exact computations at run time until they are actually needed. Our… (More)