def makeArea(gridLoc, pointList, refname=None):
" Make a Reference Area with a unique ReferenceID"
from com.vividsolutions.jts.geom import GeometryFactory, LinearRing, Coordinate, Polygon
from com.raytheon.uf.common.dataplugin.gfe.reference import ReferenceData
CoordinateType = ReferenceData.CoordinateType
geomFactory = GeometryFactory()
import jep
size = len(pointList)
if pointList[0] != pointList[size - 1]: # closing the loop
pointList.append(pointList[0])
pointArray = jep.jarray(len(pointList), Coordinate)
for i in range(len(pointList)):
pointArray[i] = pointList[i]
lr = geomFactory.createLinearRing(pointArray)
poly = geomFactory.createPolygon(lr, jep.jarray(0, LinearRing))
polyArray = jep.jarray(1, Polygon)
polyArray[0] = poly
region = geomFactory.createMultiPolygon(polyArray)
if refname is None:
refname = "Ref" + getTime()
refId = ReferenceID(refname)
refData = ReferenceData(gridLoc, refId, region, CoordinateType.LATLON)
# randerso: I don't think this is necessary
# refData.convertToAWIPS()
return refData
def append_to_errors(self, errorsList, check):
"""Clean errors list from duplicate errors and ids that must be
ignored
"""
if errorsList[0][0] == "":
#osmId == "", this tool doesn't give id of OSM objects
check.errors = [Error(check, e) for e in errorsList]
else:
if check.ignoreIds != []:
#remove OSM objects that the user wants to ignore
check.errors = [Error(check, e) for e in errorsList if e[0] not in check.ignoreIds]
#remove duplicate ids
#check.errors = dict((e.osmId, e) for e in check.errors).values()
else:
#copy all errors and remove duplicate ids
#check.errors = dict((e[0], Error(e)) for e in errorsList).values()
check.errors = [Error(check, e) for e in errorsList]
#Remove from the list of errors those that have been reviewed yet
#while clicking the "Next" button
check.errors = [e for e in check.errors if e.osmId not in check.reviewedIds]
#print "\n- errors of selected check in current zone:", [e.osmId for e in check.errors]
#Randomize the errors so that different users don't start
#correcting the same errors
Collections.shuffle(check.errors)
#Filter errors in favourite zone
if self.app.favouriteZoneStatus and self.app.favZone.zType != "rectangle":
#not rectangular favourite area, use jts
from com.vividsolutions.jts.geom import Coordinate, GeometryFactory
polygon = self.app.favZone.wktGeom
errorsInPolygon = []
for error in check.errors:
(lat, lon) = error.coords
point = GeometryFactory().createPoint(Coordinate(lon, lat))
if polygon.contains(point):
if error not in errorsInPolygon:
errorsInPolygon.append(error)
check.errors = errorsInPolygon
#Apply limits from preferences
#max number of errors
limits = []
if self.app.maxErrorsNumber != "":
limits.append(self.app.maxErrorsNumber)
try:
if self.tool.prefs["limit"] != "":
limits.append(int(self.tool.prefs["limit"]))
except:
pass
if limits != []:
check.errors = check.errors[:min(limits)]
#Reset index of current error
check.currentErrorIndex = -1
check.toDo = len(check.errors)
def getEnvelope(self):
env = None
jenv = self.jobj.getEnvelope()
if jenv:
import shapely
from com.vividsolutions.jts.geom import GeometryFactory
env = shapely.wkt.loads(
GeometryFactory().toGeometry(jenv).toText())
return env
def createOTPGraphTables():
otp = OtpsEntryPoint.fromArgs(
["--graphs", "/Users/gijspeters/otp/amsterdam", "--autoScan"])
router = otp.getRouter()
req = otp.createRequest()
req.setDateTime(MONDAY.year, MONDAY.month, MONDAY.day, 12, 0, 0)
req.setMaxTimeSec(14400)
req.setOrigin(52.37, 4.889)
sspt = router.plan(req)
spt = sspt.spt
vertices = spt.getVertices().toArray()
con = Verbinding()
con.createTable(dbtables.HEDGES)
con.createTable(dbtables.HVERTICES)
try:
monitor = VoortgangRegel(len(vertices), VoortgangRegel.MODUS_NUM,
'Vertices geschreven')
for vertex in vertices:
dbvertex = (vertex.getIndex(), vertex.getLabel(),
WKBWriter().bytesToHex(WKBWriter().write(
GeometryFactory(PrecisionModel(),
4326).createPoint(
vertex.getCoordinate()))))
sql = "INSERT INTO hvertices (vertex_id, label, geom) VALUES (%d, '%s', '%s')" % dbvertex
con.exe(sql)
monitor.plusEen()
con.commit()
sql = "SELECT vertex_id, id FROM hvertices"
hvertices = dict(con.selectAll(sql))
monitor = VoortgangRegel(len(vertices), VoortgangRegel.MODUS_NUM,
'Edges geschreven van vertices')
for vertex in vertices:
edges = vertex.getOutgoing().toArray()
for edge in edges:
naam = edge.getName()
if naam == None:
naam = ''
else:
naam = naam.replace("'", "")
try:
geom = WKBWriter().bytesToHex(WKBWriter().write(
edge.getGeometry()))
hedge = (edge.getId(), naam, hvertices[vertex.getIndex()],
hvertices[edge.getToVertex().getIndex()], geom,
edge.getDistance())
sql = "INSERT INTO hedges (edge_id, label, from_id, to_id, geom, distance) VALUES (%d, '%s', %d, %d, '%s', %f)" % hedge
except:
hedge = (edge.getId(), naam, hvertices[vertex.getIndex()],
hvertices.get(edge.getToVertex().getIndex(),
-1), edge.getDistance())
sql = "INSERT INTO hedges (edge_id, label, from_id, to_id, distance) VALUES (%d, '%s', %d, %d, %f)" % hedge
con.exe(sql)
monitor.plusEen()
con.commit()
finally:
con.sluit()
def finalDraw(self, event):
p = event.coords
width = abs(p[0].x - p[1].x)
height = abs(p[0].y - p[1].y)
geo = GeometryFactory()
shapeFac = GeometricShapeFactory(geo)
lowLeft = Coordinate()
lowLeft.x = min(p[0].x, p[1].x)
lowLeft.y = min(p[0].y, p[1].y)
shapeFac.setBase(lowLeft)
shapeFac.setWidth(width)
shapeFac.setHeight(height)
shapeFac.setNumPoints(48)
pa = shapeFac.createCircle().coordinates
p.clear()
for pt in pa:
p.add(pt)
panel = event.wc.layerViewPanel
statMsg = "[" + panel.format(width) + ", " + panel.format(height) + "]"
event.statusMessage = statMsg
def read_area_from_osm_ways(self, mode, dataset):
"""Read way in favourite area editing layer and convert them to
WKT
"""
converter = JTSConverter(False)
lines = [converter.convert(way) for way in dataset.ways]
polygonizer = Polygonizer()
polygonizer.add(lines)
polygons = polygonizer.getPolygons()
multipolygon = GeometryFactory().createMultiPolygon(list(polygons))
multipolygonWKT = WKTWriter().write(multipolygon)
if multipolygonWKT == "MULTIPOLYGON EMPTY":
if mode == "polygon":
msg = self.app.strings.getString("empty_ways_polygon_msg")
else:
msg = self.app.strings.getString("empty_ways_boundaries_msg")
JOptionPane.showMessageDialog(self,
msg,
self.app.strings.getString("Warning"),
JOptionPane.WARNING_MESSAGE)
return
return multipolygonWKT
"""
The :mod:`geom` module provides geometry classes and utilities for the construction and manipulation of geometry objects.
"""
from com.vividsolutions.jts.geom import GeometryFactory
from com.vividsolutions.jts.geom import Geometry as _Geometry
from com.vividsolutions.jts.geom.prep import PreparedGeometryFactory
from com.vividsolutions.jts.simplify import DouglasPeuckerSimplifier as DP
_factory = GeometryFactory()
_prepfactory = PreparedGeometryFactory()
Geometry = _Geometry
"""
Base class for all geometry classes.
"""
def prepare(g):
"""
Constructs a prepared geometry. Prepared geometries make repeated spatial
operations (such as intersection) more efficient.
*g* is the :class:`Geometry <geoscript.geom.Geometry>` to prepare.
>>> from geoscript.geom import readWKT
>>> prep = prepare(readWKT('POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))'))
>>> prep.intersects(readWKT('POLYGON ((4 4, 6 4, 6 6, 4 6, 4 4))'))
True
"""
return _prepfactory.create(g)
def setUp(self):
self.gf = GeometryFactory()
def getVertexGeom(self):
return WKBWriter().bytesToHex(WKBWriter().write(
GeometryFactory(PrecisionModel(), 4326).createPoint(
self.srcstate.getVertex().getCoordinate())))
