- Open Access
Supporting the building design process with graph-based methods using centrally coordinated federated databases
© The Author(s) 2017
Received: 11 November 2016
Accepted: 25 September 2017
Published: 24 October 2017
Technological developments and globalized working processes have transformed the building process. However, current digital semantic building models no longer adequately represent the increasing complexity of modern building projects. The potential of combining agent-based and graph-based methods, for example for energy calculations or spatial research strategies, is not fully exploited.
In our system, users search for building floorplans, for example as sources of inspiration, by creating conceptual hand-drawn sketches of building parts on multi-touch devices. The sketch is analyzed and used to query a federated database system comprising a building information model server, the graph database neo4j and the content management system mediaTUM. Users interact with client applications that show and continuously update a list of floorplans by sending queries to a central coordinator service. In the paper, we describe the coordinator that enables our databases to appear as a single smart information system to search for digital information about buildings and visualize their floorplans. The application case comprises search by drawing the initial design idea of a building to find similar floorplans e.g. as source of inspiration.
Our federated database system is queried using semantic building floorplan fingerprints, which are formalized as graphs and encoded in a common schema, like our AGraphML, to represent spatial configurations and perform graph matching. As graph matching is computationally expensive, the coordinator needs to analyze the queries, separate different fingerprints and metadata and pass it to specialized agents, implemented as microservices, for processing. The returned result sets are combined and the results are visualized. The use of multiple agents facilitates the recombination of the data from the underlying disparate data sources and also serves to support different execution strategies which are chosen using properties of the query and a set of predefined rules.
To deal with complex and dynamic queries, as well as dynamic results that are updated while some agents are still executing, a caching framework was developed which takes the similarity measures of the graph-based building representation into account when determining query equality.
As the complexity of building tasks and requirements increases, designers often find themselves confronted with interdisciplinary problems that go beyond the specific challenges and methods of architecture and engineering. The iterative nature of the design process results in a continuous exchange between creative, analytical and evaluative activities, through which the designer explores and identifies promising design variants. The ability to compare and evaluate relevant reference examples of already built or designed buildings helps designers assess their own design explorations and informs the design process. Most computational search methods available today rely on textual rather than graphical approaches to represent information. However, textual descriptions are not sufficient to adequately describe spatial configurations such as floor plans. To address these shortcomings, Langenhan et al. (2013) introduced a novel approach which facilitates the automatic lookup of reference solutions from a repository using graphical search keys. For the search key, the notion of a building floorplan fingerprint was introduced which describes the main characteristics of a building’s design. This forms the basis for assessing the similarity of different reference solutions to a specified problem and serves, accordingly, as an index for the building model repository.
This paper describes an information retrieval system that allows users to search for building models that are similar to a hand-drawn sketch of a building or parts of a building on a multi-touch device to support the design process of architects. The design process is an iterative process (Buxton 2007) of searching for a plausible solution involving a continual back and forth in which potential solutions are developed by various means before narrowing down the selection to the most promising candidates. Architects typically work with traditional design tools in the early design stages, such as model-making, sketches and the use of reference examples. Using reference examples is an acknowledged method in both architectural education and architectural practice and helps in learning design principles and guiding the design process, as well as for inspiration or even as an explicit solution (Richter 2010). Digital equivalents have already been devised for several traditional design tools, however many of these do not fully translate the original strengths of the analogue methods into the digital world and fail to make full use of digital possibilities.
There are six main reasons why we use coordinated microservices as our approach: First, we wish to support different types of fingerprints, each potentially implemented using its own microservice. Second, for each fingerprint, there may be multiple execution strategies available. This is particularly important for graph matching which often requires different strategies for different types of graphs in order to execute efficiently (Conte et al. 2004). It then becomes necessary to select the best service, e.g. based on a set of rules. Third, the building data is stored in a federated database system and it is useful to be able to access multiple databases in a single query. In our case the database system consists of the open source building information model server, the graph database neo4j, which stores the fingerprints, and the content management system mediaTUM, which holds pictures and metadata. Fourth, we want to be able to express complex queries that involve various microservices and obtain combined and ranked results. Fifth, since the computation of some fingerprints can be very expensive, it is necessary to reuse as much of the previous responses of the individual microservices as possible. Since reusability depends on the graph structure, an application-specific caching framework is needed. To address these problems while keeping the clients and microservices simple, we propose a central web service called the Coordinator which processes queries and distributes their parts to the microservices. Sixth, the coordinator can precompute visualization data for the client applications.
The components shown are groups of individual applications in the information cloud (servers) and on different end devices (clients). On the server-side the system is comprised of data storage, processing and coordination components. Possible clients include a desktop computer with mouse and keyboard (stationary workstation, e.g. in the office), tablet computers (transportable device, e.g. for client visits and meetings), smartphones (mobile, e.g. on-site use or site research) and a multi-touch table (stationary design environment).
The application contexts and individual design processes differ from case to case. Different abstractions are therefore necessary to allow the designer to communicate his or her mental model as completely and accurately as possible. Because designers often only have a vague and incomplete notion of the design in the early design phases, the system needs to accommodate a high degree of freedom of expression and types of abstraction.
Different layers of abstraction
“Progressive analysis: provide quick answers first, then make improvements incrementally or on-demand;
Management of dynamic data: incremental analysis instead of restarting it from the beginning;
Steerable analysis: allow long-computations to be steered by users when possible.” (Keim et al. 2010, p. 106)
Texts (for example architect, year of completion, building costs, text search, descriptions, building typology)
Tables (for example schedule of rooms, schedule of works, cost plan, specification of works, list of neighbors, access routes)
Schemes (for example diagrams, spatial arrangement, zones, orientation, proportions, passage through a room, adjacent relation to other spaces)
Freehand sketches (for example, arrangement of spaces, zoning, orientation, proportions, passage through a room, spatial delineation, floor plans, elevations, sections)
2D/3D drawings (for example, arrangement of spaces, zoning, orientation, proportions, passage through a room, adjacency relationships, cubature, floor plans, elevations, sections, perspectives).
The transformation between different digital formalization’s and visualizations and their respective levels of abstraction is of particular help in the design process and is a topic of ongoing research. The aim is to examine the technical possibilities for computer-based interpretation of user input and the visualizations of building data.
Our prototypes enable users to interactively retrieve descriptions of similar building floorplans by sending queries which are constructed visually to a Coordinator middleware. The ability to add detail to or modify one’s input, for example by adding a room to a drawing, makes it possible to formulate more granular fingerprint-queries and the mental model corresponds better to the designer’s own mental model. By providing ongoing feedback, e.g. in the form of reference projects that match the fingerprint, the information system prompts the designer to modify and adapt his or her design idea. By increasing or decreasing the degree of specification, the set of possible search results can be expanded or focused to better match the problem at hand. What density of information is adequate and necessary depends on the specific application at hand and the user. For the general definition of spaces, their relationships and the passage between them, a simple graph can be sufficient. Graphs can take the form of diagrams or tables (Beck et al. 2014, p. 88). In our information system, we have used node and edge diagrams to make it easier to depict the location and relationship between rooms or nodes. Our user interface investigations looked at ways of providing vague input about spatial situations and constellations, i.e. their basic characteristics and arrangement. The corresponding formulation of this as a graph is shown to the user at different levels of abstraction.
The system has to provide interaction approaches that allow the user to express the mental model that can be analyzed and compared with stored model schemes to produce search results. Therefore, contextual coherence between the mental model and the representations of information is necessary. Accordingly, suitable strategies need to be implemented to achieve a beneficial outcome for the user.
Whenever the user modifies the sketch or the parameters of the filters, a new query needs to be generated and sent to the Coordinator. The sketch is encoded as an AGraphML floorplan graph and the filters are encoded as XML as well. After the coordinator has received the query, it executes it by distributing parts of it to the connected microservices and combining the results.
The ability to add detail to or modify one’s input, for example by adding a room to a drawing, makes it possible to express more granular fingerprint-queries and the mental model corresponds better to the designer’s own mental model. For this purpose, we implemented separate prototypes that use the same data stock to compare different input and retrieval strategies.
Our user interface investigations looked at ways of providing vague input about spatial situations and constellations, i.e. their basic characteristics and arrangement. The corresponding mathematical formulation of this as a graph is shown to the user at different levels of abstraction.
The different use cases (e.g. in the office, when visiting a client, in a meeting, out on site or while designing) are conceived as prototypes for the respective user. For the most common office drawing situation with mouse and keyboard, we propose using the a.vista concept previously developed by Christoph Langenhan in 2008 (Langenhan and Petzold 2010), which has different semantic ways of describing a building (level, unit, zone, and room).
To incorporate such topological approaches in the design process, Thomas Stocker, Dario Banfi, Jana Pejic, Thomas Kühner, Markus Dausch, Bishwa Hang Rai, Dominic Henze, Arno Schneider and Johannes Roith have jointly developed an Add-on called Dolphin (Langenhan and Petzold 2015) for Rhino3D and its parametric design extension Grasshopper3D. The Dolphin Add-on provides a series of components for visual programming using Grasshopper3D that make it possible to query the information system using drawings in Rhino3D and additional meta information. The data can be exported for further use directly from the graph database using a service called pigeon developed by Leon Höß and Christopher Will. For example, AgraphML files can be imported with other components, either individually or as a collection, into Grasshopper3D for further use.
The Coordinator to prepare and visualize the results
Although clients can specify the list of possible or required fingerprint matches as part of the expression tree, it is also possible to allow the server to select appropriate fingerprints based on the query graph. In this case, clients include a special ’auto’ match condition in the query tree. For example, if a floorplan graph lacks node or edge labels, a fingerprint that relies on those labels can’t be computed and will not be included in the server-selected list. Fingerprints may also have parameters, for example to adjust the required precision of a match. For server-selected fingerprints, appropriate parameters need to be selected. In some cases, it may be appropriate to select multiple possible parameters and have multiple instances of the same fingerprint. For example, the room-area fingerprint is always parameterized by the room type. If created during server-side fingerprint selection, a fingerprint instance is added for each room type that is found in the query graph.
For each condition (and, by extension, fingerprint) an agent must be selected to execute it. If more than one agent is compatible with the condition/fingerprint type and parameters, a good one (that produces good results, ranks them well, executes quickly and consumes little resources) has to be picked. The rules usually look at certain features of the floorplan graph - for example the number of nodes - to make a decision.
After query preparation, all server- and client-side decisions that can affect the returned result set have been taken (based on rules and the server configuration) and specified as part of the rewritten query. The next phase deals with executing queries efficiently.
When combining intermediate result sets, duplicates need to be merged. All elements need to have a common identifier that is available in all data sources. These identifiers are encapsulated in packets, which can carry associated information, including the set of fingerprints matched so far and the current score of a result. Merges occur while results move through the execution DAG or when a result is added to the result list and an identical result is already present. For example, if two results with the same identity arrive at an AND node, they are combined before being pushed onwards. Packets support a content-specific merge operation. For example, the associated score values are merged into a new combined score.
Agents as data filters
Agents internally access the complete set of all buildings in the database and produce a subset. Instead of having agents operate on the underlying database set, it would be useful to get them to operate as filters on intermediate sets. Filters have two advantages: First, since intermediate input sets are likely to be smaller than the full underlying set, filters only have to operate on the smaller set and are likely to be faster. Second, filters could potentially depend on the structure of their input when used sequentially. For example, a fingerprint implemented using a filter might assume that its input set already has certain properties, due to being produced by another fingerprint. This can simplify the implementation of an agent. Since the data has to come from somewhere, some agents will always be data sources. Another limitation of filters is that the input set needs to be copied over the network into the agent. Finally, some agents cannot benefit from processing an input set, e.g. if they operate on pre-computed sets of the full database.
Caching and query equality
Coordinator queries are dynamic and updates can happen in both directions: Clients frequently adapt queries in response to user input and result lists change during the execution of long-running queries. To simplify the interface and the clients, clients will always issue new queries. To achieve acceptable performance, the server needs to be able to determine which parts of previous queries are semantically equal and can therefore be reused. We support a query cache, which shares the result list of an existing query and only attaches a new change event listener. In order to determine if a query can be reused, the new query is transformed as usual and the transformed AST is compared to the transformed AST of previous queries. If the ASTs are equal, the results must also be equal and the result list can be reused.
where G is the set of all AGraphML documents. For correctness we require: if e q f (g 1,g 2) then the corresponding fingerprints f 1 and f 2 must produce the same results. This is the only requirement, but for optimal sensitivity fingerprints that always produce the same result sets should also satisfy e q f (g 1,g 2)=t r u e. Similarly for good sensitivity we want: e q f (g 1,g 2) ⇒ h f (g 1)=h f (g 2). Finally, the usual considerations for good hashing performance apply.
Narrowing down the design and refining the graphical queries.
Definition of multiple levels of abstraction, which include geometrical, topological and alphanumerical data.
Supporting a flexible work process, which typically involves switching between multiple levels of abstraction when expressing queries. Additionally, users need to be able to start at a suitable point, depending on the stage of the design process.
Precise specification through logical expressions, comparisons and set operations.
Prioritizing the derived fingerprints.
Deriving sequential and parallel search strategies.
Support of a query history.
Interaction and input metaphor based on the desired information density, e.g. bubble diagrams and room volume
Browsing and using search results as queries
Suggestion of queries (trends, similar queries)
User-specific weighting of search criteria
To enable the visualization, exploration and comparison of the results, visualization methods from architecture, visual communication, information and data visualization and interactive data analysis were considered. Understandability and readability were a major concern. Based on the particular fingerprints, the degree of abstraction of the input, and a manual review of the results, candidates like line graphs, scatter plots, and more interactive approaches like coordinated and multiple views, linking and brushing were analyzed using standard tools including Orange, Rapidminer, VisTrails and Aperture Tiles.
Throughout the design process, the spatial models, rooms, and their interrelationships become increasingly concrete in geometrical and topological terms. Which interactions are reasonable and required, depends on the use case and on the user. The topology of the rooms can be formalized as graphs and visualized using edge and vertex diagrams. The implemented system uses such diagrams, since they highlight the spacial relationships between rooms.
Identifying, adding and deleting nodes. Some fingerprints need to identify nodes. This can’t be done using a graph matching algorithm or graph canonicalization, since such an approach would defeat the purpose of caching. Instead simple heuristics need to be used.
Attributes are added, changed or removed for nodes or edges. Such a change leads to cache misses if trivial implementations like the syntactical equality functions are used. Implementations can easily avoid this by providing a custom graph equivalence implementation and only comparing the attributes that can possibly affect the fingerprint.
Edges are temporarily removed by the same client and restored later. If edges need to be identified on the server, this should not be done using their id, but using the ids of the connected nodes.
Nodes are temporarily removed by the same client and restored later. Clients should try to pick the same node id for nodes that are likely to be the same as a node that previously existed. This is obviously the case for nodes that are restored via an undo/redo feature.
Sorted result list and change events
Packets eventually reach the root node of the execution DAG where they are inserted into an observable result list. The web service layer registers an observer for each query and translates the insert, remove, move, update, and error/warning events into an XML stream that is transferred to the client over HTTP one element at a time. Clients apply each event to a local list to synchronize it.
Clients can use the results to either show a global overview that does not visualize individual floor plans, but summarizes the resulting data with respect to the individual fingerprints or visualize each result separately. The visualization options range from simple bar and pie charts to complex mappings between query and result and the clustering of result sets. These include an overview of the found floor plans, the fingerprint-based mapping between rooms in the query and a selected result and the data analysis of the result set based on clustering. For example, the metis Web UI displays an overview of the results in the right column of the user interface by showing the floorplan structures from the CMS mediatum, sorted by similarity. Selecting such a floorplan produces a mapping view, making it possible to evaluate the quality of this result by comparing the room configurations. The prototype client applications a.scatch, TouchTect, ar:searchdroid and cormorant accept input from freehand drawings which are created using a digital pen. The quality of the different visualizations and interactions was evaluated in a user study (Bayer et al. 2015). This initial proof of concept indicated that while most participants liked the prototypes, paper and pen were still the preferred method.
Conclusions and future work
Our system selects agents using a database of rules when executing a condition in a query. The goal is to pick agents that are computationally efficient or produce good results. The rule-based approach is straightforward to implement and makes it easy to understand and to visualize why a particular decision was taken. A drawback is that it is difficult to determine good decision values for the various features and that the rule database has to be maintained by hand. Instead of producing the rules by hand, it might be useful to learn them using machine learning. To keep the benefit of an intelligible system with easily traceable decisions, rule learning or decision trees are a good candidate (Flach 2012). A recent overview of rule learning is published in (Fürnkranz and Kliegr 2015). By keeping the intermediate results of executions and tracking the execution time of each agent, this approach could be taken further to learn and incrementally improve the rule set online. Clients could be extended to provide feedback on the quality of results, for example by allowing users to rate them.
Goldschmidt and Smalkov have posed the underlying question of whether visual thinking is derived from mental processes or from preceding visual images (Goldschmidt and Smolkov 2006, p. 549). The history of architecture shows that design tools have influenced how the built environment was made. The influence of tools on the thinking process is, however, hard to measure. Gaenshirt has argued that every software contains a hidden ideology (Gänshirt 2007, p. 193) which conditions every object constructed with them. It might be useful to keep a history of query results and possibly also intermediate sets permanently, for example to support the machine learning case described above or other data mining scenarios. The persisted data needs to be versioned to account for changes in the database and in the involved services.
We have described the design and implementation of the Coordinator, a middleware to support graph-based floorplan retrieval. The system accepts queries in a unified query language and executes them using agents which are selected using a set of rules. Furthermore, queries can be updated and the Coordinator achieves efficient execution using a domain-specific caching framework. Future work includes automatically learning the rules, providing support for online analysis of materialized datasets and improving the prototype implementation.
1 “Data integration is the problem of providing unified and transparent access to a set of autonomous and heterogeneous sources, in order to allow for expressing queries that could not be supported by the individual data sources alone.” (Keim et al. 2010, p. 23)
2 Semantically equal means that the queries describe the same set of results, but are phrased slightly differently.
The work presented was supported by the German Research Foundation (DFG) as part of the ‘metis’ research project.
Availability of data and materials
JR is responsible for the computer-science related parts of the paper. CL and FP are responsible for the architecture-related parts of the paper. All authors read and approved the final manuscript.
Ethics approval and consent to participate
Consent for publication
The authors declare that they have no competing interests.
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Open Access This article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.
- Bayer, J, Bukhari, S, Langenhan, C, Eichenberger-Liwicki M, Althoff KD, Petzold, F, Dengel, A (2015). Migrating the classical pen-and-paper based conceptual sketching of architecture plans towards computer tools: Prototype design and evaluation. In GREC 2015. Springer International Publishing. doi:10.1007/978-3-319-52159-6_4.
- Beck, F, Burch, M, Diehl, S, Weiskopf, D (2014). The State of the Art in Visualizing Dynamic Graphs. In Proceedings State of the Art Reports (STARs). 1605.08485, (pp. 83–103).Google Scholar
- Buxton, W. (2007). Sketching User Experience. Getting the Design Right and the Right Design. San Francisco: M. Kaufmann.Google Scholar
- Conte, D, Foggia, P, Sansone, C, Vento, M (2004). Thirty Years of Graph Matching in Pattern Recognition. International Journal of Pattern Recognition and Artificial Intelligence, 18(03), 265–298.View ArticleGoogle Scholar
- Dengel, A. (2012). Semantische Technologien, (p. 461). http://link.springer.com/10.1007/978-3-8274-2664-2.
- Flach, P. (2012). Machine Learning. The Art and Science of Algorithms that Make Sense of Data vol. 2010, (p. 396). New York: Cambridge University Press.View ArticleMATHGoogle Scholar
- Fürnkranz, J, & Kliegr, T (2015). A Brief Overview of Rule Learning. In: Bassiliades, N, Gottlob, G, Sadri, F, Paschke, A, Roman, D (Eds.) In Rule Technologies: Foundations, Tools, and Applications SE - 4. Lecture Notes in Computer Science. http://link.springer.com/10.1007/978-3-319-21542-6_4, (Vol. 9202. Springer, Berlin, pp. 54–69).
- Gänshirt, C (2007). Werkzeuge Für Ideen. Einführung Ins Architektonische Entwerfen., Basel. http://www.gbv.de/dms/hebis-darmstadt/toc/187535930.pdf.
- Goldschmidt, G, & Smolkov, M (2006). Variances in the impact of visual stimuli on design problem solving performance. Design Studies, 27(5), 549–569.View ArticleGoogle Scholar
- GraphML (2017). The GraphML File Format. http://graphml.graphdrawing.org/. Accessed 4 May 2011.
- Gratzl, S, Lex, A, Gehlenborg, N, Pfister, H, Streit, M (2013). LineUp: Visual analysis of multi-attribute rankings. IEEE Transactions on Visualization and Computer Graphics, 19(12), 2277–2286.View ArticleGoogle Scholar
- Hanson, J. (1998). Decoding Homes and Houses. Cambridge; New York: Cambridge University Press.Google Scholar
- Keim, D, Kohlhammer, J, Ellis, G, Mansmann, F. (2010). Mastering the information age: Solving problems with visual analytics. Goslar: Eurographics Association.Google Scholar
- Langenhan, C (2017). Data Management in Architecture - Investigating the organisation of design information in IT infrastructures and identifying potential uses in knowledge-based systems. Dissertation. Technical University of Munich. ISBN 978-620-2-32014-6. Online verfügbar: https://mediatum.ub.tum.de/doc/1335437/1335437.pdf.
- Langenhan, C, & Petzold, F (2010). The fingerprint of architecture: sketch-based design methods for researching building layouts through the semantic fingerprinting of floor plans. International electronic scientific-educational journal: Architecture and Modern Information Technologies, 4(13), 1–8. http://www.marhi.ru/eng/AMIT/2010/4kvart10/langenhan/abstract.php.
- Langenhan, C, & Petzold, F (2015). BEYOND THE BUBBLE – Computer-aided topological analysis and parametric de-sign of room configurations in university education. In eCAADe 2015 – 33rd Annual Conference 16th–18th September 2015. Vienna. eCAADe (Education and research in Computer Aided) Architectural Design in Europe) and Faculty of Architecture and Urban Planning, TU Wien.Google Scholar
- Langenhan, C, & Petzold, F (2016). Perspectives on architecture: Different abstraction layer of building information imply special working methods and interaction metaphors to support a variety course of action. In Sigradi, 2016. XX Conference of the Iberoamerican Society of Digital Graphics.Google Scholar
- Langenhan, C, Sahm, A, Seifert, A, Teichert, A, Petzold, F (2013). Mobile application to collect information about architecture to obtain a collective knowledge base. In ASCAAD 2013.Google Scholar
- Langenhan, C, Seifert, A, Teichert, A, Petzold, F (2012). ar:searchbox: Knowledge management for architecture students. In eCAADe. eCAADe (Education and research in Computer Aided) Architectural Design in Europe) and ČVUT, Faculty of Architecture.Google Scholar
- Langenhan, C, Weber, M, Liwicki, M, Petzold, F, Dengel, A (2013). Graph-based retrieval of building information models for supporting the early design stages. Advanced Engineering Informatics, 27(4), 413–426.View ArticleGoogle Scholar
- Liebich, T. (1994). Wissensbasierter Architekturentwurf. Von Den Modellen des Entwurfs zu Einer Intelligenten Computerunterstützung. Weimar: VDG, Verlag und Datenbank für Geisteswissenschaften.Google Scholar
- Richter, K. (2010). Augmenting Designers’ Memory. Case Based Reasoning in der Architektur. Berlin: Logos-Verlag.Google Scholar
- Roith, J, Langenhan, C, Petzold, F (2016). Supporting the building design process with graph-based methods using centrally coordinated federated databases. In ICCCBE, Osaka.Google Scholar
- Roth-Berghofer, TR, & Richter, MM (2008). On explanation. Künstliche Intelligenz, 22(2), 5–7.Google Scholar
- Thurow, T, Langenhan, C, Petzold, F (2016). Assisting early architectural planning using a geometry-based graph search. In eCAADe 2016.Google Scholar
- Vatavu, RD, Anthony, L, Wobbrock, JO (2015). $P Point-Cloud Recognizer. https://depts.washington.edu/aimgroup/proj/dollar/pdollar.html.
- Weber, M, Langenhan, C, Roth-Berghofer, T, Liwicki, M, Dengel, A, Petzold, F (2010). a.scatch semantic structure for architectural floor plan retrieval. In: Bichindaritz, I, & Montani, S (Eds.) In ICCBR, (Vol. 6176. Springer, Berlin, pp. 2010–6176510524).Google Scholar
- Weber, M, Langenhan, C, Roth-Berghofer, T, Liwicki, M, Dengel, A, Petzold, F (2011). Fast subgraph isomorphism detection for graph-based retrieval. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), 6880 LNAI, 319–333.Google Scholar