/*-
* Copyright 2020 Beuth Hochschule für Technik Berlin, Hochschule für Technik Stuttgart
*
* This file is part of CityDoctor2.
*
* CityDoctor2 is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* CityDoctor2 is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with CityDoctor2. If not, see .
*/
package de.hft.stuttgart.citydoctor2.datastructure;
import java.util.ArrayList;
import java.util.List;
import org.citygml4j.factory.GMLGeometryFactory;
import org.citygml4j.model.citygml.building.AbstractBoundarySurface;
import org.citygml4j.model.citygml.building.BoundarySurfaceProperty;
import org.citygml4j.model.gml.geometry.GeometryProperty;
import org.citygml4j.model.gml.geometry.aggregates.MultiSurface;
import org.citygml4j.model.gml.geometry.aggregates.MultiSurfaceProperty;
import org.citygml4j.model.gml.geometry.complexes.CompositeSurface;
import org.citygml4j.model.gml.geometry.complexes.CompositeSurfaceProperty;
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;
public class BuildingInstallation extends CityObject {
private static final long serialVersionUID = 1576237433322680191L;
private List boundarySurfaces = new ArrayList<>(4);
private org.citygml4j.model.citygml.building.BuildingInstallation gmlBi;
private AbstractBuilding parent;
public void reCreateGeometries(GMLGeometryFactory factory, ParserConfiguration config) {
for (Geometry geom : getGeometries()) {
if (geom.getType() == GeometryType.MULTI_SURFACE) {
MultiSurface ms = CityGmlUtils.createMultiSurface(geom, factory, config);
if (ms != null) {
setGeometryAccordingToLod(geom.getLod(), new MultiSurfaceProperty(ms));
}
} else if (geom.getType() == GeometryType.COMPOSITE_SURFACE) {
CompositeSurface cs = CityGmlUtils.createCompositeSurface(geom, factory, config);
if (cs != null) {
setGeometryAccordingToLod(geom.getLod(), new CompositeSurfaceProperty(cs));
}
} else {
throw new IllegalStateException("BuildingInstallation not have Solid geometries");
}
}
for (BoundarySurface bs : boundarySurfaces) {
bs.reCreateGeometries(factory, config);
}
}
@Override
public CityObject copy() {
throw new UnsupportedOperationException("Cannot copy BuildingInstallation");
}
private void setGeometryAccordingToLod(Lod lod, GeometryProperty> ms) {
switch (lod) {
case LOD2:
gmlBi.setLod2Geometry(ms);
break;
case LOD3:
gmlBi.setLod3Geometry(ms);
break;
case LOD4:
gmlBi.setLod4Geometry(ms);
break;
default:
throw new IllegalStateException("Found geometry with LOD other than LOD2,"
+ " LOD3, LOD4, which is illegal for BuildingInstallations: " + lod);
}
}
@Override
public void accept(Check c) {
super.accept(c);
if (c.canExecute(this)) {
c.check(this);
}
for (BoundarySurface bs : boundarySurfaces) {
bs.accept(c);
}
}
@Override
public void clearAllContainedCheckResults() {
super.clearAllContainedCheckResults();
for (BoundarySurface bs : boundarySurfaces) {
bs.clearAllContainedCheckResults();
}
}
@Override
public void collectContainedErrors(List errors) {
super.collectContainedErrors(errors);
for (BoundarySurface bs : boundarySurfaces) {
bs.collectContainedErrors(errors);
}
}
@Override
public boolean containsAnyError() {
boolean hasError = super.containsAnyError();
if (hasError) {
return true;
}
for (BoundarySurface bs : boundarySurfaces) {
if (bs.containsAnyError()) {
return true;
}
}
return false;
}
@Override
public boolean containsError(CheckId checkIdentifier) {
boolean hasError = super.containsError(checkIdentifier);
if (hasError) {
return true;
}
for (BoundarySurface bs : boundarySurfaces) {
if (bs.containsError(checkIdentifier)) {
return true;
}
}
return false;
}
public void setParent(AbstractBuilding parent) {
this.parent = parent;
}
public AbstractBuilding getParent() {
return parent;
}
public void addBoundarySurface(BoundarySurface bs) {
boundarySurfaces.add(bs);
bs.setParent(this);
}
public void unsetGmlGeometries() {
gmlBi.unsetLod2Geometry();
gmlBi.unsetLod3Geometry();
gmlBi.unsetLod4Geometry();
for (BoundarySurface bs : boundarySurfaces) {
bs.unsetGmlGeometries();
}
}
public void setGmlObject(org.citygml4j.model.citygml.building.BuildingInstallation gmlBi) {
this.gmlBi = gmlBi;
}
@Override
public String toString() {
return "BuildingInstallation [id=" + getGmlId() + "]";
}
void anonymize() {
setGmlId(GmlId.generateId());
gmlBi = new org.citygml4j.model.citygml.building.BuildingInstallation();
gmlBi.setId(getGmlId().getGmlString());
for (BoundarySurface bs : boundarySurfaces) {
bs.anonymize();
gmlBi.addBoundedBySurface(new BoundarySurfaceProperty((AbstractBoundarySurface) bs.getGmlObject()));
}
}
@Override
public org.citygml4j.model.citygml.building.BuildingInstallation getGmlObject() {
return gmlBi;
}
@Override
public FeatureType getFeatureType() {
return FeatureType.BUILDING_INSTALLATION;
}
public List getBoundarySurfaces() {
if (boundarySurfaces == null) {
boundarySurfaces = new ArrayList<>(4);
}
return boundarySurfaces;
}
@Override
public void clearMetaInformation() {
super.clearMetaInformation();
for (BoundarySurface bs : boundarySurfaces) {
bs.clearMetaInformation();
}
}
@Override
public void prepareForChecking() {
super.prepareForChecking();
for (BoundarySurface bs : boundarySurfaces) {
bs.prepareForChecking();
}
}
}