import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
@Override
public GeometryObject getMultiPoint(Object geomObj) throws SQLException {
	if (geomObj instanceof Struct)
		return getMultiPoint(JGeometry.loadJS((Struct)geomObj));

	return null;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
@Override
public GeometryObject getCurve(Object geomObj) throws SQLException {
	if (geomObj instanceof Struct)
		return getCurve(JGeometry.loadJS((Struct)geomObj));

	return null;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
@Override
public GeometryObject getMultiCurve(Object geomObj) throws SQLException {
	if (geomObj instanceof Struct)
		return getMultiCurve(JGeometry.loadJS((Struct)geomObj));

	return null;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
@Override
public GeometryObject getMultiPolygon(Object geomObj) throws SQLException {
	if (geomObj instanceof Struct)
		return getMultiPolygon(JGeometry.loadJS((Struct)geomObj));

	return null;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
public BuildingNode() {
	lodGeometryId = new long[4];
	terrainIntersection = new JGeometry[4];
	multiCurve = new JGeometry[3];
	addressProperty = new ArrayList<AddressProperty>();
	childNodes = new ArrayList<BuildingNode>();
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
public PointProperty getPointProperty(JGeometry geom, boolean setSrsName) {
	PointProperty pointProperty = null;

	Point point = getPoint(geom, setSrsName);
	if (point != null) {
		pointProperty = new PointPropertyImpl();
		pointProperty.setPoint(point);
	}

	return pointProperty;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
public MultiPointProperty getMultiPointProperty(JGeometry geom, boolean setSrsName) {
	MultiPointProperty multiPointProperty = null;

	MultiPoint multiPoint = getMultiPoint(geom, setSrsName);
	if (multiPoint != null) {
		multiPointProperty = new MultiPointPropertyImpl();
		multiPointProperty.setMultiPoint(multiPoint);
	}

	return multiPointProperty;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
@Override
public GeometryObject getPoint(Object geomObj) throws SQLException {
	if (geomObj instanceof Struct)
		return getPoint(JGeometry.loadJS((Struct)geomObj));

	return null;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
@Override
public GeometryObject getPolygon(Object geomObj) throws SQLException {
	if (geomObj instanceof Struct)
		return getPolygon(JGeometry.loadJS((Struct)geomObj));

	return null;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
private JGeometry convertMultiPointToJGeometry(GeometryObject geomObj) {
	Object[] objectArray = new Object[geomObj.getNumElements()];
	for (int i = 0; i < geomObj.getNumElements(); i++)
		objectArray[i] = geomObj.getCoordinates(i);

	return JGeometry.createMultiPoint(objectArray, geomObj.getDimension(), geomObj.getSrid());
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
private JGeometry convertMultiCurveToJGeometry(GeometryObject geomObj) {
	Object[] objectArray = new Object[geomObj.getNumElements()];
	for (int i = 0; i < geomObj.getNumElements(); i++)
		objectArray[i] = geomObj.getCoordinates(i);

	return JGeometry.createLinearMultiLineString(objectArray, geomObj.getDimension(), geomObj.getSrid());
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
private JGeometry convertPolygonToJGeometry(GeometryObject geomObj) {
	if (geomObj.getNumElements() == 1) {
		return JGeometry.createLinearPolygon(geomObj.getCoordinates(0), geomObj.getDimension(), geomObj.getSrid());
	} else {
		Object[] objectArray = new Object[geomObj.getNumElements()];
		for (int i = 0; i < geomObj.getNumElements(); i++)
			objectArray[i] = geomObj.getCoordinates(i);

		return JGeometry.createLinearPolygon(objectArray, geomObj.getDimension(), geomObj.getSrid());
	} 
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
public GeometryProperty<? extends AbstractGeometry> getPointOrCurveGeometryProperty(JGeometry geom, boolean setSrsName) {
	GeometryProperty<AbstractGeometry> geometryProperty = null;
	
	AbstractGeometry geometry = getPointOrCurveGeometry(geom, setSrsName);
	if (geometry != null) {
		geometryProperty = new GeometryPropertyImpl<AbstractGeometry>();
		geometryProperty.setGeometry(geometry);
	}
	
	return geometryProperty;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
public PolygonProperty getPolygonProperty(JGeometry geom, boolean setSrsName) {
	PolygonProperty polygonProperty = null;

	Polygon polygon = getPolygon(geom, setSrsName);
	if (polygon != null && (polygon.isSetExterior() || polygon.isSetInterior())) {
		polygonProperty = new PolygonPropertyImpl();
		polygonProperty.setPolygon(polygon);
	}

	return polygonProperty;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
public Geometry convertToJTSGeometry(ValueMetaInterface vmi, Object obj, Database db) {
	if (obj instanceof oracle.sql.STRUCT) {
		try {
			// Map Oracle's SRID with the EPSG-SRID or take a custom SRS from WKT
			int oracle_srid = JGeometry.load((STRUCT)obj).getSRID();
			// see bug 2845785; disabled reading of SRS metadata as temporary workaround,
			// meanwhile one must assign SRS manually using Set SRS step
			// TODO: review everything!
			// SRS epsg_srid = convertToEPSG_SRID(oracle_srid, db.getConnection());
			SRS epsg_srid = SRS.UNKNOWN;
			vmi.setGeometrySRS(epsg_srid);
			
			WKB wkb = new WKB(ByteOrder.BIG_ENDIAN);		// Create empty WKB representation
			byte[] b = wkb.fromSTRUCT( (STRUCT) obj );		// convert: Object -> STRUCT -> byte[]
			Geometry jtsGeom = (new WKBReader()).read(b);	// convert: byte[] -> JTS-Geometry
			jtsGeom.setSRID(epsg_srid.getSRID());			// set the SRID of the JTS-Geometry
			return jtsGeom;
		} catch (Exception e) {
			LOGGER.logError("GeoKettle", "Conversion from Oracle-geometry failed.");
			return null;
		}
	} else {
		LOGGER.logDetailed("GeoKettle", "No Oracle-geometry found to convert.");
		return null;
	}
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
public Object convertToObject(ValueMetaInterface vmi, Geometry jtsGeom, Database db) {
	WKBWriter wkbWriter = new WKBWriter();
	byte[] b = wkbWriter.write(jtsGeom);
	WKB wkb = new WKB(ByteOrder.BIG_ENDIAN);
	try {
		// Map the EPSG- (or custom-) SRID with Oracle's SRID.
		// TODO: review this, probably has some of the same issues as when reading the SRID
		int oracle_srid = convertToDBMS_SRID(vmi.getGeometrySRS(), db.getConnection());
		
		STRUCT oracleStruct = wkb.toSTRUCT(b, db.getConnection());			// convert: byte[] --> STRUCT (using DB connection)
		JGeometry oracleGeom = JGeometry.load(oracleStruct);				// convert: STRUCT --> JGeometry
		oracleGeom.setSRID(oracle_srid);									// set the SRID
		oracleStruct = JGeometry.store(db.getConnection(), oracleGeom);		// convert: JGeometry --> STRUCT (using DB connection)
		return oracleStruct;
	} catch (Exception e) {
		LOGGER.logError("GeoKettle", "Conversion to Oracle-geometry failed.");
		return null;
	}
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
@Override
public GeometryObject getEnvelope(Object geomObj) throws SQLException {
	GeometryObject envelope = null;

	if (geomObj instanceof Struct) {
		JGeometry geometry = JGeometry.loadJS((Struct)geomObj);
		double[] ordinates = geometry.getMBR();
		double[] coordinates;

		if (geometry.getDimensions() == 3)
			coordinates = new double[]{ordinates[0], ordinates[1], ordinates[2], ordinates[3], ordinates[4], ordinates[5]};
		else 
			coordinates = new double[]{ordinates[0], ordinates[1], 0, ordinates[2], ordinates[3], 0};

		envelope = GeometryObject.createEnvelope(coordinates, 3, geometry.getSRID());
	}

	return envelope;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
private double[][] getPolygonCoordinates(JGeometry geometry) {
	int[] elemInfo = geometry.getElemInfo();
	double[] ordinates = geometry.getOrdinatesArray();
	if (elemInfo.length < 3)
		return null;

	int[] ringLimits = new int[elemInfo.length / 3];
	ringLimits[ringLimits.length - 1] = ordinates.length;
	for (int i = 3, j = 0; i < elemInfo.length; i += 3, j++)
		ringLimits[j] = elemInfo[i] - 1;

	double[][] coordinates = new double[ringLimits.length][];			
	for (int i = 0, ordinate = 0; i < ringLimits.length; i++) {
		coordinates[i] = new double[ringLimits[i] - ordinate];
		for (int j = 0; ordinate < ringLimits[i]; ordinate++, j++)
			coordinates[i][j] = ordinates[ordinate];
	}
	
	return coordinates;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
@Override
public GeometryObject getGeometry(Object geomObj) throws SQLException {
	if (geomObj instanceof Struct) {
		JGeometry geometry = JGeometry.loadJS((Struct)geomObj);
		switch (geometry.getType()) {
		case JGeometry.GTYPE_POINT:
			return getPoint(geometry);
		case JGeometry.GTYPE_MULTIPOINT:
			return getMultiPoint(geometry);
		case JGeometry.GTYPE_CURVE:
			return getCurve(geometry);
		case JGeometry.GTYPE_MULTICURVE:
			return getMultiCurve(geometry);
		case JGeometry.GTYPE_POLYGON:
			return getPolygon(geometry);
		case JGeometry.GTYPE_MULTIPOLYGON:
			return getMultiPolygon(geometry);
		default:
			throw new SQLException("Cannot convert Oracle geometry type '" + geometry.getType() + "' to internal representation: Unsupported type.");
		}
	}

	return null;
}
 

import oracle.spatial.geometry.JGeometry; //导入依赖的package包/类
private JGeometry convertMultiPolygonToJGeometry(GeometryObject geomObj) {
	int[] elemInfo = new int[geomObj.getNumElements() * 3];
	double[] ordinates = new double[geomObj.getNumCoordinates()];
	
	int ordinatesIndex = 0;
	int elemInfoIndex = 0;
	
	for (int i = 0; i < geomObj.getNumElements(); i++) {			
		elemInfo[elemInfoIndex++] = ordinatesIndex + 1;
		elemInfo[elemInfoIndex++] = geomObj.getElementType(i) == ElementType.EXTERIOR_LINEAR_RING ? 1003 : 2003;
		elemInfo[elemInfoIndex++] = 1;
		
		double[] coordinates = geomObj.getCoordinates(i);
		for (int j = 0; j < coordinates.length; j++)
			ordinates[ordinatesIndex++] = coordinates[j];
	}
	
	return new JGeometry(JGeometry.GTYPE_MULTIPOLYGON, geomObj.getSrid(), elemInfo, ordinates);
}