Flávio Keidi Miyazawa

An ultra-fast user-steered image segmentation paradigm: live wire on the fly

The authors have been developing general user steered image segmentation strategies for routine use in applications involving a large number of data sets. In the past, they have presented three segmentation paradigms: live wire, live lane, and a three-dimensional (3-D) extension of the live-wire method. Here, they introduce an ultra-fast live-wire method, referred to as live wire on the fly for further reducing users time compared to the basic live-wire method. In live wire, 3-D/four-dimensional (4-D) object boundaries are segmented in a slice-by-slice fashion. To segment a two-dimensional (2-D) boundary, the user initially picks a point on the boundary and all possible minimum-cost paths from this point to all other points in the image are computed via Dijkstras algorithm. Subsequently, a live wire is displayed in real time from the initial point to any subsequent position taken by the cursor. If the cursor is close to the desired boundary, the live wire snaps on to the boundary. The cursor is then deposited and a new live-wire segment is found next. The entire 2-D boundary is specified via a set of live-wire segments in this fashion. A drawback of this method is that the speed of optimal path computation depends on image size. On modestly powered computers, for images of even modest size, some sluggishness appears in user interaction, which reduces the overall segmentation efficiency. In this work, the authors solve this problem by exploiting some known properties of graphs to avoid unnecessary minimum-cost path computation during segmentation. In live wire on the fly, when the user selects a point on the boundary the live-wire segment is computed and displayed in real time from the selected point to any subsequent position of the cursor in the image, even for large images and even on low-powered computers. Based on 492 tracing experiments from an actual medical application, the authors demonstrate that live wire on the fly is 1.331 times faster than live wire for actual segmentation for varying image sizes, although the pure computational part alone is found to be about 120 times faster.

Algorithms for two-dimensional cutting stock and strip packing problems using dynamic programming and column generation

We investigate several two-dimensional guillotine cutting stock problems and their variants in which orthogonal rotations are allowed. We first present two dynamic programming based algorithms for the Rectangular Knapsack (RK) problem and its variants in which the patterns must be staged. The first algorithm solves the recurrence formula proposed by Beasley; the second algorithm - for staged patterns - also uses a recurrence formula. We show that if the items are not so small compared to the dimensions of the bin, then these algorithms require polynomial time. Using these algorithms we solved all instances of the RK problem found at the OR-LIBRARY, including one for which no optimal solution was known. We also consider the Two-dimensional Cutting Stock problem. We present a column generation based algorithm for this problem that uses the first algorithm above mentioned to generate the columns. We propose two strategies to tackle the residual instances. We also investigate a variant of this problem where the bins have different sizes. At last, we study the Two-dimensional Strip Packing problem. We also present a column generation based algorithm for this problem that uses the second algorithm above mentioned where staged patterns are imposed. In this case we solve instances for two-, three- and four-staged patterns. We report on some computational experiments with the various algorithms we propose in this paper. The results indicate that these algorithms seem to be suitable for solving real-world instances. We give a detailed description (a pseudo-code) of all the algorithms presented here, so that the reader may easily implement these algorithms.

An algorithm for the three-dimensional packing problem with asymptotic performance analysis

The three-dimensional packing problem can be stated as follows. Given a list of boxes, each with a given length, width, and height, the problem is to pack these boxes into a rectangular box of fixed-size bottom and unbounded height, so that the height of this packing is minimized. The boxes have to be packed orthogonally and oriented in all three dimensions. We present an approximation algorithm for this problem and show that its asymptotic performance bound is between 2.5 and 2.67. This result answers a question raised by Li and Cheng [5] about the existence of an algorithm for this problem with an asymptotic performance bound less than 2.89.

Ultrafast user-steered image segmentation paradigm: live-wire-on-the-fly

In the past, we have presented three user-steered image segmentation paradigms: live wire, live lane, and the 3D extension of the live-wire method. In this paper, we introduce an ultra-fast live-wire method, referred to as live-wire-on-the-fly, for further reducing users time compared to live wire. For both approaches, given a slice and a 2D boundary of interest in this slice, we translate the problem of finding the best boundary segment between any two points specified by the user on this boundary to the problem of finding the minimum-cost path between two vertices in a weighted and directed graph. The entire 2D boundary is identified as a set of consecutive boundary segments, each specified and detected in this fashion. A drawback in live wire is that the speed for optimal path computation depends on image size, compromising the overall segmentation efficiency. In this work, we solve this problem by exploiting some properties of graph theory to avoid unnecessary minimum-cost path computation during segmentation. Based on 164 segmentation experiments from an actual medical application, we demonstrate that live-wire- on-the-fly is about 1.5 to 33 times faster than live wire for actual segmentation, although the pure computational part alone is found to be over a hundred times faster.

Self-adjustment of resource allocation for grid applications

Grids involve coordinated resource sharing and problem solving in heterogeneous dynamic environments to meet the needs of a generation of researchers requiring large amounts of bandwidth and more powerful computational resources. The lack of resource ownership by grid schedulers and fluctuations in resource availability require mechanisms which will enable grids to adjust themselves to cope with fluctuations. The lack of a central controller implies a need for self-adaptation. Grids must thus be enabled with the ability to discover, monitor and manage the use of resources so they can operate autonomously. Two different approaches have been conceived to match the resource demands of grid applications to resource availability: Dynamic scheduling and adaptive scheduling. However, these two approaches fail to address at least one of three important issues: (i) the production of feasible schedules in a reasonable amount of time in relation to that required for the execution of an application; (ii) the impact of network link availability on the execution time of an application; and (iii) the necessity of migrating codes to decrease the execution time of an application. To overcome these challenges, this paper proposes a procedure for enabling grid applications, composed of various dependent tasks, to deal with the availability of hosts and links bandwidth. This procedure involves task scheduling, resource monitoring and task migration, with the goal of decreasing the execution time of grid applications. The procedure differs from other approaches in the literature because it constantly considers changes in resource availability, especially network bandwidth availability, to trigger task migration. The proposed procedure is illustrated via simulation using various scenarios involving fluctuation of resource availability. An additional contribution of this paper is the introduction of a set of schedulers offering solutions which differ in terms of both schedule length and computational complexity. The distinguishing aspect of this set of schedulers is the consideration of time requirements in the production of feasible schedules. Performance is then evaluated considering various network topologies and task dependencies.

Algorithms for 3D guillotine cutting problems

We present algorithms for the following three-dimensional (3D) guillotine cutting problems: unbounded knapsack, cutting stock and strip packing. We consider the case where the items have fixed orientation and the case where orthogonal rotations around all axes are allowed. For the unbounded 3D knapsack problem, we extend the recurrence formula proposed by [1] for the rectangular knapsack problem and present a dynamic programming algorithm that uses reduced raster points. We also consider a variant of the unbounded knapsack problem in which the cuts must be staged. For the 3D cutting stock problem and its variants in which the bins have different sizes (and the cuts must be staged), we present column generation-based algorithms. Modified versions of the algorithms for the 3D cutting stock problems with stages are then used to build algorithms for the 3D strip packing problem and its variants. The computational tests performed with the algorithms described in this paper indicate that they are useful to solve instances of moderate size.

Approximation Algorithms for the Orthogonal Z -Oriented Three-Dimensional Packing Problem

We present approximation algorithms for the orthogonal z-oriented three-dimensional packing problem (TPPz) and analyze their asymptotic performance bound. This problem consists in packing a list of rectangular boxes L=(b1,b2,. . . ,bn) into a rectangular box B=(l,w,\infty)

A set of schedulers for grid networks

, orthogonally and oriented in the z-axis, in such a way that the height of the packing is minimized. We say that a packing is oriented in the z-axis when the boxes in L are allowed to be rotated (by ninety degrees) around the z-axis. This problem has some nice applications but has been less investigated than the well-known variant of it---denoted by TPP (three-dimensional orthogonal packing problem)---in which rotations of the boxes are not allowed. The problem TPP can be reduced to TPPz. Given an algorithm for TPPz, we can obtain an algorithm for TPP with the same asymptotic bound. We present an algorithm for TPPz, called R, and three other algorithms, called LS, BS, and SS, for special cases of this problem in which the instances are more restricted. The algorithm LS is for the case in which all boxes in L have square bottoms; BS is for the case in which the box B has a square bottom, and SS is for the case in which the box B and all boxes in L have square bottoms. For an algorithm

Packing Problems with Orthogonal Rotations

\wa

Heuristics for two-dimensional knapsack and cutting stock problems with items of irregular shape

, we denote by