Catalogue Search | MBRL
Are you sure you want to remove the book from the shelf?
{{itemTitle}}
22
result(s) for
"Lyons, Damian M"
Sort by:
Cluster computing for robotics and computer vision
In this book, we look at how cluster technology can be leveraged to build better robots. Algorithms and approaches in key areas of robotics and computer vision, such as map building, target tracking, action selection and landmark learning, are reviewed and cluster implementations for these are presented.
eBook
Homing with stereovision
Visual Homing is a navigation method based on comparing a stored image of a goal location to the current image to determine how to navigate to the goal location. It is theorized that insects such as ants and bees employ visual homing techniques to return to their nest or hive, and inspired by this, several researchers have developed elegant robot visual homing algorithms. Depth information, from visual scale, or other modality such as laser ranging, can improve the quality of homing. While insects are not well equipped for stereovision, stereovision is an effective robot sensor. We describe the challenges involved in using stereovision derived depth in visual homing and our proposed solutions. Our algorithm, Homing with Stereovision (HSV), utilizes a stereo camera mounted on a pan-tilt unit to build composite wide-field stereo images and estimate distance and orientation from the robot to the goal location. HSV is evaluated in a set of 200 indoor trials using two Pioneer 3-AT robots showing it effectively leverages stereo depth information when compared to a depth from scale approach.
Journal Article
Towards Lakosian Multilingual Software Design Principles
Large software systems often comprise programs written in different programming languages. In the case when cross-language interoperability is accomplished with a Foreign Function Interface (FFI), for example pybind11, Boost.Python, Emscripten, PyV8, or JNI, among many others, common software engineering tools, such as call-graph analysis, are obstructed by the opacity of the FFI. This complicates debugging and fosters potential inefficiency and security problems. One contributing issue is that there is little rigorous software design advice for multilingual software. In this paper, we present our progress towards a more rigorous design approach to multilingual software. The approach is based on the existing approach to the design of large-scale C++ systems developed by Lakos. The Lakosian approach is one of the few design methodologies to address physical design rather than just logical design. Using the MLSA toolkit developed in prior work for analysis of multilingual software, we focus in on one FFI -- the pybind11 FFI. An extension to the Lakosian C++ design rules is proposed to address multilingual software that uses pybind11. Using a sample of 50 public GitHub repositories that use pybind11, we measure how many repositories would currently satisfy these rules. We conclude with a proposed generalization of the pybind11-based rules for any multilingual software using an FFI interface.
Paper
Lightweight Multilingual Software Analysis
Developer preferences, language capabilities and the persistence of older languages contribute to the trend that large software codebases are often multilingual, that is, written in more than one computer language. While developers can leverage monolingual software development tools to build software components, companies are faced with the problem of managing the resultant large, multilingual codebases to address issues with security, efficiency, and quality metrics. The key challenge is to address the opaque nature of the language interoperability interface: one language calling procedures in a second (which may call a third, or even back to the first), resulting in a potentially tangled, inefficient and insecure codebase. An architecture is proposed for lightweight static analysis of large multilingual codebases: the MLSA architecture. Its modular and table-oriented structure addresses the open-ended nature of multiple languages and language interoperability APIs. We focus here as an application on the construction of call-graphs that capture both inter-language and intra-language calls. The algorithms for extracting multilingual call-graphs from codebases are presented, and several examples of multilingual software engineering analysis are discussed. The state of the implementation and testing of MLSA is presented, and the implications for future work are discussed.
Paper
Lightweight Call-Graph Construction for Multilingual Software Analysis
Analysis of multilingual codebases is a topic of increasing importance. In prior work, we have proposed the MLSA (MultiLingual Software Analysis) architecture, an approach to the lightweight analysis of multilingual codebases, and have shown how it can be used to address the challenge of constructing a single call graph from multilingual software with mutual calls. This paper addresses the challenge of constructing monolingual call graphs in a lightweight manner (consistent with the objective of MLSA) which nonetheless yields sufficient information for resolving language interoperability calls. A novel approach is proposed which leverages information from a compiler-generated AST to provide the quality of call graph necessary, while the program itself is written using an Island Grammar that parses the AST providing the lightweight aspect necessary. Performance results are presented for a C/C++ implementation of the approach, PAIGE (Parsing AST using Island Grammar Call Graph Emitter) showing that despite its lightweight nature, it outperforms Doxgen, is robust to changes in the (Clang) AST, and is not restricted to C/C++.
Paper
Robot Motion
The following sections are included:
Motion of a Mobile Robot in Two Dimensions
Calculation of Location by Dead-Reckoning
Partitioning: Block Data Decomposition
Program Design
Analysis
Dead-Reckoning with Intermediate Results
Partitioning
Program Design
Analysis
Dead-Reckoning for a Team of Robots
Partitioning
Program Design
Analysis
Local and Global Buffers
Summary
References
Book Chapter
Clusters and Robots
The following sections are included:
Parallel Computation
Parallel Architectures
Multiprocessor
Multicomputer
Clusters
Terminology
Cluster Configuration
Programming the Cluster
Configuring the Cluster
Simple Cluster Configuration with OpenMPI
Connecting the Cluster to the Robot
Summary
References
Book Chapter
Learning Landmarks
The following sections are included:
Landmark Spatiograms
K-Means Clustering
Partitioning
Program Design
Analysis
EM Clustering
Partitioning
Program Design
Analysis
Summary
References
Book Chapter
Mapping and Localization
The following sections are included:
Constructing a Spatial Occupancy Map
Probabilistic Sonar Model
Bayesian Filtering
Partitioning by Map
Program Design
Phase 1
Phase 2
Phase 3
Phase 4
Analysis
Partitioning by Sensor Readings
Program Design
Analysis
Monte-Carlo Localization
Partitioning
Program Design
Analysis
Improving the Serial Fraction
Summary
References
Book Chapter