Summary This paper shows how to simplify and speed up distributed JR program start‐up. We accomplish this goal by extending JR's operation abstraction so that it includes the creation of virtual machines and remote objects, the key components in distributed JR programs. This extension is conceptually simple, fits well with the rest of the JR language, and provides additional flexibility. Extending JR's operation abstraction yields a considerably less complex solution and a simpler implementation than other approaches, which would have led to redundant or ad‐hoc language mechanisms. The extension also allows for reduced distributed JR program start‐up costs because the creation of virtual machines and remote objects can now be done in parallel. This paper also describes how we have simulated this extension and have implemented a prototype that provides this extension. These reflect closely what we would need to do to actually include the extension within the standard JR implementation. Using the simulation and prototype, we obtained performance data on a few typical distributed applications written to use the extension. The data show large reductions, ranging from about 50% to 95%, in distributed JR program start‐up times. Our experiments also explored a few strategies to further reduce start‐up times, but, among our strategies, the straightforward strategies seem the best. This paper also discusses design alternatives for creating virtual machines and remote objects. Our experience suggests that the proposed extension to JR's operation abstraction is actually worthwhile to add to the standard JR language and implementation.

Summary The JR concurrent programming language extends Java with a richer concurrency model, by adding several new types and statements. JR provides dynamic remote virtual machine creation, dynamic remote object creation, remote method invocation, dynamic process creation, rendezvous, asynchronous message passing, semaphores, concurrent invocation, and shared variables. This paper presents RJ, a package for Java that provides JR‐like features. The paper gives an overview of RJ and its key features; describes the implications of RJ's design, including how RJ provides additional, useful flexibility; discusses the implementation of RJ; and gives qualitative and quantitative evaluations of our work with respect to feasibility and usability, experimentation, migration, and performance. RJ has been successful in meeting these goals and in providing insight into the trade‐offs between using a concurrent programming language versus using the equivalent concurrent package. Our work has yielded a few surprises in dealing with some concurrent programming language features, in understanding the run‐time performances of JR versus RJ programs, and in obtaining some additional, useful flexibility for concurrent programming applications. Copyright © 2015 John Wiley & Sons, Ltd.

Summary Message passing notations (language, package, etc.) typically include some form of asynchronous or synchronous invocation. In a synchronous invocation, the invoker waits for the invocation's servicer to pass back results. Some message passing notations also include early reply or deferred reply (including forwarding), which alters how and when the servicer passes back its results; this additional flexibility is useful in realistic applications. It is well known how to transform a synchronous invocation into only asynchronous invocations. This paper extends such transformations to early reply and forward. This paper also describes the use of these transformations within the implementations of programming notations. Using the transformation simplifies the implementation without significantly affecting run‐time costs. Copyright © 2015 John Wiley & Sons, Ltd.

SUMMARY Over the last decade, the popularity of Python has increased considerably. Python is widely used and has been demonstrated to be effective over many problem domains including scripting, prototyping, and simulation. Python's easy to use and concise syntax is highly expressive and allows a developer to create considerably shorter and easier to understand programs than semantically equivalent programs written in languages like C, C++, or Java. An important aspect of any language's flexibility is a highly parallelizable environment that allows its users to write concurrent programs. However, Python is still lacking a high‐level, expressive concurrent and distributed programming environment. This paper presents our experience creating PySy, a Python package (on the basis of the SR and JR concurrent programming languages), which provides an easy to use and expressive concurrent environment and allows for the distributed sharing of resources. This paper discusses our design decisions, describes our implementation, and shows qualitative and quantitative analyses of well‐known concurrent programs written in PySy. Overall, PySy is reasonable to use for expressing the more common programming scenarios, while it provides acceptable performance. Copyright © 2012 John Wiley & Sons, Ltd.

We describe a real-time 3-D augmented reality video- conferencing system. With this technology, an observer sees the real world from his viewpoint, but modified so that the image of a remote collaborator is rendered into the scene. We register the image of the collaborator with the world by estimating the 3-D transformation between the camera and a fiducial marker. We describe a novel shape- from-silhouette algorithm, which generates the appropriate view of the collaborator and the associated depth map at 30 fps. When this view is superimposed upon the real world, it gives the strong impression that the collaborator is a real part of the scene. We also demonstrate interaction in virtual environments with a live fully 3-D collaborator. Finally, we consider interaction between users in the real world and collaborators in a virtual space, using a tangible AR interface.

We present a complete system for live capture of 3D content and simultaneous presentation in augmented reality. The user sees the real world from his viewpoint, but modified so that the image of a remote collaborator is rendered into the scene. Fifteen cameras surround the collaborator, and the resulting video streams are used to construct a three-dimensional model of the subject using a shape-from-silhouette algorithm. Users view a two-dimensional fiducial marker using a video-see-through augmented reality interface. The geometric relationship between the marker and head-mounted camera is calculated, and the equivalent view of the subject is computed and drawn into the scene. Our system can generate 384 /spl times/ 288 pixel images of the models at 25 fps, with a latency of < 100 ms. The result gives the strong impression that the subject is a real part of the 3D scene. We demonstrate applications of this system in 3D videoconferencing and entertainment.

Presents a trinocular stereo algorithm that we have developed as part of an obstacle detection system that detects small obstacles at long range on the highway. We describe the stages of the stereo algorithm itself and the reasons behind the design decisions that were made. This is followed by a description of the obstacle detection system that we have built. Finally, we show results from our system for a variety of different obstacles.

This paper presents a multibaseline stereo technique specially suited to detecting obstacles. A method is described for weakly calibrating a set of multibaseline stereo cameras with high accuracy. This method is then used to tailor the stereo search space to the special case where the world in front of the cameras consists mainly of nearly horizontal planar surfaces (the ground), where we are interested in deviations from those planar surfaces (obstacles). The resulting disparity maps are presented and compared to the output of a traditional stereo algorithm.