183,378 research outputs found
Prototyping Information Visualization in 3D City Models: a Model-based Approach
When creating 3D city models, selecting relevant visualization techniques is
a particularly difficult user interface design task. A first obstacle is that
current geodata-oriented tools, e.g. ArcGIS, have limited 3D capabilities and
limited sets of visualization techniques. Another important obstacle is the
lack of unified description of information visualization techniques for 3D city
models. If many techniques have been devised for different types of data or
information (wind flows, air quality fields, historic or legal texts, etc.)
they are generally described in articles, and not really formalized. In this
paper we address the problem of visualizing information in (rich) 3D city
models by presenting a model-based approach for the rapid prototyping of
visualization techniques. We propose to represent visualization techniques as
the composition of graph transformations. We show that these transformations
can be specified with SPARQL construction operations over RDF graphs. These
specifications can then be used in a prototype generator to produce 3D scenes
that contain the 3D city model augmented with data represented using the
desired technique.Comment: Proc. of 3DGeoInfo 2014 Conference, Dubai, November 201
Analytical modelling in Dynamo
BIM is applied as modern database for civil
engineering. Its recent development allows to preserve
both structure geometrical and analytical information. The
analytical model described in the paper is derived directly
from BIM model of a structure automatically but in most
cases it requires manual improvements before being sent
to FEM software. Dynamo visual programming language
was used to handle the analytical data. Authors developed
a program which corrects faulty analytical model obtained
from BIM geometry, thus providing better automation for
preparing FEM model. Program logic is explained and test
cases shown
Improving Usability of Interactive Graphics Specification and Implementation with Picking Views and Inverse Transformations
Specifying and programming graphical interactions are difficult tasks,
notably because designers have difficulties to express the dynamics of the
interaction. This paper shows how the MDPC architecture improves the usability
of the specification and the implementation of graphical interaction. The
architecture is based on the use of picking views and inverse transforms from
the graphics to the data. With three examples of graphical interaction, we show
how to express them with the architecture, how to implement them, and how this
improves programming usability. Moreover, we show that it enables implementing
graphical interaction without a scene graph. This kind of code prevents from
errors due to cache consistency management
Declarative Ajax Web Applications through SQL++ on a Unified Application State
Implementing even a conceptually simple web application requires an
inordinate amount of time. FORWARD addresses three problems that reduce
developer productivity: (a) Impedance mismatch across the multiple languages
used at different tiers of the application architecture. (b) Distributed data
access across the multiple data sources of the application (SQL database, user
input of the browser page, session data in the application server, etc). (c)
Asynchronous, incremental modification of the pages, as performed by Ajax
actions.
FORWARD belongs to a novel family of web application frameworks that attack
impedance mismatch by offering a single unifying language. FORWARD's language
is SQL++, a minimally extended SQL. FORWARD's architecture is based on two
novel cornerstones: (a) A Unified Application State (UAS), which is a virtual
database over the multiple data sources. The UAS is accessed via distributed
SQL++ queries, therefore resolving the distributed data access problem. (b)
Declarative page specifications, which treat the data displayed by pages as
rendered SQL++ page queries. The resulting pages are automatically
incrementally modified by FORWARD. User input on the page becomes part of the
UAS.
We show that SQL++ captures the semi-structured nature of web pages and
subsumes the data models of two important data sources of the UAS: SQL
databases and JavaScript components. We show that simple markup is sufficient
for creating Ajax displays and for modeling user input on the page as UAS data
sources. Finally, we discuss the page specification syntax and semantics that
are needed in order to avoid race conditions and conflicts between the user
input and the automated Ajax page modifications.
FORWARD has been used in the development of eight commercial and academic
applications. An alpha-release web-based IDE (itself built in FORWARD) enables
development in the cloud.Comment: Proceedings of the 14th International Symposium on Database
Programming Languages (DBPL 2013), August 30, 2013, Riva del Garda, Trento,
Ital
Spatial Aggregation: Theory and Applications
Visual thinking plays an important role in scientific reasoning. Based on the
research in automating diverse reasoning tasks about dynamical systems,
nonlinear controllers, kinematic mechanisms, and fluid motion, we have
identified a style of visual thinking, imagistic reasoning. Imagistic reasoning
organizes computations around image-like, analogue representations so that
perceptual and symbolic operations can be brought to bear to infer structure
and behavior. Programs incorporating imagistic reasoning have been shown to
perform at an expert level in domains that defy current analytic or numerical
methods. We have developed a computational paradigm, spatial aggregation, to
unify the description of a class of imagistic problem solvers. A program
written in this paradigm has the following properties. It takes a continuous
field and optional objective functions as input, and produces high-level
descriptions of structure, behavior, or control actions. It computes a
multi-layer of intermediate representations, called spatial aggregates, by
forming equivalence classes and adjacency relations. It employs a small set of
generic operators such as aggregation, classification, and localization to
perform bidirectional mapping between the information-rich field and
successively more abstract spatial aggregates. It uses a data structure, the
neighborhood graph, as a common interface to modularize computations. To
illustrate our theory, we describe the computational structure of three
implemented problem solvers -- KAM, MAPS, and HIPAIR --- in terms of the
spatial aggregation generic operators by mixing and matching a library of
commonly used routines.Comment: See http://www.jair.org/ for any accompanying file
An NMF solution for the Flowgraphs case at the TTC 2013
Software systems are getting more and more complex. Model-driven engineering
(MDE) offers ways to handle such increased complexity by lifting development to
a higher level of abstraction. A key part in MDE are transformations that
transform any given model into another. These transformations are used to
generate all kinds of software artifacts from models. However, there is little
consensus about the transformation tools. Thus, the Transformation Tool Contest
(TTC) 2013 aims to compare different transformation engines. This is achieved
through three different cases that have to be tackled. One of these cases is
the Flowgraphs case. A solution has to transform a Java code model into a
simplified version and has to derive control and data flow. This paper presents
the solution for this case using NMF Transformations as transformation engine.Comment: In Proceedings TTC 2013, arXiv:1311.753
- …