Ricardo C. Farias

A parallel heuristic for the Vehicle Routing Problem with Simultaneous Pickup and Delivery

This paper presents a parallel approach for solving the Vehicle Routing Problem with Simultaneous Pickup and Delivery (VRPSPD). The parallel algorithm is embedded with a multi-start heuristic which consists of a variable neighborhood descent procedure, with a random neighborhood ordering (RVND), integrated in an iterated local search (ILS) framework. The experiments were performed in a cluster with a multi-core architecture using up to 256 cores. The results obtained on the benchmark problems, available in the literature, show that the proposed algorithm not only improved several of the known solutions, but also presented a very satisfying scalability.

Out-of-core rendering of large, unstructured grids

We address the problem of rendering large, unstructured volumetric grids and present a set of techniques that render arbitrarily large data sets on machines with limited memory. We present two techniques that vary in rendering speed, disk and memory usage, ease of implementation, and preprocessing costs. The first is a memory-insensitive rendering (MIR) technique that is completely disk-based and requires a small amount of constant main memory. The second technique is based on our ZSweep algorithm. It is more involved in its preprocessing, implementation, and main-memory requirements but can be substantially faster.

A unified infrastructure for parallel out-of-core isosurface extraction and volume rendering of unstructured grids

We present a unified infrastructure for parallel out-of-core isosurface extraction and volume rendering of large unstructured grids on distributed-memory parallel machines. We parallelize the out-of-core isosurface extraction algorithm of Chiang et al. (1998) and the out-of-core ZSweep technique (Farias and Silva, 2001) for direct volume rendering, using the meta-cell technique as a unified underlying building block. Our one-time preprocessing first partitions the dataset into meta-cells that are stored in disk. From the meta-cells, we build a BBIO tree in disk, which can be used to speed up isosurface extraction, and a bounding-box file in disk, which is used for direct volume rendering. At run-time, we use a simple self-scheduling scheme to achieve load balancing among the processors. We perform several experiments on a sixteen-node cluster of PCs connected by a gigabit Ethernet, using datasets as large as 6.6 million cells. For the larger datasets, we have found that both our isosurface extraction and direct volume rendering approaches are perfectly scalable up to sixteen nodes.

Parallelizing the ZSWEEP algorithm for distributed-shared memory architectures

In this paper we describe a simple parallelization of the ZSWEEP algorithm for rendering unstructured volumetric grids on distributed-shared memory machines, and study its performance on three generations of SGI multiprocessors, including the new Origin 3000 series. The main idea of the ZSWEEP algorithm is very simple; it is based on sweeping the data with a plane parallel to the viewing plane, in order of increasing z, projecting the faces of cells that are incident to vertices as they are encountered by the sweep plane. Our parallel extension of the basic algorithm makes use of an image-based task partitioning scheme. Essentially, the screen is divided in more tiles than the number of processors, then each processor performs the sweep independently on the next available tile, until no more tiles are available to render. Here, we detail the modifications necessary to efficiently extend the sequential algorithm to work on shared-memory machines. We report on the performance of our implementation, and show that the tile-based ZSWEEP is naturally cache friendly, achieves fast rendering times, and substantial speedups on all the machines we used for testing. On one processor of our Origin 3000, we measure the L2 data cache hit rate of the tile-based ZSWEEP to be over 99%; a parallel efficiency of 83% on 16 processors; and rendering rates of about 300 thousand tetrahedra per second for a 1024 × 1024 image.

Hardware-assisted projected tetrahedra

We present a flexible and highly efficient hardware‐assisted volume renderer grounded on the original Projected Tetrahedra (PT) algorithm. Unlike recent similar approaches, our method is exclusively based on the rasterization of simple geometric primitives and takes full advantage of graphics hardware. Both vertex and geometry shaders are used to compute the tetrahedral projection, while the volume ray integral is evaluated in a fragment shader; hence, volume rendering is performed entirely on the GPU within a single pass through the pipeline. We apply a CUDA‐based visibility ordering achieving rendering and sorting performance of over 6 M Tet/s for unstructured datasets. Furthermore, as each tetrahedron is processed independently, we employ a data‐parallel solution which is neither bound by GPU memory size nor does it rely on auxiliary volume information. In addition, iso‐surfaces can be readily extracted during the rendering process, and time‐varying data are handled without extra burden.

Time-critical rendering of irregular grids

Many papers have presented rendering techniques and simplification ideas with the objective of speeding up image generation for irregular grid data sets. For large data sets, however, even the current fastest algorithms are known to require seconds to generate each image, making real time analysis of such data sets very difficult, or even impossible, unless one has access to powerful and expensive computer hardware. In order to synthesize a system for handling very large data set analysis, we have assembled algorithms for rendering, simplification and triangulation, and added to them some optimizations. We have made some improvements on one of the best current algorithms for rendering irregular grids, and added to it some simple approximation methods in both image and object space, resulting in a system that achieves high frame rates, even on slow computers without any specific graphic hardware. The algorithm adapts itself to the time budget it has available for each image generation, using hierarchical representations of the mesh for faster delivery of images when transformations are imposed to the data. When given additional time, the algorithm generates finer images, obtaining the precise final image if given sufficient time. We were able to obtain frame rates of the order of 5 Hz for medium-sized data sets, which is about 20 times faster than previous rendering algorithms. With a trade-off between image accuracy and speed, similar frame rates can be achieved on different computers.

Volume and Isosurface Rendering with GPU-Accelerated Cell Projection*

We present an efficient Graphics Processing Unit GPU‐based implementation of the Projected Tetrahedra (PT) algorithm. By reducing most of the CPU–GPU data transfer, the algorithm achieves interactive frame rates (up to 2.0 M Tets/s) on current graphics hardware. Since no topology information is stored, it requires substantially less memory than recent interactive ray casting approaches. The method uses a two‐pass GPU approach with two fragment shaders. This work includes extended volume inspection capabilities by supporting interactive transfer function editing and isosurface highlighting using a Phong illumination model.

A robust and rotationally invariant local surface descriptor with applications to non-local mesh processing

In recent years, we have witnessed a striking increase in research concerning how to describe a meshed surface. These descriptors are commonly used to encode mesh properties or guide mesh processing, not to augment existing computations by replication. In this work, we first define a robust surface descriptor based on a local height field representation, and present a transformation via the extraction of Zernike moments. Unlike previous work, our local surface descriptor is innately rotationally invariant. Second, equipped with this novel descriptor, we present SAMPLE - similarity augmented mesh processing using local exemplars - a method which uses feature neighbourhoods to propagate mesh processing done in one part of the mesh, the local exemplar, to many others. Finally, we show that SAMPLE can be used in a number of applications, such as detail transfer and parameterization.

An integrated CPU–GPU heuristic inspired on variable neighbourhood search for the single vehicle routing problem with deliveries and selective pickups

Environmental issues have become increasingly important to industry and business in recent days. This trend forces the companies to take responsibility for product recovery, and proper recycling and disposal, moving towards the design of sustainable green supply chains. This paper addresses the backward stream in transportation of products, by means of reverse logistics applied to vehicle routing. This problem, called single vehicle routing problem with deliveries and selective pickups, consists in finding a route that starts from the depot and visits all delivery customers. Some pickup customers may also be visited, since the capacity of the truck is not exceeded, and there is also a revenue associated with each pickup. We develop an algorithm inspired on the variable neighbourhood search metaheuristic that explores the power of modern graphics processing unit (GPU) to provide routes in reasonable computational time. The proposed algorithm called four-neighbourhood variable neighbourhood search (FN-VNS) includes a novel high-quality initial solution generator, a CPU–GPU integrated perturbation strategy and four different neighbourhood searches implemented purely in GPU for the local search phase. Our experimental results show that FN-VNS is able to improve the quality of the solution for 51 instances out of 68 instances taken from the literature. Finally, we obtained speedups up to 14.49 times, varying from 17.42 up to 76.84 for each local search, measured over a set of new large-size instances.

GPU-Based Cell Projection for Interactive Volume Rendering

We present a practical approach for implementing the projected tetrahedra (PT) algorithm for interactive volume rendering of unstructured data using programmable graphics cards. Unlike similar works reported earlier, our method employs two fragment shaders, one for computing the tetrahedra projections and another for rendering the elements. We achieve interactive rates by storing the model in texture memory and avoiding redundant projections of implementations using vertex shaders. Our algorithm is capable of rendering over 2.0 M Tet/s on current graphics hardware, making it competitive with recent ray-casting approaches, while occupying a substantially smaller memory footprint