Merge branch 'dev' into 'master'

CityDoctor Release Version 3.16.0

See merge request !11

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityFurniture.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.check.Check;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
+import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import org.citygml4j.core.model.core.AbstractCityObject;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+import org.xmlobjects.gml.model.geometry.primitives.Solid;
+import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
+
+import java.io.Serial;
+
+public class CityFurniture extends CityObject {
+
+    @Serial
+    private static final long serialVersionUID = 3325661061543962473L;
+
+    private org.citygml4j.core.model.cityfurniture.CityFurniture cgmlCityFurniture;
+
+    @Override
+    public void accept(Check c) {
+        super.accept(c);
+        if (c.canExecute(this)) {
+            c.check(this);
+        }
+    }
+
+
+    @Override
+    public AbstractCityObject getGmlObject() {
+        return cgmlCityFurniture;
+    }
+
+    public void setGmlObject(org.citygml4j.core.model.cityfurniture.CityFurniture gmlCityFurniture) {
+        cgmlCityFurniture = gmlCityFurniture;
+    }
+
+    @Override
+    public void unsetGmlGeometries() {
+        cgmlCityFurniture.setLod0MultiSurface(null);
+        cgmlCityFurniture.setLod2MultiSurface(null);
+        cgmlCityFurniture.setLod3MultiSurface(null);
+        cgmlCityFurniture.setLod1Solid(null);
+        cgmlCityFurniture.setLod2Solid(null);
+        cgmlCityFurniture.setLod3Solid(null);
+        cgmlCityFurniture.getDeprecatedProperties().setLod4Geometry(null);
+    }
+
+    @Override
+    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+        for (Geometry geom : getGeometries()) {
+            if (geom instanceof ImplicitGeometryHolder) {
+                continue;
+            }
+            if (geom.getType() == GeometryType.MULTI_SURFACE) {
+                MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
+                setMultiSurfaceAccordingToLod(geom, ms);
+            } else {
+                Solid solid = CityGmlUtils.createSolid(geom, factory, config);
+                setSolidAccordingToLod(geom, solid);
+            }
+        }
+    }
+
+    private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
+        switch (geom.getLod()) {
+            case LOD0:
+                cgmlCityFurniture.setLod0MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD2:
+                cgmlCityFurniture.setLod2MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD3:
+                cgmlCityFurniture.setLod3MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            default:
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " multi surface to buildings");
+        }
+    }
+
+    private void setSolidAccordingToLod(Geometry geom, Solid solid) {
+        switch (geom.getLod()) {
+            case LOD1:
+                cgmlCityFurniture.setLod1Solid(new SolidProperty(solid));
+                break;
+            case LOD2:
+                cgmlCityFurniture.setLod2Solid(new SolidProperty(solid));
+                break;
+            case LOD3:
+                cgmlCityFurniture.setLod3Solid(new SolidProperty(solid));
+                break;
+            default:
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " solid to buildings");
+        }
+    }
+
+    @Override
+    public FeatureType getFeatureType() {
+        return FeatureType.CITY_FURNITURE;
+    }
+
+    @Override
+    public Copyable createCopyInstance() {
+        return new CityFurniture();
+    }
+
+    @Override
+    public void fillValues(Copyable original, CopyHandler handler) {
+        super.fillValues(original, handler);
+        CityFurniture originalCF = (CityFurniture) original;
+        cgmlCityFurniture = originalCF.cgmlCityFurniture;
+    }
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CityObject.java

@@ -18,20 +18,19 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import java.io.Serial;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-
-import org.citygml4j.core.model.core.AbstractCityObject;
-import org.citygml4j.core.util.geometry.GeometryFactory;
-
 import de.hft.stuttgart.citydoctor2.check.Check;
 import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.CheckId;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
 import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import org.citygml4j.core.model.core.AbstractCityObject;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
 
 /**
  * Abstract class for general features such as Buildings, Water objects, ...
@@ -39,7 +38,6 @@ import de.hft.stuttgart.citydoctor2.utils.Copyable;
  * Contains the geometries
  *
  * @author Matthias Betz
- *
  */
 public abstract class CityObject extends GmlElement {
 
@@ -47,7 +45,7 @@ public abstract class CityObject extends GmlElement {
     private static final long serialVersionUID = 651712070755024188L;
 
     private final List<Geometry> geometryList = new ArrayList<>();
-
+    private final List<GenericAttribute> genericAttributeList = new ArrayList<>();
     /**
      * Recreates the CityGML4j geometry in this object. The CityGML4j geometry is
      * deleted from the data structure as was mapped to the city doctor data
@@ -79,6 +77,7 @@ public abstract class CityObject extends GmlElement {
         geom.setParent(this);
     }
 
+
     public List<Geometry> getGeometries() {
         return geometryList;
     }
@@ -103,6 +102,14 @@ public abstract class CityObject extends GmlElement {
         return highestLodGeometry;
     }
 
+    public void addGenericAttribute(GenericAttribute genericAttribute) {
+        genericAttributeList.add(genericAttribute);
+    }
+
+    public List<GenericAttribute> getGenericAttributes() {
+        return genericAttributeList;
+    }
+
     public abstract FeatureType getFeatureType();
 
     @Override

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/CompositeCollection.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ * @author Riegel
+ */
+public final class CompositeCollection {
+
+    @Serial
+    private static final long serialVersionUID = -1867197873443341287L;
+
+    private GmlId gmlId;
+    private List<ConcretePolygon> compositeMembers = new ArrayList<>();
+    private List<CompositeCollection> childComposites = new ArrayList<>();
+
+    public void addCompositeMember(ConcretePolygon p) {
+        compositeMembers.add(p);
+        p.setPartOfComposite(this);
+    }
+
+    public void addAllChildComposites(List<CompositeCollection> children) {
+        childComposites.addAll(children);
+    }
+
+    public List<CompositeCollection> getChildComposites() {
+        return childComposites;
+    }
+
+    public List<ConcretePolygon> getCompositeMembers() {
+        List<ConcretePolygon> copy = new ArrayList<>(compositeMembers);
+        for (CompositeCollection c : childComposites) {
+            copy.addAll(c.getCompositeMembers());
+        }
+        return copy;
+    }
+
+    public List<ConcretePolygon> getNonRecursiveCompositeMembers() {
+        return compositeMembers;
+    }
+
+    public void setGmlId(GmlId gmlId) {
+        this.gmlId = gmlId;
+    }
+
+    public GmlId getGmlId() {
+        return gmlId;
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ConcretePolygon.java

@@ -18,11 +18,6 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import java.io.Serial;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
 import de.hft.stuttgart.citydoctor2.check.Check;
 import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.CheckId;
@@ -33,6 +28,11 @@ import de.hft.stuttgart.citydoctor2.tesselation.TesselatedPolygon;
 import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
 import de.hft.stuttgart.citydoctor2.utils.Copyable;
 
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
 /**
  * A polygon that actually contains the rings and points representing the
  * geometry
@@ -49,12 +49,11 @@ public class ConcretePolygon extends Polygon {
 	private List<LinearRing> innerRings;
 	private BoundarySurface partOfSurface;
 	private Installation partfOfInstallation;
+	private CompositeCollection partOfComposite = null;
 	private Geometry parent;
 	private LinkedPolygon linkedFromPolygon;
 	
-	public ConcretePolygon() {
-		// TODO Auto-generated constructor stub
-	}
+	public ConcretePolygon() {}
 
 	/*
 	 * (non-Javadoc)
@@ -138,6 +137,18 @@ public class ConcretePolygon extends Polygon {
 		parent = geometry;
 	}
 
+	protected void setPartOfComposite(CompositeCollection comp) {
+		this.partOfComposite = comp;
+	}
+
+	public CompositeCollection getPartOfComposite() {
+		return partOfComposite;
+	}
+
+	public boolean isCompositeMember() {
+		return (partOfComposite != null);
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Edge.java

@@ -18,19 +18,18 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
+import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
+
 import java.io.Serial;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
 
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
-
 /**
  * Representing an edge between two consecutive points of a linear ring
  *
  * @author Matthias Betz
- *
  */
 public class Edge implements Serializable, Copyable {
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/FeatureType.java

@@ -22,11 +22,10 @@ package de.hft.stuttgart.citydoctor2.datastructure;
  * Possible feature types in CityGML
  *
  * @author Matthias Betz
- *
  */
 public enum FeatureType {
 
     BUILDING, TRANSPORTATION, VEGETATION, BRIDGE, LAND, WATER, BOUNDARY_SURFACE, INSTALLATION, OPENING,
-	BUILDING_PART, BRIDGE_CONSTRUCTION_ELEMENT, BRIDGE_INSTALLATION
-
+    BUILDING_PART, BUILDING_SUBDIVISION, BRIDGE_CONSTRUCTION_ELEMENT, BRIDGE_INSTALLATION, ROOM, FURNITURE, CITY_FURNITURE,
+    GENERIC_CITY_OBJECT, TUNNEL, TUNNEL_PART, TUNNEL_CONSTRUCTION_ELEMENT, TUNNEL_INSTALLATION,
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GenericAttribute.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.citygml4j.core.model.core.AbstractGenericAttributeProperty;
+import org.citygml4j.core.model.generics.*;
+
+
+public class GenericAttribute {
+
+    private static final Logger logger = LogManager.getLogger(GenericAttribute.class);
+
+    private final AbstractGenericAttributeProperty original;
+
+    private String type;
+    private String name;
+    private String value;
+
+    public GenericAttribute(AbstractGenericAttributeProperty attributeProperty) {
+        original = attributeProperty;
+        if (attributeProperty.getObject() == null) {
+            logger.warn("GenericAttribute {} is null", attributeProperty);
+            return;
+        }
+        name = attributeProperty.getObject().getName();
+
+        if (attributeProperty.getObject() instanceof StringAttribute sa) {
+            type = "StringAttribute";
+            value = sa.getValue();
+        } else if (attributeProperty.getObject() instanceof IntAttribute ia) {
+            type = "IntAttribute";
+            value = ia.getValue().toString();
+        } else if (attributeProperty.getObject() instanceof DoubleAttribute da) {
+            type = "DoubleAttribute";
+            value = da.getValue().toString();
+        } else if (attributeProperty.getObject() instanceof DateAttribute date) {
+            type = "DateAttribute";
+            value = date.getValue().toString();
+        } else if (attributeProperty.getObject() instanceof UriAttribute ua) {
+            type = "UriAttribute";
+            value = ua.getValue();
+        } else if (attributeProperty.getObject() instanceof MeasureAttribute ma) {
+            type = "MeasureAttribute";
+            value = ma.getValue().toString();
+        } else if (attributeProperty.getObject() instanceof CodeAttribute ca) {
+            type = "CodeAttribute";
+            value = ca.getValue().toString();
+        } else {
+            logger.warn("GenericAttribute {} is of unknown type {}", attributeProperty, attributeProperty.getObject());
+            value = attributeProperty.getObject().getValue().toString();
+            type = "Unknown type";
+        }
+
+    }
+
+    public AbstractGenericAttributeProperty getOriginal() {
+        return original;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%s: [ %s = %s ]", type, name, value);
+    }
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GenericCityObject.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.check.Check;
+import de.hft.stuttgart.citydoctor2.check.CheckError;
+import de.hft.stuttgart.citydoctor2.check.CheckId;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
+import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.citygml4j.core.model.core.AbstractCityObject;
+import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
+import org.xmlobjects.gml.model.geometry.primitives.Solid;
+import org.xmlobjects.gml.model.geometry.primitives.SolidProperty;
+
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ */
+public class GenericCityObject extends CityObject {
+
+    @Serial
+    private static final long serialVersionUID = 5886527664552294353L;
+
+    private org.citygml4j.core.model.generics.GenericOccupiedSpace cgmlGos;
+
+    private static final Logger logger = LogManager.getLogger(GenericCityObject.class);
+
+    private final List<BoundarySurface> boundarySurfaceList = new ArrayList<>();
+
+    @Override
+    public void accept(Check c) {
+        super.accept(c);
+        if (c.canExecute(this)) {
+            c.check(this);
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.accept(c);
+        }
+    }
+
+    @Override
+    public void reCreateGeometries(GeometryFactory factory, ParserConfiguration config) {
+        for (Geometry geom : getGeometries()) {
+            if (geom instanceof ImplicitGeometryHolder) {
+                continue;
+            }
+            if (geom.getType() == GeometryType.MULTI_SURFACE) {
+                MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
+                setMultiSurfaceAccordingToLod(geom, ms);
+            } else {
+                Solid solid = CityGmlUtils.createSolid(geom, factory, config);
+                setSolidAccordingToLod(geom, solid);
+            }
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            reCreateBoundarySurface(factory, config, bs);
+        }
+    }
+
+    private void reCreateBoundarySurface(GeometryFactory factory, ParserConfiguration config, BoundarySurface bs) {
+        if (bs.getGeometries().isEmpty()) {
+            for (AbstractSpaceBoundaryProperty bsp : cgmlGos.getBoundaries()) {
+                if (bsp.getObject() != null && bsp.getObject() == bs.getGmlObject()) {
+                    logger.warn("Found empty boundary surface: {}, removing from generic object", bs.getGmlId());
+                    cgmlGos.getBoundaries().remove(bsp);
+                    break;
+                }
+            }
+            return;
+        }
+        bs.reCreateGeometries(factory, config);
+    }
+
+    private void setMultiSurfaceAccordingToLod(Geometry geom, MultiSurface ms) {
+        switch (geom.getLod()) {
+            case LOD0:
+                cgmlGos.setLod0MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD2:
+                cgmlGos.setLod2MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            case LOD3:
+                cgmlGos.setLod3MultiSurface(new MultiSurfaceProperty(ms));
+                break;
+            default:
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " multi surface to buildings");
+        }
+    }
+
+    private void setSolidAccordingToLod(Geometry geom, Solid solid) {
+        switch (geom.getLod()) {
+            case LOD1:
+                cgmlGos.setLod1Solid(new SolidProperty(solid));
+                break;
+            case LOD2:
+                cgmlGos.setLod2Solid(new SolidProperty(solid));
+                break;
+            case LOD3:
+                cgmlGos.setLod3Solid(new SolidProperty(solid));
+                break;
+            default:
+                throw new IllegalStateException("Cannot add " + geom.getLod() + " solid to buildings");
+        }
+    }
+
+    @Override
+    public void collectContainedErrors(List<CheckError> errors) {
+        super.collectContainedErrors(errors);
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.collectContainedErrors(errors);
+        }
+    }
+
+    @Override
+    public void clearAllContainedCheckResults() {
+        super.clearAllContainedCheckResults();
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.clearAllContainedCheckResults();
+        }
+    }
+
+    @Override
+    public boolean containsError(CheckId checkIdentifier) {
+        boolean hasError = super.containsError(checkIdentifier);
+        if (hasError) {
+            return true;
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            if (bs.containsError(checkIdentifier)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean containsAnyError() {
+        boolean hasError = super.containsAnyError();
+        if (hasError) {
+            return true;
+        }
+        for (BoundarySurface bs : boundarySurfaceList) {
+            if (bs.containsAnyError()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void prepareForChecking() {
+        super.prepareForChecking();
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.prepareForChecking();
+        }
+    }
+
+    @Override
+    public void clearMetaInformation() {
+        super.clearMetaInformation();
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.clearMetaInformation();
+        }
+    }
+
+    @Override
+    public void collectInstances(CopyHandler handler) {
+        super.collectInstances(handler);
+        handler.addInstance(boundarySurfaceList);
+    }
+
+    @Override
+    public void fillValues(Copyable original, CopyHandler handler) {
+        super.fillValues(original, handler);
+        GenericCityObject originalGos = (GenericCityObject) original;
+        for (BoundarySurface originalBs : originalGos.boundarySurfaceList) {
+            boundarySurfaceList.add(handler.getCopyInstance(originalBs));
+        }
+        cgmlGos = originalGos.cgmlGos;
+    }
+
+    @Override
+    public AbstractCityObject getGmlObject() {
+        return null;
+    }
+
+    @Override
+    public FeatureType getFeatureType() {
+        return FeatureType.GENERIC_CITY_OBJECT;
+    }
+
+    public List<BoundarySurface> getBoundarySurfaces() {
+        return boundarySurfaceList;
+    }
+
+    @Override
+    public void unsetGmlGeometries() {
+        cgmlGos.setLod1Solid(null);
+        cgmlGos.setLod2Solid(null);
+        cgmlGos.setLod3Solid(null);
+        cgmlGos.setLod2MultiSurface(null);
+        cgmlGos.setLod3MultiSurface(null);
+        for (BoundarySurface bs : boundarySurfaceList) {
+            bs.unsetGmlGeometries();
+        }
+    }
+
+    public void setGmlObject(org.citygml4j.core.model.generics.GenericOccupiedSpace gos) {
+        this.cgmlGos = gos;
+    }
+
+    public void addBoundarySurface(BoundarySurface bs) {
+        boundarySurfaceList.add(bs);
+        bs.setParent(this);
+    }
+
+
+    @Override
+    public Copyable createCopyInstance() {
+        return new GenericCityObject();
+    }
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Geometry.java

@@ -18,16 +18,6 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import java.io.Serial;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Random;
-import java.util.Set;
-
 import de.hft.stuttgart.citydoctor2.check.Check;
 import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.CheckId;
@@ -39,11 +29,14 @@ import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
 import de.hft.stuttgart.citydoctor2.utils.Copyable;
 import de.hft.stuttgart.citydoctor2.utils.SerializablePair;
 
+import java.io.Serial;
+import java.util.*;
+import java.util.Map.Entry;
+
 /**
  * Representation of a geometry containing the polygons and edges
  *
  * @author Matthias Betz
- *
  */
 public class Geometry extends GmlElement {
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryType.java

@@ -22,7 +22,6 @@ package de.hft.stuttgart.citydoctor2.datastructure;
  * Available geometry types
  *
  * @author Matthias Betz
- *
  */
 public enum GeometryType {
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GmlElement.java

@@ -28,7 +28,6 @@ import java.io.Serial;
  * A general GML element that has a gml id
  *
  * @author Matthias Betz
- *
  */
 public abstract class GmlElement extends Checkable implements Copyable {
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GmlId.java

@@ -27,7 +27,6 @@ import java.util.concurrent.atomic.AtomicInteger;
  * generated by city doctor
  *
  * @author Matthias Betz
- *
  */
 public class GmlId implements Serializable {
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/ImplicitGeometryHolder.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.check.Check;
+import de.hft.stuttgart.citydoctor2.check.CheckError;
+import de.hft.stuttgart.citydoctor2.check.CheckId;
+import de.hft.stuttgart.citydoctor2.math.TransformationMatrix;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.citygml4j.core.model.core.ImplicitGeometry;
+
+import java.io.Serial;
+import java.util.List;
+
+/**
+ * Datastructure for representation and resolving of implicit geometries
+ *
+ * @author Riegel
+ */
+public class ImplicitGeometryHolder extends Geometry {
+
+    private static final Logger logger = LogManager.getLogger(ImplicitGeometryHolder.class);
+    @Serial
+    private static final long serialVersionUID = -8938931081577196349L;
+
+    private ImplicitGeometry cgmlImplicitGeometry = null;
+
+    private final PrototypeGeometryType type;
+    private final Geometry prototypeGeometry;
+
+    public ImplicitGeometryHolder(ImplicitGeometry cgmlImplicitGeometry, LibraryObject libObject) {
+        super(libObject.getType(), libObject.getLod());
+        prototypeGeometry = libObject;
+        type = PrototypeGeometryType.LIBRARY_OBJECT;
+        this.cgmlImplicitGeometry = cgmlImplicitGeometry;
+        applyTransformation();
+    }
+
+    public ImplicitGeometryHolder(ImplicitGeometry cgmlImplicitGeometry, RelativeGeometry relativeGeometry) {
+        super(relativeGeometry.getType(), relativeGeometry.getLod());
+        prototypeGeometry = relativeGeometry;
+        type = PrototypeGeometryType.RELATIVE_GEOMETRY;
+        this.cgmlImplicitGeometry = cgmlImplicitGeometry;
+        applyTransformation();
+    }
+
+
+    /**
+     * Applies the transformation matrix of the implicit geometry to a copy of the reference geometry and copies the resulting
+     * transformed geometry into this object.
+     */
+    private void applyTransformation() {
+        TransformationMatrix transformMatrix = new TransformationMatrix(cgmlImplicitGeometry);
+        Geometry transformedGeom = transformMatrix.transformGeometry(prototypeGeometry);
+        transformedGeom.getPolygons().forEach(this::addPolygon);
+        this.updateEdgesAndVertices();
+    }
+
+    public PrototypeGeometryType getPrototypeGeometryType() {
+        return type;
+    }
+
+    @Override
+    public void accept(Check c) {
+        prototypeGeometry.accept(c);
+    }
+
+    @Override
+    public boolean containsError(CheckId checkIdentifier) {
+        return prototypeGeometry.containsError(checkIdentifier);
+    }
+
+    @Override
+    public void clearAllContainedCheckResults() {
+        prototypeGeometry.clearAllContainedCheckResults();
+    }
+
+    @Override
+    public void collectContainedErrors(List<CheckError> errors) {
+        prototypeGeometry.clearAllContainedCheckResults();
+    }
+
+    @Override
+    public boolean containsAnyError() {
+        return prototypeGeometry.containsAnyError();
+    }
+
+    @Override
+    public void prepareForChecking() {
+        this.updateEdgesAndVertices();
+        prototypeGeometry.prepareForChecking();
+    }
+
+    @Override
+    public boolean isValidated() {
+        return prototypeGeometry.isValidated();
+    }
+
+    public enum PrototypeGeometryType {
+        LIBRARY_OBJECT, RELATIVE_GEOMETRY
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Installation.java

@@ -18,10 +18,13 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import java.io.Serial;
-import java.util.ArrayList;
-import java.util.List;
-
+import de.hft.stuttgart.citydoctor2.check.Check;
+import de.hft.stuttgart.citydoctor2.check.CheckError;
+import de.hft.stuttgart.citydoctor2.check.CheckId;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
+import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
 import org.citygml4j.core.model.bridge.BridgeInstallation;
 import org.citygml4j.core.model.construction.AbstractInstallation;
 import org.citygml4j.core.model.core.AbstractSpaceBoundaryProperty;
@@ -32,13 +35,9 @@ import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
 import org.xmlobjects.gml.model.geometry.complexes.CompositeSurface;
 import org.xmlobjects.gml.model.geometry.primitives.SurfaceProperty;
 
-import de.hft.stuttgart.citydoctor2.check.Check;
-import de.hft.stuttgart.citydoctor2.check.CheckError;
-import de.hft.stuttgart.citydoctor2.check.CheckId;
-import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
-import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
-import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
 
 public class Installation extends CityObject {
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LandObject.java

@@ -18,24 +18,22 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
+import de.hft.stuttgart.citydoctor2.check.Check;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
+import de.hft.stuttgart.citydoctor2.utils.Copyable;
 import org.citygml4j.core.model.core.AbstractCityObject;
 import org.citygml4j.core.model.landuse.LandUse;
 import org.citygml4j.core.util.geometry.GeometryFactory;
 import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
 import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
 
-import de.hft.stuttgart.citydoctor2.check.Check;
-import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
-import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
-import de.hft.stuttgart.citydoctor2.utils.Copyable;
-
 import java.io.Serial;
 
 /**
  * Represents a land use CityGML object.
  *
  * @author Matthias Betz
- *
  */
 public class LandObject extends CityObject {
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LibraryObject.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.parser.CityGmlParseException;
+import de.hft.stuttgart.citydoctor2.parser.CityGmlParser;
+import de.hft.stuttgart.citydoctor2.parser.InvalidGmlFileException;
+import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.Serial;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Reference object for handling of implicit geometries with a library object contained in an external file
+ *
+ * @author Riegel
+ */
+public class LibraryObject extends Geometry {
+
+    private static final Logger logger = LogManager.getLogger(LibraryObject.class);
+    @Serial
+    private static final long serialVersionUID = -50293435187454911L;
+    private final String filepath;
+    private final ParserConfiguration config;
+    private static Map<String, LibraryObject> libraryObjects = new ConcurrentHashMap<>();
+
+    public static LibraryObject of(Path path, ParserConfiguration config) {
+        if (libraryObjects.containsKey(path.toString())) {
+            return libraryObjects.get(path.toString());
+        }
+        Geometry protoGeom = parseFile(path, config);
+        if (protoGeom == null) {
+            return null;
+        }
+        LibraryObject libOb = new LibraryObject(protoGeom.getType(), protoGeom.getLod(), path, config);
+        protoGeom.getPolygons().forEach(libOb::addPolygon);
+        libOb.updateEdgesAndVertices();
+        libraryObjects.put(path.toString(), libOb);
+        return libOb;
+    }
+
+    private LibraryObject(GeometryType type, Lod lod, Path path, ParserConfiguration config) {
+        super(type, lod);
+        this.filepath = path.toString();
+        this.config = config;
+    }
+
+
+    private static Geometry parseFile(Path path, ParserConfiguration config) {
+        Geometry geo = null;
+        if (path.toFile().exists()) {
+            try {
+                CityGmlParser.gagLogger(true);
+                CityDoctorModel model = CityGmlParser.parseCityGmlFile(path.toString(), config);
+                List<CityObject> objects = model.createFeatureStream().toList();
+                if (objects.isEmpty()) {
+                    throw new InvalidGmlFileException("Referenced library-object's gml file does not contain a CityGML object!");
+                } else if (objects.size() > 1) {
+                    throw new InvalidGmlFileException("Referenced library-object's gml file contains more than one CityGML object!");
+                }
+                geo = objects.get(0).getHighestLodGeometry();
+            } catch (CityGmlParseException e) {
+                logger.error(String.format(
+                        "Encountered an error while parsing library object %s", path));
+                logger.error(e.getStackTrace());
+            } catch (InvalidGmlFileException e) {
+                logger.error(e.getStackTrace());
+            } finally {
+                // Failsafe to remove gag should parsing fail
+                CityGmlParser.gagLogger(false);
+            }
+        } else {
+            logger.error(String.format("Implicit geometry references non-existing library object file %s.", path));
+        }
+        return geo;
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LinearRing.java

@@ -18,24 +18,19 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import java.io.Serial;
-import java.util.ArrayList;
-import java.util.List;
-
 import de.hft.stuttgart.citydoctor2.check.Check;
-import de.hft.stuttgart.citydoctor2.math.ProjectionAxis;
-import de.hft.stuttgart.citydoctor2.math.Ring2d;
-import de.hft.stuttgart.citydoctor2.math.UnitVector3d;
-import de.hft.stuttgart.citydoctor2.math.Vector2d;
-import de.hft.stuttgart.citydoctor2.math.Vector3d;
+import de.hft.stuttgart.citydoctor2.math.*;
 import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
 import de.hft.stuttgart.citydoctor2.utils.Copyable;
 
+import java.io.Serial;
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * Represents a linear ring used in polygons. The ring contains the vertices.
  *
  * @author Matthias Betz
- *
  */
 public class LinearRing extends GmlElement {
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LinkedPolygon.java

@@ -18,10 +18,6 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import java.io.Serial;
-import java.util.List;
-import java.util.Map;
-
 import de.hft.stuttgart.citydoctor2.check.Check;
 import de.hft.stuttgart.citydoctor2.check.CheckError;
 import de.hft.stuttgart.citydoctor2.check.CheckId;
@@ -31,12 +27,15 @@ import de.hft.stuttgart.citydoctor2.tesselation.TesselatedPolygon;
 import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
 import de.hft.stuttgart.citydoctor2.utils.Copyable;
 
+import java.io.Serial;
+import java.util.List;
+import java.util.Map;
+
 /**
  * A polygon that does not contain the geometry but is only a link to an actual
  * polygon. Created when href in CityGML are used.
  *
  * @author Matthias Betz
- *
  */
 public class LinkedPolygon extends Polygon {
 
@@ -50,7 +49,6 @@ public class LinkedPolygon extends Polygon {
     }
 
     /**
-	 * 
      * @param poly   polygon this is linked to
      * @param parent the parent of the linked polygon
      */

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Lod.java

@@ -22,7 +22,6 @@ package de.hft.stuttgart.citydoctor2.datastructure;
  * The different LODs available in CityGML
  *
  * @author Matthias Betz
- *
  */
 public enum Lod {
 

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/Opening.java

@@ -18,17 +18,16 @@
  */
 package de.hft.stuttgart.citydoctor2.datastructure;
 
-import org.citygml4j.core.model.construction.AbstractFillingSurface;
-import org.citygml4j.core.model.core.AbstractCityObject;
-import org.citygml4j.core.util.geometry.GeometryFactory;
-import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
-import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
-
 import de.hft.stuttgart.citydoctor2.check.Check;
 import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
 import de.hft.stuttgart.citydoctor2.utils.CityGmlUtils;
 import de.hft.stuttgart.citydoctor2.utils.CopyHandler;
 import de.hft.stuttgart.citydoctor2.utils.Copyable;
+import org.citygml4j.core.model.construction.AbstractFillingSurface;
+import org.citygml4j.core.model.core.AbstractCityObject;
+import org.citygml4j.core.util.geometry.GeometryFactory;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurface;
+import org.xmlobjects.gml.model.geometry.aggregates.MultiSurfaceProperty;
 
 import java.io.Serial;
 
@@ -38,7 +37,6 @@ import java.io.Serial;
  * in.
  *
  * @author Matthias Betz
- *
  */
 public class Opening extends CityObject {