org.simantics.district.network/src/org/simantics/district/network/DistrictNetworkUtil.java

   1 package org.simantics.district.network;
   2
   3 import java.awt.geom.Rectangle2D;
   4 import java.util.ArrayList;
   5 import java.util.Collection;
   6 import java.util.Collections;
   7 import java.util.HashMap;
   8 import java.util.Iterator;
   9 import java.util.List;
  10 import java.util.Map;
  11 import java.util.UUID;
  12 import java.util.stream.Collectors;
  13 import java.util.stream.Stream;
  14
  15 import org.simantics.databoard.Bindings;
  16 import org.simantics.datatypes.literal.RGB;
  17 import org.simantics.datatypes.literal.RGB.Integer;
  18 import org.simantics.db.ReadGraph;
  19 import org.simantics.db.Resource;
  20 import org.simantics.db.WriteGraph;
  21 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
  22 import org.simantics.db.common.request.IndexRoot;
  23 import org.simantics.db.common.request.ResourceRead;
  24 import org.simantics.db.common.utils.OrderedSetUtils;
  25 import org.simantics.db.exception.BindingException;
  26 import org.simantics.db.exception.DatabaseException;
  27 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
  28 import org.simantics.db.exception.ServiceException;
  29 import org.simantics.db.indexing.IndexUtils;
  30 import org.simantics.db.layer0.QueryIndexUtils;
  31 import org.simantics.db.layer0.request.PossibleVariable;
  32 import org.simantics.db.layer0.variable.Variable;
  33 import org.simantics.diagram.stubs.DiagramResource;
  34 import org.simantics.diagram.synchronization.graph.DiagramGraphUtil;
  35 import org.simantics.diagram.synchronization.graph.layer.GraphLayer;
  36 import org.simantics.diagram.synchronization.graph.layer.IGraphLayerUtil;
  37 import org.simantics.district.network.ontology.DistrictNetworkResource;
  38 import org.simantics.district.network.visualisations.DynamicVisualisationsContributions;
  39 import org.simantics.district.network.visualisations.model.ColorBarOptions;
  40 import org.simantics.district.network.visualisations.model.ColorBarOptions.ColorBarsLocation;
  41 import org.simantics.district.network.visualisations.model.ColorBarOptions.ColorBarsSize;
  42 import org.simantics.district.network.visualisations.model.DynamicColorContribution;
  43 import org.simantics.district.network.visualisations.model.DynamicColorMap;
  44 import org.simantics.district.network.visualisations.model.DynamicSizeContribution;
  45 import org.simantics.district.network.visualisations.model.DynamicSizeMap;
  46 import org.simantics.district.network.visualisations.model.SizeBarOptions;
  47 import org.simantics.district.network.visualisations.model.SizeBarOptions.SizeBarsLocation;
  48 import org.simantics.district.network.visualisations.model.SizeBarOptions.SizeBarsSize;
  49 import org.simantics.layer0.Layer0;
  50 import org.simantics.maps.elevation.server.SingletonTiffTileInterface;
  51 import org.simantics.maps.elevation.server.prefs.MapsElevationServerPreferences;
  52 import org.simantics.modeling.ModelingResources;
  53 import org.simantics.modeling.adapters.NewCompositeActionFactory;
  54 import org.simantics.operation.Layer0X;
  55 import org.simantics.utils.datastructures.Pair;
  56 import org.slf4j.Logger;
  57 import org.slf4j.LoggerFactory;
  58
  59 public class DistrictNetworkUtil {
  60
  61     private static final Logger LOGGER = LoggerFactory.getLogger(DistrictNetworkUtil.class);
  62
  63     public static Resource createEdge(WriteGraph graph, Resource composite, double[] detailedGeometryCoords) throws DatabaseException {
  64         return createEdge(graph, composite, graph.getPossibleObject(composite, DistrictNetworkResource.getInstance(graph).EdgeDefaultMapping), detailedGeometryCoords);
  65     }
  66
  67     public static Resource createEdge(WriteGraph graph, Resource composite, Resource mapping, double[] detailedGeometryCoords) throws DatabaseException {
  68         Layer0 L0 = Layer0.getInstance(graph);
  69         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
  70         if (mapping == null) {
  71             mapping = graph.getSingleObject(composite, DN.EdgeDefaultMapping);
  72         }
  73
  74         Resource edge = graph.newResource();
  75         graph.claim(edge, L0.InstanceOf, DN.Edge);
  76
  77         graph.claim(edge, DN.HasMapping, null, mapping);
  78
  79         OrderedSetUtils.addFirst(graph, composite, edge);
  80         graph.claim(composite, L0.ConsistsOf, L0.PartOf, edge);
  81
  82         claimFreshElementName(graph, composite, edge);
  83
  84         // We need to put GraphLayer to newLayers so...
  85         for (Resource layer : graph.getObjects(composite, DiagramResource.getInstance(graph).HasLayer)) {
  86             IGraphLayerUtil layerUtil = graph.adapt(graph.getSingleObject(layer, Layer0.getInstance(graph).InstanceOf), IGraphLayerUtil.class);
  87
  88             GraphLayer gl = layerUtil.loadLayer(graph, layer);
  89             gl.forEachTag(tag -> {
  90                 DiagramGraphUtil.tag(graph, edge, tag, true);
  91             });
  92         }
  93
  94         // add detailed geometry (if any)
  95         graph.claimLiteral(edge, DN.Edge_HasGeometry, detailedGeometryCoords, Bindings.DOUBLE_ARRAY);
  96         return edge;
  97     }
  98
  99     /**
 100      * @param graph
 101      * @param composite
 102      * @param coords
 103      * @param elevation Double.MAX_VALUE to fetch elevation from elevation server (if enabled and has data)
 104      * @return
 105      * @throws DatabaseException
 106      */
 107     public static Resource createVertex(WriteGraph graph, Resource composite, double[] coords, double elevation) throws DatabaseException {
 108         Resource defaultVertexMapping = graph.getPossibleObject(composite, DistrictNetworkResource.getInstance(graph).VertexDefaultMapping);
 109         return createVertex(graph, composite, coords, elevation, defaultVertexMapping);
 110     }
 111
 112     /**
 113      * @param graph
 114      * @param composite
 115      * @param coords
 116      * @param elevation Double.MAX_VALUE to fetch elevation from elevation server (if enabled and has data)
 117      * @param mapping
 118      * @return
 119      * @throws DatabaseException
 120      */
 121     public static Resource createVertex(WriteGraph graph, Resource composite, double[] coords, double elevation, Resource mapping) throws DatabaseException {
 122         // Double.MAX_VALUE is our secret to lookup elevation from elevation server
 123         if (elevation == Double.MAX_VALUE) {
 124             // ok, resolve from server or default to 0
 125             if (MapsElevationServerPreferences.useElevationServer()) {
 126                 // ok! we use new elevation API to resolve possible elevations for the starting points
 127                 try {
 128                     elevation = SingletonTiffTileInterface.lookup(coords[1], coords[0]).doubleValue();
 129                 } catch (Exception ee) {
 130                     LOGGER.error("Could not get elevation from tiff interface", ee);
 131                 }
 132             } else {
 133                 elevation = 0;
 134             }
 135         }
 136
 137         Layer0 L0 = Layer0.getInstance(graph);
 138         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 139         DiagramResource DIA = DiagramResource.getInstance(graph);
 140         Resource vertex = graph.newResource();
 141         graph.claim(vertex, L0.InstanceOf, DN.Vertex);
 142         graph.claimLiteral(vertex, DIA.HasLocation, coords);
 143         graph.claimLiteral(vertex, DN.Vertex_HasElevation, elevation, Bindings.DOUBLE);
 144
 145         graph.claim(vertex, DN.HasMapping, null, mapping);
 146
 147         OrderedSetUtils.add(graph, composite, vertex);
 148         graph.claim(composite, L0.ConsistsOf, L0.PartOf, vertex);
 149
 150         claimFreshElementName(graph, composite, vertex);
 151
 152         // We need to put GraphLayer to newLayers so...
 153         for (Resource layer : graph.getObjects(composite, DiagramResource.getInstance(graph).HasLayer)) {
 154             IGraphLayerUtil layerUtil = graph.adapt(graph.getSingleObject(layer, Layer0.getInstance(graph).InstanceOf), IGraphLayerUtil.class);
 155
 156             GraphLayer gl = layerUtil.loadLayer(graph, layer);
 157             gl.forEachTag(tag -> {
 158                 DiagramGraphUtil.tag(graph, vertex, tag, true);
 159             });
 160         }
 161
 162         return vertex;
 163     }
 164
 165     public static Resource joinVertices(WriteGraph graph, Collection<Resource> vertices) throws DatabaseException {
 166         if (vertices.isEmpty())
 167             throw new IllegalArgumentException("vertices-collection should not be empty for joining vertices!");
 168         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 169         Iterator<Resource> verticeIterator = vertices.iterator();
 170         Resource master = verticeIterator.next();
 171         while (verticeIterator.hasNext()) {
 172             Resource slave = verticeIterator.next();
 173             Resource composite = graph.getSingleObject(slave, Layer0.getInstance(graph).PartOf);
 174             Collection<Resource> startVertexEdges = graph.getObjects(slave, DN.HasStartVertex_Inverse);
 175             for (Resource startVertexEdge : startVertexEdges) {
 176                 graph.deny(startVertexEdge, DN.HasStartVertex);
 177                 graph.claim(startVertexEdge, DN.HasStartVertex, master);
 178             }
 179             Collection<Resource> endVertexEdges = graph.getObjects(slave, DN.HasEndVertex_Inverse);
 180             for (Resource endVertexEdge : endVertexEdges) {
 181                 graph.deny(endVertexEdge, DN.HasEndVertex);
 182                 graph.claim(endVertexEdge, DN.HasEndVertex, master);
 183             }
 184             OrderedSetUtils.remove(graph, composite, slave);
 185             // Remove ConsistsOf statement
 186             graph.deny(composite, Layer0.getInstance(graph).ConsistsOf, slave);
 187         }
 188         return master;
 189     }
 190
 191     public static double calculateDistance(ReadGraph graph, Resource startVertex, Resource endVertex) throws DatabaseException {
 192         Layer0 L0 = Layer0.getInstance(graph);
 193         Resource startComposite = graph.getSingleObject(startVertex, L0.PartOf);
 194         Resource endComposite = graph.getSingleObject(endVertex, L0.PartOf);
 195         if (!startComposite.equalsResource(endComposite)) {
 196             throw new DatabaseException("Can not calculate distance between vertices on different composites! " + startVertex + " -> " + endVertex);
 197         }
 198         Resource crs = graph.getSingleObject(startComposite, DistrictNetworkResource.getInstance(graph).HasSpatialRefSystem);
 199
 200         CRS crsClass = graph.adapt(crs, CRS.class);
 201
 202         double[] startCoords = graph.getRelatedValue2(startVertex, DiagramResource.getInstance(graph).HasLocation, Bindings.DOUBLE_ARRAY);
 203         double[] endCoords = graph.getRelatedValue2(endVertex, DiagramResource.getInstance(graph).HasLocation, Bindings.DOUBLE_ARRAY);
 204
 205         return crsClass.calculateDistance(startCoords, endCoords);
 206     }
 207
 208     public static final String claimFreshElementName(WriteGraph graph, Resource diagram, Resource element) throws DatabaseException {
 209         Layer0 L0 = Layer0.getInstance(graph);
 210         DiagramResource DIA = DiagramResource.getInstance(graph);
 211         // Get name prefix from diagram
 212         String namePrefix = graph.getPossibleRelatedValue2(diagram, Layer0X.getInstance(graph).HasGeneratedNamePrefix);
 213         if (namePrefix == null)
 214             namePrefix = "";
 215         // Give running name to element and increment the counter attached to the diagram.
 216         Long l = graph.getPossibleRelatedValue(diagram, DIA.HasModCount, Bindings.LONG);
 217         if (l == null)
 218             l = Long.valueOf(0L);
 219         String name = namePrefix + l.toString();
 220         graph.claimLiteral(element, L0.HasName, name, Bindings.STRING);
 221         graph.claimLiteral(diagram, DIA.HasModCount, ++l, Bindings.LONG);
 222         return name;
 223     }
 224
 225     public static Resource getDiagramElement(ReadGraph graph, Resource component) throws DatabaseException {
 226         if (component == null)
 227             return null;
 228         DiagramResource DIA = DiagramResource.getInstance(graph);
 229         if (graph.isInstanceOf(component, DIA.Element))
 230             return component;
 231         ModelingResources MOD = ModelingResources.getInstance(graph);
 232         Resource element = graph.getPossibleObject(component, MOD.ComponentToElement);
 233         return element != null && graph.isInstanceOf(element, DIA.Element) ? element : null;
 234     }
 235
 236     public static Resource getMappedElement(ReadGraph graph, Resource element) throws DatabaseException {
 237         if (element == null)
 238             return null;
 239         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 240         return graph.getPossibleObject(element, DN.MappedComponent);
 241     }
 242
 243     public static Resource getMappedComponent(ReadGraph graph, Resource element) throws DatabaseException {
 244         if (element == null)
 245             return null;
 246         Resource mappedElement = getMappedElement(graph, element);
 247         if (mappedElement == null)
 248             return null;
 249         ModelingResources MOD = ModelingResources.getInstance(graph);
 250         return graph.getPossibleObject(mappedElement, MOD.ElementToComponent);
 251     }
 252
 253     public static Resource getMappedComponentCached(ReadGraph graph, Resource vertex) throws DatabaseException {
 254         return graph.syncRequest(new MappedComponentRequest(vertex), TransientCacheListener.instance());
 255     }
 256
 257     public static Resource getMappedDNElement(ReadGraph graph, Resource element) throws DatabaseException {
 258         if (element == null)
 259             return null;
 260         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 261         return graph.getPossibleObject(element, DN.MappedFromElement);
 262     }
 263
 264     public static Variable toMappedConfigurationModule(ReadGraph graph, Resource input) throws DatabaseException {
 265         if (input == null)
 266             return null;
 267
 268         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 269         if (graph.isInstanceOf(input, DN.Element)) {
 270             Resource mappedElement = getMappedElement(graph, input);
 271             if (mappedElement == null)
 272                 return null;
 273
 274             ModelingResources MOD = ModelingResources.getInstance(graph);
 275             Resource mappedComponent = graph.getPossibleObject(mappedElement, MOD.ElementToComponent);
 276             if (mappedComponent == null)
 277                 return null;
 278
 279             return graph.syncRequest(new PossibleVariable(mappedComponent));
 280         }
 281         return null;
 282     }
 283
 284     public static void toggleDrawMap(WriteGraph graph, Resource diagram) throws ManyObjectsForFunctionalRelationException, BindingException, ServiceException {
 285         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 286         Boolean current = graph.getPossibleRelatedValue(diagram, DN.Diagram_drawMapEnabled, Bindings.BOOLEAN);
 287         if (current == null)
 288             current = true;
 289         graph.claimLiteral(diagram, DN.Diagram_drawMapEnabled, !current, Bindings.BOOLEAN);
 290     }
 291
 292     public static Boolean drawMapEnabled(ReadGraph graph, Resource diagram) throws ManyObjectsForFunctionalRelationException, BindingException, ServiceException {
 293         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 294         Boolean current = graph.getPossibleRelatedValue(diagram, DN.Diagram_drawMapEnabled, Bindings.BOOLEAN);
 295         return current != null ? current : true;
 296     }
 297
 298     public static void changeMapBackgroundColor(WriteGraph graph, Resource diagram, Integer integer) throws DatabaseException {
 299         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 300         graph.claimLiteral(diagram, DN.Diagram_backgroundColor, integer, Bindings.getBindingUnchecked(RGB.Integer.class));
 301     }
 302
 303     public static Boolean trackChangesEnabled(ReadGraph graph, Resource diagram) throws DatabaseException {
 304         if (diagram != null && graph.hasStatement(diagram)) {
 305             return Boolean.TRUE.equals(graph.getPossibleRelatedValue(diagram,
 306                 DistrictNetworkResource.getInstance(graph).Diagram_trackChangesEnabled));
 307         } else {
 308             return false;
 309         }
 310     }
 311
 312     public static RGB.Integer backgroundColor(ReadGraph graph, Resource diagram) throws DatabaseException {
 313         return graph.getPossibleRelatedValue(diagram,
 314                 DistrictNetworkResource.getInstance(graph).Diagram_backgroundColor,
 315                 Bindings.getBindingUnchecked(RGB.Integer.class));
 316     }
 317
 318     public static Resource createNetworkDiagram(WriteGraph graph, Resource target, Resource compositeType, String defaultName, Resource defaultEdgeMapping, Resource defaultVertexMapping, Resource rightClickVertexMapping, Resource leftClickVertexMapping, Resource crs) throws DatabaseException {
 319         Resource composite = NewCompositeActionFactory.createComposite(graph, target, defaultName, compositeType);
 320
 321         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 322         Resource diagram = graph.getSingleObject(composite, ModelingResources.getInstance(graph).CompositeToDiagram);
 323         graph.claim(diagram, DN.EdgeDefaultMapping, defaultEdgeMapping);
 324         graph.claim(diagram, DN.VertexDefaultMapping, defaultVertexMapping);
 325         graph.claim(diagram, DN.RightClickDefaultMapping, rightClickVertexMapping);
 326         graph.claim(diagram, DN.LeftClickDefaultMapping, leftClickVertexMapping);
 327         graph.claim(diagram, DN.HasSpatialRefSystem, crs);
 328
 329         // Generated name prefix from composite name
 330         String compositeName = graph.getRelatedValue2(composite, Layer0.getInstance(graph).HasName, Bindings.STRING);
 331         graph.claimLiteral(diagram, Layer0X.getInstance(graph).HasGeneratedNamePrefix, "N" + compositeName.substring(compositeName.length() - 1, compositeName.length()));
 332
 333         return composite;
 334     }
 335
 336     public static final class MappedComponentRequest extends ResourceRead<Resource> {
 337         public MappedComponentRequest(Resource element) {
 338             super(element);
 339         }
 340
 341         @Override
 342         public Resource perform(ReadGraph graph) throws DatabaseException {
 343             return getMappedComponent(graph, resource);
 344         }
 345     }
 346
 347     public static class ResourceVertex {
 348
 349         public final boolean isConsumer;
 350         public final Resource vertex;
 351         public final double[] coords;
 352
 353         public ResourceVertex(Resource vertex, double[] coords, boolean isConsumer) {
 354             this.vertex = vertex;
 355             this.coords = coords;
 356             this.isConsumer = isConsumer;
 357         }
 358     }
 359
 360     public static void changeMappingType(WriteGraph graph, Resource newMapping, List<Resource> elements) throws DatabaseException {
 361         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 362         for (Resource element : elements) {
 363             graph.deny(element, DN.HasMapping);
 364             graph.claim(element, DN.HasMapping, newMapping);
 365         }
 366     }
 367
 368     public static Stream<Resource> findDNElementsById(ReadGraph graph, Resource context, String idToFind) throws DatabaseException {
 369         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 370         return IndexUtils.findByType(graph,
 371             graph.syncRequest(new IndexRoot(context)),
 372             DN.Element
 373         ).stream().filter(element -> {
 374             try {
 375                 String id = graph.getPossibleRelatedValue(element, DN.HasId, Bindings.STRING);
 376                 return id != null && id.contains(idToFind);
 377             } catch (DatabaseException e) {
 378                 LOGGER.error("Could not read id for element {]", element, e);
 379                 return false;
 380             }
 381         });
 382     }
 383
 384     public static Resource findDNElementById(ReadGraph graph, Resource context, String idToFind) throws DatabaseException {
 385         List<Resource> elements = findDNElementsById(graph, context, idToFind).collect(Collectors.toList());
 386         if (elements.size() == 1) {
 387             return elements.iterator().next();
 388         }
 389         return null;
 390     }
 391
 392     public static List<Resource> findDNElementByXYCoordinates(ReadGraph graph, Resource context, double lat, double lon, double padding) throws DatabaseException {
 393         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 394         DiagramResource DIA = DiagramResource.getInstance(graph);
 395         List<Resource> results = new ArrayList<>();
 396         Collection<Resource> vertices = IndexUtils.findByType(graph, graph.syncRequest(new IndexRoot(context)), DN.Vertex);
 397         Rectangle2D rect = new Rectangle2D.Double(lat, lon, padding, padding);
 398         for (Resource vertex : vertices) {
 399             double[] location = graph.getRelatedValue(vertex, DIA.HasLocation, Bindings.DOUBLE_ARRAY);
 400             if (rect.contains(location[0], location[1])) {
 401                 results.add(vertex);
 402             }
 403         }
 404         return results;
 405     }
 406
 407     public static ColorBarOptions colorBarOptions(ReadGraph graph, Resource visualisation) throws DatabaseException {
 408         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 409         if (visualisation != null) {
 410             String colorBarLocation = graph.getPossibleRelatedValue(visualisation, DN.Diagram_Visualisations_ColorBarLocation, Bindings.STRING);
 411             String colorBarSize = graph.getPossibleRelatedValue(visualisation, DN.Diagram_Visualisations_ColorBarSize, Bindings.STRING);
 412             Boolean show = graph.getPossibleRelatedValue(visualisation, DN.Diagram_Visualisations_ShowColorBars, Bindings.BOOLEAN);
 413             Boolean showTicks = graph.getPossibleRelatedValue(visualisation, DN.Diagram_Visualisations_ShowColorBarTicks, Bindings.BOOLEAN);
 414             Boolean useGradients = graph.getPossibleRelatedValue(visualisation, DN.Diagram_Visualisations_UseColorBarGradients, Bindings.BOOLEAN);
 415             if (colorBarLocation != null) {
 416                 return new ColorBarOptions()
 417                     .showColorBars(show != null ? show : false)
 418                     .showColorBarsTicks(showTicks != null ? showTicks : false)
 419                     .useGradients(useGradients != null ? useGradients : false)
 420                     .withLocation(ColorBarsLocation.valueOf(colorBarLocation))
 421                     .withSize(ColorBarsSize.valueOf(colorBarSize));
 422             }
 423         }
 424         return ColorBarOptions.useDefault();
 425     }
 426
 427     public static void setColorBarOptions(WriteGraph graph, Resource visualisation, ColorBarOptions options) throws DatabaseException {
 428         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 429         graph.claimLiteral(visualisation, DN.Diagram_Visualisations_ColorBarLocation, options.getLocation().toString(), Bindings.STRING);
 430         graph.claimLiteral(visualisation, DN.Diagram_Visualisations_ColorBarSize, options.getSize().toString(), Bindings.STRING);
 431         graph.claimLiteral(visualisation, DN.Diagram_Visualisations_ShowColorBars, options.isShowColorBars(), Bindings.BOOLEAN);
 432         graph.claimLiteral(visualisation, DN.Diagram_Visualisations_ShowColorBarTicks, options.isShowColorBarsTicks(), Bindings.BOOLEAN);
 433         graph.claimLiteral(visualisation, DN.Diagram_Visualisations_UseColorBarGradients, options.isUseGradients(), Bindings.BOOLEAN);
 434     }
 435
 436     public static Resource createVisualisation(WriteGraph graph, Resource parent, String visualisationName) throws DatabaseException {
 437         Resource vf = getOrCreateVisualisationsFolder(graph, parent);
 438         Layer0 L0 = Layer0.getInstance(graph);
 439         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 440         Resource visualisation = graph.newResource();
 441         graph.claim(visualisation, L0.InstanceOf, DN.Diagram_Visualisations);
 442         graph.claimLiteral(visualisation, L0.HasName, visualisationName);
 443         graph.claim(vf, DN.Diagram_hasVisualisation, visualisation);
 444         return visualisation;
 445     }
 446
 447     public static Resource getOrCreateVisualisationsFolder(WriteGraph graph, Resource model) throws DatabaseException {
 448         Resource rf = getVisualisationFolder(graph, model);
 449         if (rf == null) {
 450             Layer0 L0 = Layer0.getInstance(graph);
 451             DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 452             rf = graph.newResource();
 453             graph.claim(rf, L0.InstanceOf, null, DN.VisualisationsFolder);
 454             graph.claimLiteral(rf, L0.HasName, L0.NameOf, L0.String, UUID.randomUUID().toString(), Bindings.STRING);
 455             graph.claim(model, L0.ConsistsOf, L0.PartOf, rf);
 456         }
 457         return rf;
 458     }
 459
 460     public static Resource getVisualisationFolder(ReadGraph graph, Resource model) throws DatabaseException {
 461         List<Resource> visualisationsFolders = QueryIndexUtils.searchByType(graph, model, DistrictNetworkResource.getInstance(graph).VisualisationsFolder);
 462         if (visualisationsFolders.size() > 0)
 463             return visualisationsFolders.get(0);
 464         return null;
 465     }
 466
 467     public static SizeBarOptions sizeBarOptions(ReadGraph graph, Resource visualisation) throws DatabaseException {
 468         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 469         if (visualisation != null) {
 470             String sizeBarLocation = graph.getPossibleRelatedValue(visualisation, DN.Diagram_Visualisations_SizeBarLocation, Bindings.STRING);
 471             String sizeBarSize = graph.getPossibleRelatedValue(visualisation, DN.Diagram_Visualisations_SizeBarSize, Bindings.STRING);
 472             Boolean show = graph.getPossibleRelatedValue(visualisation, DN.Diagram_Visualisations_ShowSizeBars, Bindings.BOOLEAN);
 473             Boolean showTicks = graph.getPossibleRelatedValue(visualisation, DN.Diagram_Visualisations_ShowSizeBarTicks, Bindings.BOOLEAN);
 474             Boolean useGradients = graph.getPossibleRelatedValue(visualisation, DN.Diagram_Visualisations_UseSizeBarGradients, Bindings.BOOLEAN);
 475             if (sizeBarLocation != null) {
 476                 return new SizeBarOptions()
 477                     .showSizeBars(show != null ? show : false)
 478                     .showSizeBarsTicks(showTicks != null ? showTicks : false)
 479                     .useGradients(useGradients != null ? useGradients : false)
 480                     .withLocation(SizeBarsLocation.valueOf(sizeBarLocation))
 481                     .withSize(SizeBarsSize.valueOf(sizeBarSize));
 482             }
 483         }
 484         return SizeBarOptions.useDefault();
 485     }
 486
 487     public static void setSizeBarOptions(WriteGraph graph, Resource visualisation, SizeBarOptions options) throws DatabaseException {
 488         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 489         graph.claimLiteral(visualisation, DN.Diagram_Visualisations_SizeBarLocation, options.getLocation().toString(), Bindings.STRING);
 490         graph.claimLiteral(visualisation, DN.Diagram_Visualisations_SizeBarSize, options.getSize().toString(), Bindings.STRING);
 491         graph.claimLiteral(visualisation, DN.Diagram_Visualisations_ShowSizeBars, options.isShowSizeBars(), Bindings.BOOLEAN);
 492         graph.claimLiteral(visualisation, DN.Diagram_Visualisations_ShowSizeBarTicks, options.isShowSizeBarsTicks(), Bindings.BOOLEAN);
 493         graph.claimLiteral(visualisation, DN.Diagram_Visualisations_UseSizeBarGradients, options.isUseGradients(), Bindings.BOOLEAN);
 494     }
 495
 496     public static Map<String, DynamicColorContribution> colorContributions(ReadGraph graph, Resource visualisation) throws DatabaseException {
 497         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 498         if (visualisation == null) {
 499             return Collections.emptyMap();
 500         }
 501         Map<String, DynamicColorContribution> contributions = new HashMap<>();
 502
 503         Map<String, DynamicColorMap> colorMaps = DynamicVisualisationsContributions.dynamicColorMaps(graph);
 504
 505         Collection<Resource> colorContributions = graph.getObjects(visualisation, DN.Diagram_Visualisations_colorContributions);
 506         for (Resource colorContribution : colorContributions) {
 507             String ucName = graph.getRelatedValue(colorContribution, DN.Diagram_Visualisations_colorContributionContributorName, Bindings.STRING);
 508             String label = graph.getRelatedValue(colorContribution, DN.Diagram_Visualisations_colorContributionLabel, Bindings.STRING);
 509             String moduleName = graph.getRelatedValue(colorContribution, DN.Diagram_Visualisations_colorContributionModuleName, Bindings.STRING);
 510             String attributeName = graph.getRelatedValue(colorContribution, DN.Diagram_Visualisations_colorContributionModuleAttribute, Bindings.STRING);
 511             String unit = graph.getRelatedValue(colorContribution, DN.Diagram_Visualisations_colorContributionUnit, Bindings.STRING);
 512             Double variableGain = graph.getRelatedValue(colorContribution, DN.Diagram_Visualisations_colorContributionVariableGain, Bindings.DOUBLE);
 513             Double variableBias = graph.getRelatedValue(colorContribution, DN.Diagram_Visualisations_colorContributionVariableBias, Bindings.DOUBLE);
 514             String dynamicColorMap = graph.getRelatedValue(colorContribution, DN.Diagram_Visualisations_colorContributionDefaultColorMap, Bindings.STRING);
 515             Double defaultMin = graph.getRelatedValue(colorContribution, DN.Diagram_Visualisations_colorContributionDefaultMin, Bindings.DOUBLE);
 516             Double defaultMax = graph.getRelatedValue(colorContribution, DN.Diagram_Visualisations_colorContributionDefaultMax, Bindings.DOUBLE);
 517             Boolean used = graph.getRelatedValue(colorContribution, DN.Diagram_Visualisations_colorContributionUsed, Bindings.BOOLEAN);
 518             Boolean useDefault = graph.getRelatedValue(colorContribution, DN.Diagram_Visualisations_colorContributionUseDefault, Bindings.BOOLEAN);
 519             DynamicColorContribution dynamicColorContribution = new DynamicColorContribution(label, moduleName, attributeName, unit, variableGain, variableBias, colorMaps.get(dynamicColorMap), defaultMin, defaultMax);
 520             dynamicColorContribution.setUsed(used != null ? used : false);
 521             dynamicColorContribution.setUseDefault(useDefault != null ? useDefault : false);
 522             contributions.put(ucName, dynamicColorContribution);
 523         }
 524         return contributions;
 525     }
 526
 527     public static void setColorContributions(WriteGraph graph, Resource visualisation, List<Pair<String, DynamicColorContribution>> collect) throws DatabaseException {
 528         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 529         Layer0 L0 = Layer0.getInstance(graph);
 530
 531         graph.deny(visualisation, DN.Diagram_Visualisations_colorContributions);
 532         for (Pair<String, DynamicColorContribution> coll : collect) {
 533             Resource colorContribution = graph.newResource();
 534             graph.claim(colorContribution, L0.InstanceOf, DN.Diagram_Visualisations_ColorContribution);
 535             graph.claimLiteral(colorContribution, L0.HasName, coll.first);
 536
 537             DynamicColorContribution contr = coll.second;
 538             graph.claimLiteral(colorContribution, DN.Diagram_Visualisations_colorContributionContributorName, coll.first);
 539             graph.claimLiteral(colorContribution, DN.Diagram_Visualisations_colorContributionLabel, contr.getLabel());
 540             graph.claimLiteral(colorContribution, DN.Diagram_Visualisations_colorContributionModuleName, contr.getModuleName());
 541             graph.claimLiteral(colorContribution, DN.Diagram_Visualisations_colorContributionModuleAttribute, contr.getAttributeName());
 542             graph.claimLiteral(colorContribution, DN.Diagram_Visualisations_colorContributionUnit, contr.getUnit());
 543             graph.claimLiteral(colorContribution, DN.Diagram_Visualisations_colorContributionVariableGain, contr.getVariableGain());
 544             graph.claimLiteral(colorContribution, DN.Diagram_Visualisations_colorContributionVariableBias, contr.getVariableBias());
 545             graph.claimLiteral(colorContribution, DN.Diagram_Visualisations_colorContributionDefaultColorMap, contr.getDefaultColorMap().getLabel());
 546             graph.claimLiteral(colorContribution, DN.Diagram_Visualisations_colorContributionDefaultMin, contr.getDefaultMin());
 547             graph.claimLiteral(colorContribution, DN.Diagram_Visualisations_colorContributionDefaultMax, contr.getDefaultMax());
 548             graph.claimLiteral(colorContribution, DN.Diagram_Visualisations_colorContributionUsed, contr.isUsed());
 549             graph.claimLiteral(colorContribution, DN.Diagram_Visualisations_colorContributionUseDefault, contr.isUseDefault());
 550
 551             graph.claim(visualisation, DN.Diagram_Visualisations_colorContributions, colorContribution);
 552         }
 553     }
 554
 555     public static Map<String, DynamicSizeContribution> sizeContributions(ReadGraph graph, Resource visualisation) throws DatabaseException {
 556         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 557         if (visualisation == null) {
 558             return Collections.emptyMap();
 559         }
 560         Map<String, DynamicSizeContribution> contributions = new HashMap<>();
 561
 562         Map<String, DynamicSizeMap> sizeMaps = DynamicVisualisationsContributions.dynamicSizeMaps(graph);
 563
 564         Collection<Resource> sizeContributions = graph.getObjects(visualisation, DN.Diagram_Visualisations_sizeContributions);
 565         for (Resource sizeContribution : sizeContributions) {
 566             String ucName = graph.getRelatedValue(sizeContribution, DN.Diagram_Visualisations_sizeContributionContributorName, Bindings.STRING);
 567             String label = graph.getRelatedValue(sizeContribution, DN.Diagram_Visualisations_sizeContributionLabel, Bindings.STRING);
 568             String moduleName = graph.getRelatedValue(sizeContribution, DN.Diagram_Visualisations_sizeContributionModuleName, Bindings.STRING);
 569             String attributeName = graph.getRelatedValue(sizeContribution, DN.Diagram_Visualisations_sizeContributionModuleAttribute, Bindings.STRING);
 570             String unit = graph.getRelatedValue(sizeContribution, DN.Diagram_Visualisations_sizeContributionUnit, Bindings.STRING);
 571             Double variableGain = graph.getRelatedValue(sizeContribution, DN.Diagram_Visualisations_sizeContributionVariableGain, Bindings.DOUBLE);
 572             Double variableBias = graph.getRelatedValue(sizeContribution, DN.Diagram_Visualisations_sizeContributionVariableBias, Bindings.DOUBLE);
 573             String dynamicSizeMap = graph.getRelatedValue(sizeContribution, DN.Diagram_Visualisations_sizeContributionDefaultSizeMap, Bindings.STRING);
 574             Double defaultMin = graph.getRelatedValue(sizeContribution, DN.Diagram_Visualisations_sizeContributionDefaultMin, Bindings.DOUBLE);
 575             Double defaultMax = graph.getRelatedValue(sizeContribution, DN.Diagram_Visualisations_sizeContributionDefaultMax, Bindings.DOUBLE);
 576             Boolean used = graph.getRelatedValue(sizeContribution, DN.Diagram_Visualisations_sizeContributionUsed, Bindings.BOOLEAN);
 577             Boolean useDefault = graph.getRelatedValue(sizeContribution, DN.Diagram_Visualisations_sizeContributionUseDefault, Bindings.BOOLEAN);
 578             DynamicSizeContribution dsc = new DynamicSizeContribution(label, moduleName, attributeName, unit, variableGain, variableBias, sizeMaps.get(dynamicSizeMap), defaultMin, defaultMax);
 579             dsc.setUsed(used != null ? used : false);
 580             dsc.setUseDefault(useDefault != null ? useDefault : false);
 581             contributions.put(ucName, dsc);
 582         }
 583         return contributions;
 584     }
 585
 586     public static void setSizeContributions(WriteGraph graph, Resource visualisation, List<Pair<String, DynamicSizeContribution>> collect) throws DatabaseException {
 587         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 588         Layer0 L0 = Layer0.getInstance(graph);
 589
 590         graph.deny(visualisation, DN.Diagram_Visualisations_sizeContributions);
 591         for (Pair<String, DynamicSizeContribution> coll : collect) {
 592             Resource sizeContribution = graph.newResource();
 593             graph.claim(sizeContribution, L0.InstanceOf, DN.Diagram_Visualisations_SizeContribution);
 594             graph.claimLiteral(sizeContribution, L0.HasName, coll.first);
 595
 596             DynamicSizeContribution contr = coll.second;
 597             graph.claimLiteral(sizeContribution, DN.Diagram_Visualisations_sizeContributionContributorName, coll.first);
 598             graph.claimLiteral(sizeContribution, DN.Diagram_Visualisations_sizeContributionLabel, contr.getLabel());
 599             graph.claimLiteral(sizeContribution, DN.Diagram_Visualisations_sizeContributionModuleName, contr.getModuleName());
 600             graph.claimLiteral(sizeContribution, DN.Diagram_Visualisations_sizeContributionModuleAttribute, contr.getAttributeName());
 601             graph.claimLiteral(sizeContribution, DN.Diagram_Visualisations_sizeContributionUnit, contr.getUnit());
 602             graph.claimLiteral(sizeContribution, DN.Diagram_Visualisations_sizeContributionVariableGain, contr.getVariableGain());
 603             graph.claimLiteral(sizeContribution, DN.Diagram_Visualisations_sizeContributionVariableBias, contr.getVariableBias());
 604             graph.claimLiteral(sizeContribution, DN.Diagram_Visualisations_sizeContributionDefaultSizeMap, contr.getDefaultSizeMap().getLabel());
 605             graph.claimLiteral(sizeContribution, DN.Diagram_Visualisations_sizeContributionDefaultMin, contr.getDefaultMin());
 606             graph.claimLiteral(sizeContribution, DN.Diagram_Visualisations_sizeContributionDefaultMax, contr.getDefaultMax());
 607             graph.claimLiteral(sizeContribution, DN.Diagram_Visualisations_sizeContributionUsed, contr.isUsed());
 608             graph.claimLiteral(sizeContribution, DN.Diagram_Visualisations_sizeContributionUseDefault, contr.isUseDefault());
 609
 610             graph.claim(visualisation, DN.Diagram_Visualisations_sizeContributions, sizeContribution);
 611         }
 612     }
 613
 614     public static void setActiveVisualisation(WriteGraph graph, Resource diagram, Resource visualisationTemplate) throws DatabaseException {
 615         DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
 616         graph.deny(diagram, DN.Diagram_hasActiveVisualisation);
 617         graph.claim(diagram, DN.Diagram_hasActiveVisualisation, visualisationTemplate);
 618     }
 619
 620 }