Skip to main content



Graph Transformations and Model-Driven Engineering: The Merits of Manfred Nagl

Graph Transformations and Model-Driven Engineering: The Merits of Manfred Nagl

Manfred was born in 1944 in Landskron, Czechia. In 1963, he enrolled for mathematics and physics at the University of Erlangen-Nuremberg, from which he received a master degree in 1969. Subsequently, he worked at a research lab of Siemens AG in the area of graphics software. In 1971, he returned to the University of Erlangen-Nuremberg. At the chair of programming languages headed by Hans-Jürgen Schneider, he focused on graph grammars and graph rewriting systems. Manfred received a doctoral degree in 1974 and a habilitation degree in 1979, both from the Engineering Faculty of the University of Erlangen- Nuremberg.

In 1979, Manfred obtained his first position as a professor at the University of Koblenz-Landau, where he worked as an associate professor of computer science until 1981. He then moved to the University of Osnabrück, where he held the chair of applied computer science as a full professor until 1986. From then on, Manfred held a chair of computer science at RWTH Aachen University until he retired in July 2009.

Gregor Engels, Claus Lewerentz, Wilhelm Schäfer, Andy Schürr, Bernhard Westfechtel

Graph Transformations: Theory and Applications

The Edge of Graph Transformation — Graphs for Behavioural Specification

The title of this paper, besides being a pun, can be taken to mean either the

frontier of research

in graph transformation, or the

advantage of using

graph transformation. To focus on the latter: Why should anyone not already educated in the field adopt graph transformation-based methods, rather than a mainstream modelling language or a process algebra; or vice versa, what is holding potential users back? These questions can be further refined by focusing on particular aspects like usability (available tools) or power (available theory).

In this paper, we take a fresh and honest look at these issues. Our perspective is the use of graph transformation as a formalism for the specification and analysis of system behaviour. There is no question that the general nature of graphs is at once their prime selling point (essentially everything can be specified in terms of graphs) and their main drawback (the manipulation of graphs is complex, and many properties that are useful in more specialised formalisms no longer hold for general graphs).

The outcome of this paper is a series of recommendations that can be used to outline a research and development programme for the coming decade. This may help to stimulate the continued and increasing acceptance of graph transformation within the rest of the scientific community, thereby ensuring research that is relevant, innovative and on the edge.

Arend Rensink

Graph Transformation by Computational Category Theory

The categorical approach is well-suited for concise definitions of graph transformation concepts. At the same time, it allows for elegant proofs of their properties. We show that these categorical concepts also allow for a similarly simple and modular implementation of graphs and graph transformations by following Rydeheard and Burstall’s idea of Computational Category Theory. We first present an implementation of some categorical definitions and constructions, e.g., colimits, in Java, and we demonstrate how this language supports the genericity of the categorical approach. We then show that applying the constructions to the category of sets as well as the category of graphs already provides an implementation of graph transformations that can be used as the foundation of an extensible graph transformation language.

Mark Minas, Hans Jürgen Schneider

On GS-Monoidal Theories for Graphs with Nesting

We propose a sound and complete axiomatisation of a class of graphs with nesting and either locally or globally restricted nodes. Such graphs allow to represent explicitly and at the right level of abstraction some relevant topological and logical features of models and systems, including nesting, hierarchies, sharing of resources, and pointers or links. We also provide an encoding of the proposed algebra into terms of a gs-monoidal theory, and through these into a suitable class of ”wellscoped” term graphs, showing that this encoding is sound and complete with respect to the axioms of the algebra.

Roberto Bruni, Andrea Corradini, Fabio Gadducci, Alberto Lluch Lafuente, Ugo Montanari

Stochastic Modelling and Simulation of Mobile Systems

Distributed systems with mobile components are naturally modelled by graph transformations. To formalise and predict properties such as performance or reliability of such systems, stochastic methods are required. Stochastic graph transformations allow the integrated modelling of these two concerns by associating with each rule and match a probability distribution governing the delay of its application. Depending on the nature of these distributions, different techniques for analysis are available, ranging from stochastic model checking for exponential distributions to simulation for systems with general distributions.

In this paper we explore further the second notion, adding a model of global time to avoid the overhead of frequent local clock updates. We also transfer the notion of stochastic graph transformation system from an algebraic to a general background, allowing an arbitrary graph transformation approach to be used for the underlying system. We present a correspondingly extended semantic model, simulation algorithm and tool. The concepts are justified and illustrated by an accident management scenario which requires a model of physical mobility and sophisticated transformation concepts.

Reiko Heckel, Paolo Torrini

Autonomous Units and Their Semantics – The Concurrent Case

Communities of autonomous units are rule-based and graph-transformational devices to model processes that act and interact, move and communicate, cooperate and compete in a common environment. The autonomous units are independent of each other, and the environment may be large and structured in such a way that a global synchronization of process activities is not reasonable or not feasible. To reflect this assumption properly, a concurrent-process semantics of autonomous units is introduced and studied in this paper employing the idea of true concurrency. In particular, causal dependency between actions of autonomous units is compared with shift equivalence known from graph transformation, and concurrent processes in the present approach are related to canonical derivations.

Hans-Jörg Kreowski, Sabine Kuske

Parallel Independence of Amalgamated Graph Transformations Applied to Model Transformation

The theory of algebraic graph transformation has proven to be a suitable underlying formal framework to reason about the behavior of model transformations. In order to model an arbitrary number of actions at different places in the same model, the concept of amalgamated graph transformation has been proposed. Rule applications of certain regularity are described by a rule scheme which contains multi-rules modeling elementary actions and a common kernel rule for their synchronization (amalgamation). The amalgamation theorem by Böhm et al. ensures that for two multi-rules, the application of the amalgamated rule yields the same result as two iterative rule applications, respecting their common kernel rule application. In this paper, we propose an extension of the amalgamation theorem to an arbitrary finite number of synchronous rule applications. The theorem is used to show parallel independence of amalgamated graph transformations by analyzing the underlying multi-rules. As example, we specify an excerpt of a model transformation from Business Process Models (BPM) to the Business Process Execution Language (BPEL).

Enrico Biermann, Hartmut Ehrig, Claudia Ermel, Ulrike Golas, Gabriele Taentzer

Extended Triple Graph Grammars with Efficient and Compatible Graph Translators

Model-based software development processes often force their users to translate instances of one modeling language into related instances of another modeling language and vice-versa. The underlying data structure of such languages usually are some sort of graphs. Triple graph grammars (TGGs) are a formally founded language for describing correspondence relationships between two graph languages in a declarative way. Bidirectional graph language translators can be derived from a TGG, which maps pairs of related graph instances onto each other. These translators must fulfill certain compatibility properties with respect to the correspondence relationships established by their TGG. These properties are guaranteed for the original TGG approach as published 15 years ago. However, its expressiveness is pushed to the limit in most real world scenarios. Furthermore, the original approach relies on a parsing algorithm with exponential runtime complexity. In this contribution, we study a more expressive class of TGGs with

negative application conditions

and show for the first time that derived translators with a polynomial runtime complexity still preserve the above mentioned compatibility properties. For this purpose, we introduce a new characterization of well-formed TGGs together with a new translation rule scheduling algorithm that considers

dangling edges

of input graphs.

Felix Klar, Marius Lauder, Alexander Königs, Andy Schürr

Controlling Reuse in Pattern-Based Model-to-Model Transformations

Model-to-model transformation is a central activity in Model-Driven Engineering that consists of transforming models from a source to a target language. Pattern-based model-to-model transformation is our approach for specifying transformations in a declarative, relational and formal style. The approach relies on patterns describing allowed or forbidden relations between two models. These patterns are compiled into operational mechanisms to perform forward and backward transformations.

Inspired by QVT-Relations, in this paper we incorporate into our framework the so-called check-before-enforce semantics, which checks the existence of suitable elements before creating them (i.e. it promotes reuse). Moreover, we enable the use of


in order to describe when two elements are considered equal. The presented techniques are illustrated with a bidirectional transformation between Web Services Description Language and Enterprise Java Beans models.

Esther Guerra, Juan de Lara, Fernando Orejas

Lessons Learned from Building a Graph Transformation System

Model-driven software development is a language- and transformation-based paradigm, where the various development tasks of engineers are cast in this framework. During the past decade we have developed, evolved, and applied in practical projects a manifestation of this principle through a suite of tools we call the Model-Integrated Computing suite. Graph transformations are fundamental to this environment and tools for constructing model translators, for the specification of the semantics of languages, for the evolution of modeling languages, models, and their transformations have been built. Designing and building these tools have taught us interesting lessons about graph transformation techniques, language engineering, scalability and abstractions, pragmatic semantics, verification, and evolutionary changes in tools and designs. In the paper we briefly summarize the techniques and tools we have developed and used, and highlight our experience in constructing and using them.

Gabor Karsai

Workflow-Driven Tool Integration Using Model Transformations

The design of safety-critical systems and business-critical services necessitates to coordinate between a large variety of tools used in different phases of the development process. As certification frequently prescribes to achieve justified compliance with regulations of authorities, integrated tool chain should strictly adhere to the development process itself. In order to manage complexity, we follow a model-driven approach where the development process is captured using a precise domain-specific modeling language. Each individual step within this process is represented transparently as a service. Moreover, to carry out individual tasks, systems engineers are guided by semi-automated transformation steps and well-formedness constraint checking. Both of them are formalized by graph patterns and graph transformation rules as provided by the


framework. In our prototype implementation, we use the popular JBPM workflow engine as orchestration means between different design and verification tools. We also give some insights how this tool integration approach was applied in recent projects.

András Balogh, Gábor Bergmann, György Csertán, László Gönczy, Ákos Horváth, István Majzik, András Pataricza, Balázs Polgár, István Ráth, Dániel Varró, Gergely Varró

Software Architectures and Reengineering

The Architecture Description Language MoDeL

This paper is devoted to the topic of architecture modeling for software systems. The architecture describes the structural composition of a system from components and relationships between these components. Thereby, it provides a basis for the system’s realization on technical as well as on organizational level.

We present some key concepts of the architecture description language MoDeL (Modular Design Language). By selecting and combining modeling elements which proved to be helpful for the design of software systems, this approach is integrative and pragmatic: It allows the definition of “clean” logical structures as well as adaptations necessary due to implementation constraints. Both the logical architecture as well as concrete architectures reflecting respective modifications are considered as individual results of architecture modeling. Even more, the transformation steps describing the changes induced by a particular realization constraint contain valuable modeling knowledge as well.

Peter Klein

Towards Managing Software Architectures with Ontologies

Software architectures are key enabling assets within organizations that develop complex software systems. Among other purposes, software architectures are useful to maintain intellectual control over a software product. We propose a method to continuously check the consistency between a specified architecture model and structural information reverse engineered from the code. We develop criteria that a design language for architectures should fulfill and show that an ontology based description has substantial benefits over the standard modeling languages MOF/UML/OCL. Using ontologies allows the explicit modelling of architectural styles as well as concrete system structures in a single architecture design language. The resulting specifications are modular, compositional and evolvable. Using ontologies we can apply an ontology reasoner to implement consistency checks. Our method integrates previously separate checks such as checking for allowed dependencies and coding style into a single framework and enables more powerful and flexible analyses.

Marcel Bennicke, Claus Lewerentz

Using Role-Play Diagrams to Improve Scenario Role-Play

CRC-cards are a common lightweight approach to collaborative object-oriented analysis and design. They have been adopted by many educators and trainers to teach object-oriented modelling. In our experience, we have noticed many subtle problems and issues that have largely gone unnoticed in the literature. Two of the major issues are related to the CRC-card role-play as described in the literature. Although CRC-cards are representing classes, they are also utilized as substitutes for the actual objects during the scenario role-play. Furthermore, it is quite difficult to document or trace the scenario role-play. We propose using Role-Play Diagrams (RPDs) to overcome these problems. Our experience so far is quite positive. Novices have fewer problems with role-play activities when using these diagrams. Teaching and learning the new type of diagram adds only little overhead to the overall CRC-approach. Although our improvements specifically target the teaching and learning of object-oriented modelling, we believe that RPDs can be successfully applied in professional software development.

Jürgen Börstler

Reverse Engineering Using Graph Queries

Software Reverse Engineering is the process of extracting (usually more abstract) information from software artifacts. Graph-based engineering tools work on fact repositories that keep all artifacts as graphs. Hence, information extraction can be viewed as querying this repository. This paper describes the graph query language GReQL and its use in reverse engineering tools.

GReQL is an expression language based on set theory and predicate logics including regular path expressions (RPEs) as first class values. The GReQL evaluator is described in some detail with an emphasis on the efficient evaluation of RPEs for reachability and path-finding queries. Applications for reverse engineering Java software are added as sample use cases.

Jürgen Ebert, Daniel Bildhauer

Graph-Based Structural Analysis for Telecommunication Systems

Many methods and tools for the reengineering of software systems have been developed so far. However, the domain-specific requirements of telecommunication systems have not been addressed sufficiently. The E-CARES project is dedicated to reverse engineering of complex legacy telecommunication systems by providing graph-based tools. With E-CARES, the software architecture of a telecommunication system is recovered in two steps. In the first step (program analysis), the source code is parsed to build a structure graph which uses the abstractions of the underlying programming language and describes the internals of program units (blocks) as well as their communication via exchange of signals. In the second step, a software architecture description is abstracted from the structure graph. The software architecture is described in ROOM, a real-time object-oriented modeling language for embedded systems design. Both program analysis and architecture recovery are based on graphs and graph transformations. In both steps, domain-specific knowledge — referred to as methods of use — is exploited which refers to the ways how language constructs are used to realize processing concepts of telecommunication systems.

André Marburger, Bernhard Westfechtel

Process Support

Do We Really Know How to Support Processes? Considerations and Reconstruction

Since approximately 20 years process management is regarded as innovative technology both for the description of complex applications and for supporting their execution. Soon after the beginning of this process era, an inflation of process management systems started to flood the market. However, many users were very frustrated when they had to experience that these process management systems did not support their applications properly. One of the main causes for failing process applications was that process management was totally underestimated. In this contribution we try to get to the bottom of process management, i.e. we reconstruct the real requirements of process management which are the basis for the construction of working process solutions.

Stefan Jablonski

A Meta-Method for Defining Software Engineering Methods

Today’s software systems demand for sophisticated software engineering processes and methods. Especially the globally distributed development of large software systems requires precise and documented methods, but also lightweight and agile methods need to have a precise foundation. Effort that is invested once in the methods can be systematically reused in projects. We describe MetaME, a meta-method for modeling and tailoring software engineering methods. It builds on a meta-model of software engineering concepts. MetaME combines ideas from meta-modeling and method engineering. The meta-method comprises a product dimension and a process dimension. When the meta-method is applied, software development concepts are paired with languages for their representation to form artifact types. In the process dimension of the software engineering method, software development tasks are described as operations that act upon the artifacts. These tasks are performed as activities in the method’s process workflow model. Tools can then be built that use the artifact model as the foundation of their repository structure and the task and workflow models as the basis for the supported functionality.

Gregor Engels, Stefan Sauer

Techniques for Merging Views of Software Processes

Models of software development processes have many uses such as an aid to understanding, composing, assessing, improving and automating workflows. However, eliciting descriptive models from actual work environments can be quite complex due to multiplicity of roles, activities, artefacts, conditions, distributivity, locations and others. One way to manage this complexity is to elicit, from different sources, partial models (called views) of the subject process and then merge them into a coherent whole. In this paper, we describe “view-merging” algorithms, which form a core part of a view-based model elicitation system. The algorithms aid in identifying overlaps and inconsistencies and in presenting possible resolutions which, by interacting with the model elicitor, leads towards an incrementally built, unified, coherent process model. These algorithms have been implemented in a system called V elicit, which has been validated empirically.

Josée Tassé, Nazim H. Madhavji, Amandeep Azad

Embedded Systems Engineering

Model Checking Programmable Router Configurations

Programmable networks offer the ability to customize router behaviour at run time, thus increasing flexibility of network administration. Programmable network routers are configured using domain-specific languages. In this paper, we describe our approach to defining the syntax and semantics of such a domain-specific language. The ability to evolve router programs dynamically creates potential for misconfigurations. By exploiting domain-specific abstractions, we are able to translate router configurations into Promela and validate them using the Spin model checker, thus providing reasoning support for our domain-specific language. To evaluate our approach we use our configuration language to express the IETF’s Differentiated Services specification and show that industrial-sized DiffServ router configurations can be validated using Spin on a standard PC.

Luca Zanolin, Cecilia Mascolo, Wolfgang Emmerich

Architectural Issues of Adaptive Pervasive Systems

Pervasive systems are often made out of distributed software components that run on different computational units (appliances, sensing and actuating devices, computers). Such components are often developed, maintained, and even operated by different parties. Applications are increasingly built by dynamically discovering and composing such components in a situation-aware manner. By this we mean that applications follow some strategies to self-organize themselves to adapt their behavior depending on the changing situation in which they operate, for example the physical environment. They may also evolve autonomously in response to changing requirements. Software architectures are considered a well-suited abstraction to achieve situational adaptation. In this paper, we review some existing architectural approaches to self-adaptation and propose a high-level meta-model for architectures that supports dynamic adaptation. The meta-model is then instantiated in a specific ambient computing case study, which is used to illustrate its applicability.

Mauro Caporuscio, Marco Funaro, Carlo Ghezzi

Using Graph Grammars for Modeling Wiring Harnesses – An Experience Report

The Fujaba project has created a light weight graph grammar approach allowing the use of graph grammar concepts in usual Java programs. Fujaba comes with visual editors for graph schemas / class diagrams, control structures / activity diagrams, and graph rewrite rules / extended object diagrams. Thereby the user may specify executable programs that are translated into complete Java programs without any need for further low level Java programming. In addition, Fujaba provides dedicated visual language support for scenario based testing. This is complemented with support for model versioning and distributed applications. Last but not least Fujaba provides model level debugging.

This paper is an experience report applying Fujaba techniques for requirements analysis and implementation in an industrial project in the automotive industry. The considered project has created a tool for the design of car electronic systems. This project involved an enormous amount of domain knowledge. The challenge was to involve the domain experts in the analysis, design, and implementation activities such that the transfer of domain knowledge is fostered. This paper reports how we used graph grammar based Fujaba techniques and languages to achieve domain expert involvement.

Albert Zündorf, Leif Geiger, Ralf Gemmerich, Ruben Jubeh, Jürgen Leohold, Dieter Müller, Carsten Reckord, Christian Schneider, Sven Semmelrodt

Model-Driven Development with Mechatronic UML

Today, mechanical engineering products can largely be classified as

mechatronic systems

, i.e. systems integrating electrical and mechanical components with


. Mechatronic systems are often employed in safety-critical areas, for instance in the automotive or railway domain.


UML is a UML profile specifically tailored towards the modelling of mechatronic systems. It aims at bringing model-based design and formal analysis to the mechatronic area, which has originally been dominated by engineering techniques. In this paper we give a survey of the modelling as well as verification techniques supported by



Wilhelm Schäfer, Heike Wehrheim

Model Synchronization at Work: Keeping SysML and AUTOSAR Models Consistent

During the overall development of complex engineering systems different modeling notations are employed. For example, in the domain of automotive systems system engineering models are employed quite early to capture the requirements and basic structuring of the entire system, while software engineering models are used later on to describe the concrete software architecture. Each model helps in addressing the specific design issue with appropriate notations and at a suitable level of abstraction. However, when we step forward from system design to the software design, the engineers have to ensure that all decisions captured in the system design model are correctly transferred to the software engineering model. Even worse, when changes occur later on in either model, today the consistency has to be reestablished in a cumbersome manual step. In this paper, we present how model synchronization and consistency rules can be applied to automate this task and ensure that the different models are kept consistent. We also introduce a general approach for model synchronization. Besides synchronization, the approach consists of tool adapters as well as consistency rules covering the overlap between the synchronized parts of a model and the rest. We present the model synchronization algorithm based on triple graph grammars in detail and further exemplify the general approach by means of a model synchronization solution between system engineering models in SysML and software engineering models in AUTOSAR which has been developed for an industrial partner.

Holger Giese, Stephan Hildebrandt, Stefan Neumann

Multi-view Modeling to Support Embedded Systems Engineering in SysML

Embedded systems engineering problems often involve many domains, each with their own experts and tools. To help these experts with analysis and decision making in their domain, it is desirable to present them with a view of the system that is tailored to their particular task. In this paper, a model integration framework is demonstrated to address issues associated with multi-view modeling. The Systems Modeling Language (OMG SysML


) is used as a general language to represent a common model for the system as well as the dependencies between the different domain-specific tools and languages. To maintain consistency between these domain-specific views, model transformations are defined that map the interdependent constructs to and from a common SysML model. The approach is illustrated by means of a mechatronic design problem involving views in multiple domain-specific tools, namely EPLAN Fluid


(to create production ready layouts) and Modelica® (for dynamic system analysis).

Aditya A. Shah, Aleksandr A. Kerzhner, Dirk Schaefer, Christiaan J. J. Paredis

Engineering Design Applications

Requirements Engineering in Complex Domains

Complexity in the application domains of software-intensive systems is continuously growing due to at least two reasons. Firstly, technical complexity grows as hardware and software have to interact in individual or even communicating embedded systems. Secondly, social complexity grows as the process organizations of the 1990’s are gradually being replaced by loosely coupled networks of actors, often organized around community platforms. In this chapter, we discuss recent solution attempts for these two issues individually, and end with speculating about their possible future interaction.

Matthias Jarke, Ralf Klamma, Klaus Pohl, Ernst Sikora

Tool Support for Dynamic Development Processes

Development processes in engineering disciplines are highly dynamic. Since development projects cannot be planned completely in advance, the process to be executed changes at run time. We present a process management system which seamlessly integrates planning and enactment. The system manages processes at the project management level, but goes beyond the functionality of project management systems inasmuch as it both monitors and controls development processes and supports enactment of tasks through a work environment. However, the process management system does not provide process automation as performed in workflow management systems. Therefore, we have developed tools for integrating process management and workflow management such that repetitive fragments of the overall development process may be enacted in workflow management systems and monitored in the process management system. Even in the case of repetitive process fragments, the need for deviations from the workflow definition may occur while a workflow is being enacted. Thus, we have also realized a tool which allows to perform dynamic changes of workflows during enactment. Altogether, dynamic development processes are supported through a synergistic combination of process and workflow management systems, integrating process planning and enactment.

Thomas Heer, Markus Heller, Bernhard Westfechtel, René Wörzberger

An Extensible Modeling Language for the Representation of Work Processes in the Chemical and Process Industries

Expressive models of the work processes performed in the chemical and process industries provide a basis for diverse applications like work process documentation, analysis, and enactment. In this contribution, we present a generic modeling language for different types of work processes to allow for their integrated representation in the life cycle of a chemical plant. Further, the generic language allows for extensions specific to certain types of work processes. For two important types – design and operational processes – such extensions have been elaborated. These extensions enable the adequate representation of the context of a work process that strongly depends on the process type: for instance, the specification of a chemical plant is a product of a design process, whereas the plant takes the role of a resource during an operational process. This contribution also briefly introduces a modeling tool developed by our group for applying the modeling language in industrial practice.

Ri Hai, Manfred Theißen, Wolfgang Marquardt

Integration Tools for Consistency Management between Design Documents in Development Processes

Development processes in engineering disciplines are inherently complex. Throughout the development process, the system to be built is modeled from different perspectives and on different levels of abstraction in multiple documents. They are related by manifold dependencies and need to be maintained mutually consistent with respect to these dependencies. In addition, development processes are highly incremental and iterative. Thus, tools are urgently needed which assist developers in maintaining consistency between inter-dependent documents. These tools have to operate incrementally and need to support user interactions, as the effects of changes cannot always be determined automatically and deterministically. At the Department of Computer Science 3 at RWTH Aachen University, triple graph grammars (TGG) have been invented as a formal approach to handling integration problems. During multiple research activities at the department and many other research groups, TGGs have been used as a basis to design algorithms and modeling formalisms and have been further elaborated. At the department they were implemented and enhanced in different ways for the support of rapid integration tool construction for real-world interactive development processes. This paper gives an insight into specification, algorithms, and tool construction for interactive, incremental integration and shows the application within the design process of a chemical plant executed in a commercial product.

Simon M. Becker, Anne-Thérèse Körtgen

Towards Semantic Navigation in Mobile Robotics

Nowadays mobile robots find application in many areas of production, public transport, security and defense, exploration of space, etc. In order to make further progress in this domain of engineering, a significant barrier has to be broken: robots must be able to understand the meaning of surrounding world. Until now, mobile robots have only perceived geometrical features of the environment. Rapid progress in sensory devices (video cameras, laser range finders, microwave radars) and sufficient computational power available on-board makes it possible to develop robot controllers that possess certain knowledge about the area of application and which are able to reason at a semantic level.

The first part of the paper deals with mobile robots dedicated to operate inside buildings. A concept of the semantic navigation based upon hypergraphs is introduced. Then it is shown how semantic information, useful for mobile robots, can be extracted from the digital documentation of a building.

In the second part of the paper we report the latest results on extracting semantic features from the raw data supplied by laser scanners. The aim of this research is to develop a system that will enable a mobile robot to operate in a building with ability to recognise and identify objects of certain classes. Data processing techniques involved in this system include a 3D-model of the environment updated on-line, rule-based and feature-based classifiers of objects, a path planner utilizing cellular networks and other advanced tools. Experiments carried out under real-life conditions validate the proposed solutions.

Adam Borkowski, Barbara Siemiatkowska, Jacek Szklarski

Model Driven Engineering in Operative Industrial Process Control Environments

- Overview -

Industrial process control is a profitable field for model driven approaches. The paper presents an overview and discusses the basic concepts and architectural principles. In future an increasing demand for engineering and reengineering activities in the operative phase is expected. In the industrial process control environment the necessary software changes in the operative phase often have to be performed without stopping the execution of the control system. The paper presents ideas and concepts to improve the model driven approaches and outlines ways to an assisted and partially automated control engineering.

Ulrich Epple


Weitere Informationen

Premium Partner

Neuer Inhalt

BranchenIndex Online

Die B2B-Firmensuche für Industrie und Wirtschaft: Kostenfrei in Firmenprofilen nach Lieferanten, Herstellern, Dienstleistern und Händlern recherchieren.



Product Lifecycle Management im Konzernumfeld – Herausforderungen, Lösungsansätze und Handlungsempfehlungen

Für produzierende Unternehmen hat sich Product Lifecycle Management in den letzten Jahrzehnten in wachsendem Maße zu einem strategisch wichtigen Ansatz entwickelt. Forciert durch steigende Effektivitäts- und Effizienzanforderungen stellen viele Unternehmen ihre Product Lifecycle Management-Prozesse und -Informationssysteme auf den Prüfstand. Der vorliegende Beitrag beschreibt entlang eines etablierten Analyseframeworks Herausforderungen und Lösungsansätze im Product Lifecycle Management im Konzernumfeld.
Jetzt gratis downloaden!