org.citygml4j.model.gml.geometry.AbstractGeometry Java Examples

public void marshalDomainSet(DomainSet<? extends AbstractGeometry> src, DomainSetType dest) {		
	if (src.isSetRemoteSchema())
		dest.setRemoteSchema(src.getRemoteSchema());

	if (src.isSetType())
		dest.setType(TypeType.fromValue(src.getType().getValue()));

	if (src.isSetHref())
		dest.setHref(src.getHref());

	if (src.isSetRole())
		dest.setRole(src.getRole());

	if (src.isSetArcrole())
		dest.setArcrole(src.getArcrole());

	if (src.isSetTitle())
		dest.setTitle(src.getTitle());

	if (src.isSetShow())
		dest.setShow(ShowType.fromValue(src.getShow().getValue()));

	if (src.isSetActuate())
		dest.setActuate(ActuateType.fromValue(src.getActuate().getValue()));
}
 

@Override
public void visit(AbstractGeometry geometry) {
	switch (geometry.getGMLClass()) {
		case POLYGON:
		case COMPOSITE_SURFACE:
		case SURFACE:
		case TRIANGULATED_SURFACE:
		case TIN:
		case SOLID:
		case COMPOSITE_SOLID:
		case MULTI_POLYGON:
		case MULTI_SURFACE:
		case MULTI_SOLID:
		case MULTI_GEOMETRY:
			count++;
	}
}
 

protected long doImport(AbstractGeometry surfaceGeometry, long cityObjectId) throws CityGMLImportException, SQLException {
	// check whether we can deal with the geometry
	if (!geometryConverter.isSurfaceGeometry(surfaceGeometry)) {
		importer.logOrThrowErrorMessage("Unsupported geometry type " + importer.getObjectSignature(surfaceGeometry));
		return 0;
	}

	boolean success = pkManager.retrieveIds(surfaceGeometry);
	if (!success) {
		importer.logOrThrowErrorMessage("Failed to acquire primary key values for surface geometry from database.");
		return 0;
	}

	if (surfaceGeometry.isSetId())
		surfaceGeometry.setLocalProperty(CoreConstants.OBJECT_ORIGINAL_GMLID, surfaceGeometry.getId());

	long surfaceGeometryId = pkManager.nextId();
	doImport(surfaceGeometry, surfaceGeometryId, 0, surfaceGeometryId, false, false, false, cityObjectId);
	pkManager.clear();

	return surfaceGeometryId;
}
 

public boolean isPointOrLineGeometry(AbstractGeometry abstractGeometry) {
	switch (abstractGeometry.getGMLClass()) {
		case POINT:
		case MULTI_POINT:
		case LINE_STRING:
		case CURVE:
		case COMPOSITE_CURVE:
		case ORIENTABLE_CURVE:
		case MULTI_CURVE:
			return true;
		case GEOMETRIC_COMPLEX:
			GeometricComplex complex = (GeometricComplex) abstractGeometry;
			return containsPointPrimitives(complex) || containsCurvePrimitives(complex);
		default:
			return false;
	}
}
 

public GeometryObject getPointOrCurveGeometry(AbstractGeometry abstractGeometry) {
	switch (abstractGeometry.getGMLClass()) {
		case POINT:
			return getPoint((Point) abstractGeometry);
		case MULTI_POINT:
			return getMultiPoint((MultiPoint) abstractGeometry);
		case LINE_STRING:
		case CURVE:
		case COMPOSITE_CURVE:
		case ORIENTABLE_CURVE:
			return getCurve((AbstractCurve) abstractGeometry);
		case MULTI_CURVE:
			return getMultiCurve((MultiCurve) abstractGeometry);
		case GEOMETRIC_COMPLEX:
			GeometricComplex complex = (GeometricComplex) abstractGeometry;
			if (containsPointPrimitives(complex))
				return getPointGeometry((GeometricComplex) abstractGeometry);
			else if (containsCurvePrimitives(complex))
				return getCurveGeometry((GeometricComplex) abstractGeometry);
			else
				return null;
		default:
			return null;
	}
}
 

public void marshalAbstractGeometry(AbstractGeometry src, AbstractGeometryType dest) {
	marshalAbstractGML(src, dest);

	if (src.isSetGid())
		dest.setGid(src.getGid());

	if (src.isSetSrsName())
		dest.setSrsName(src.getSrsName());

	if (src.isSetSrsDimension())
		dest.setSrsDimension(BigInteger.valueOf(src.getSrsDimension()));

	if (src.isSetAxisLabels())
		dest.setAxisLabels(src.getAxisLabels());

	if (src.isSetUomLabels())
		dest.setUomLabels(src.getUomLabels());
}
 

public GeometryArrayProperty<AbstractGeometry> unmarshalGeometryArrayProperty(GeometryArrayPropertyType src) {
	GeometryArrayProperty<AbstractGeometry> dest = new GeometryArrayProperty<AbstractGeometry>();

	if (src.isSet_Geometry()) {
		for (JAXBElement<? extends AbstractGeometryType> elem : src.get_Geometry()) {			
			try {
				ModelObject abstractGeometry = jaxb.unmarshal(elem);
				if (abstractGeometry instanceof AbstractGeometry)
					dest.addGeometry((AbstractGeometry)abstractGeometry);
			} catch (MissingADESchemaException e) {
				//
			}
		}
	}

	return dest;
}
 

public AbstractGeometry getPointOrCurveGeometry(GeometryObject geomObj, boolean setSrsName) {
	if (geomObj != null) {
		switch (geomObj.getGeometryType()) {
		case MULTI_LINE_STRING:
			return getMultiCurve(geomObj, setSrsName);
		case LINE_STRING:
			return getLineString(geomObj, setSrsName);
		case MULTI_POINT:
			return getMultiPoint(geomObj, setSrsName);
		case POINT:
			return getPoint(geomObj, setSrsName);
		default:
			return null;
		}
	}

	return null;
}
 

public <T extends AbstractGeometry> void visit(GeometryArrayProperty<T> geometryArrayProperty) {
	if (geometryArrayProperty.isSetGeometry()) {
		for (AbstractGeometry abstractGeometry : new ArrayList<AbstractGeometry>(geometryArrayProperty.getGeometry()))
			if (shouldWalk)
				abstractGeometry.accept(this);
	}
}
 

public GeometryProperty<? extends AbstractGeometry> getPointOrCurveGeometryProperty(GeometryObject geomObj, boolean setSrsName) {
	GeometryProperty<AbstractGeometry> geometryProperty = null;

	AbstractGeometry geometry = getPointOrCurveGeometry(geomObj, setSrsName);
	if (geometry != null) {
		geometryProperty = new GeometryProperty<AbstractGeometry>();
		geometryProperty.setGeometry(geometry);
	}

	return geometryProperty;
}
 

public T apply(GeometricComplex geometricComplex) {
	T object = apply((AbstractGeometry)geometricComplex);
	if (object != null)
		return object;

	if (geometricComplex.isSetElement()) {
		for (GeometricPrimitiveProperty geometricPrimitiveProperty : new ArrayList<GeometricPrimitiveProperty>(geometricComplex.getElement())) {
			object = apply(geometricPrimitiveProperty);
			if (object != null)
				return object;
		}
	}

	return null;
}
 

public MultiGeometryType marshalMultiGeometry(MultiGeometry src) {
	MultiGeometryType dest = gml.createMultiGeometryType();
	marshalAbstractGeometricAggregate(src, dest);

	if (src.isSetGeometryMember()) {
		for (GeometryProperty<? extends AbstractGeometry> member : src.getGeometryMember())
			dest.getGeometryMember().add(marshalGeometryProperty(member));
	}

	if (src.isSetGeometryMembers())
		dest.setGeometryMembers(marshalGeometryArrayProperty(src.getGeometryMembers()));

	return dest;
}
 

public void visit(MultiGeometry multiGeometry) {
	visit((AbstractGeometricAggregate)multiGeometry);

	if (multiGeometry.isSetGeometryMember())
		for (GeometryProperty<? extends AbstractGeometry> geometryProperty : new ArrayList<GeometryProperty<? extends AbstractGeometry>>(multiGeometry.getGeometryMember()))
			visit(geometryProperty);

	if (multiGeometry.isSetGeometryMembers())
		visit(multiGeometry.getGeometryMembers());
}
 

public void visit(GeometricComplex geometricComplex) {
	visit((AbstractGeometry)geometricComplex);

	if (geometricComplex.isSetElement())
		for (GeometricPrimitiveProperty geometricPrimitiveProperty : new ArrayList<GeometricPrimitiveProperty>(geometricComplex.getElement()))
			visit(geometricPrimitiveProperty);
}
 

@Override
public void visit(AbstractGeometry geometry) {
	if (state == ResolverState.GET_GEOMETRY && geometry.isSetId()) {
		List<GeometryProperty<?>> properties = this.properties.get(geometry.getId());
		if (properties != null) {
			for (GeometryProperty<?> property : properties) {
				if (property.getAssociableClass().isAssignableFrom(geometry.getClass()))
					property.setLocalProperty(CityJSONMarshaller.GEOMETRY_XLINK, geometry);
			}
		}
	}
	
	super.visit(geometry);
}
 

@Override
public <T extends AbstractGeometry> void visit(GeometryProperty<T> geometryProperty) {
	if (geometryProperty.isSetGeometry()) {
		String gmlId = geometryProperty.getGeometry().getId();
		if (gmlId != null)
			geometryProperty.setHref("#" + gmlId);
		
		geometryProperty.unsetGeometry();
	}
}
 

public Object copyTo(Object target, CopyBuilder copyBuilder) {
	Value copy = (target == null) ? new Value() : (Value)target;
	
	if (isSetValueObject()) {
		copy.setValueObject((ValueObject)copyBuilder.copy(valueObject));
		if (copy.getValueObject() == valueObject)
			valueObject.setParent(this);
	}
	
	if (isSetGeometry()) {
		copy.setGeometry((AbstractGeometry)copyBuilder.copy(geometry));
		if (copy.getGeometry() == geometry)
			geometry.setParent(this);
	}
	
	if (isSetGenericValueObject()) {
		copy.setGenericValueObject((GenericValueObject)copyBuilder.copy(genericValueObject));
		if (copy.getGenericValueObject() == genericValueObject)
			genericValueObject.setParent(this);
	}
	
	if (isSetNull()) {
		copy.setNull((Null)copyBuilder.copy(_null));
		if (copy.getNull() == _null)
			_null.setParent(this);
	}
	
	copy.unsetParent();
	
	return copy;
}
 

public void resolveGlobalAppearance(AbstractGeometry geometry) {
	if (geometry.isSetId()) {
		List<SurfaceDataInfo> surfaceData = globalSurfaceDatas.get(geometry.getId());
		if (surfaceData != null)
			geometry.setLocalProperty(CityJSONMarshaller.GEOMETRY_SURFACE_DATA, surfaceData);
	}
}
 

public T apply(GeometricComplex geometricComplex) {
	T object = apply((AbstractGeometry)geometricComplex);
	if (object != null)
		return object;

	if (geometricComplex.isSetElement()) {
		for (GeometricPrimitiveProperty geometricPrimitiveProperty : new ArrayList<GeometricPrimitiveProperty>(geometricComplex.getElement())) {
			object = apply(geometricPrimitiveProperty);
			if (object != null)
				return object;
		}
	}

	return null;
}
 

@SuppressWarnings("unchecked")
public DomainSetType marshalDomainSet(DomainSet<? extends AbstractGeometry> src) {
	DomainSetType dest = gml.createDomainSetType();
	marshalDomainSet(src, dest);

	if (src.isSetGeometry()) {
		JAXBElement<?> elem = jaxb.marshalJAXBElement(src.getGeometry());
		if (elem != null && elem.getValue() instanceof RectifiedGridType)
			dest.set_Geometry((JAXBElement<? extends AbstractGeometryType>)elem);
	}

	return dest;
}
 

public void process(AbstractGeometry src, AbstractSolidCollectionType dest, SemanticsBuilder semanticsBuilder) {
	this.dest = dest;
	this.semanticsBuilder = semanticsBuilder;
	
	src.accept(this);
	postprocess(dest, index, true);
}
 

public <E extends AbstractGeometry> T apply(GeometryProperty<E> geometryProperty) {
	if (geometryProperty.isSetGeometry() && shouldWalk) {
		T object = geometryProperty.getGeometry().accept(this);
		if (object != null)
			return object;
	}

	return null;
}
 

public String getGeometrySignature(AbstractGeometry object) {
	StringBuilder signature = new StringBuilder("gml:").append(object.getGMLClass().toString());
	String gmlId = object.hasLocalProperty(CoreConstants.OBJECT_ORIGINAL_GMLID) ?
			(String)object.getLocalProperty(CoreConstants.OBJECT_ORIGINAL_GMLID) :
			object.getId();

	if (gmlId != null)
		signature.append(" '").append(gmlId).append("'");
	else
		signature.append(" (unknown gml:id)");

	return signature.toString();
}
 

public void setLod4Geometry(GeometryProperty<? extends AbstractGeometry> lod4Geometry) {
	this.lod4Geometry = ModelObjects.setParent(lod4Geometry, this);
}
 

public void setLod2Geometry(GeometryProperty<? extends AbstractGeometry> lod2Geometry) {
	this.lod2Geometry = ModelObjects.setParent(lod2Geometry, this);
}
 

public void setLod3Geometry(GeometryProperty<? extends AbstractGeometry> lod3Geometry) {
	this.lod3Geometry = ModelObjects.setParent(lod3Geometry, this);
}
 

public GeometryProperty<? extends AbstractGeometry> getLod4Geometry() {
	return lod4Geometry;
}
 

public void setLod2Geometry(GeometryProperty<? extends AbstractGeometry> lod2Geometry) {
	this.lod2Geometry = ModelObjects.setParent(lod2Geometry, this);
}
 

public T apply(AbstractGeometry abstractGeometry) {
	return null;
}
 

public GeometryProperty<? extends AbstractGeometry> getLod3Geometry() {
	return lod3Geometry;
}