Java CityGMLBuilder类代码示例

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public DBExportWorkerFactory(
		SchemaMapping schemaMapping,
		CityGMLBuilder cityGMLBuilder,
		FeatureWriter featureWriter,
		WorkerPool<DBXlink> xlinkExporterPool,
		UIDCacheManager uidCacheManager,
		CacheTableManager cacheTableManager,
		Query query,
		Config config,
		EventDispatcher eventDispatcher) {
	this.schemaMapping = schemaMapping;
	this.cityGMLBuilder = cityGMLBuilder;
	this.featureWriter = featureWriter;
	this.xlinkExporterPool = xlinkExporterPool;
	this.uidCacheManager = uidCacheManager;
	this.cacheTableManager = cacheTableManager;
	this.query = query;
	this.config = config;
	this.eventDispatcher = eventDispatcher;
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public DBImportWorkerFactory(SchemaMapping schemaMapping,
		CityGMLBuilder cityGMLBuilder,
		WorkerPool<DBXlink> xlinkWorkerPool,
		UIDCacheManager uidCacheManager,
		CityGMLFilter filter,
		AffineTransformer affineTransformer,
		ImportLogger importLogger,
		Config config,
		EventDispatcher eventDispatcher) {
	this.schemaMapping = schemaMapping;
	this.cityGMLBuilder = cityGMLBuilder;
	this.xlinkWorkerPool = xlinkWorkerPool;
	this.uidCacheManager = uidCacheManager;
	this.filter = filter;
	this.affineTransformer = affineTransformer;
	this.importLogger = importLogger;
	this.config = config;
	this.eventDispatcher = eventDispatcher;
	
	connection = null;
	databaseAdapter = null;
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public DBImportWorker(SchemaMapping schemaMapping,
		CityGMLBuilder cityGMLBuilder,
		WorkerPool<DBXlink> xlinkPool,
		UIDCacheManager uidCacheManager,
		CityGMLFilter filter,
		AffineTransformer affineTransformer,
		ImportLogger importLogger,
		Config config,
		EventDispatcher eventDispatcher) throws SQLException {
	this.filter = filter;
	this.importLogger = importLogger;
	this.eventDispatcher = eventDispatcher;

	AbstractDatabaseAdapter databaseAdapter = DatabaseConnectionPool.getInstance().getActiveDatabaseAdapter();
	connection = DatabaseConnectionPool.getInstance().getConnection();
	connection.setAutoCommit(false);
	globalTransaction = false;

	// try and change workspace for both connections if needed
	if (databaseAdapter.hasVersioningSupport()) {
		Workspace workspace = config.getProject().getDatabase().getWorkspaces().getImportWorkspace();
		databaseAdapter.getWorkspaceManager().gotoWorkspace(connection, workspace);
	}

	init(databaseAdapter, schemaMapping, cityGMLBuilder, xlinkPool, uidCacheManager, affineTransformer, config);
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public JAXBInputFactory(CityGMLBuilder builder, SchemaHandler schemaHandler) {
	this.builder = builder;
	this.schemaHandler = schemaHandler;

	xmlInputFactory = XMLInputFactory.newInstance();
	xmlInputFactory.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, Boolean.TRUE);

	gmlIdManager = DefaultGMLIdManager.getInstance();
	validationEventHandler = null;
	featureReadMode = FeatureReadMode.NO_SPLIT;
	excludes = new ArrayList<QName>();
	splitAtFeatureProperties = new ArrayList<QName>();
	keepInlineAppearance = true;
	parseSchema = true;
	useValidation = false;
	failOnMissingADESchema = true;
	supportCityGML040 = false;
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public CityGMLExportManager(Connection connection,
		Query query,
		AbstractDatabaseAdapter databaseAdapter,
		SchemaMapping schemaMapping,
		CityGMLBuilder cityGMLBuilder,
		FeatureWriter featureWriter,
		WorkerPool<DBXlink> xlinkPool,
		UIDCacheManager uidCacheManager,
		CacheTableManager cacheTableManager,
		Config config) throws CityGMLExportException, SQLException {
	this.connection = connection;
	this.query = query;
	this.databaseAdapter = databaseAdapter;
	this.schemaMapping = schemaMapping;
	this.cityGMLBuilder = cityGMLBuilder;
	this.featureWriter = featureWriter;
	this.xlinkPool = xlinkPool;
	this.uidCacheManager = uidCacheManager;
	this.cacheTableManager = cacheTableManager;
	this.config = config;

	adeManager = ADEExtensionManager.getInstance();
	hasADESupport = !adeManager.getEnabledExtensions().isEmpty();

	attributeValueSplitter = new AttributeValueSplitter();
	lodGeometryChecker = new LodGeometryChecker(schemaMapping);
	exportCounter = new ExportCounter(schemaMapping);

	if (config.getProject().getExporter().getAppearances().isSetExportAppearance())
		appearanceRemover = new AppearanceRemover(xlinkPool);

	try {
		jaxbUnmarshaller = cityGMLBuilder.createJAXBUnmarshaller();
		jaxbUnmarshaller.setThrowMissingADESchema(false);
		jaxbUnmarshaller.setParseSchema(false);
	} catch (CityGMLBuilderException e) {
		throw new CityGMLExportException("Failed to build JAXB unmarshaller.", e);
	}
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public Exporter(CityGMLBuilder cityGMLBuilder, 
		SchemaMapping schemaMapping, 
		Config config, 
		EventDispatcher eventDispatcher) {
	this.cityGMLBuilder = cityGMLBuilder;
	this.schemaMapping = schemaMapping;
	this.config = config;
	this.eventDispatcher = eventDispatcher;

	databaseAdapter = DatabaseConnectionPool.getInstance().getActiveDatabaseAdapter();
	objectCounter = new HashMap<>();
	geometryCounter = new EnumMap<>(GMLClass.class);
	totalObjectCounter = new HashMap<>();
	totalGeometryCounter = new EnumMap<>(GMLClass.class);
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public DBExportWorker(SchemaMapping schemaMapping,
		CityGMLBuilder cityGMLBuilder,
		FeatureWriter featureWriter,
		WorkerPool<DBXlink> xlinkPool,
		UIDCacheManager uidCacheManager,
		CacheTableManager cacheTableManager,
		Query query,
		Config config,
		EventDispatcher eventDispatcher) throws CityGMLExportException, SQLException {		
	this.eventDispatcher = eventDispatcher;
	this.config = config;

	AbstractDatabaseAdapter databaseAdapter = DatabaseConnectionPool.getInstance().getActiveDatabaseAdapter();
	connection = DatabaseConnectionPool.getInstance().getConnection();

	// try and change workspace the connections if needed
	if (databaseAdapter.hasVersioningSupport()) {
		databaseAdapter.getWorkspaceManager().gotoWorkspace(
				connection, 
				config.getProject().getDatabase().getWorkspaces().getExportWorkspace());
	}

	exporter = new CityGMLExportManager(
			connection, 
			query,
			databaseAdapter,
			schemaMapping, 
			cityGMLBuilder,
			featureWriter,
			xlinkPool,
			uidCacheManager,
			cacheTableManager,
			config);

	eventDispatcher.addEventHandler(EventType.INTERRUPT, this);
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public Importer(CityGMLBuilder cityGMLBuilder, 
		SchemaMapping schemaMapping,
		Config config, 
		EventDispatcher eventDispatcher) {
	this.cityGMLBuilder = cityGMLBuilder;
	this.schemaMapping = schemaMapping;
	this.config = config;
	this.eventDispatcher = eventDispatcher;

	databaseAdapter = DatabaseConnectionPool.getInstance().getActiveDatabaseAdapter();
	objectCounter = new HashMap<>();
	geometryCounter = new EnumMap<>(GMLClass.class);
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
private void init(AbstractDatabaseAdapter databaseAdapter, 
		SchemaMapping schemaMapping, 
		CityGMLBuilder cityGMLBuilder,
		WorkerPool<DBXlink> xlinkPool,
		UIDCacheManager uidCacheManager,
		AffineTransformer affineTransformer,
		Config config) throws SQLException {
	importer = new CityGMLImportManager(connection, 
			databaseAdapter,
			schemaMapping,
			cityGMLBuilder,
			xlinkPool,
			uidCacheManager,
			affineTransformer,
			config);

	Integer commitAfterProp = config.getProject().getDatabase().getUpdateBatching().getFeatureBatchValue();
	if (commitAfterProp != null && commitAfterProp > 0)
		commitAfter = commitAfterProp;

	bboxOptions = BoundingBoxOptions.defaults()				
			.useExistingEnvelopes(true)
			.assignResultToFeatures(true)
			.useReferencePointAsFallbackForImplicitGeometries(true);

	eventDispatcher.addEventHandler(EventType.INTERRUPT, this);
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public JAXBOutputFactory(CityGMLBuilder builder, ModuleContext moduleContext, SchemaHandler schemaHandler) {
	this.builder = builder;
	this.schemaHandler = schemaHandler;
	this.moduleContext = moduleContext;

	gmlIdManager = DefaultGMLIdManager.getInstance();
	featureWriteMode = FeatureWriteMode.NO_SPLIT;
	excludes = new HashSet<>();
	keepInlineAppearance = true;
	splitCopy = true;
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public JAXBMarshaller(CityGMLBuilder builder, ModuleContext moduleContext) {
	this.builder = builder;
	this.moduleContext = moduleContext;

	citygml = new CityGMLMarshaller(this);
	gml = new GMLMarshaller(this);
	xal = new XALMarshaller();
	ade = new ADEMarshaller(this);
	
	try {
		dataTypeFactory = DatatypeFactory.newInstance();
	} catch (DatatypeConfigurationException e) {
		throw new RuntimeException("Failed to create DatatypeFactory.", e);
	}
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public JAXBUnmarshaller(CityGMLBuilder builder, SchemaHandler schemaHandler) {
	this.builder = builder;
	this.schemaHandler = schemaHandler;

	citygml = new CityGMLUnmarshaller(this);
	gml = new GMLUnmarshaller(this);
	xal = new XALUnmarshaller();
	ade = new ADEUnmarshaller(this);
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
	SimpleDateFormat df = new SimpleDateFormat("[HH:mm:ss] "); 

	System.out.println(df.format(new Date()) + "setting up citygml4j context and CityGML builder");
	CityGMLContext ctx = CityGMLContext.getInstance();
	CityGMLBuilder builder = ctx.createCityGMLBuilder();

	System.out.println(df.format(new Date()) + "reading only roads from CityGML file LOD2_CityObjectGroup_v100.gml");
	CityGMLInputFactory in = builder.createCityGMLInputFactory();
	in.setProperty(CityGMLInputFactory.FEATURE_READ_MODE, FeatureReadMode.SPLIT_PER_FEATURE);

	CityGMLReader reader = in.createCityGMLReader(new File("datasets/LOD2_CityObjectGroup_v100.gml"));
	reader = in.createFilteredCityGMLReader(reader, new CityGMLInputFilter() {

		// return true if you want to consume the CityGML feature
		// of the given qualified XML name, false otherwise
		public boolean accept(QName name) {
			return Modules.isModuleNamespace(name.getNamespaceURI(), CityGMLModuleType.TRANSPORTATION)
					&& name.getLocalPart().equals("Road");
		}
		
	});

	System.out.println(df.format(new Date()) + "printing road features");
	while (reader.hasNext()) {
		Road road = (Road)reader.nextFeature();
		System.out.println(df.format(new Date()) + "found Road with gml:id " + road.getId());	
		
		System.out.println(df.format(new Date()) + "\t" + road.getTrafficArea().size() + " traffic area(s)");	
		System.out.println(df.format(new Date()) + "\t" + road.getAuxiliaryTrafficArea().size() + " auxiliary traffic area(s)");	
	}

	reader.close();
	System.out.println(df.format(new Date()) + "sample citygml4j application successfully finished");
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
	SimpleDateFormat df = new SimpleDateFormat("[HH:mm:ss] "); 

	System.out.println(df.format(new Date()) + "setting up citygml4j context and CityGML builder");
	CityGMLContext ctx = CityGMLContext.getInstance();
	CityGMLBuilder builder = ctx.createCityGMLBuilder();
	
	System.out.println(df.format(new Date()) + "reading CityGML file LOD2_Buildings_v100.gml completely into main memory");
	CityGMLInputFactory in = builder.createCityGMLInputFactory();
	CityGMLReader reader = in.createCityGMLReader(new File("datasets/LOD2_Buildings_v100.gml"));
	
	while (reader.hasNext()) {
		CityGML citygml = reader.nextFeature();

		if (citygml.getCityGMLClass() == CityGMLClass.CITY_MODEL) {
			CityModel cityModel = (CityModel)citygml;

			System.out.println(df.format(new Date()) + "Found " + citygml.getCityGMLClass() + " version " + cityModel.getCityGMLModule().getVersion());
			System.out.println(df.format(new Date()) + "going through city model and counting building instances");

			int count = 0;
			for (CityObjectMember cityObjectMember : cityModel.getCityObjectMember()) {
				AbstractCityObject cityObject = cityObjectMember.getCityObject();
				if (cityObject.getCityGMLClass() == CityGMLClass.BUILDING)
					count++;
			}

			System.out.println(df.format(new Date()) + "The city model contains " + count + " building features");
		}	
	}			
	
	reader.close();
	System.out.println(df.format(new Date()) + "sample citygml4j application successfully finished");
}
 

import org.citygml4j.builder.jaxb.CityGMLBuilder; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
	SimpleDateFormat df = new SimpleDateFormat("[HH:mm:ss] "); 

	System.out.println(df.format(new Date()) + "setting up citygml4j context and CityGML builder");
	CityGMLContext ctx = CityGMLContext.getInstance();
	CityGMLBuilder builder = ctx.createCityGMLBuilder();
	
	System.out.println(df.format(new Date()) + "reading CityGML file LOD3_Building_v200.gml feature by feature");
	CityGMLInputFactory in = builder.createCityGMLInputFactory();
	in.setProperty(CityGMLInputFactory.FEATURE_READ_MODE, FeatureReadMode.SPLIT_PER_FEATURE);
	in.setProperty(CityGMLInputFactory.EXCLUDE_FROM_SPLITTING, new QName[]{new QName("Door"), new QName("Address")});

	// see difference when setting to true
	in.setProperty(CityGMLInputFactory.KEEP_INLINE_APPEARANCE, false);
	
	CityGMLReader reader = in.createCityGMLReader(new File("datasets/LOD3_Building_v200.gml"));
	
	System.out.println(df.format(new Date()) + "printing feature currently read and its (transitive) parents");
	while (reader.hasNext()) {
		CityGML chunk = reader.nextFeature();	
		System.out.println("found: " + chunk.getCityGMLClass());
		
		if (reader.isSetParentInfo()) {
			ParentInfo parentInfo = reader.getParentInfo();
			System.out.println(" --parent: " + parentInfo.getCityGMLClass());
			
			while ((parentInfo = parentInfo.getParentInfo()) != null)
				System.out.println(" --transitive parent: " + parentInfo.getCityGMLClass());
		}
		
	}

	reader.close();
	System.out.println(df.format(new Date()) + "sample citygml4j application successfully finished");
}