import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
@Override
@Transactional(readOnly = true)
public List<Geometry> loadSplicedGeometries(final Collection<Long> zoneIds) {
    if (zoneIds.isEmpty()) {
        return emptyList();
    }

    final GeometryFactory geometryFactory = GISUtils.getGeometryFactory(GISUtils.SRID.ETRS_TM35FIN);
    final WKBReader wkbReader = new WKBReader(geometryFactory);
    final MapSqlParameterSource params = new MapSqlParameterSource()
            .addValue("chunkSize", 2048)
            .addValue("zoneIds", zoneIds);

    return namedParameterJdbcTemplate.query(
            "SELECT ST_AsBinary(ST_SubDivide(geom, :chunkSize)) AS geom FROM zone WHERE zone_id IN (:zoneIds)",
            params, (resultSet, i) -> {
                final byte[] wkb = resultSet.getBytes("geom");

                try {
                    return wkbReader.read(wkb);
                } catch (ParseException e) {
                    throw new RuntimeException(e);
                }
            });
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的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 com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
@Override
public void fromBinary(
		final byte[] bytes ) {
	final ByteBuffer buf = super.binaryBuffer(bytes);
	final byte[] payload = buf.array();
	if (payload.length > 0) {
		try {
			footprint = new WKBReader().read(payload);
		}
		catch (final ParseException e) {
			LOGGER.warn(
					"Unable to parse WKB",
					e);
		}
	}
	else {
		footprint = null;
	}
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
@Override
public void fromBinary(
		final byte[] bytes ) {
	final ByteBuffer buf = ByteBuffer.wrap(bytes);
	compareOp = CompareOperation.values()[buf.getInt()];
	nonSpatialCompareOp = BasicQueryCompareOperation.values()[buf.getInt()];

	final byte[] crsBinary = new byte[buf.getInt()];
	final byte[] superBinary = new byte[buf.getInt()];
	buf.get(crsBinary);
	crsCode = crsBinary.length > 0 ? StringUtils.stringFromBinary(crsBinary) : null;
	buf.get(superBinary);
	super.fromBinary(superBinary);
	final byte[] geometryBinary = new byte[bytes.length - superBinary.length - crsBinary.length - 16];
	buf.get(geometryBinary);
	try {
		queryGeometry = new WKBReader().read(geometryBinary);
	}
	catch (final ParseException e) {
		LOGGER.warn(
				"Unable to read query geometry as well-known binary",
				e);
	}
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
public Geometry getGeometryNoCopy() {
    if (geometry == null) {
        try {
            geometry = new WKBReader().read(bytes);
        } catch (ParseException ex) {
            throw DbException.convert(ex);
        }
    }
    return geometry;
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
private static List<Geometry> readGeometries(final String fileName) {
    try (final Reader reader = new FileReader(new File(fileName))) {
        final GeometryFactory geometryFactory = GISUtils.getGeometryFactory(GISUtils.SRID.ETRS_TM35FIN);
        final WKBReader wkbReader = new WKBReader(geometryFactory);
        final WKBHexFileReader wkbHexFileReader = new WKBHexFileReader(reader, wkbReader);
        return wkbHexFileReader.read();

    } catch (ParseException | IOException e) {
        throw new RuntimeException(e);
    }
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
@Override
protected void doEvaluate(TExecutionContext context, LazyList<? extends ValueSource> inputs, ValueTarget output) {
    byte[] data = new byte[0];

    if (inputs.get(0).hasAnyValue()) {
        Object o = inputs.get(0).getObject();
        if (o instanceof BlobRef) {
            BlobRef blob;
            blob = (BlobRef) o;
            String mode = context.getQueryContext().getStore().getConfig().getProperty(AkBlob.RETURN_UNWRAPPED);
            if (mode.equalsIgnoreCase(AkBlob.UNWRAPPED)){
                data = blob.getBytes();
            }
            else {
                if (blob.isShortLob()) {
                    data = blob.getBytes();
                } else {
                    LobService ls = context.getQueryContext().getServiceManager().getServiceByClass(LobService.class);
                    data = ls.readBlob(context.getQueryContext().getSession(), blob.getId());
                }
            }
        } else if (o instanceof byte[]) {
            data = (byte[])o;
        }
    }
    
    WKBReader reader = (WKBReader)context.preptimeObjectAt(READER_CONTEXT_POS);
    try {
        Geometry geometry = reader.read(data);
        output.putObject(geometry);
    } catch(ParseException e) {
        throw new InvalidSpatialObjectException(e.getMessage());
    }
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
/**
 * This method initializes the MapMatcher. It checks whether all given
 * database tables and their columns exist,
 */
public void init() {
	// 1. check if table, rows and so on of input data exists.
	checkInputdata();

	// 2. init WKBReader and WKBWriter
	wkbReader = new WKBReader();
	wkbWriter = new WKBWriter(2, true);

}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
public StreetDataSource(Connection con, Properties p) {
	this.con = con;
	this.p = p;
	wkbReader = new WKBReader();
	retrieveData();

}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
public static Geometry Binary2Geometry(final byte[] geometryAsBytes) throws ParseException {
	final byte[] wkb = new byte[geometryAsBytes.length - 4];
	System.arraycopy(geometryAsBytes, 4, wkb, 0, wkb.length);
	final WKBReader wkbReader = new WKBReader();
	final Geometry geom = wkbReader.read(wkb);
	return geom;
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
public Geometry convertToJTSGeometry(ValueMetaInterface vmi, Object o, Database db) {
	if (o instanceof byte[]) {
		try {
			// treat the values read from MySQL as byte stream
			InputStream inStream = new ByteArrayInputStream( (byte[]) o );
			if (inStream == null) {
				throw new IOException("Could not read from byte array!");
			}
			
			// read first 4 bytes that represent the SRID
			byte[] sridFromByteArray = new byte[4];
			inStream.read(sridFromByteArray);
			
			// Map MySQL's SRID with the EPSG-SRID or take a custom SRS from WKT
			int mysql_srid = ByteOrderValues.getInt(sridFromByteArray, ByteOrderValues.LITTLE_ENDIAN);
			SRS epsg_srid = convertToEPSG_SRID(mysql_srid, db.getConnection());
			vmi.setGeometrySRS(epsg_srid);
			
			// parse the rest of the byte array as WKB and convert to Geometry
			Geometry geom = new WKBReader().read( new InputStreamInStream(inStream) );
			geom.setSRID(epsg_srid.getSRID());
			return geom;
		} catch (Exception e) {
			LOGGER.logError("GeoKettle", "Conversion from MySQL-geometry failed.");
			return null;
		}
	} else {
		LOGGER.logDetailed("GeoKettle", "No MySQL-geometry found to convert");
		return null;
	}
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
private Geometry convertBinaryToGeometry(byte[] binary) {
  	Geometry geom = null;
try {
	geom = new WKBReader().read(binary);
} catch (com.vividsolutions.jts.io.ParseException e) {
	// TODO: log error
	// e.printStackTrace();
}
  	return geom;
  }
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
public static Geometry fromWkb(ValueMetaInterface metaA, Object dataA) throws KettleValueException{
  	Geometry geom = null;
  	WKBReader wkbReader = new WKBReader();
      if (dataA==null || !metaA.isString()) 
      	return null;
      try {
	geom = wkbReader.read(WKBReader.hexToBytes(metaA.getString(dataA)));
	return geom;
} catch (ParseException e) {
	return null;
}
  }
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
@Override
public ShapeBlobCell deserialize(DataCellDataInput input) throws IOException {
	byte[] bytes = new byte[input.readInt()];

	input.readFully(bytes);

	try {
		return new ShapeBlobCell(new WKBReader().read(bytes));
	} catch (ParseException e) {
		throw new IOException(e.getMessage());
	}
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
static void writeGeom(long geomId,byte[]bjsonBytes, byte[] geomBytes, DataOutputStream dos) throws IOException {
	// check geometry is valid
	try {
		if(new WKBReader().read(geomBytes)==null){
			throw new RuntimeException();
		}			
	} catch (Exception e) {
		throw new RuntimeException("Trying to save corrupt geometry: geomId=" + geomId);
	}

	
	dos.writeLong(geomId);
	writeByteArray(bjsonBytes, dos);
	writeByteArray(geomBytes, dos);
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
/**
 * Converts a byte array as well-known binary to a JTS geometry
 *
 * @param binary
 *            The well known binary
 * @return The JTS geometry
 */
public static Geometry geometryFromBinary(
		final byte[] binary ) {
	try {
		return new WKBReader().read(binary);
	}
	catch (final ParseException e) {
		LOGGER.warn(
				"Unable to deserialize geometry data",
				e);
	}
	return null;
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
public Object convertWKBHex(Object obj) throws IOException, SQLException,
			ParseException {
		if (obj == null) return null;
		String hex = obj.toString();
		Geometry geom = wkbReader.read(WKBReader.hexToBytes(hex));
//		Geometry geom = wkbReader.read(new HexStringInStream(hex));
		return geom;
	}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
protected void onGeometryLoadingFinished(Cursor cursor) {
    try {
        if (cursor == null || cursor.getCount() == 0)
            return;

        Log.v(TAG, "Geometries loaded: " + cursor.getCount());

        final int colId = cursor.getColumnIndexOrThrow(mIdColumn);
        final int colGeom = cursor.getColumnIndexOrThrow(mGeomColumn);
        final int colName = cursor.getColumnIndex(mNameColumn);
        final WKBReader geomReader = new WKBReader();

        cursor.moveToFirst();
        while (!cursor.isAfterLast()) {
            final long id = cursor.getLong(colId);
            final String name = (colName != -1) ? cursor.getString(colName) : null;
            final String key = createGeomKey(mLoaderId, id);
            if (mGeomKeys.contains(key))
                continue;

            Geometry geom;
            //Geometry geom = mGeomCache.getGeometry(key);
            //if (geom == null)
            //{
            try {
                final byte[] geomBlob = cursor.getBlob(colGeom);
                if (geomBlob == null) {
                    Log.e(TAG, "Malformed or null geometry with id=" + id + ", name=" + name + " in table " + mTable);
                    continue;
                }
                geom = geomReader.read(geomBlob);
                //mGeomCache.putGeometry(key, geom);
                addGeometry(geom, name);
            } catch (Exception ex) {
                Log.e(TAG, "Failed to parse geometry blob with id=" + id + ", name=" + name + " in table " + mTable);
                ex.printStackTrace();
            } finally {
                // Add the key even if geometry is broken just to prevent perpetual attempts to load it
                mGeomKeys.add(key);

                cursor.moveToNext();
            }
            //}
        }
    } catch (SQLiteException sqlEx) {
        Log.e(TAG, sqlEx.getMessage());
    } finally {
        Utils.closeSilently(cursor);
        final GeomLoader loader = getLoader();
        loader.gotoPhase(0, null);
    }
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
@Override
public void finishPreptimePhase(TPreptimeContext context) {
    context.set(READER_CONTEXT_POS, new WKBReader());
}
 

import com.vividsolutions.jts.io.WKBReader; //导入依赖的package包/类
public static Geometry read(final byte[] b) throws IOException, ParseException {
	final WKBReader wkb = new WKBReader();
	final Geometry geom = wkb.read(b);
	return geom;
}