10679630
Video completion using tracking and fragment merging
Video completion is the problem of automatically filling space–time holes in video sequences left by the removal of unwanted objects in a scene. We solve it using texture synthesis, filling a hole inwards using three steps iteratively: we select the most promising target pixel at the edge of the hole, we find the source fragment most similar to the known part of the target’s neighborhood, and we merge source and target fragments to complete the target neighborhood, reducing the size of the hole.Earlier methods were slow, due to searching the whole video data for source fragments or completing holes pixel by pixel; they also produced blurred results due to sampling and smoothing. For speed, we track moving objects, allowing us to use a much smaller search space when seeking source fragments; we also complete holes fragment by fragment instead of pixelwise. Fine details are maintained by use of a graph cut algorithm when merging source and target fragments. Further techniques ensure temporal consistency of hole filling over successive frames.Examples demonstrate the effectiveness of our method.
27145850
A non-Euclidean implementation of LOGO
Abstract This paper describes an implementation of the LOGO Turtle Graphics programming environment in non-Euclidean geometry. Turtle graphics and non-Euclidean geometry are described briefly, and consideration is given to some of the details and problems of implementation. We describe the ways in which the LOGO language must be modified for a non-Euclidean environment, and the geometrical problems encountered during implementation.
750888
Detecting approximate incomplete symmetries in discrete point sets
Motivated by the need to detect design intent in approximate boundary representation models, we give an algorithm to detect incomplete symmetries of discrete points, giving the models' potential local symmetries at various automatically detected tolerances. Here, incomplete symmetry is defined as a set of incomplete cycles which are constructed by, e.g., a set of consecutive vertices of an approximately regular polygon, induced by a single isometry. All seven 3D elementary isometries are considered for symmetry detection. Incomplete cycles are first found using a tolerance-controlled point expansion approach. Subsequently, these cycles are clustered for incomplete symmetry detection. The resulting clusters have welldefined, unambiguous approximate symmetries suitable for design intent detection, as demonstrated experimentally.
2214669
Fast degree elevation and knot insertion for B-spline curves
We give a new, simple algorithm for simultaneous degree elevation and knot insertion for B-spline curves. The method is based on the simple approach of computing derivatives using the control points, resampling the knot vector, and then computing the new control points from the derivatives. We compare our approach with previous algorithms and illustrate it with examples.
17590358
Constructing Regularity Feature Trees for Solid Models
Approximate geometric models, e.g. as created by reverse engineering, describe the approximate shape of an object, but do not record the underlying design intent. Automatically inferring geometric aspects of the design intent, represented by feature trees and geometric constraints, enhances the utility of such models for downstream tasks. One approach to design intent detection in such models is to decompose them into regularity features. Geometric regularities such as symmetries may then be sought in each regularity feature, and subsequently be combined into a global, consistent description of the model's geometric design intent. This paper describes a systematic approach for finding such regularity features based on recovering broken symmetries in the model. The output is a tree of regularity features for subsequent use in regularity detection and selection. Experimental results are given to demonstrate the operation and efficiency of the algorithm.
5659182
Finding approximate shape regularities in reverse engineered solid models bounded by simple surfaces
Current reverse engineering systems are able to generate simple valid boundary representation (B-rep) models from 3D range data. Such models suffer from various inaccuracies caused by noise in the input data and algorithms. The quality of reverse engineered geometric models can potentially be improved by finding candidate shape regularities in such an initial model, and imposing a suitable subset of them on the model by using constraints, in a postprocessing step called beautification. Finding such candidate regularities is a necessary first step, and is discussed in this paper. Algorithms for analysis are presented which use feature objects to describe properties of faces, edges and vertices, and small groups of these elements in a B-rep model with only planar, spherical, cylindrical, conical and toroidal faces. The methods seek similarities between feature objects, e.g. axes which are parallel, for each property type. For each group of similar feature objects they also try to find a special feature object which might represent the group, e.g. an integer value which approximates the radius of similar cylinders. The feature objects used represent shape parameters, directions, axes and positions present in the model. Experiments show that the regularities found by these algorithms include the desired regularities. Although other spurious regularities which must be discarded in subsequent beautification steps are also produced, their number can be reduced by appropriate choice of tolerance values.
5430944
Distributed selfish load balancing
Suppose that a set of m tasks are to be shared as equally as possible amongst a set of n resources. A game-theoretic mechanism to find a suitable allocation is to associate each task with a "selfish agent", and require each agent to select a resource, with the cost of a resource being the number of agents to select it. Agents would then be expected to migrate from overloaded to underloaded resources, until the allocation becomes balanced.Recent work has studied the question of how this can take place within a distributed setting in which agents migrate selfishly without any centralized control. In this paper we discuss a natural protocol for the agents which combines the following desirable features: It can be implemented in a strongly distributed setting, uses no central control, and has good convergence properties. For m ≫ n, the system becomes approximately balanced (an ε-Nash equilibrium) in expected time O(log log m). We show using a martingale technique that the process converges to a perfectly balanced allocation in expected time O(log log m + n4). We also give a lower bound of Ω (max{log log m, n}) for the convergence time.
94046
Rapidly mixing Markov chains for sampling contingency tables with a constant number of rows
We consider the problem of sampling almost uniformly from the set of contingency tables with given row and column sums, when the number of rows is a constant. (2002) have recently given a fully polynomial randomized approximation scheme (fpras) for the related counting problem, which only employs Markov chain methods indirectly. But they leave open the question as to whether a natural Markov chain on such tables mixes rapidly. Here we answer this question in the affirmative, and hence provide a very different proof of the main result of Cryan and Dyer. We show that the "2 /spl times/ 2 heat-bath" Markov chain is rapidly mixing. We prove this by considering first a heat-bath chain operating on a larger window. Using techniques developed by Morris and Sinclair (2002) (see also Morris (2002)) for the multidimensional knapsack problem, we show that this chain mixes rapidly. We then apply the comparison method of Diaconis and Saloff-Coste (1993) to show that the 2 /spl times/ 2 chain is rapidly mixing. As part of our analysis, we give the first proof that the 2 /spl times/ 2 chain mixes in time polynomial in the input size when both the number of rows and the number of columns is constant.
17312370
A note on short cycles in a hypercube
How many edges can a quadrilateral-free subgraph of a hypercube have? This question was raised by Paul Erdos about 27 years ago. His conjecture that such a subgraph asymptotically has at most half the edges of a hypercube is still unresolved. Let f(n,C"l) be the largest number of edges in a subgraph of a hypercube Q"n containing no cycle of length l. It is known that f(n,C"l)=o(|E(Q"n)|), when l=4k, k>=2 and that f(n,C"6)>=13|E(Q"n)|. It is an open question to determine f(n,C"l) for l=4k+2, k>=2. Here, we give a general upper bound for f(n,C"l) when l=4k+2 and provide a coloring of E(Q"n) by four colors containing no induced monochromatic C"1"0.
16901231
A Noise Suppression System for the AMR Speech Codec
In this paper we describe a noise reduction preprocessing algorithm for the adaptive multirate (AMR) speech codec of the GSM system. The algorithm is based on spectral weighting and explicitly takes into account the properties of the human auditory system. The weighting rule results in the smallest possible speech distortion under the constraint that the background noise should exhibit no audible distortions. The algorithm was implemented in 16 Bit fixed-point arithmetic and submitted to the ETSI AMR noise reduction standardization contest. Compared to other algorithms, our noise reduction method gave very good results in CCR tests and good results in ACR tests.
18074193
Dynamic Diffusion Load Balancing
We consider the problem of dynamic load balancing in arbitrary (connected) networks on n nodes. Our load generation model is such that during each round, n tasks are generated on arbitrary nodes, and then (possibly after some balancing) one task is deleted from every non-empty node. Notice that this model fully saturates the resources of the network in the sense that we generate just as many new tasks per round as the network is able to delete. We show that even in this situation the system is stable, in that the total load remains bounded (as a function of n alone) over time. Our proof only requires that the underlying “communication” graph be connected. (It of course also works if we generate less than n new tasks per round, but the major contribution of this paper is the fully saturated case.) We further show that the upper bound we obtain is asymptotically tight (up to a moderate multiplicative constant) by demonstrating a corresponding lower bound on the system load for the particular example of a linear array (or path). We also show some simple negative results (i.e., instability) for work-stealing based diffusion-type algorithms in this setting.