CityDoctorModel.java 10.9 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*-
 *  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 <https://www.gnu.org/licenses/>.
 */
package de.hft.stuttgart.citydoctor2.datastructure;

Matthias Betz's avatar
Matthias Betz committed
21
import java.io.BufferedWriter;
22
import java.io.File;
Matthias Betz's avatar
Matthias Betz committed
23
24
25
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
26
import java.util.ArrayList;
Matthias Betz's avatar
Matthias Betz committed
27
import java.util.EnumMap;
28
import java.util.HashSet;
Matthias Betz's avatar
Matthias Betz committed
29
import java.util.LinkedHashMap;
30
import java.util.List;
31
32
import java.util.Map;
import java.util.Set;
33
34
import java.util.stream.Stream;

Matthias Betz's avatar
Matthias Betz committed
35
36
import org.citygml4j.core.model.CityGMLVersion;
import org.citygml4j.core.model.core.CityModel;
37

Matthias Betz's avatar
Matthias Betz committed
38
39
import de.hft.stuttgart.citydoctor2.check.AbstractCheck;
import de.hft.stuttgart.citydoctor2.check.Check;
40
import de.hft.stuttgart.citydoctor2.check.CheckError;
Matthias Betz's avatar
Matthias Betz committed
41
import de.hft.stuttgart.citydoctor2.exceptions.CityDoctorWriteException;
42
import de.hft.stuttgart.citydoctor2.parser.ParserConfiguration;
Matthias Betz's avatar
Matthias Betz committed
43
44
import de.hft.stuttgart.citydoctor2.writer.CityGMLWriterUtils;
import de.hft.stuttgart.quality.model.types.ValidationPlan;
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

/**
 * The complete CityGML model containing all features that are used in
 * CityDoctor
 * 
 * @author Matthias Betz
 *
 */
public class CityDoctorModel {

	private static final String COULD_NOT_FIND_FEATURE = "Could not find feature: ";
	private List<Building> buildings;
	private List<Vegetation> vegetation;
	private List<BridgeObject> bridges;
	private List<LandObject> land;
	private List<TransportationObject> roads;
	private List<WaterObject> water;
	private CityModel cModel;
	private ParserConfiguration config;
	private String fileName;
	private File file;
	private List<CheckError> globalErrors;
67
68
	private boolean isValidated = false;
	private ValidationPlan plan;
Matthias Betz's avatar
Matthias Betz committed
69
	private CityGMLVersion cityGMLVersion;
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

	public CityDoctorModel(ParserConfiguration config, File file) {
		if (config == null) {
			throw new IllegalArgumentException("Parser configuration may not be null");
		}
		this.fileName = file.getName();
		this.config = config;
		this.file = file;
		buildings = new ArrayList<>();
		vegetation = new ArrayList<>();
		bridges = new ArrayList<>();
		land = new ArrayList<>();
		roads = new ArrayList<>();
		water = new ArrayList<>();
		globalErrors = new ArrayList<>();
	}

87
88
89
90
91
92
93
94
	public boolean isValidated() {
		return isValidated;
	}

	public void setValidated(ValidationPlan plan) {
		this.plan = plan;
		this.isValidated = true;
	}
Matthias Betz's avatar
Matthias Betz committed
95
96
97
98
	
	public ValidationPlan getValidationPlan() {
		return plan;
	}
99

100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
	public void addGlobalError(CheckError err) {
		globalErrors.add(err);
	}

	public void addGlobalErrors(List<? extends CheckError> generalErrors) {
		globalErrors.addAll(generalErrors);
	}

	public List<CheckError> getGlobalErrors() {
		return globalErrors;
	}

	public File getFile() {
		return file;
	}

	public Stream<CityObject> createFeatureStream() {
		return Stream.of(buildings.stream(), vegetation.stream(), bridges.stream(), land.stream(), roads.stream(),
				water.stream()).flatMap(co -> co);
	}

Matthias Betz's avatar
Matthias Betz committed
121
	public void saveAs(String file) throws CityDoctorWriteException {
Matthias Betz's avatar
Matthias Betz committed
122
123
124
125
126
127
128
		if (file.endsWith(".off")) {
			exportAsOff(file);
		} else {
			exportAsGML(file);
		}
	}

Matthias Betz's avatar
Matthias Betz committed
129
130
	private void exportAsGML(String file) throws CityDoctorWriteException {
		CityGMLWriterUtils.writeCityModel(file, this);
131
132
	}

Matthias Betz's avatar
Matthias Betz committed
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
	private void exportAsOff(String file) {
		file = file.substring(0, file.lastIndexOf('.'));
		File folder = new File(file);
		folder.mkdirs();
		createFeatureStream().forEach(co -> {
			Map<Lod, Set<Polygon>> polygonMap = new EnumMap<>(Lod.class);
			Check c = new AbstractCheck() {
				
				@Override
				public void check(Geometry geom) {
					polygonMap.compute(geom.getLod(), (lod, polys) -> {
						if (polys == null) {
							polys = new HashSet<>();
						}
						for (Polygon poly : geom.getPolygons()) {
							polys.add(poly.getOriginal());
						}
						return polys;
					});
				}
			};
			co.accept(c);
			
			Set<Polygon> highestLod = polygonMap.get(Lod.LOD2);
			if (highestLod == null) {
				highestLod = polygonMap.get(Lod.LOD1);
			}
			if (highestLod == null) {
				return;
			}
			Map<Vertex, Integer> idMap = new LinkedHashMap<>();
			int counter = 0;
			for (Polygon poly : highestLod) {
				counter = addRing(poly.getExteriorRing(), idMap, counter);
			}
			
			try (BufferedWriter writer = Files.newBufferedWriter(folder.toPath().resolve(co.getGmlId() + ".off"))) {
				writer.write("OFF\n");
				writer.write(Integer.toString(idMap.size()));
				writer.write(' ');
				writer.write(Integer.toString(highestLod.size()));
				writer.write(" 0\n");
				for (Vertex v : idMap.keySet()) {
					writer.write(Double.toString(v.getX()));
					writer.write(' ');
					writer.write(Double.toString(v.getY()));
					writer.write(' ');
					writer.write(Double.toString(v.getZ()));
					writer.write('\n');
				}
				for (Polygon poly : highestLod) {
					writer.write(Integer.toString(poly.getExteriorRing().getVertices().size() - 1));
					writer.write(' ');
					for (int i = 0; i < poly.getExteriorRing().getVertices().size() - 1; i++) {
						Vertex v = poly.getExteriorRing().getVertices().get(i);
						writer.write(Integer.toString(idMap.get(v)));
						writer.write(' ');
					}
					writer.write('\n');
				}
			} catch (IOException e) {
				throw new UncheckedIOException(e);
			} 
			
		});
	}

	private int addRing(LinearRing ring, Map<Vertex, Integer> idMap, int counter) {
		for (Vertex v : ring.getVertices()) {
			if (!idMap.containsKey(v)) {
				idMap.put(v, counter);
				counter++;
			}
		}
		return counter;
	}

210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
	public Set<CheckError> collectErrors() {
		List<CheckError> errors = new ArrayList<>();
		collectErrorsFromList(errors, buildings);
		collectErrorsFromList(errors, vegetation);
		collectErrorsFromList(errors, bridges);
		collectErrorsFromList(errors, land);
		collectErrorsFromList(errors, roads);
		collectErrorsFromList(errors, water);
		return new HashSet<>(errors);
	}

	private void collectErrorsFromList(List<CheckError> errors, List<? extends CityObject> cos) {
		for (CityObject co : cos) {
			co.collectContainedErrors(errors);
		}
	}

227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
	public String getFileName() {
		return fileName;
	}

	public void addBridge(BridgeObject coBridge) {
		bridges.add(coBridge);
	}

	public void addBuilding(Building coBuilding) {
		buildings.add(coBuilding);
	}

	public List<Building> getBuildings() {
		return buildings;
	}

	public List<BridgeObject> getBridges() {
		return bridges;
	}

	public void setCityModel(CityModel cModel) {
		this.cModel = cModel;
	}

	public CityModel getCityModel() {
		return cModel;
	}

	public List<TransportationObject> getTransportation() {
		return roads;
	}

	public List<WaterObject> getWater() {
		return water;
	}

	public List<LandObject> getLand() {
		return land;
	}

	public List<Vegetation> getVegetation() {
		return vegetation;
	}

	public void addWater(WaterObject wo) {
		water.add(wo);
	}

	public void addLand(LandObject lo) {
		land.add(lo);
	}

	public void addVegetation(Vegetation veg) {
		vegetation.add(veg);
	}

	public void addTransportation(TransportationObject to) {
		roads.add(to);
	}

	public int getNumberOfFeatures() {
		return buildings.size() + vegetation.size() + bridges.size() + land.size() + roads.size() + water.size();
	}

	public ParserConfiguration getParserConfig() {
		return config;
	}

	public void replaceFeature(CityObject currentFeature, CityObject nextFeature) {
		if (nextFeature instanceof Building) {
			replaceBuilding(currentFeature, nextFeature);
		} else if (nextFeature instanceof BridgeObject) {
			replaceBridge(currentFeature, nextFeature);
		} else if (nextFeature instanceof TransportationObject) {
			replaceTransportationObject(currentFeature, nextFeature);
		} else if (nextFeature instanceof Vegetation) {
			replaceVegetation(currentFeature, nextFeature);
		} else if (nextFeature instanceof LandObject) {
			replaceLandObject(currentFeature, nextFeature);
		} else if (nextFeature instanceof WaterObject) {
			replaceWaterObject(currentFeature, nextFeature);
		}
	}

	private void replaceWaterObject(CityObject currentFeature, CityObject nextFeature) {
		int index = water.indexOf(currentFeature);
		if (index == -1) {
			throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in water objects");
		}
		water.set(index, (WaterObject) nextFeature);
	}

	private void replaceLandObject(CityObject currentFeature, CityObject nextFeature) {
		int index = land.indexOf(currentFeature);
		if (index == -1) {
			throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in land objects");
		}
		land.set(index, (LandObject) nextFeature);
	}

	private void replaceVegetation(CityObject currentFeature, CityObject nextFeature) {
		int index = vegetation.indexOf(currentFeature);
		if (index == -1) {
			throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in vegetation");
		}
		vegetation.set(index, (Vegetation) nextFeature);
	}

	private void replaceTransportationObject(CityObject currentFeature, CityObject nextFeature) {
		int index = roads.indexOf(currentFeature);
		if (index == -1) {
			throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in transportation objects");
		}
		roads.set(index, (TransportationObject) nextFeature);
	}

	private void replaceBridge(CityObject currentFeature, CityObject nextFeature) {
		int index = bridges.indexOf(currentFeature);
		if (index == -1) {
			throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in bridges");
		}
		bridges.set(index, (BridgeObject) nextFeature);
	}

	private void replaceBuilding(CityObject currentFeature, CityObject nextFeature) {
		int index = buildings.indexOf(currentFeature);
		if (index == -1) {
			throw new IllegalStateException(COULD_NOT_FIND_FEATURE + currentFeature + " in buildings");
		}
		buildings.set(index, (Building) nextFeature);
	}
358
359

	public void addCityObject(CityObject co) {
Matthias Betz's avatar
Matthias Betz committed
360
361
362
363
364
365
366
367
368
369
370
371
		if (co instanceof Building b) {
			buildings.add(b);
		} else if (co instanceof BridgeObject bo) {
			bridges.add(bo);
		} else if (co instanceof TransportationObject to) {
			roads.add(to);
		} else if (co instanceof Vegetation veg) {
			vegetation.add(veg);
		} else if (co instanceof LandObject lo) {
			land.add(lo);
		} else if (co instanceof WaterObject wo) {
			water.add(wo);
372
373
		}
	}
Matthias Betz's avatar
Matthias Betz committed
374
375
376
377
378
379
380
381

	public void setParsedCityGMLVersion(CityGMLVersion cityGMLVersion) {
		this.cityGMLVersion = cityGMLVersion;
	}
	
	public CityGMLVersion getCityGMLVersion() {
		return cityGMLVersion;
	}
382
}