SEARCH · Search NASA
Search indexed NASA NTRS and DOE OSTI research on propulsion, heat transfer, battery materials and energy systems. Follow report and document links to the original sources.
Quote a phrase for an exact phrase match. Source license links do not imply unrestricted reuse.
Explore the source record for details and available documents.
In this paper, we propose a resource-efficient approach to provide an autonomous UAV with an on-board perception method to detect safe, hazard-free landing sites during flights over complex 3D terrain. We aggregate 3D measurements acquired from a sequence of monocular images by a Structure-from-Motion approach into a local, robot-centric, multi-resolution elevation map of the overflown terrain, which fuses depth measurements according to their lateral surface resolution (pixel-footprint) in a probabilistic framework based on the concept of dynamic Level of Detail. Map aggregation only requires depth maps and the associated poses, which are obtained from an on-board Visual Odometry algorithm. An efficient landing site detection method then exploits the features of the underlying multi-resolution map to detect safe landing sites based on the slope, roughness, and quality of the reconstructed terrain surface. The evaluation of the performance of the mapping and landing site detection modules are analyzed independently and jointly in simulated and realworld experiments in order to establish the efficacy of the proposed approach.
The invention combines radiation detection instrumentation, data processing algorithms, and visualization software to enable, for the first time ever, simultaneous, real-time imaging of both gamma ray and neutron sources (fast and slow). Radiation detectors sensitive to gamma rays and neutrons are integrated with readout electronics that allow discriminated particles to be incorporated into real-time 3D volumetric reconstructions as two separate data streams. Using the Scene Data Fusion (SDF) conceptual framework and contextual sensors from the Localization and Mapping Platform (LAMP) developed at LBNL, gamma-ray and neutron data are fused onto contextual information from the environment around the detection system. The invention is compatible with radiation detection media capable of detecting and discriminating between gamma rays and neutrons or the pairing of multiple detectors separately capable of detecting gamma rays and/or neutrons. It can be integrated into a compact, lightweight imaging platform for operation as a hand-carry device, on unmanned aerial systems, and with unmanned vehicles. The ability to measure neutron enables the detection and 3D localization of shielded nuclear materials such as Pu-239 which is not possible with means of gamma-ray detection and spectroscopy overcoming of major limitation in the detection of such materials to-date.
Hazardous nuclear and industrial facilities are rarely designed for robots. Work in these domains demand precise manipulation and robust mobility in cluttered, constrained spaces where off-the-shelf platforms struggle and “one-size-fits-all” machines become costly and complex. Idaho National Laboratory (INL) is developing an autonomous, multi-robot inspection system that coordinates task-specific platforms rather than relying on a single omni-tool robot. An electric truck serves as a power and compute hub for a custom manipulator co-developed with Florida International University (FIU), a commercial mini crawler, a pan–tilt–zoom camera, and a Nexxis Argus LiDAR mapping system. Working in concert, these robots generate spatial, radiation, and temperature maps of the pit environments at the Hanford Waste Tank Farms. These systems will capture visual records and environmental telemetry to allow for analysis post inspection. The system architecture uses Robot Operating System 2 (ROS 2) for publish/subscribe integration, NVIDIA Isaac Sim and Unity for simulation and visualization, and algorithms such as NVBlox to fuse data into unified 3D overlays. This robot-agnostic approach reduces operator burden by enabling autonomy across heterogeneous platforms and lets each robot be used where it is strongest. Having autonomous functions means operators don’t have to fully control multiple different components. The ease of use could allow for more widespread adoption of advanced robotics at waste management sites that see continued use. By coordinating simpler, purpose-built mechanisms, the approach lowers design and manufacturing complexity, reduces capital risk in contaminated settings, and improves controllability for complex inspection and manipulation tasks. We present the architecture, early results, and lessons learned from building and deploying this coordinated multi-robot system, with the goal of accelerating safe, cost-effective adoption of advanced robotics at waste-management sites.
This paper presents the results of research into providing a means for users to flexibly create visualizations of the reasoning processes of forward-chaining rule-based expert systems using algorithm animation techniques. Levels of reasoning are described in order to identify the information necessary from the expert system development environment for these visualizations. A dual-process visualization environment is presented consisting of: (1) a version of CLIPS modified for the identified information access requirements; and (2) VISOR, an algorithm animation-based system for creating visualizations of arbitrary complexity which can be triggered by 'interesting event' messages from the running expert-system application. This is followed by examples from several visualizations performed during the scope of this work.
Visualization is an important tool for scientists to extract understanding from complex scientific data. Scientists need to understand the uncertainty inherent in all scientific data in order to interpret the data correctly. Uncertainty visualization has been an active and growing area of research to address this challenge. Algorithms for uncertainty visualization can be expensive, and research efforts have been focused mainly on structured grid types. Further, support for uncertainty visualization in production tools is limited. In this paper, we adapt an algorithm for computing key metrics for visualizing uncertainty in Marching Cubes (MC) to multi-core devices and present the design, implementation, and evaluation for a Filter for uncertainty visualization of Marching Cubes on Multi-Core devices (FunMC2). FunMC2 accelerates the uncertainty visualization of MC significantly, and it is portable across multi-core CPUs and GPUs. Evaluation results show that FunMC2 based on OpenMP runs around 11× to 41× faster on multi-core CPUs than the corresponding serial version using one CPU core. FunMC2 based on a single GPU is around 5× to 9× faster than FunMC2 running by OpenMP. Moreover, FunMC2 is flexible enough to process ensemble data with both structured and unstructured mesh types. Furthermore, we demonstrate that FunMC2 can be seamlessly integrated as a plugin into ParaView, a production visualization tool for post-processing.
Explore the source record for details and available documents.
There are multiple algorithms for parallelizing particle advection for scientific visualization workloads. While many previous studies have contributed to the understanding of individual algorithms, our study aims to provide a holistic understanding of how algorithms perform relative to each other on various workloads. To accomplish this, we consider four popular parallelization algorithms and run a “bake-off” study (i.e., an empirical study) to identify the best matches for each. The study includes 216 tests, going to a concurrency of up to 8192 cores and considering data sets as large as 34 billion cells with 300 million particles. Overall, our study informs three important research questions: (1) which parallelization algorithms perform best for a given workload?, (2) why?, and (3) what are the unsolved problems in parallel particle advection? In terms of findings, we find that the seeding box is the most important factor in choosing the best algorithm, and also that there is a significant opportunity for improvement in execution time, scalability, and efficiency.
Most of today’s visualization libraries and applications are based off of what is known today as the visualization pipeline. In the visualization pipeline model, algorithms are encapsulated as “filtering” components with inputs and outputs. These components can be combined by connecting the outputs of one filter to the inputs of another filter. The visualization pipeline model is popular because it provides a convenient abstraction that allows users to combine algorithms in powerful ways. Unfortunately, the visualization pipeline cannot run effectively on exascale computers. Experts agree that the exascale machine will comprise processors that contain many cores. Furthermore, physical limitations will prevent data movement in and out of the chip (that is, between main memory and the processing cores) from keeping pace with improvements in overall compute performance. To use these processors to their fullest capability, it is essential to carefully consider memory access. This is where the visualization pipeline fails. Each filtering component in the visualization library is expected to take a data set in its entirety, perform some computation across all of the elements, and output the complete results. The process of iterating over all elements must be repeated in each filter, which is one of the worst possible ways to traverse memory when trying to maximize the number of executions per memory access. This project investigates a new type of visualization framework that exhibits a pervasive parallelism necessary to run on exascale machines. Our framework achieves this by defining algorithms in terms of functors, which are localized, stateless operations. Functors can be composited in much the same way as filters in the visualization pipeline. But, functors’ design allows them to be concurrently running on massive amounts of lightweight threads. Only with such fine-grained parallelism can we hope to fill the billions of threads we expect will be necessary for efficient computation on an exascale computer. This project concludes with a functional prototype containing pervasively parallel algorithms that perform demonstratively well on many-core processors. These algorithms are fundamental for performing data analysis and visualization at extreme scale.
Extreme scale systems require a new programming model and a fundamental change in how we design algorithms. To address these issues we created VTK-m: the visualization toolkit for multi-/many-core architectures. VTK-m supports a number of algorithms and the ability to design further algorithms through a top-down design with an emphasis on extreme parallelism. VTK-m also provides support for finding and building links across topologies, making it possible to perform operations that determine manifold surfaces, interpolate generated values, and find adjacencies. Although VTK-m provides a simplified high-level interface for programming, its template-based code removes the overhead of abstraction. VTK-m simplifies the development of parallel scientific visualization algorithms by providing a framework of supporting functionality that allows developers to focus on visualization operations. Additionally, VTK-m provides data abstractions not provided by other libraries that make code written in VTK-m more versatile.
Hughes Aircraft Company and the University of Chicago propose to transfer existing medical imaging registration algorithms to the area of multi-sensor data fusion. The University of Chicago's algorithms have been successfully demonstrated to provide pixel by pixel comparison capability for medical sensors with different characteristics. The research will attempt to fuse GOES, AVHRR, and SSM/I sensor data which will benefit a wide range of researchers. The algorithms will utilize data visualization and algorithm development tools created by Hughes in its EOSDIS prototyping. This will maximize the work on the fusion algorithms since support software (e.g. input/output routines) will already exist. The research will produce a portable software library with documentation for use by other researchers.
Hughes Aircraft Company and the University of Chicago propose to transfer existing medical imaging registration algorithms to the area of multi-sensor data fusion. The University of Chicago's algorithms have been successfully demonstrated to provide pixel by pixel comparison capability for medical sensors with different characteristics. The research will attempt to fuse GOES (Geostationary Operational Environmental Satellite), AVHRR (Advanced Very High Resolution Radiometer), and SSM/I (Special Sensor Microwave Imager) sensor data which will benefit a wide range of researchers. The algorithms will utilize data visualization and algorithm development tools created by Hughes in its EOSDIS (Earth Observation SystemData/Information System) prototyping. This will maximize the work on the fusion algorithms since support software (e.g. input/output routines) will already exist. The research will produce a portable software library with documentation for use by other researchers.
The algorithms foundational to visualization are central to the production visualization tools running at computing centers around the world and consume tremendous amounts of finite, limited resources. We believe that understanding the performance characteristics of these algorithms is critical in being good stewards of computational centers' resources. In this paper, we report initial studies on one such foundational algorithm: parallel particle advection. We have performed an extensive parameter study of the de facto standard algorithm that is commonly used in parallel production visualization tools as well as for in situ visualization environments. Our study has shown that the default parameters used in this algorithm lead to generally poor results, and identify settings that optimized performance on the system in our parameter sweep.
An algorithm denoted Gamma-SLAM performs further processing, in real time, of preprocessed digitized images acquired by a stereoscopic pair of electronic cameras aboard an off-road robotic ground vehicle to build accurate maps of the terrain and determine the location of the vehicle with respect to the maps. Part of the name of the algorithm reflects the fact that the process of building the maps and determining the location with respect to them is denoted simultaneous localization and mapping (SLAM). Most prior real-time SLAM algorithms have been limited in applicability to (1) systems equipped with scanning laser range finders as the primary sensors in (2) indoor environments (or relatively simply structured outdoor environments). The few prior vision-based SLAM algorithms have been feature-based and not suitable for real-time applications and, hence, not suitable for autonomous navigation on irregularly structured terrain. The Gamma-SLAM algorithm incorporates two key innovations: Visual odometry (in contradistinction to wheel odometry) is used to estimate the motion of the vehicle. An elevation variance map (in contradistinction to an occupancy or an elevation map) is used to represent the terrain. The Gamma-SLAM algorithm makes use of a Rao-Blackwellized particle filter (RBPF) from Bayesian estimation theory for maintaining a distribution over poses and maps. The core idea of the RBPF approach is that the SLAM problem can be factored into two parts: (1) finding the distribution over robot trajectories, and (2) finding the map conditioned on any given trajectory. The factorization involves the use of a particle filter in which each particle encodes both a possible trajectory and a map conditioned on that trajectory. The base estimate of the trajectory is derived from visual odometry, and the map conditioned on that trajectory is a Cartesian grid of elevation variances. In comparison with traditional occupancy or elevation grid maps, the grid elevation variance maps are much better for representing the structure of vegetated or rocky terrain.
In a numerical flow simulation. it is common to generate several thousand time steps of unsteady (time-dependent) flow data. Each time step may require tens to hundreds of megabytes for disk storage, and the total disk requirement for storing the unsteady flow data may be hundreds of gigabytes. Interactive visualization of unsteady flow data of this magnitude is presently impossible with the current hardware technology. This chapter describes the current approaches for unsteady flow visualization. An effective particle tracing technique for unsteady flow is also described. First, the life cycle of a typical numerical flow simulation is outlined. Several unsteady flow data sets from real-world problems are then given. The current approaches for visualizing unsteady flow are then described. There are many existing systems for flow visualization, and some of them are discussed. Streaklines depict time-varying phenomena that are sometimes difficult or impossible to see with other visualization techniques. The algorithms for computing streaklines are described. Several unsteady flow data sets have been visualized using streaklines, and the results are presented. Finally, some current issues in unsteady flow visualization are discussed.
Reeb graphs are an important tool for abstracting and representing the topological structure of a function defined on a manifold. We have identified three properties for faithfully representing Reeb graphs in a visualization: they should be constrained to the boundary, compact, and aligned with the function gradient. Existing algorithms for drawing Reeb graphs are agnostic to or violate these properties. In this paper, we introduce an algorithm to generate Reeb graph visualizations, called GASP, that is cognizant of these properties, thereby producing visualizations that are more representative of the underlying data. To demonstrate the improvements, the resulting Reeb graphs are evaluated both qualitatively and quantitatively against the geometric barycenter algorithm, using its implementation available in the Topology ToolKit (TTK), a widely adopted tool for calculating and visualizing Reeb graphs.
Vector field visualization techniques are essential to help us understand the complex dynamics of flow fields. These can be found in a wide range of applications such as study of flows around an aircraft, the blood flow in our heart chambers, ocean circulation models, and severe weather predictions. The vector fields from these various applications can be visually depicted using a number of techniques such as particle traces and advecting textures. In this tutorial, we present several fundamental algorithms in flow visualization including particle integration, particle tracking in time-dependent flows, and seeding strategies. For flows near surfaces, a wide variety of synthetic texture-based algorithms have been developed to depict near-body flow features. The most common approach is based on the Line Integral Convolution (LIC) algorithm. There also exist extensions of LIC to support more flexible texture generations for 3D flow data. This tutorial reviews these algorithms. Tensor fields are found in several real-world applications and also require the aid of visualization to help users understand their data sets. Examples where one can find tensor fields include mechanics to see how material respond to external forces, civil engineering and geomechanics of roads and bridges, and the study of neural pathway via diffusion tensor imaging. This tutorial will provide an overview of the different tensor field visualization techniques, discuss basic tensor decompositions, and go into detail on glyph based methods, deformation based methods, and streamline based methods. Practical examples will be used when presenting the methods; and applications from some case studies will be used as part of the motivation.
Tracktable is a toolkit for analysis and visualization of the trajectories of moving objects. Its main focus is on air and sea traffic. It can also work with more abstract trajectories such as eye tracking data. We supply a set of core data structures, input/output routines, math and machine learning algorithms that operate on those data structures, and visualization algorithms to produce movies and still images of the results.