Jesús Manuel Almendros-Jiménez

A performance comparison of distance-based query algorithms using R-trees in spatial databases

Efficient processing of distance-based queries (DBQs) is of great importance in spatial databases due to the wide area of applications that may address such queries. The most representative and known DBQs are the K Nearest Neighbors Query (KNNQ), @r Distance Range Query (@rDRQ), K Closest Pairs Query (KCPQ) and @r Distance Join Query (@rDJQ). In this paper, we propose new pruning mechanism to apply them in the design of new Recursive Best-First Search (RBFS) algorithms for DBQs between spatial objects indexed in R-trees. RBFS is a general search algorithm that runs in linear space and expands nodes in best-first order, but it can suffer from node re-expansion overhead (i.e. to expand nodes in best-first order, some nodes can be considered more than once). The R-tree and its variations are commonly cited spatial access methods that can be used for answering such spatial queries. Moreover, an exhaustive experimental study was also included using R-trees, which resulted to several conclusions about the efficiency of proposed RBFS algorithm and its comparison with respect to other search algorithms (Best-First Search (BFS) and Depth-First Branch-and-Bound (DFBnB)), in terms of disk accesses, response time and main memory requirements, taking into account several important parameters as maximum branching factor (Cmax), cardinality of the final query result (K), distance threshold (@r) and size of a global LRU buffer (B). In general RBFS is competitive for KNNQ and KCPQ where the maximum branching factor (Cmax) is large enough (even better than DFBnB and very close to BFS), and it is a good alternative when we have main memory limitations in our computer due to high process overload in our system, since it is linear space consuming with respect to the height of the R-trees. Nevertheless, RBFS is the worst alternative for @rDRQ and @rDJQ. DFBnB is also a linear space algorithm and it obtains the same behavior as BFS for @rDRQ and @rDJQ; and it is the best when an LRU buffer was included. Finally, we have been able to check experimentally that BFS is the best for all DBQs, but it can consume many main memory resources to perform spatial queries.

Designing GUI components from UML use cases

In this paper we present how to develop graphical user interfaces from two UML models: use case and activity diagrams. Our method obtains from them a UML class diagram for representing GUI components, and it is suitable for generating code fragments, which can be considered as GUI prototypes.

A flexible XPath-based query language implemented with fuzzy logic programming

In this paper we present an extension of the XPath query language for the handling of flexible queries. In order to provide ranked answers, our approach proposes fuzzy variants of and, or and avg operators for XPath conditions, as well as two structural constraints, called down and deep, for which a certain degree of relevance is associated. Our proposal has been implemented with a fuzzy logic language to take profit of the clear sinergies between both target and source fuzzy languages.

Querying xml documents in logic programming

Extensible Markup Language (XML) is a simple, very flexible text format derived from SGML. Originally designed to meet the challenges of large-scale electronic publishing, XML is also playing an increasingly important role in the exchange of a wide variety of data on the Web and elsewhere. XPath language is the result of an effort to provide address parts of an XML document. In support of this primary purpose, it becomes in a query language against an XML document. In this paper we present a proposal for the implementation of the XPath language in logic programming. With this aim we will describe the representation of XML documents by means of a logic program. Rules and facts can be used for representing the document schema and the XML document itself. In particular, we will present how to index XML documents in logic programs: rules are supposed to be stored in main memory, however facts are stored in secondary memory by using two kind of indexes: one for each XML tag, and other for each group of terminal items. In addition, we will study how to query by means of the XPath language against a logic program representing an XML document. It evolves the specialization of the logic program with regard to the XPath expression. Finally, we will also explain how to combine the indexing and the top-down evaluation of the logic program.

An extension of UML for the modeling of WIMP user interfaces

The Unified Modeling Language (UML) [OMG, Unified Modeling Language Specification, Version 2.0, Technical Report, Object Management Group , 2005] provides system architects working on analysis and design (A&D) with one consistent language for specifying, visualizing, constructing, and documenting the artifacts of software systems, as well as for the business modeling. The user interface (UI), as a significant part of most applications, should be modeled using UML, and automatic CASE tools may help to generate UIs from UML designs. In this paper, we describe how to use and specialize UML diagrams in order to describe the UIs of a software system based on WIMP (Windows, Icons, Menus and Pointers). Use case diagrams are used for extracting the main UIs. Use cases are described by means of user-interaction diagrams, a special kind of activity diagrams in which states represent data output actions and transitions represent data input events. Input and output interactions in the user-interaction diagrams help the designer to extract the UI components used in each UI. We obtain a new and specialized version of the use case diagram for the UI modeling (called UI diagram) and a class diagram for UI components-called UI-class diagram. The user-interaction, UI and UI-class diagrams, can be seen as the UML-based UI models of the system. Finally, UI prototypes can be generated from UI-class diagrams with CASE tool support. As case study of our technique, we will describe an Internet book shopping system.

Describing use cases with activity charts

The Model-Driven Development (MDD) describes and maintains models of the system under development. The Unified Modeling Language (UML) supports a set of semantics and notation that addresses all scales of architectural complexity by using a MDD perspective. Use Cases and Activity Charts are two modeling techniques of the UML. The first one helps the designers to identify the requirements of the system discovering its high level functionality. The second one helps them to specify the internal behaviour of a certain entity or subsystem of the software developed, such as a database, a graphical interface, a software component, or any specific software. However, there is not a direct way to relate/model the requirements (use cases) with their internal behavior (activity charts). In this paper we present a method for describing use cases with activity charts. Our technique also allow us to identify the two main use case relationships —include and generalization— by means of activity charts. As a case study, we will show how to use the activity charts to describe graphical user interfaces (GUI) from use cases. In particular, we will show an Internet book shopping system example.

Describing Use-Case Relationships with Sequence Diagrams

One of the key tools of the unified modelling language for behaviour modelling is the use-case model. The behaviour of a use case can be described by means of interaction diagrams (sequence and collaboration diagrams), activity charts and state diagrams or by pre-conditions and post-conditions, as well as natural language text, where appropriate. This article explains a technique to describe use cases by means of sequence diagrams. It compares sequence diagrams in order to define sequence-diagram relationships for identifying and defining use-case relationships. This article uses an automatic teller machine system case study to illustrate our proposal.

A Framework for Ocean Satellite Image Classification Based on Ontologies

In this paper we present a framework for ocean image classification based on ontologies. With this aim, we will describe how low and high level content of ocean satellite images can be modeled with an ontology. In addition, we will show how the image classification can be modeled with the ontology in which decision tree based classifiers and rule-based expert systems are represented. Particularly, the rule based expert systems include rules about low-level features (called training and labeling rules), and rules defined from the labeling (called human expert rules). The modeling with the ontology provides an extensible framework in which accommodate several methods of image classification. One of the main aims of our proposal is to provide a mechanism to share data about image classification between applications. We have developed an extensible Protégé plugin to classify images.

An RDF Query Language based on Logic Programming

In this paper we investigate an extension of XQuery for querying (and inferring) from RDF documents. Following a graph based approach for specifying queries against RDF, XQuery is extended with construction of answers and boolean predicates for RDF entailment relationship inference. We will also study how to implement it in logic programming by using logic rules for executing RDF/XQuery queries.

An Encoding of XQuery in Prolog

In this paper we describe the implementation of (a subset of) the XQuery language using logic programming (in particular, by means of Prolog). Such implementation has been developed using the Prolog interpreter SWI-Prolog. XML files are handled by means of the XML Library of SWI-Prolog. XPath/XQuery are encoded by means of Prolog rules. Such Prolog rules are executed in order to obtain the answer of the query.