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