def tight_envelope(geom):
"""
return the geometry which builds an envelope around `geom`
"""
if hasattr(geom, 'geoms'):
g0 = max((sub.envelope.area, sub) for sub in geom.geoms)[1]
g00 = asPolygon(g0.exterior)
elif isinstance(geom, Polygon):
g00 = asPolygon(geom.exterior)
return g00
def test_polygon(self):
a = numpy.array([[1.0, 1.0, 2.0, 2.0, 1.0], [3.0, 4.0, 4.0, 3.0, 3.0]])
t = a.T
s = geometry.asPolygon(t)
self.failUnlessEqual(
list(s.exterior.coords),
[(1.0, 3.0), (1.0, 4.0), (2.0, 4.0), (2.0, 3.0), (1.0, 3.0)] )
def __init__(self, *args, **kwargs):
super(UnstructuredMap, self).__init__(*args, **kwargs)
self._point = {}
last_offset = 0
for (cell_id, offset) in enumerate(self._offset):
cell = self._connectivity[last_offset:offset]
last_offset = offset
for point_id in cell:
try:
self._point[point_id].append(cell_id)
except KeyError:
self._point[point_id] = [cell_id]
(point_x, point_y) = (self.get_x(), self.get_y())
self._polys = []
last_offset = 0
for (cell_id, offset) in enumerate(self._offset):
cell = self._connectivity[last_offset:offset]
last_offset = offset
(x, y) = (point_x.take(cell), point_y.take(cell))
if len(x) > 2:
self._polys.append(asPolygon(zip(x, y)))
elif len(x) == 2:
self._polys.append(asLineString(zip(x, y)))
else:
self._polys.append(asPoint(zip(x, y)))
def poly_relocate(polylist):
"""
Relocates all polygons to be centered on 0,0
Input: A list of polygons as arrays of points (2L), the output of
polygon_rotator found in img_geometry.
Output: A list of similar shape to the input
requires Shapely.geometry as sg
numpy as np
"""
cent = sg.asPolygon(polylist[0]).centroid.wkt #find polygon centroid
cent_x = np.float64(cent[7:np.uint8((len(cent)+6)/2)]) #pull x as float
cent_y = np.float64(cent[np.uint8(( len(cent)+7)/2):
len(cent)-1]) #pull y as float
## Subtract centroid value from all points in all rotations of the input polygon
rot_std = []
for pt in polylist:
rot_stdx = []
rot_stdy = []
for ptx, pty in pt:
rot_stdx.append(ptx-cent_x)
rot_stdy.append(pty-cent_y)
rot_std.append(np.asarray(zip(rot_stdx, rot_stdy)))
#avg_x
return(rot_std)
def get_mask(l, p):
p = _normalize_point(p)
total_diam = (r+wallwidth)*2
perp0 = perpendicular_at(l, p, total_diam)
p2 = line_extrapolate_point(l, p, (r+wallwidth)*1.01)
perp1 = perpendicular_at(l, p2, total_diam)
mask = asPolygon(
linering(perp0.coords[0], perp0.coords[1], perp1.coords[1], perp1.coords[0])
).convex_hull
return mask
def setUp(self):
# insert an initial feature in the datadabase
feature = Polygon()
feature.name = "foo"
feature.geometry = asPolygon(((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0), (0.0, 0.0)),
[((0.5, 0.5), (0.5, 0.7), (0.7, 0.7), (0.7, 0.5), (0.5, 0.5))])
Session.add(feature)
Session.commit()
self.fid = feature.id
self.fids = [feature.id]
def shape_buffer(self, shape=None, size=1., res=1):
"""
Function that returns a new polygon of the larger buffered points.
Can import polygon into function if desired. Default is
self.shape_poly()
"""
if shape is None:
self.polygon = self.shape_poly()
return asPolygon(self.polygon.buffer(size, resolution=res)\
.exterior)
def _polygon_wkt_to_xyz(polygon, as_wkt=False):
'''Converts a polygon in 'POLYGON' wkt format to xyz. If as_wkt is
True, will return the xyz output back as a wkt format, otherwise
it will return an array'''
polygon = wkt.loads(polygon)
polygon = polygon.boundary.xy
number_nodes = len(polygon[0])
xyz = spherical_to_cartesian(polygon[0], polygon[1],
np.zeros(number_nodes, dtype=float))
if as_wkt:
xyz = asPolygon(xyz[:, :-1]).wkt
return xyz
def build_polygon(shape_data):
point_list = [None] * len(shape_data)
counter = 0
for point in shape_data:
lat_lng = [float(coord) for coord in point.split(",")]
point_list.insert(counter, lat_lng)
counter += 1
point_list = [x for x in point_list if x is not None]
p = asPolygon(point_list)
return p
def minkowski_sum_2(poly1, poly2):
''' Slower minkowski sum algorithm (convex hull operation is a lot slower), but
uses blazing fast numpy sums and doesn't require particular polygon orientation'''
assert poly1.is_valid, validation.explain_validity(poly1)
assert poly2.is_valid, validation.explain_validity(poly2)
ext1 = np.array(poly1.boundary)[:-1,:]
ext2 = np.array(poly2.boundary)[:-1,:]
n_ext2 = ext2.shape[0]
n_ext1 = ext1.shape[0]
ext_sum = np.repeat(ext1, n_ext2, axis=0) + np.tile(ext2, (n_ext1, 1))
return geom.asPolygon(ext_sum).convex_hull
#compute normal orientation of the segment
normal = (p[1] - p[0]) * np.array([1, -1])
normal[0], normal[1], = normal[1], normal[0]
#exchanging x and y, wihtout copy
normal = normal / np.linalg.norm(normal)
print(normal)
#creating the upper point and down point for first and second (hopefully last) point in segment
p1u = p[0] + normal * r1
p1d = p[0] - normal * r1
p2u = p[1] + normal * r2
p2d = p[1] - normal * r2
output_line = (p1u, p2u, p2d, p1d, p1u)
ogeom = asPolygon(output_line)
print(ogeom)
pp1.pprint(str(geom))
#outputing for postgis : @NOTE : if inside postgres, hex =False, if outside, hex=True
output = wkb.dumps(ogeom, hex=True)
print(output)
# ##emulation of postgres output
# #return None ;
# #return { "center": center, "radius": radius , "t1": t1, "t2":t2}
#==============================================================================
def get_rate(path, mianliao_h):
# 加载零件数据
boxes = get_boxes_data(path)
# print(PolyArea(boxes[0]['x_list'], boxes[0]['y_list']))
# print(boxes[0]['space'])
# 按宽度对boxes进行排序
boxes = sorted(boxes, key=itemgetter('w'), reverse=True)
# 零件个数
boxes_len = len(boxes)
# 初始化
move_list = []
move_xy = np.array([0.0, 0.0])
flag = 0
for i in range(boxes_len):
move_list.append(move_xy)
cur_point = np.array([0.0, 0.0])
init_point = np.array([0.0, 0.0])
# 排列零件
for i in range(boxes_len):
if boxes[i]['isuse']:
continue
cur_point = init_point
available_h = mianliao_h
last_up = 0.0 # 用于计算两零件之间的高度间距(存储上一次y轴坐标）
last_box = {
'x_list': [cur_point[0], 20000.0],
'y_list': [cur_point[1], cur_point[1]],
'id': 0
}
for j in range(i, boxes_len):
move = boxes[j]['bl_point'] - cur_point
# rec_width = boxes[j]['w']
# rec_height = boxes[j]['h']
# x_min = cur_point[0]
# y_min = cur_point[1]
# x_list = np.array([x_min, x_min, x_min + rec_width, x_min + rec_width, x_min]) # 第j个矩形的所有轮廓点的x坐标集合
# y_list = np.array([y_min, y_min + rec_height, y_min + rec_height, y_min, y_min])
# message = {'cur_point': cur_point, 'move': move, 'rec_x': x_list, 'rec_y': y_list}
if boxes[j]['h'] <= available_h and boxes[j]['isuse'] is False:
# plt.plot(message['rec_x'], message['rec_y'], linewidth=0.5) # 这一行是用来显示矩形边缘的
boxes[j]['isuse'] = True
move_list[j] = move
# 存储移动后的多边形顶点坐标
for k in range(len(boxes[j]['x_list'])):
boxes[j]['x_list'][
k] = boxes[j]['x_list'][k] - move_list[j][0]
boxes[j]['y_list'][
k] = boxes[j]['y_list'][k] - move_list[j][1]
# 绘制多边形
plt.plot(boxes[j]['x_list'], boxes[j]['y_list'], linewidth=0.3)
# 计算gap
gap_h = boxes[j]['y_left'][0] - move[1] - last_up
last_up = boxes[j]['y_left'][1] - move[1]
# 搜索放置在gap间的小零件
for small in range(j + 1, boxes_len):
if boxes[small]['h'] <= gap_h \
and boxes[small]['h'] <= available_h \
and boxes[small]['isuse'] is False:
# 零件small的外接矩形的4个顶点和中心点
move_s = boxes[small]['bl_point'] - cur_point
tmp_x2 = boxes[small]['x1'] + boxes[small][
'w'] - move_s[0]
tmp_y2 = boxes[small]['y1'] + boxes[small][
'h'] - move_s[1]
tmp_x1 = boxes[small]['x1'] - move_s[0]
tmp_y1 = boxes[small]['y1'] - move_s[1]
tmp_mx = boxes[small][
'x1'] + boxes[small]['w'] / 2 - move_s[0]
tmp_my = boxes[small][
'y1'] + boxes[small]['h'] / 2 - move_s[1]
tmp_s = [] # 移动后的零件small所有顶点坐标
# 判断4个顶点和中心点是否在已排列零件内部
if inpolygon(tmp_x2, tmp_y2, boxes[j]['x_list'], boxes[j]['y_list'])[0] + 0 == 0 \
and inpolygon(tmp_x1, tmp_y2, boxes[j]['x_list'], boxes[j]['y_list'])[0] + 0 == 0 \
and inpolygon(tmp_x1, tmp_y1, boxes[j]['x_list'], boxes[j]['y_list'])[0] + 0 == 0 \
and inpolygon(tmp_x2, tmp_y1, boxes[j]['x_list'], boxes[j]['y_list'])[0] + 0 == 0 \
and inpolygon(tmp_mx, tmp_my, boxes[j]['x_list'], boxes[j]['y_list'])[0] + 0 == 0:
# 计算移动后的多边形顶点坐标
for k in range(len(boxes[small]['x_list'])):
tmp_s.append([
boxes[small]['x_list'][k] - move_s[0],
boxes[small]['y_list'][k] - move_s[1]
])
tmp_pols = np.array(tmp_s)
# 判断small零件与已排放的boxes[j]是否重叠
tmp_polj = tranfer_(boxes[j]['x_list'],
boxes[j]['y_list'])
pol_s = asPolygon(tmp_pols)
pol_j = asPolygon(tmp_polj)
if pol_s.disjoint(pol_j):
boxes[small]['isuse'] = True
move_list[small] = move_s
# 存储移动后的多边形顶点坐标
for k in range(len(boxes[small]['x_list'])):
boxes[small]['x_list'][k] = boxes[small][
'x_list'][k] - move_list[small][0]
boxes[small]['y_list'][k] = boxes[small][
'y_list'][k] - move_list[small][1]
# 绘制多边形
plt.plot(boxes[small]['x_list'],
boxes[small]['y_list'],
linewidth=0.3)
break
available_h = available_h - boxes[j]['h']
# 零件排列到布料顶端的情况
if boxes[j]['h'] > available_h and flag == 0:
flag = 1 # 标记用于只需判断1次布料顶端能否排列下小零件（small)
# 计算gap
gap_h = mianliao_h - (boxes[j]['y_left'][1] - move[1])
# print(gap_h)
# 搜索放置在gap间的小零件
for small in range(j + 1, boxes_len):
if boxes[small]['h'] <= gap_h \
and boxes[small]['isuse'] is False:
# 零件small的外接矩形的4个顶点和中心点
move_s = boxes[small]['bl_point'] + np.array([
0.0, boxes[small]['h'] - 5
]) - np.array([cur_point[0], mianliao_h])
tmp_x2 = boxes[small]['x1'] + boxes[small][
'w'] - move_s[0]
tmp_y2 = boxes[small]['y1'] + boxes[small][
'h'] - move_s[1]
tmp_x1 = boxes[small]['x1'] - move_s[0]
tmp_y1 = boxes[small]['y1'] - move_s[1]
tmp_mx = boxes[small][
'x1'] + boxes[small]['w'] / 2 - move_s[0]
tmp_my = boxes[small][
'y1'] + boxes[small]['h'] / 2 - move_s[1]
# 判断4个顶点和中心点是否在已排列零件内部
tmp_s = []
if inpolygon(tmp_x2, tmp_y2, boxes[j]['x_list'], boxes[j]['y_list'])[0] + 0 == 0 \
and inpolygon(tmp_x1, tmp_y2, boxes[j]['x_list'], boxes[j]['y_list'])[0] + 0 == 0 \
and inpolygon(tmp_x1, tmp_y1, boxes[j]['x_list'], boxes[j]['y_list'])[0] + 0 == 0 \
and inpolygon(tmp_x2, tmp_y1, boxes[j]['x_list'], boxes[j]['y_list'])[0] + 0 == 0 \
and inpolygon(tmp_mx, tmp_my, boxes[j]['x_list'], boxes[j]['y_list'])[0] + 0 == 0:
# 计算移动后的多边形顶点坐标
for k in range(len(boxes[small]['x_list'])):
tmp_s.append([
boxes[small]['x_list'][k] - move_s[0],
boxes[small]['y_list'][k] - move_s[1]
])
tmp_pols = np.array(tmp_s)
# 判断small零件与已排放的boxes[j]是否重叠
tmp_polj = tranfer_(boxes[j]['x_list'],
boxes[j]['y_list'])
pol_s = asPolygon(tmp_pols)
pol_j = asPolygon(tmp_polj)
if pol_s.disjoint(pol_j):
boxes[small]['isuse'] = True
move_list[small] = move_s
# 存储移动后的多边形顶点坐标
for k in range(len(
boxes[small]['x_list'])):
boxes[small]['x_list'][
k] = boxes[small]['x_list'][
k] - move_list[small][0]
boxes[small]['y_list'][
k] = boxes[small]['y_list'][
k] - move_list[small][1]
# 绘制多边形
plt.plot(boxes[small]['x_list'],
boxes[small]['y_list'],
linewidth=0.3)
break
break
last_box = boxes[j]
cur_point = cur_point + np.array([0.0, boxes[j]['h']])
init_point = init_point + np.array([boxes[i]['w'], 0.0])
flag = 0
# 计算布料利用率
area_box = 0
width = init_point[0]
for box in boxes:
area_box += PolyArea(box['x_list'], box['y_list'])
rate = area_box / (width * mianliao_h)
# 保存排样图片
path_name = path.split("\\")[-1].split('.')[0]
path_plot = path_name + '.png'
plt.title(r'%s——%0.4f' % (path_name, rate))
plt.savefig(path_plot, dpi=600)
# plt.ylim((0, 1600))
plt.show()
# 保存csv文件
path_csv = path_name + '.csv'
headers = ['下料批次号', '零件号', '面料号', '零件外轮廓线坐标']
values = []
for box in boxes:
values.append([
box['batch'], box['id'], box['cloth'],
str(
tranfer_(box['x_list'].round(1),
box['y_list'].round(1)).tolist())
])
csv_file = open(path_csv, "w", encoding='utf-8', newline='')
# csv按行写入
writer = csv.writer(csv_file)
writer.writerow(headers)
writer.writerows(values)
csv_file.close()
return rate
prop["valid"] = boundary.contains(geom)
return geom, prop
@_layer_operation
def layer_contained(boundary: geo, **kwargs):
"""Analyse containment for all features within a single-layer vector file according to a Geometry
and return a single GeoJSON file."""
geom, prop = kwargs["geom"], kwargs["prop"]
if isinstance(geom, geo.Polygon):
prop["valid"] = boundary.contains(geom)
return geom, prop
if __name__ == "__main__":
source = Path("/home/tjs/Downloads/GIS_Data/hydro_s")
vec = source.joinpath("hydro_s.shp")
output_folder = source.joinpath("output")
output_file = source.joinpath("output.json")
bound = geo.asPolygon([(-71.5, 49), (-71.5, 54), (-63.5, 54), (-63.5, 49),
(-71.5, 49)])
# feature_convex_hull(vector=vec, output=output_folder)
feature_contained(boundary=bound, vector=vec, output=output_folder)
print(feature_envelope.__doc__, "\n")
print(inspect.signature(feature_envelope))
layer_contained(boundary=bound, vector=vec, output=output_file)
print(layer_envelope.__doc__, "\n")
print(inspect.signature(layer_envelope))
def _plausibilize_group(regionspolys, rogroup, mark_for_deletion,
mark_for_merging):
LOG = getLogger('processor.RepairSegmentation')
wait_for_deletion = list()
reading_order = dict()
regionrefs = list()
ordered = False
# the reading order does not have to include all regions
# but it may include all types of regions!
if isinstance(rogroup, (OrderedGroupType, OrderedGroupIndexedType)):
regionrefs = (rogroup.get_RegionRefIndexed() +
rogroup.get_OrderedGroupIndexed() +
rogroup.get_UnorderedGroupIndexed())
ordered = True
if isinstance(rogroup, (UnorderedGroupType, UnorderedGroupIndexedType)):
regionrefs = (rogroup.get_RegionRef() + rogroup.get_OrderedGroup() +
rogroup.get_UnorderedGroup())
for elem in regionrefs:
reading_order[elem.get_regionRef()] = elem
if not isinstance(elem, (RegionRefType, RegionRefIndexedType)):
# recursive reading order element (un/ordered group):
_plausibilize_group(regionspolys, elem, mark_for_deletion,
mark_for_merging)
for regionpoly in regionspolys:
delete = regionpoly.region.id in mark_for_deletion
merge = regionpoly.region.id in mark_for_merging
if delete or merge:
region = regionpoly.region
poly = regionpoly.polygon
if merge:
# merge region with super region:
superreg = mark_for_merging[region.id]
# granularity will necessarily be lost here --
# this is not for workflows/processors that already
# provide good/correct segmentation and reading order
# (in which case orientation, script and style detection
# can be expected as well), but rather as a postprocessor
# for suboptimal segmentation (possibly before reading order
# detection/correction); hence, all we now do here is
# show warnings when granularity is lost; but there might
# be good reasons to do more here when we have better processors
# and use-cases in the future
superpoly = Polygon(
polygon_from_points(superreg.get_Coords().points))
superpoly = superpoly.union(poly)
if superpoly.type == 'MultiPolygon':
superpoly = superpoly.convex_hull
if superpoly.minimum_clearance < 1.0:
superpoly = asPolygon(np.round(superpoly.exterior.coords))
superpoly = make_valid(superpoly)
superpoly = superpoly.exterior.coords[:-1] # keep open
superreg.get_Coords().set_points(
points_from_polygon(superpoly))
# FIXME should we merge/mix attributes and features?
if region.get_orientation() != superreg.get_orientation():
LOG.warning(
'Merging region "{}" with orientation {} into "{}" with {}'
.format(region.id, region.get_orientation(),
superreg.id, superreg.get_orientation()))
if region.get_type() != superreg.get_type():
LOG.warning(
'Merging region "{}" with type {} into "{}" with {}'.
format(region.id, region.get_type(), superreg.id,
superreg.get_type()))
if region.get_primaryScript() != superreg.get_primaryScript():
LOG.warning(
'Merging region "{}" with primaryScript {} into "{}" with {}'
.format(region.id, region.get_primaryScript(),
superreg.id, superreg.get_primaryScript()))
if region.get_primaryLanguage(
) != superreg.get_primaryLanguage():
LOG.warning(
'Merging region "{}" with primaryLanguage {} into "{}" with {}'
.format(region.id, region.get_primaryLanguage(),
superreg.id, superreg.get_primaryLanguage()))
if region.get_TextStyle():
LOG.warning(
'Merging region "{}" with TextStyle {} into "{}" with {}'
.format(
region.id,
region.get_TextStyle(), # FIXME needs repr...
superreg.id,
superreg.get_TextStyle())) # ...to be informative
if region.get_TextEquiv():
LOG.warning(
'Merging region "{}" with TextEquiv {} into "{}" with {}'
.format(
region.id,
region.get_TextEquiv(), # FIXME needs repr...
superreg.id,
superreg.get_TextEquiv())) # ...to be informative
wait_for_deletion.append(region)
if region.id in reading_order:
regionref = reading_order[region.id]
# TODO: re-assign regionref.continuation and regionref.type to other?
# could be any of the 6 types above:
regionrefs = rogroup.__getattribute__(
regionref.__class__.__name__.replace('Type', ''))
# remove in-place
regionrefs.remove(regionref)
if ordered:
# re-index the reading order!
regionrefs.sort(key=RegionRefIndexedType.get_index)
for i, regionref in enumerate(regionrefs):
regionref.set_index(i)
for region in wait_for_deletion:
if region.parent_object_:
# remove in-place
region.parent_object_.get_TextRegion().remove(region)
def test_polygon(self):
# Initialization
# Linear rings won't usually be created by users, but by polygons
coords = ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0))
ring = LinearRing(coords)
self.assertEqual(len(ring.coords), 5)
self.assertEqual(ring.coords[0], ring.coords[4])
self.assertEqual(ring.coords[0], ring.coords[-1])
self.assertTrue(ring.is_ring)
# Coordinate modification
ring.coords = ((0.0, 0.0), (0.0, 2.0), (2.0, 2.0), (2.0, 0.0))
self.assertEqual(
ring.__geo_interface__,
{'type': 'LinearRing',
'coordinates': ((0.0, 0.0), (0.0, 2.0), (2.0, 2.0), (2.0, 0.0),
(0.0, 0.0))})
# Test ring adapter
coords = [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]]
ra = asLinearRing(coords)
self.assertTrue(ra.wkt.upper().startswith('LINEARRING'))
self.assertEqual(dump_coords(ra),
[(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0),
(0.0, 0.0)])
coords[3] = [2.0, -1.0]
self.assertEqual(dump_coords(ra),
[(0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (2.0, -1.0),
(0.0, 0.0)])
# Construct a polygon, exterior ring only
polygon = Polygon(coords)
self.assertEqual(len(polygon.exterior.coords), 5)
# Ring Access
self.assertIsInstance(polygon.exterior, LinearRing)
ring = polygon.exterior
self.assertEqual(len(ring.coords), 5)
self.assertEqual(ring.coords[0], ring.coords[4])
self.assertEqual(ring.coords[0], (0., 0.))
self.assertTrue(ring.is_ring)
self.assertEqual(len(polygon.interiors), 0)
# Create a new polygon from WKB
data = polygon.wkb
polygon = None
ring = None
polygon = load_wkb(data)
ring = polygon.exterior
self.assertEqual(len(ring.coords), 5)
self.assertEqual(ring.coords[0], ring.coords[4])
self.assertEqual(ring.coords[0], (0., 0.))
self.assertTrue(ring.is_ring)
polygon = None
# Interior rings (holes)
polygon = Polygon(coords, [((0.25, 0.25), (0.25, 0.5),
(0.5, 0.5), (0.5, 0.25))])
self.assertEqual(len(polygon.exterior.coords), 5)
self.assertEqual(len(polygon.interiors[0].coords), 5)
with self.assertRaises(IndexError): # index out of range
polygon.interiors[1]
# Test from another Polygon
copy = Polygon(polygon)
self.assertEqual(len(polygon.exterior.coords), 5)
self.assertEqual(len(polygon.interiors[0].coords), 5)
with self.assertRaises(IndexError): # index out of range
polygon.interiors[1]
# Coordinate getters and setters raise exceptions
self.assertRaises(NotImplementedError, polygon._get_coords)
with self.assertRaises(NotImplementedError):
polygon.coords
# Geo interface
self.assertEqual(
polygon.__geo_interface__,
{'type': 'Polygon',
'coordinates': (((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (2.0, -1.0),
(0.0, 0.0)), ((0.25, 0.25), (0.25, 0.5),
(0.5, 0.5), (0.5, 0.25), (0.25, 0.25)))})
# Adapter
hole_coords = [((0.25, 0.25), (0.25, 0.5), (0.5, 0.5), (0.5, 0.25))]
pa = asPolygon(coords, hole_coords)
self.assertEqual(len(pa.exterior.coords), 5)
self.assertEqual(len(pa.interiors), 1)
self.assertEqual(len(pa.interiors[0].coords), 5)
# Test Non-operability of Null rings
r_null = LinearRing()
self.assertEqual(r_null.wkt, 'GEOMETRYCOLLECTION EMPTY')
self.assertEqual(r_null.length, 0.0)
# Check that we can set coordinates of a null geometry
r_null.coords = [(0, 0), (1, 1), (1, 0)]
self.assertAlmostEqual(r_null.length, 3.414213562373095)
# Error handling
with self.assertRaises(ValueError):
# A LinearRing must have at least 3 coordinate tuples
Polygon([[1, 2], [2, 3]])
def show_output(tf_vars, deb_oo, deb_jo, d_query, session, smooth_pairs,
d_postfix, f_postfix, um):
colors = stealth_colors
p_deb = os.path.join(d_query, 'debug_isec' + d_postfix)
if not os.path.exists(p_deb):
os.makedirs(p_deb)
# os.system("rm %s/*.png" % p_deb)
# os.system("rm %s/*.svg" % p_deb)
# else:
# assert np.allclose(tf_vars.oo_mask_same.eval(),
# tf_vars.oo_mask_same_2.eval())
# assert np.allclose(tf_vars.oo_mask_cat.eval(),
# tf_vars.oo_mask_cat_2.eval())
# assert np.allclose(tf_vars.oo_mask_interacting_2,
# tf_vars._oo_mask_interacting.eval())
# assert np.isclose(tf_vars._oo_mask_interacting_sum_inv.eval(),
# tf_vars.oo_mask_interacting_sum_inv_2.eval())
obj_vxs_t = tf_vars.obj_2d_vertices_transformed
o_obj_vxs_t, o_joints, o_smooth_pairs, distances, o_mgrid_vxs_t = \
session.run([obj_vxs_t, deb_jo['joints'], smooth_pairs,
deb_jo['d'], tf_vars._obj_2d_mgrid_vertices_transformed])
o_polys, o_poly_indices = session.run(
[tf_vars.obj_2d_polys, tf_vars._obj_2d_poly_transform_indices])
o_oo_mask, o_d_oo = session.run([deb_oo['oo_mask'], deb_oo['d_oo']])
py_cat_ids = np.squeeze(tf_vars.cat_ids_polys.eval(), axis=0)
lg.debug("distances: %s" % repr(distances.shape))
lg.debug("obj_vxs_t: %s" % repr(o_obj_vxs_t.shape))
lg.debug("joints: %s" % repr(o_joints.shape))
mn1 = np.min(o_obj_vxs_t, axis=0)[[0, 2]]
mx1 = np.max(o_obj_vxs_t, axis=0)[[0, 2]]
mn2 = np.min(o_smooth_pairs, axis=0)
mn2 = np.minimum(mn2[:3], mn2[3:])[[0, 2]]
mx2 = np.max(o_smooth_pairs, axis=0)
mx2 = np.maximum(mx2[:3], mx2[3:])[[0, 2]]
mn = np.minimum(mn1, mn2)
mx = np.maximum(mx1, mx2)
assert o_joints.shape[0] // 5 == distances.shape[0]
o_joints = o_joints.reshape(5, -1, 3)[0, ...]
assert o_polys.shape[0] == distances.shape[1]
fig = plt.figure()
ax0 = fig.add_subplot(111, aspect='equal')
# for pair in o_smooth_pairs:
# ax0.plot([pair[0], pair[3]], [pair[2], pair[5]], 'k--')
# for id_pnt in range(1, o_joints.shape[0]):
# pnt0 = o_joints[id_pnt, :]
o_joints_ordered = np.asarray([
e[1]
for e in sorted([(um.pids_2_scenes[pid].frame_id, o_joints[pid, ...])
for pid in range(o_joints.shape[0])],
key=lambda e: e[0])
])
assert o_joints_ordered.ndim == 2 and o_joints_ordered.shape[1] == 3
ax0.plot(o_joints_ordered[:, 0], o_joints_ordered[:, 2], 'kx--')
for id_poly in range(distances.shape[1]):
idx_t = o_poly_indices[id_poly, 0]
color = tuple(c / 255. for c in colors[(idx_t + 1) % len(colors)])
d_sum = 0.
# poly = np.concatenate((
# o_obj_vxs_t[4*id_poly:4*(id_poly+1), :],
# o_obj_vxs_t[4*id_poly:4*id_poly+1, :]))
# ax0.plot(o_polys[id_poly, :, 0], o_polys[id_poly, :, 2], color=color)
shapely_poly = geom.asPolygon(o_polys[id_poly, :, [0, 2]].T)
patch = PolygonPatch(shapely_poly,
facecolor=color,
edgecolor=color,
alpha=0.25)
ax0.add_artist(patch)
cat = next(cat for cat in CATEGORIES
if CATEGORIES[cat] == py_cat_ids[id_poly])
xy = (shapely_poly.centroid.xy[0][0] - 0.1,
shapely_poly.centroid.xy[1][0])
ax0.annotate(cat, xy=xy, color=color, fontsize=6)
for id_pnt in range(distances.shape[0]):
d_ = distances[id_pnt, id_poly]
if d_ < 0.:
pnt = o_joints[id_pnt, :]
ax0.scatter(pnt[0],
pnt[2],
s=(5 * (1 + d_))**2,
color=color,
zorder=5)
d_sum += distances[id_pnt, id_poly]
ax0.annotate("%.2f" % d_,
xy=(np.random.rand() * 0.1 + pnt[0] - 0.05,
np.random.rand() * 0.1 + pnt[2] - 0.05),
fontsize=4)
for id_pnt in range(o_d_oo.shape[0]):
d_ = o_d_oo[id_pnt, id_poly]
if d_ < 0.:
pnt = o_mgrid_vxs_t[id_pnt, :]
ax0.scatter(pnt[0],
pnt[2],
s=(7 * (1 + d_))**2,
edgecolor=color,
zorder=5,
color=(1., 1., 1., 0.))
ax0.annotate("%.2f" % d_,
xy=(np.random.rand() * 0.1 + pnt[0] - 0.05,
np.random.rand() * 0.1 + pnt[2] - 0.05),
fontsize=8,
color='r',
zorder=6)
# fig.suptitle("d_sum: %s" % d_sum)
p_out = os.path.join(p_deb, "op_%s.png" % f_postfix)
plt.draw()
ax0.set_xlim(mn[0] - 0.2, mx[0] + 0.2)
ax0.set_ylim(mn[1] - 0.2, mx[1] + 0.2)
# plt.show()
try:
fig.savefig(p_out, dpi=300)
lg.debug("saved to %s" % p_out)
except PermissionError as e:
lg.error("Could not save %s" % e)
plt.close(fig)
def main():
gdal.AllRegister()
path = auxil.select_directory('Input directory')
if path:
os.chdir(path)
# input image
infile = auxil.select_infile(title='Image file')
if infile:
inDataset = gdal.Open(infile,GA_ReadOnly)
cols = inDataset.RasterXSize
rows = inDataset.RasterYSize
bands = inDataset.RasterCount
projection = inDataset.GetProjection()
geotransform = inDataset.GetGeoTransform()
if geotransform is not None:
gt = list(geotransform)
else:
print 'No geotransform available'
return
imsr = osr.SpatialReference()
imsr.ImportFromWkt(projection)
else:
return
pos = auxil.select_pos(bands)
if not pos:
return
N = len(pos)
rasterBands = []
for b in pos:
rasterBands.append(inDataset.GetRasterBand(b))
# training algorithm
trainalg = auxil.select_integer(1,msg='1:Maxlike,2:Backprop,3:Congrad,4:SVM')
if not trainalg:
return
# training data (shapefile)
trnfile = auxil.select_infile(filt='.shp',title='Train shapefile')
if trnfile:
trnDriver = ogr.GetDriverByName('ESRI Shapefile')
trnDatasource = trnDriver.Open(trnfile,0)
trnLayer = trnDatasource.GetLayer()
trnsr = trnLayer.GetSpatialRef()
else:
return
tstfile = auxil.select_outfile(filt='.tst', title='Test results file')
if not tstfile:
print 'No test output'
# outfile
outfile, outfmt = auxil.select_outfilefmt(title='Classification file')
if not outfile:
return
if trainalg in (2,3,4):
# class probabilities file, hidden neurons
probfile, probfmt = auxil.select_outfilefmt(title='Probabilities file')
else:
probfile = None
if trainalg in (2,3):
L = auxil.select_integer(8,'Number of hidden neurons')
if not L:
return
# coordinate transformation from training to image projection
ct= osr.CoordinateTransformation(trnsr,imsr)
# number of classes
K = 1
feature = trnLayer.GetNextFeature()
while feature:
classid = feature.GetField('CLASS_ID')
if int(classid)>K:
K = int(classid)
feature = trnLayer.GetNextFeature()
trnLayer.ResetReading()
K += 1
print '========================='
print 'supervised classification'
print '========================='
print time.asctime()
print 'image: '+infile
print 'training: '+trnfile
if trainalg == 1:
print 'Maximum Likelihood'
elif trainalg == 2:
print 'Neural Net (Backprop)'
elif trainalg ==3:
print 'Neural Net (Congrad)'
else:
print 'Support Vector Machine'
# loop through the polygons
Gs = [] # train observations
ls = [] # class labels
classnames = '{unclassified'
classids = set()
print 'reading training data...'
for i in range(trnLayer.GetFeatureCount()):
feature = trnLayer.GetFeature(i)
classid = str(feature.GetField('CLASS_ID'))
classname = feature.GetField('CLASS_NAME')
if classid not in classids:
classnames += ', '+ classname
classids = classids | set(classid)
l = [0 for i in range(K)]
l[int(classid)] = 1.0
polygon = feature.GetGeometryRef()
# transform to same projection as image
polygon.Transform(ct)
# convert to a Shapely object
poly = shapely.wkt.loads(polygon.ExportToWkt())
# transform the boundary to pixel coords in numpy
bdry = np.array(poly.boundary)
bdry[:,0] = bdry[:,0]-gt[0]
bdry[:,1] = bdry[:,1]-gt[3]
GT = np.mat([[gt[1],gt[2]],[gt[4],gt[5]]])
bdry = bdry*np.linalg.inv(GT)
# polygon in pixel coords
polygon1 = asPolygon(bdry)
# raster over the bounding rectangle
minx,miny,maxx,maxy = map(int,list(polygon1.bounds))
pts = []
for i in range(minx,maxx+1):
for j in range(miny,maxy+1):
pts.append((i,j))
multipt = MultiPoint(pts)
# intersection as list
intersection = np.array(multipt.intersection(polygon1),dtype=np.int).tolist()
# cut out the bounded image cube
cube = np.zeros((maxy-miny+1,maxx-minx+1,len(rasterBands)))
k=0
for band in rasterBands:
cube[:,:,k] = band.ReadAsArray(minx,miny,maxx-minx+1,maxy-miny+1)
k += 1
# get the training vectors
for (x,y) in intersection:
Gs.append(cube[y-miny,x-minx,:])
ls.append(l)
polygon = None
polygon1 = None
feature.Destroy()
trnDatasource.Destroy()
classnames += '}'
m = len(ls)
print str(m) + ' training pixel vectors were read in'
Gs = np.array(Gs)
ls = np.array(ls)
# stretch the pixel vectors to [-1,1] for ffn
maxx = np.max(Gs,0)
minx = np.min(Gs,0)
for j in range(N):
Gs[:,j] = 2*(Gs[:,j]-minx[j])/(maxx[j]-minx[j]) - 1.0
# random permutation of training data
idx = np.random.permutation(m)
Gs = Gs[idx,:]
ls = ls[idx,:]
# setup output datasets
driver = gdal.GetDriverByName(outfmt)
outDataset = driver.Create(outfile,cols,rows,1,GDT_Byte)
projection = inDataset.GetProjection()
geotransform = inDataset.GetGeoTransform()
if geotransform is not None:
outDataset.SetGeoTransform(tuple(gt))
if projection is not None:
outDataset.SetProjection(projection)
outBand = outDataset.GetRasterBand(1)
if probfile:
driver = gdal.GetDriverByName(probfmt)
probDataset = driver.Create(probfile,cols,rows,K,GDT_Byte)
if geotransform is not None:
probDataset.SetGeoTransform(tuple(gt))
if projection is not None:
probDataset.SetProjection(projection)
probBands = []
for k in range(K):
probBands.append(probDataset.GetRasterBand(k+1))
if tstfile:
# train on 2/3 training examples
Gstrn = Gs[0:2*m//3,:]
lstrn = ls[0:2*m//3,:]
Gstst = Gs[2*m//3:,:]
lstst = ls[2*m//3:,:]
else:
Gstrn = Gs
lstrn = ls
if trainalg == 1:
classifier = sc.Maxlike(Gstrn,lstrn)
elif trainalg == 2:
classifier = sc.Ffnbp(Gstrn,lstrn,L)
elif trainalg == 3:
classifier = sc.Ffncg(Gstrn,lstrn,L)
elif trainalg == 4:
classifier = sc.Svm(Gstrn,lstrn)
print 'training on %i pixel vectors...' % np.shape(Gstrn)[0]
start = time.time()
result = classifier.train()
print 'elapsed time %s' %str(time.time()-start)
if result:
if trainalg in [2,3]:
cost = np.log10(result)
ymax = np.max(cost)
ymin = np.min(cost)
xmax = len(cost)
plt.plot(range(xmax),cost,'k')
plt.axis([0,xmax,ymin-1,ymax])
plt.title('Log(Cross entropy)')
plt.xlabel('Epoch')
# classify the image
print 'classifying...'
start = time.time()
tile = np.zeros((cols,N))
for row in range(rows):
for j in range(N):
tile[:,j] = rasterBands[j].ReadAsArray(0,row,cols,1)
tile[:,j] = 2*(tile[:,j]-minx[j])/(maxx[j]-minx[j]) - 1.0
cls, Ms = classifier.classify(tile)
outBand.WriteArray(np.reshape(cls,(1,cols)),0,row)
if probfile:
Ms = np.byte(Ms*255)
for k in range(K):
probBands[k].WriteArray(np.reshape(Ms[k,:],(1,cols)),0,row)
outBand.FlushCache()
print 'elapsed time %s' %str(time.time()-start)
outDataset = None
inDataset = None
if probfile:
for probBand in probBands:
probBand.FlushCache()
probDataset = None
print 'class probabilities written to: %s'%probfile
K = lstrn.shape[1]+1
if (outfmt == 'ENVI') and (K<19):
# try to make an ENVI classification header file
hdr = header.Header()
headerfile = outfile+'.hdr'
f = open(headerfile)
line = f.readline()
envihdr = ''
while line:
envihdr += line
line = f.readline()
f.close()
hdr.read(envihdr)
hdr['file type'] ='ENVI Classification'
hdr['classes'] = str(K)
classlookup = '{0'
for i in range(1,3*K):
classlookup += ', '+str(str(ctable[i]))
classlookup +='}'
hdr['class lookup'] = classlookup
hdr['class names'] = classnames
f = open(headerfile,'w')
f.write(str(hdr))
f.close()
print 'thematic map written to: %s'%outfile
if trainalg in [2,3]:
print 'please close the cross entropy plot to continue'
plt.show()
if tstfile:
with open(tstfile,'w') as f:
print >>f, 'FFN test results for %s'%infile
print >>f, time.asctime()
print >>f, 'Classification image: %s'%outfile
print >>f, 'Class probabilities image: %s'%probfile
print >>f, lstst.shape[0],lstst.shape[1]
classes, _ = classifier.classify(Gstst)
labels = np.argmax(lstst,axis=1)+1
for i in range(len(classes)):
print >>f, classes[i], labels[i]
f.close()
print 'test results written to: %s'%tstfile
print 'done'
else:
print 'an error occured'
return
def main():
depth_img = cv2.imread("./images/depth/kaula_depth_map_50fov.png",cv2.IMREAD_GRAYSCALE)
intensity_img = cv2.imread("./images/intensity/kaula_int_4.jpg",cv2.IMREAD_GRAYSCALE)
depth_img_transformed = np.empty_like(intensity_img)
cv2.namedWindow(depthWindow)
cv2.namedWindow(intensityWindow)
cv2.namedWindow(blendedWindow, cv2.WINDOW_AUTOSIZE)
cv2.namedWindow("contour", cv2.WINDOW_AUTOSIZE)
depth_img = cv2.pyrDown(depth_img)
intensity_img = cv2.pyrDown(intensity_img)
intensity_img = cv2.pyrDown(intensity_img)
intensity_img = cv2.pyrDown(intensity_img)
cv2.imshow(depthWindow, depth_img)
cv2.imshow(intensityWindow, intensity_img)
cv2.waitKey(1000)
cv2.createTrackbar("lowerThresh", depthWindow, 5, 255, nothing)
cv2.createTrackbar("higherThresh", depthWindow, 8, 255, nothing)
cv2.createTrackbar("lowerThresh", intensityWindow, 5, 255, nothing)
cv2.createTrackbar("higherThresh", intensityWindow, 10, 255, nothing)
cv2.createTrackbar("corner offset", intensityWindow, 5, 255, nothing)
cv2.createTrackbar("bilat int", intensityWindow, 50, 255, nothing)
cv2.createTrackbar("bilat space", intensityWindow, 50, 255, nothing)
cv2.createTrackbar("blend", blendedWindow, 5, 255, nothing)
contours_found = []
cv2.setMouseCallback(depthWindow,mouseCallbackDepth)
pressedKey = cv2.waitKey(100)
while pressedKey != 27:
if pressedKey == ord('c'): #key c
lower_threshold = cv2.getTrackbarPos("lowerThresh", depthWindow)
higher_threshold = cv2.getTrackbarPos("higherThresh", depthWindow)
depth_img_edge = cv2.Canny(depth_img, lower_threshold, higher_threshold)
bilat_int = cv2.getTrackbarPos("bilat int", intensityWindow)
bilat_col = cv2.getTrackbarPos("bilat space", intensityWindow)
intensity_img_filtered = cv2.bilateralFilter(intensity_img, 7, bilat_int, bilat_col)
lower_threshold = cv2.getTrackbarPos("lowerThresh", intensityWindow)
higher_threshold = cv2.getTrackbarPos("higherThresh", intensityWindow)
intensity_img_edge = cv2.Canny(intensity_img_filtered, lower_threshold, higher_threshold)
structuring_element = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))
cv2.dilate(intensity_img_edge, structuring_element, intensity_img_edge)
cv2.erode(intensity_img_edge, structuring_element, intensity_img_edge)
corner_offset = cv2.getTrackbarPos("corner offset", intensityWindow)
corners = cv2.goodFeaturesToTrack(intensity_img, 10, 0.02, 100)
for i,point in zip(range(0,3),corners[corner_offset:corner_offset+3]):
cvt_ponint= (int(point[0,0]), int(point[0,1]))
cv2.circle(intensity_img_edge,cvt_ponint,5,(130+i*50),2)
cv2.imshow(depthWindow, depth_img_edge)
cv2.imshow(intensityWindow, intensity_img_edge)
if pressedKey == ord('t'): # key t
transformMatrix = cv2.getAffineTransform(corners[corner_offset:corner_offset+3],depthTransformPoints)
#transformMatrix = cv2.getAffineTransform(corners[corner_offset:corner_offset+3],np.array([[286, 13],[107, 15],[338, 88]],dtype=np.float32))
map_x = np.empty_like(intensity_img, dtype=np.float32)
map_y = np.empty_like(intensity_img, dtype=np.float32)
for x in range(intensity_img.shape[0]):
for y in range(intensity_img.shape[1]):
transformed = np.dot(transformMatrix,[y, x, 1])
map_x[x, y] = transformed[0]
map_y[x, y] = transformed[1]
depth_img_transformed = cv2.remap(depth_img, map_x, map_y, interpolation=cv2.INTER_LINEAR)
cv2.setMouseCallback(blendedWindow, mouseCallbackBlended, param=depth_img_transformed)
intensity_img_edge[0, :] = 255
intensity_img_edge[-1, :] = 255
intensity_img_edge[:, 0] = 255
intensity_img_edge[:, -1] = 255
# lower_threshold = cv2.getTrackbarPos("lowerThresh", depthWindow)
# higher_threshold = cv2.getTrackbarPos("higherThresh", depthWindow)
contour = np.copy(intensity_img_edge)
image, contours_found, hierarchy = cv2.findContours(contour,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
print("contour shape",contour.shape)
cv2.imshow(depthWindow,contour)
print("transformed depth size:", depth_img_transformed.shape, "intensity img size", intensity_img.shape)
if pressedKey == ord('b'):
blend = cv2.getTrackbarPos("blend", blendedWindow)
blended_img = cv2.addWeighted(depth_img_transformed, blend / 255.0, intensity_img, 1 - (blend / 255.0), 0.0)
for rect in rectList:
number_of_pts = rect.number_of_added_points()
for i in range(1,number_of_pts):
cv2.line(blended_img,(rect.points[i,1], rect.points[i,0]),(rect.points[i-1,1], rect.points[i-1,0]), 0, 2)
if number_of_pts == 4:
cv2.line(blended_img, (rect.points[3, 1], rect.points[3, 0]), (rect.points[0, 1], rect.points[0, 0]), 0, 2)
cv2.imshow(blendedWindow, blended_img)
if pressedKey == ord('p'):
print("model writing started")
globalVertexList = np.empty((1,3),dtype=np.float32) # first element is empty
for rect in rectList:
rect.regression_coeffitients()
rectList.sort(key=lambda rect: rect.beta[0]) # ezt lehet meg kel forditani
faceList = []
for i in range(len(rectList)): # goes through every rect
localVertexList = np.empty((4,3), dtype=np.float32)
localSegmentList = np.empty((1,2), dtype=np.int)
local_rect_list = []
localVertexList[0, :] = rectList[i].estimate_point(rectList[i].points[0, :2])
localVertexList[1, :] = rectList[i].estimate_point(rectList[i].points[1, :2])
localVertexList[2, :] = rectList[i].estimate_point(rectList[i].points[2, :2])
localVertexList[3, :] = rectList[i].estimate_point(rectList[i].points[3, :2])
for j in reversed( range(i) ): #select every rectangle before current
rect_project_to = asPolygon(rectList[i].points[:, :2])
projected_rect = asPolygon(rectList[j].points[:, :2])
inside = projected_rect.within(rect_project_to)
if inside == True:
segLen = len(localVertexList)
temp_vertex_list = np.empty((4, 3), dtype=np.float32)
temp_vertex_list[0] = rectList[i].estimate_point(rectList[j].points[0, :2])
temp_vertex_list[1] = rectList[i].estimate_point(rectList[j].points[1, :2])
temp_vertex_list[2] = rectList[i].estimate_point(rectList[j].points[2, :2])
temp_vertex_list[3] = rectList[i].estimate_point(rectList[j].points[3, :2])
thisRect = asPolygon(temp_vertex_list)
stop_adding=False
for other_rect in local_rect_list:
if thisRect.within(other_rect):
stop_adding=True
if not stop_adding:
local_rect_list.append(thisRect)
localVertexList = np.append( localVertexList,temp_vertex_list,axis=0)
temp_segment_list = [[segLen,segLen+1],
[segLen + 1, segLen + 2],
[segLen + 2, segLen + 3],
[segLen + 3, segLen]]
localSegmentList = np.append(localSegmentList,temp_segment_list,axis=0)
triangulation_input = {}
localSegmentList = np.delete(localSegmentList,0,0)
triangulation_input['vertices'] = localVertexList[:, 0:2]
if len(localSegmentList) > 0 :
triangulation_input['segments'] = localSegmentList
tria = tri.triangulate(triangulation_input)
triangle_offset = len(globalVertexList)
for triangle in tria['triangles']:
vertices = np.array([localVertexList[triangle[0]], localVertexList[triangle[1]], localVertexList[triangle[2]]])
trianglePolygon = asPolygon(vertices)
add_triangle = True
for rect in local_rect_list:
if trianglePolygon.within(rect):
add_triangle = False
if add_triangle:
triangle_to_add = triangle + triangle_offset
faceList.append(triangle_to_add)
globalVertexList = np.append(globalVertexList, localVertexList, axis=0)
globalVertexList = np.delete(globalVertexList, 0, 0)
textureCoordinates = np.copy(globalVertexList[:,:2])
textureCoordinates[:, 0] = -1*(textureCoordinates[:, 0]/float(intensity_img.shape[0]))+1
textureCoordinates[:, 1] = textureCoordinates[:, 1]/float(intensity_img.shape[1])
make_obj_file("model.obj", globalVertexList, faceList,textureCoordinates,"material.mtl","Kaula")
print("model written to file")
pressedKey = cv2.waitKey(10)
cv2.destroyAllWindows()
def __init__(self,
polygon_file=None,
proj4_str='+proj=lonlat +ellps=WGS84'):
# self.proj4 = '+proj=lonlat +ellps=WGS84'
self.proj4 = proj4_str
self.crs = pyproj.CRS(self.proj4)
# self.skippoly = skippoly
super(Reader, self).__init__()
shore = np.loadtxt(
polygon_file) # nan-delimited closed polygons for land and islands
if 'lonlat' not in proj4_str: # not functional yet - polygons must be in wgs84 for now
print(
'custom landmask polygon must be in WGS84 coordinates..for now'
)
import pdb
pdb.set_trace()
# if not in wgs84 coordinates already, convert now to lon,lat
xx, yy = self.xy2lonlat(shore[:, 0], shore[:, 1])
xx[np.where(np.isinf(xx))] = np.nan
yy[np.where(np.isinf(yy))] = np.nan
# update the shore polygon
shore[:, 0] = xx.copy()
shore[:, 1] = yy.copy()
# update the projection
self.proj4 = '+proj=lonlat +ellps=WGS84'
self.crs = pyproj.CRS(self.proj4)
# this doesnt work because self.proj.crs.is_geographic remains false in basereader.py
# not sure why/how ?
import pdb
pdb.set_trace()
# Depth
self.z = None
self.xmin, self.ymin = np.nanmin(shore[:, 0]), np.nanmin(shore[:, 1])
self.xmax, self.ymax = np.nanmax(shore[:, 0]), np.nanmax(shore[:, 1])
# convert to xy
self.xmin, self.ymin = self.lonlat2xy(self.xmin, self.ymin)
self.xmax, self.ymax = self.lonlat2xy(self.xmax, self.ymax)
# setup landmask
# self.mask = Landmask(extent, skippoly)
# Loop through polygon to build MultiPolygon object
#
# make sure that start and end lines are [nan,nan] as well
if not np.isnan(shore[0, 0]):
shore = np.vstack(([np.nan, np.nan], shore))
if not np.isnan(shore[-1, 0]):
shore = np.vstack((shore, [np.nan, np.nan]))
id_nans = np.where(np.isnan(shore[:, 0]))[0]
poly = []
for cnt, id_i in enumerate(id_nans[:-1]):
# The shapely.geometry.asShape() family of functions can be used to wrap Numpy coordinate arrays
# https://shapely.readthedocs.io/en/latest/manual.html
poly.append(
asPolygon(shore[id_nans[cnt] + 1:id_nans[cnt + 1] - 1, :]))
# We can pass multiple Polygon -objects into our MultiPolygon as a list
self.mask = MultiPolygon(poly)
self.mask = shapely.prepared.prep(self.mask)
state, bboxes, rboxes = siamese_track(state,
im,
mask_enable=True,
refine_enable=True,
device=device) # track
print("---- FRAME ", f, " -------")
print("num_bxs = ", len(rboxes))
rboxes = filter_bboxes(rboxes, 5, c=10 *
len(rboxes)) #puto recursiu, funciona be
print("num_filtered = ", len(rboxes), " - ", rboxes[0][1])
# dibuixar nomes la bbox filtrada si esta fora de la bona (state)
locaux_bona = np.int0(state['ploygon'].flatten()).reshape((-1, 2))
locaux_filt = rboxes[0][0]
pol_a = asPolygon(locaux_bona)
pol_b = asPolygon(locaux_filt)
intersection_area = pol_a.intersection(pol_b)
if ((intersection_area.area / (pol_a.area + pol_b.area)) <= 0.2):
for i in range(len(rboxes)):
location = rboxes[i][0].flatten()
location = np.int0(location).reshape((-1, 1, 2))
cv2.polylines(im, [location], True, (255, 255, 0), 1)
traj = np.average(location, axis=0)[0]
frame_boxes.append([traj])
cv2.circle(im, (int(traj[0]), int(traj[1])), 3,
(255, 255, 0), 2)
location = state['ploygon'].flatten()
mask = state['mask'] > state['p'].seg_thr
im[:, :, 2] = (mask > 0) * 255 + (mask == 0) * im[:, :, 2]
def minkowski_sum(poly1, poly2):
''' minkowski sum of two convex polygons.
Any random polygon that gets input here should be:
oriented with geom.polygon.orient
made convex with *.convex_hull
cleaned with *.buffer(0)
Some of this might be unnecesary but who knows.'''
#assert poly1.is_valid, validation.explain_validity(poly1)
#assert poly2.is_valid, validation.explain_validity(poly2)
# Ensure correct edge ordering
poly1 = geom.polygon.orient(poly1)
poly2 = geom.polygon.orient(poly2)
sum_edges = []
sum_angles = []
min_angle_points = []
for p in [poly1, poly2]:
try:
boundary_pts = np.array(p.boundary)
except TypeError:
print 'In minkowski sum: p.boundary didn\'t work, so trying p.exterior'
plt.figure()
plt.gca().add_patch(plt.Polygon(np.array(p.exterior)))
plt.gca().add_patch(plt.Polygon(np.array(p.convex_hull.exterior), alpha=0.5))
plt.autoscale()
plt.pause(2)
plt.close()
raise Exception
edges = np.diff(boundary_pts, axis=0)
angles = np.arctan2(edges[:,1], edges[:,0]) # polar angles
angles[angles<0] = angles[angles<0] + 2*np.pi # wrap [0, 2pi]
# save the point where the smallest-angle edge originates so we can shift final
# shape correctly
min_angle_points.append(boundary_pts[np.argmin(angles),:])
min_idx = angles.argmin() # does first edge have the smallest polar angle?
if min_idx != 0: # shuffle until edges are sorted by angle
edges = np.roll(edges, -min_idx, axis=0)
angles = np.roll(angles, -min_idx)
sum_edges.append(edges)
sum_angles.append(angles)
sum_edges = np.concatenate(sum_edges) # stick into a big numpy array
sum_angles = np.concatenate(sum_angles)
idx = np.argsort(sum_angles)
sum_edges = sum_edges[idx,:] # sorted edges of the minkowski sum
sum_angles = sum_angles[idx] # sorted angles
# find exterior points on the resulting minkowski sum polygon
# do this hack to get the absolute coord of the first point
first_point = min_angle_points[0] + min_angle_points[1]
sum_ext = np.cumsum(np.concatenate((first_point[np.newaxis,:],sum_edges)), axis=0)
sum_ext[-1,:] = sum_ext[0,:] # ensure start and end points match
poly = geom.asPolygon(sum_ext)
#assert poly.is_valid
return poly
def main():
usage = '''
Usage:
---------------------------------------------------------
python %s [-p bandPositions] [- a algorithm] [-L number of hidden neurons]
[-P generate class probabilities image] filename trainShapefile
bandPositions is a list, e.g., -p [1,2,4]
algorithm 1=MaxLike
2=NNet(backprop)
3=NNet(congrad)
4=SVM
If the input file is named
path/filenbasename.ext then
The output classification file is named
path/filebasename_class.ext
the class probabilities output file is named
path/filebasename_classprobs.ext
and the test results file is named
path/filebasename_<classifier>.tst
--------------------------------------------------------''' %sys.argv[0]
options, args = getopt.getopt(sys.argv[1:],'hnPp:a:L:')
pos = None
probs = False
L = 8
trainalg = 1
graphics = True
for option, value in options:
if option == '-h':
print usage
return
elif option == '-p':
pos = eval(value)
elif option == '-n':
graphics = False
elif option == '-a':
trainalg = eval(value)
elif option == '-L':
L = eval(value)
elif option == '-P':
probs = True
if len(args) != 2:
print 'Incorrect number of arguments'
print usage
sys.exit(1)
if trainalg == 1:
algorithm = 'MaxLike'
elif trainalg == 2:
algorithm = 'NNet(Backprop)'
elif trainalg == 3:
algorithm = 'NNet(Congrad)'
else:
algorithm = 'SVM'
infile = args[0]
trnfile = args[1]
gdal.AllRegister()
if infile:
inDataset = gdal.Open(infile,GA_ReadOnly)
cols = inDataset.RasterXSize
rows = inDataset.RasterYSize
bands = inDataset.RasterCount
projection = inDataset.GetProjection()
geotransform = inDataset.GetGeoTransform()
if geotransform is not None:
gt = list(geotransform)
else:
print 'No geotransform available'
return
imsr = osr.SpatialReference()
imsr.ImportFromWkt(projection)
else:
return
if pos is None:
pos = range(1,bands+1)
N = len(pos)
rasterBands = []
for b in pos:
rasterBands.append(inDataset.GetRasterBand(b))
# output files
path = os.path.dirname(infile)
basename = os.path.basename(infile)
root, ext = os.path.splitext(basename)
outfile = '%s/%s_class%s'%(path,root,ext)
tstfile = '%s/%s_%s.tst'%(path,root,algorithm)
if (trainalg in (2,3,4)) and probs:
# class probabilities file
probfile = '%s/%s_classprobs%s'%(path,root,ext)
else:
probfile = None
# training data
trnDriver = ogr.GetDriverByName('ESRI Shapefile')
trnDatasource = trnDriver.Open(trnfile,0)
trnLayer = trnDatasource.GetLayer()
trnsr = trnLayer.GetSpatialRef()
# coordinate transformation from training to image projection
ct = osr.CoordinateTransformation(trnsr,imsr)
# number of classes
K = 1
feature = trnLayer.GetNextFeature()
while feature:
classid = feature.GetField('CLASS_ID')
if int(classid)>K:
K = int(classid)
feature = trnLayer.GetNextFeature()
trnLayer.ResetReading()
K += 1
# es kann losgehen
print '========================='
print 'supervised classification'
print '========================='
print time.asctime()
print 'image: '+infile
print 'training: '+trnfile
print 'algorithm: '+algorithm
# loop through the polygons
Gs = [] # train observations
ls = [] # class labels
classnames = '{unclassified'
classids = set()
print 'reading training data...'
for i in range(trnLayer.GetFeatureCount()):
feature = trnLayer.GetFeature(i)
classid = str(feature.GetField('CLASS_ID'))
classname = feature.GetField('CLASS_NAME')
if classid not in classids:
classnames += ', '+ classname
classids = classids | set(classid)
# label for this ROI
l = [0 for i in range(K)]
l[int(classid)] = 1.0
polygon = feature.GetGeometryRef()
# transform to same projection as image
polygon.Transform(ct)
# convert to a Shapely object
poly = shapely.wkt.loads(polygon.ExportToWkt())
# transform the boundary to pixel coords in numpy
bdry = np.array(poly.boundary)
bdry[:,0] = bdry[:,0]-gt[0]
bdry[:,1] = bdry[:,1]-gt[3]
GT = np.mat([[gt[1],gt[2]],[gt[4],gt[5]]])
bdry = bdry*np.linalg.inv(GT)
# polygon in pixel coords
polygon1 = asPolygon(bdry)
# raster over the bounding rectangle
minx,miny,maxx,maxy = map(int,list(polygon1.bounds))
pts = []
for i in range(minx,maxx+1):
for j in range(miny,maxy+1):
pts.append((i,j))
multipt = MultiPoint(pts)
# intersection as list
intersection = np.array(multipt.intersection(polygon1),dtype=np.int).tolist()
# cut out the bounded image cube
cube = np.zeros((maxy-miny+1,maxx-minx+1,len(rasterBands)))
k=0
for band in rasterBands:
cube[:,:,k] = band.ReadAsArray(minx,miny,maxx-minx+1,maxy-miny+1)
k += 1
# get the training vectors
for (x,y) in intersection:
Gs.append(cube[y-miny,x-minx,:])
ls.append(l)
polygon = None
polygon1 = None
feature.Destroy()
trnDatasource.Destroy()
classnames += '}'
m = len(ls)
print str(m) + ' training pixel vectors were read in'
Gs = np.array(Gs)
ls = np.array(ls)
# stretch the pixel vectors to [-1,1] for ffn
maxx = np.max(Gs,0)
minx = np.min(Gs,0)
for j in range(N):
Gs[:,j] = 2*(Gs[:,j]-minx[j])/(maxx[j]-minx[j]) - 1.0
# random permutation of training data
idx = np.random.permutation(m)
Gs = Gs[idx,:]
ls = ls[idx,:]
# train on 2/3 training examples
Gstrn = Gs[0:2*m//3,:]
lstrn = ls[0:2*m//3,:]
Gstst = Gs[2*m//3:,:]
lstst = ls[2*m//3:,:]
# setup output datasets
driver = inDataset.GetDriver()
outDataset = driver.Create(outfile,cols,rows,1,GDT_Byte)
projection = inDataset.GetProjection()
geotransform = inDataset.GetGeoTransform()
if geotransform is not None:
outDataset.SetGeoTransform(tuple(gt))
if projection is not None:
outDataset.SetProjection(projection)
outBand = outDataset.GetRasterBand(1)
if probfile:
probDataset = driver.Create(probfile,cols,rows,K,GDT_Byte)
if geotransform is not None:
probDataset.SetGeoTransform(tuple(gt))
if projection is not None:
probDataset.SetProjection(projection)
probBands = []
for k in range(K):
probBands.append(probDataset.GetRasterBand(k+1))
# initialize classifier
if trainalg == 1:
classifier = sc.Maxlike(Gstrn,lstrn)
elif trainalg == 2:
classifier = sc.Ffnbp(Gstrn,lstrn,L)
elif trainalg == 3:
classifier = sc.Ffncg(Gstrn,lstrn,L)
elif trainalg == 4:
classifier = sc.Svm(Gstrn,lstrn)
# train it
print 'training on %i pixel vectors...' % np.shape(Gstrn)[0]
start = time.time()
result = classifier.train()
print 'elapsed time %s' %str(time.time()-start)
if result:
if (trainalg in [2,3]) and graphics:
cost = np.log10(result)
ymax = np.max(cost)
ymin = np.min(cost)
xmax = len(cost)
plt.plot(range(xmax),cost,'k')
plt.axis([0,xmax,ymin-1,ymax])
plt.title('Log(Cross entropy)')
plt.xlabel('Epoch')
# classify the image
print 'classifying...'
start = time.time()
tile = np.zeros((cols,N),dtype=np.float32)
for row in range(rows):
for j in range(N):
tile[:,j] = rasterBands[j].ReadAsArray(0,row,cols,1)
tile[:,j] = 2*(tile[:,j]-minx[j])/(maxx[j]-minx[j]) - 1.0
cls, Ms = classifier.classify(tile)
outBand.WriteArray(np.reshape(cls,(1,cols)),0,row)
if probfile:
Ms = np.byte(Ms*255)
for k in range(K):
probBands[k].WriteArray(np.reshape(Ms[k,:],(1,cols)),0,row)
outBand.FlushCache()
print 'elapsed time %s' %str(time.time()-start)
outDataset = None
inDataset = None
if probfile:
for probBand in probBands:
probBand.FlushCache()
probDataset = None
print 'class probabilities written to: %s'%probfile
K = lstrn.shape[1]+1
print 'thematic map written to: %s'%outfile
if trainalg in [2,3]:
plt.show()
if tstfile:
with open(tstfile,'w') as f:
print >>f, algorithm +'test results for %s'%infile
print >>f, time.asctime()
print >>f, 'Classification image: %s'%outfile
print >>f, 'Class probabilities image: %s'%probfile
print >>f, lstst.shape[0],lstst.shape[1]
classes, _ = classifier.classify(Gstst)
labels = np.argmax(lstst,axis=1)+1
for i in range(len(classes)):
print >>f, classes[i], labels[i]
f.close()
print 'test results written to: %s'%tstfile
print 'done'
else:
print 'an error occured'
return
kelias.juostos[-1].plotis)
offset_lines = []
for offset in kelias.juostos:
l = kelias_line.parallel_offset(offset.plotis * offset_multiplier,
offset.kryptis,
join_style=2)
offset_lines.append(l)
ax.plot(*l.xy,
linewidth=.5,
dashes=offset.dashes,
color=offset.spalva,
zorder=kelias.kat)
# kelio poligonas su plotu
kelias_poly = np.vstack((offset_lines[0].coords, offset_lines[-1].coords))
ax.add_patch(
PolygonPatch(asPolygon(kelias_poly),
fc='white',
zorder=kelias.kat,
linewidth=0))
keliai_l[id] = kelias_l(line=kelias_line, offsets=offset_lines)
# kelių anotacijos
for id, kelias in keliai_l.items():
linestart, lineend = np.array(kelias.offsets[-1].coords)[0:2]
delta = lineend - linestart
angle = atan(delta[1] / delta[0]) * 180 / pi
offset = road_annotations[id]
ax.annotate(id,
kelias.offsets[-1].coords[0],
zorder=KAT0,
textcoords='offset points',
def __init__(self, points, visible=True):
self.points = np.array(points)
self.polygon = asPolygon(self.points)
self.visible = visible
#compute normal orientation of the segment
normal = (p[1]-p[0]) * np.array([ 1,-1] ) ;
normal[0], normal[1], = normal[1],normal[0] ; #exchanging x and y, wihtout copy
normal = normal/np.linalg.norm(normal) ;
print(normal) ;
#creating the upper point and down point for first and second (hopefully last) point in segment
p1u = p[0] + normal * r1 ;
p1d = p[0] - normal * r1 ;
p2u = p[1] + normal * r2 ;
p2d = p[1] - normal * r2 ;
output_line = (p1u,p2u,p2d,p1d,p1u) ;
ogeom = asPolygon(output_line) ;
print(ogeom) ;
pp1.pprint( str(geom));
#outputing for postgis : @NOTE : if inside postgres, hex =False, if outside, hex=True
output = wkb.dumps(ogeom, hex=True);
print(output) ;
# ##emulation of postgres output
# #return None ;
# #return { "center": center, "radius": radius , "t1": t1, "t2":t2}
#==============================================================================
def test_polygon(self):
# Initialization
# Linear rings won't usually be created by users, but by polygons
coords = ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0))
ring = LinearRing(coords)
self.assertEqual(len(ring.coords), 5)
self.assertEqual(ring.coords[0], ring.coords[4])
self.assertEqual(ring.coords[0], ring.coords[-1])
self.assertTrue(ring.is_ring)
# Ring from sequence of Points
self.assertEqual(LinearRing((map(Point, coords))), ring)
# Coordinate modification
ring.coords = ((0.0, 0.0), (0.0, 2.0), (2.0, 2.0), (2.0, 0.0))
self.assertEqual(
ring.__geo_interface__, {
'type':
'LinearRing',
'coordinates':
((0.0, 0.0), (0.0, 2.0), (2.0, 2.0), (2.0, 0.0), (0.0, 0.0))
})
# Test ring adapter
coords = [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]]
ra = asLinearRing(coords)
self.assertTrue(ra.wkt.upper().startswith('LINEARRING'))
self.assertEqual(dump_coords(ra), [(0.0, 0.0), (0.0, 1.0), (1.0, 1.0),
(1.0, 0.0), (0.0, 0.0)])
coords[3] = [2.0, -1.0]
self.assertEqual(dump_coords(ra), [(0.0, 0.0), (0.0, 1.0), (1.0, 1.0),
(2.0, -1.0), (0.0, 0.0)])
# Construct a polygon, exterior ring only
polygon = Polygon(coords)
self.assertEqual(len(polygon.exterior.coords), 5)
# Ring Access
self.assertIsInstance(polygon.exterior, LinearRing)
ring = polygon.exterior
self.assertEqual(len(ring.coords), 5)
self.assertEqual(ring.coords[0], ring.coords[4])
self.assertEqual(ring.coords[0], (0., 0.))
self.assertTrue(ring.is_ring)
self.assertEqual(len(polygon.interiors), 0)
# Create a new polygon from WKB
data = polygon.wkb
polygon = None
ring = None
polygon = load_wkb(data)
ring = polygon.exterior
self.assertEqual(len(ring.coords), 5)
self.assertEqual(ring.coords[0], ring.coords[4])
self.assertEqual(ring.coords[0], (0., 0.))
self.assertTrue(ring.is_ring)
polygon = None
# Interior rings (holes)
polygon = Polygon(coords, [((0.25, 0.25), (0.25, 0.5), (0.5, 0.5),
(0.5, 0.25))])
self.assertEqual(len(polygon.exterior.coords), 5)
self.assertEqual(len(polygon.interiors[0].coords), 5)
with self.assertRaises(IndexError): # index out of range
polygon.interiors[1]
# Test from another Polygon
copy = Polygon(polygon)
self.assertEqual(len(polygon.exterior.coords), 5)
self.assertEqual(len(polygon.interiors[0].coords), 5)
with self.assertRaises(IndexError): # index out of range
polygon.interiors[1]
# Coordinate getters and setters raise exceptions
self.assertRaises(NotImplementedError, polygon._get_coords)
with self.assertRaises(NotImplementedError):
polygon.coords
# Geo interface
self.assertEqual(
polygon.__geo_interface__, {
'type':
'Polygon',
'coordinates':
(((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (2.0, -1.0), (0.0, 0.0)),
((0.25, 0.25), (0.25, 0.5), (0.5, 0.5), (0.5, 0.25),
(0.25, 0.25)))
})
# Adapter
hole_coords = [((0.25, 0.25), (0.25, 0.5), (0.5, 0.5), (0.5, 0.25))]
pa = asPolygon(coords, hole_coords)
self.assertEqual(len(pa.exterior.coords), 5)
self.assertEqual(len(pa.interiors), 1)
self.assertEqual(len(pa.interiors[0].coords), 5)
# Test Non-operability of Null rings
r_null = LinearRing()
self.assertEqual(r_null.wkt, 'GEOMETRYCOLLECTION EMPTY')
self.assertEqual(r_null.length, 0.0)
# Check that we can set coordinates of a null geometry
r_null.coords = [(0, 0), (1, 1), (1, 0)]
self.assertAlmostEqual(r_null.length, 3.414213562373095)
# Error handling
with self.assertRaises(ValueError):
# A LinearRing must have at least 3 coordinate tuples
Polygon([[1, 2], [2, 3]])
def readshp(trnfile, inDataset, pos):
# projection info from input image
projection = inDataset.GetProjection()
geotransform = inDataset.GetGeoTransform()
gt = list(geotransform)
imsr = osr.SpatialReference()
imsr.ImportFromWkt(projection)
trnDriver = ogr.GetDriverByName('ESRI Shapefile')
trnDatasource = trnDriver.Open(trnfile, 0)
trnLayer = trnDatasource.GetLayer()
trnsr = trnLayer.GetSpatialRef()
# coordinate transformation from training to image projection
ct = osr.CoordinateTransformation(trnsr, imsr)
# image bands
rasterBands = []
for b in pos:
rasterBands.append(inDataset.GetRasterBand(b))
# number of classes
K = 1
feature = trnLayer.GetNextFeature()
while feature:
classid = feature.GetField('CLASS_ID')
if int(classid) > K:
K = int(classid)
feature = trnLayer.GetNextFeature()
trnLayer.ResetReading()
K += 1
# loop through the polygons
Xs = [] # train observations (data matrix)
Ls = [] # class labels (lists)
classnames = []
classids = set()
print 'reading training data...'
for i in range(trnLayer.GetFeatureCount()):
feature = trnLayer.GetFeature(i)
classid = str(feature.GetField('CLASS_ID'))
classname = feature.GetField('CLASS_NAME')
if classid not in classids:
classnames.append(classname)
classids = classids | set(classid)
# label for this ROI
y = int(classid)
l = [0 for i in range(K)]
l[y] = 1.0
polygon = feature.GetGeometryRef()
# transform to same projection as image
polygon.Transform(ct)
# convert to a Shapely object
poly = shapely.wkt.loads(polygon.ExportToWkt())
# transform the boundary to pixel coords in numpy
bdry = np.array(poly.boundary)
bdry[:, 0] = bdry[:, 0] - gt[0]
bdry[:, 1] = bdry[:, 1] - gt[3]
GT = np.mat([[gt[1], gt[2]], [gt[4], gt[5]]])
bdry = bdry * np.linalg.inv(GT)
# polygon in pixel coords
polygon1 = asPolygon(bdry)
# raster over the bounding rectangle
minx, miny, maxx, maxy = map(int, list(polygon1.bounds))
pts = []
for i in range(minx, maxx + 1):
for j in range(miny, maxy + 1):
pts.append((i, j))
multipt = MultiPoint(pts)
# intersection as list
intersection = np.array(multipt.intersection(polygon1),
dtype=np.int).tolist()
# cut out the bounded image cube
cube = np.zeros((maxy - miny + 1, maxx - minx + 1, len(rasterBands)))
k = 0
for band in rasterBands:
cube[:, :, k] = band.ReadAsArray(minx, miny, maxx - minx + 1,
maxy - miny + 1)
k += 1
# get the training vectors
for (x, y) in intersection:
Xs.append(cube[y - miny, x - minx, :])
Ls.append(l)
polygon = None
polygon1 = None
feature.Destroy()
trnDatasource.Destroy()
Xs = np.array(Xs)
Ls = np.array(Ls)
return (Xs, Ls, K, classnames)
def main():
gdal.AllRegister()
path = auxil.select_directory('Input directory')
if path:
os.chdir(path)
# input image
infile = auxil.select_infile(title='Image file')
if infile:
inDataset = gdal.Open(infile, GA_ReadOnly)
cols = inDataset.RasterXSize
rows = inDataset.RasterYSize
bands = inDataset.RasterCount
projection = inDataset.GetProjection()
geotransform = inDataset.GetGeoTransform()
if geotransform is not None:
gt = list(geotransform)
else:
print 'No geotransform available'
return
imsr = osr.SpatialReference()
imsr.ImportFromWkt(projection)
else:
return
pos = auxil.select_pos(bands)
if not pos:
return
N = len(pos)
rasterBands = []
for b in pos:
rasterBands.append(inDataset.GetRasterBand(b))
# training algorithm
trainalg = auxil.select_integer(1,
msg='1:Maxlike,2:Backprop,3:Congrad,4:SVM')
if not trainalg:
return
# training data (shapefile)
trnfile = auxil.select_infile(filt='.shp', title='Train shapefile')
if trnfile:
trnDriver = ogr.GetDriverByName('ESRI Shapefile')
trnDatasource = trnDriver.Open(trnfile, 0)
trnLayer = trnDatasource.GetLayer()
trnsr = trnLayer.GetSpatialRef()
else:
return
tstfile = auxil.select_outfile(filt='.tst', title='Test results file')
if not tstfile:
print 'No test output'
# outfile
outfile, outfmt = auxil.select_outfilefmt(title='Classification file')
if not outfile:
return
if trainalg in (2, 3, 4):
# class probabilities file, hidden neurons
probfile, probfmt = auxil.select_outfilefmt(title='Probabilities file')
else:
probfile = None
if trainalg in (2, 3):
L = auxil.select_integer(8, 'Number of hidden neurons')
if not L:
return
# coordinate transformation from training to image projection
ct = osr.CoordinateTransformation(trnsr, imsr)
# number of classes
K = 1
feature = trnLayer.GetNextFeature()
while feature:
classid = feature.GetField('CLASS_ID')
if int(classid) > K:
K = int(classid)
feature = trnLayer.GetNextFeature()
trnLayer.ResetReading()
K += 1
print '========================='
print 'supervised classification'
print '========================='
print time.asctime()
print 'image: ' + infile
print 'training: ' + trnfile
if trainalg == 1:
print 'Maximum Likelihood'
elif trainalg == 2:
print 'Neural Net (Backprop)'
elif trainalg == 3:
print 'Neural Net (Congrad)'
else:
print 'Support Vector Machine'
# loop through the polygons
Gs = [] # train observations
ls = [] # class labels
classnames = '{unclassified'
classids = set()
print 'reading training data...'
for i in range(trnLayer.GetFeatureCount()):
feature = trnLayer.GetFeature(i)
classid = str(feature.GetField('CLASS_ID'))
classname = feature.GetField('CLASS_NAME')
if classid not in classids:
classnames += ', ' + classname
classids = classids | set(classid)
l = [0 for i in range(K)]
l[int(classid)] = 1.0
polygon = feature.GetGeometryRef()
# transform to same projection as image
polygon.Transform(ct)
# convert to a Shapely object
poly = shapely.wkt.loads(polygon.ExportToWkt())
# transform the boundary to pixel coords in numpy
bdry = np.array(poly.boundary)
bdry[:, 0] = bdry[:, 0] - gt[0]
bdry[:, 1] = bdry[:, 1] - gt[3]
GT = np.mat([[gt[1], gt[2]], [gt[4], gt[5]]])
bdry = bdry * np.linalg.inv(GT)
# polygon in pixel coords
polygon1 = asPolygon(bdry)
# raster over the bounding rectangle
minx, miny, maxx, maxy = map(int, list(polygon1.bounds))
pts = []
for i in range(minx, maxx + 1):
for j in range(miny, maxy + 1):
pts.append((i, j))
multipt = MultiPoint(pts)
# intersection as list
intersection = np.array(multipt.intersection(polygon1),
dtype=np.int).tolist()
# cut out the bounded image cube
cube = np.zeros((maxy - miny + 1, maxx - minx + 1, len(rasterBands)))
k = 0
for band in rasterBands:
cube[:, :, k] = band.ReadAsArray(minx, miny, maxx - minx + 1,
maxy - miny + 1)
k += 1
# get the training vectors
for (x, y) in intersection:
Gs.append(cube[y - miny, x - minx, :])
ls.append(l)
polygon = None
polygon1 = None
feature.Destroy()
trnDatasource.Destroy()
classnames += '}'
m = len(ls)
print str(m) + ' training pixel vectors were read in'
Gs = np.array(Gs)
ls = np.array(ls)
# stretch the pixel vectors to [-1,1] for ffn
maxx = np.max(Gs, 0)
minx = np.min(Gs, 0)
for j in range(N):
Gs[:, j] = 2 * (Gs[:, j] - minx[j]) / (maxx[j] - minx[j]) - 1.0
# random permutation of training data
idx = np.random.permutation(m)
Gs = Gs[idx, :]
ls = ls[idx, :]
# setup output datasets
driver = gdal.GetDriverByName(outfmt)
outDataset = driver.Create(outfile, cols, rows, 1, GDT_Byte)
projection = inDataset.GetProjection()
geotransform = inDataset.GetGeoTransform()
if geotransform is not None:
outDataset.SetGeoTransform(tuple(gt))
if projection is not None:
outDataset.SetProjection(projection)
outBand = outDataset.GetRasterBand(1)
if probfile:
driver = gdal.GetDriverByName(probfmt)
probDataset = driver.Create(probfile, cols, rows, K, GDT_Byte)
if geotransform is not None:
probDataset.SetGeoTransform(tuple(gt))
if projection is not None:
probDataset.SetProjection(projection)
probBands = []
for k in range(K):
probBands.append(probDataset.GetRasterBand(k + 1))
if tstfile:
# train on 2/3 training examples
Gstrn = Gs[0:2 * m // 3, :]
lstrn = ls[0:2 * m // 3, :]
Gstst = Gs[2 * m // 3:, :]
lstst = ls[2 * m // 3:, :]
else:
Gstrn = Gs
lstrn = ls
if trainalg == 1:
classifier = sc.Maxlike(Gstrn, lstrn)
elif trainalg == 2:
classifier = sc.Ffnbp(Gstrn, lstrn, L)
elif trainalg == 3:
classifier = sc.Ffncg(Gstrn, lstrn, L)
elif trainalg == 4:
classifier = sc.Svm(Gstrn, lstrn)
print 'training on %i pixel vectors...' % np.shape(Gstrn)[0]
start = time.time()
result = classifier.train()
print 'elapsed time %s' % str(time.time() - start)
if result:
if trainalg in [2, 3]:
cost = np.log10(result)
ymax = np.max(cost)
ymin = np.min(cost)
xmax = len(cost)
plt.plot(range(xmax), cost, 'k')
plt.axis([0, xmax, ymin - 1, ymax])
plt.title('Log(Cross entropy)')
plt.xlabel('Epoch')
# classify the image
print 'classifying...'
start = time.time()
tile = np.zeros((cols, N))
for row in range(rows):
for j in range(N):
tile[:, j] = rasterBands[j].ReadAsArray(0, row, cols, 1)
tile[:, j] = 2 * (tile[:, j] - minx[j]) / (maxx[j] -
minx[j]) - 1.0
cls, Ms = classifier.classify(tile)
outBand.WriteArray(np.reshape(cls, (1, cols)), 0, row)
if probfile:
Ms = np.byte(Ms * 255)
for k in range(K):
probBands[k].WriteArray(np.reshape(Ms[k, :], (1, cols)), 0,
row)
outBand.FlushCache()
print 'elapsed time %s' % str(time.time() - start)
outDataset = None
inDataset = None
if probfile:
for probBand in probBands:
probBand.FlushCache()
probDataset = None
print 'class probabilities written to: %s' % probfile
K = lstrn.shape[1] + 1
if (outfmt == 'ENVI') and (K < 19):
# try to make an ENVI classification header file
hdr = header.Header()
headerfile = outfile + '.hdr'
f = open(headerfile)
line = f.readline()
envihdr = ''
while line:
envihdr += line
line = f.readline()
f.close()
hdr.read(envihdr)
hdr['file type'] = 'ENVI Classification'
hdr['classes'] = str(K)
classlookup = '{0'
for i in range(1, 3 * K):
classlookup += ', ' + str(str(ctable[i]))
classlookup += '}'
hdr['class lookup'] = classlookup
hdr['class names'] = classnames
f = open(headerfile, 'w')
f.write(str(hdr))
f.close()
print 'thematic map written to: %s' % outfile
if trainalg in [2, 3]:
print 'please close the cross entropy plot to continue'
plt.show()
if tstfile:
with open(tstfile, 'w') as f:
print >> f, 'FFN test results for %s' % infile
print >> f, time.asctime()
print >> f, 'Classification image: %s' % outfile
print >> f, 'Class probabilities image: %s' % probfile
print >> f, lstst.shape[0], lstst.shape[1]
classes, _ = classifier.classify(Gstst)
labels = np.argmax(lstst, axis=1) + 1
for i in range(len(classes)):
print >> f, classes[i], labels[i]
f.close()
print 'test results written to: %s' % tstfile
print 'done'
else:
print 'an error occured'
return
out1 = watershed_seg(image, show_img=True, file_name="eroded_seal.png") out1[0][0][0] splotches = out1[0] ########## Working out overlap/rotation for matching rots = polygon_rotator(out1[0][16], angle=2*math.pi/180) #test1 eroded rots_1 = polygon_rotator(out2[0][20], angle=2*math.pi/4) #seal1_1 eroded1 sg.Polygon(rots[18]).is_valid out2 = out1 #test1 PercentOverlap = poly1.intersection(poly2).area / poly1.union(poly2).area print PercentOverlap poly1 = sg.asPolygon(out1[0][0]) poly1 = sg.asPolygon(rots[0]) poly2 = sg.asPolygon(rots_1[0]) #pol2cart(rots_1[18]) poly2 = poly1 poly3 = sg.Polygon(pol2cart(rots[18])) poly4 = sg.Polygon(pol2cart(rots_1[20])) poly3.buffer(0).wkt poly4 = poly3.buffer(0) poly1 poly2 PercentOverlap = poly1.intersection(poly2).area / poly1.union(poly2).area poly1.type poly1.is_valid
def test_polygon_adapter_deprecated():
coords = ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0))
hole_coords = [((0.25, 0.25), (0.25, 0.5), (0.5, 0.5), (0.5, 0.25))]
with pytest.warns(ShapelyDeprecationWarning, match="proxy geometries"):
asPolygon(coords, hole_coords)
def response(self, x, y, method='fractional'):
r"""
Compute the response function of the aperture to the sky over
a regular grid. This is the same as rendering an "image" of
the aperture.
The integral of the returned map is normalized to the
aperture area.
Args:
x (array-like):
The list of x coordinates for the grid. Must be
linearly spaced.
y (array-like):
The list of y coordinates for the grid. Must be
linearly spaced.
method (:obj:`str`, optional):
Method used to construct the overlap grid. Options
are:
- 'whole': Any grid cell with its center inside the
aperture is set to the area of the grid cell. All
others set to 0.
- 'fractional': Perform the detailed calculation of
the fraction of each grid-cell within the
aperture.
Returns:
`numpy.ndarray`_: An array with shape :math:`(N_x, N_y)`
with the fraction of each grid cell covered by the
aperture.
Raises:
ValueError:
Raised if the provided arguments are not regularly
spaced, or if there aren't at least 2 grid points in
each dimension.
"""
# Check input
if len(x) < 2 or len(y) < 2:
raise ValueError('Must provide at least 2 points per grid point.')
minimum_x_difference = 0 if numpy.issubdtype(x.dtype, numpy.integer) \
else numpy.finfo(x.dtype).eps*100
minimum_y_difference = 0 if numpy.issubdtype(y.dtype, numpy.integer) \
else numpy.finfo(y.dtype).eps*100
if numpy.any(numpy.absolute(numpy.diff(numpy.diff(x))) > minimum_x_difference):
raise ValueError('X coordinates are not regular to numerical precision.')
if numpy.any(numpy.absolute(numpy.diff(numpy.diff(y))) > minimum_y_difference):
raise ValueError('Y coordinates are not regular to numerical precision.')
# Grid shape
nx = len(x)
ny = len(y)
# Get the cell size
dx = abs(x[1]-x[0])
dy = abs(y[1]-y[0])
cell_area = dx*dy
if method == 'whole':
# Only include whole pixels
# X,Y = map(lambda x : x.ravel(), numpy.meshgrid(x, y))
# img = numpy.array(list(map(lambda x: self.shape.contains(Point(x[0],x[1])),
# zip(X,Y)))).reshape(ny,nx).astype(int)/cell_area
# Build the coordinate of the pixel centers
coo = numpy.array(list(map(lambda x : x.ravel(), numpy.meshgrid(x, y)))).T
# Find the pixels with their centers inside the shape
img = point_inside_polygon(self.vertices(), coo).reshape(ny,nx).astype(int)/cell_area
# Return after adjusting to match the defined area
return img * (self.area/numpy.sum(img)/cell_area)
elif method == 'fractional':
# Allow for fractional pixels by determining the overlap
# between the shape and each grid cell
# # Build the cell polygons
# cells, sx, ex, sy, ey = self._overlapping_grid_polygons(x, y)
#
# # Construct a grid with the fractional area covered by the
# # aperture
# img = numpy.zeros((len(y), len(x)), dtype=float)
# img[sy:ey,sx:ex] = numpy.array(list(map(lambda x: self.shape.intersection(x).area,
# cells))).reshape(ey-sy,ex-sx)/cell_area
# return img * (self.area/numpy.sum(img)/cell_area)
# NOTE: This is much faster than the above
sx, ex, _, sy, ey, _ = self._overlapping_region(x,y)
X,Y = map(lambda x : x.ravel(), numpy.meshgrid(x[sx:ex], y[sy:ey]))
# Get the points describing the corners of each overlapping grid cell
cx = X[:,None] + (numpy.array([-0.5,0.5,0.5,-0.5])*dx)[None,:]
cy = Y[:,None] + (numpy.array([-0.5,-0.5,0.5,0.5])*dy)[None,:]
cells = numpy.append(cx, cy, axis=1).reshape(-1,2,4).transpose(0,2,1).reshape(-1,2)
# cells has shape (ncell*4,2)
inside_shape = point_inside_polygon(self.vertices(), cells).reshape(-1,4)
indx = numpy.all(inside_shape, axis=1)
_img = indx.astype(float)
intersect = numpy.any(inside_shape, axis=1) & numpy.invert(indx)
_img[intersect] = numpy.array(list(map(lambda x:
self.shape.intersection(asPolygon(x)).area,
cells.reshape(-1,4,2)[intersect,...])))/cell_area
img = numpy.zeros((len(y), len(x)), dtype=float)
img[sy:ey,sx:ex] = _img.reshape(ey-sy,ex-sx)
return img * (self.area/numpy.sum(img)/cell_area)
raise ValueError('Unknown response method {0}.'.format(method))
def main():
gdal.AllRegister()
path = auxil.select_directory('Choose input directory')
if path:
os.chdir(path)
# input image
infile = auxil.select_infile(title='Choose image file')
if infile:
inDataset = gdal.Open(infile,GA_ReadOnly)
cols = inDataset.RasterXSize
rows = inDataset.RasterYSize
bands = inDataset.RasterCount
projection = inDataset.GetProjection()
geotransform = inDataset.GetGeoTransform()
if geotransform is not None:
gt = list(geotransform)
else:
print 'No geotransform available'
return
imsr = osr.SpatialReference()
imsr.ImportFromWkt(projection)
else:
return
pos = auxil.select_pos(bands)
if not pos:
return
N = len(pos)
rasterBands = []
for b in pos:
rasterBands.append(inDataset.GetRasterBand(b))
# training data (shapefile)
trnfile = auxil.select_infile(filt='.shp',title='Choose train shapefile')
if trnfile:
trnDriver = ogr.GetDriverByName('ESRI Shapefile')
trnDatasource = trnDriver.Open(trnfile,0)
trnLayer = trnDatasource.GetLayer()
trnsr = trnLayer.GetSpatialRef()
else:
return
# hidden neurons
L = auxil.select_integer(8,'number of hidden neurons')
if not L:
return
# outfile
outfile, fmt = auxil.select_outfilefmt()
if not outfile:
return
# coordinate transformation from training to image projection
ct= osr.CoordinateTransformation(trnsr,imsr)
# number of classes
feature = trnLayer.GetNextFeature()
while feature:
classid = feature.GetField('CLASS_ID')
feature = trnLayer.GetNextFeature()
trnLayer.ResetReading()
K = int(classid)+1
print '========================='
print ' ffncg'
print '========================='
print time.asctime()
print 'image: '+infile
print 'training: '+trnfile
# loop through the polygons
Gs = [] # train observations
ls = [] # class labels
print 'reading training data...'
for i in range(trnLayer.GetFeatureCount()):
feature = trnLayer.GetFeature(i)
classid = feature.GetField('CLASS_ID')
l = [0 for i in range(K)]
l[int(classid)] = 1.0
polygon = feature.GetGeometryRef()
# transform to same projection as image
polygon.Transform(ct)
# convert to a Shapely object
poly = shapely.wkt.loads(polygon.ExportToWkt())
# transform the boundary to pixel coords in numpy
bdry = np.array(poly.boundary)
bdry[:,0] = bdry[:,0]-gt[0]
bdry[:,1] = bdry[:,1]-gt[3]
GT = np.mat([[gt[1],gt[2]],[gt[4],gt[5]]])
bdry = bdry*np.linalg.inv(GT)
# polygon in pixel coords
polygon1 = asPolygon(bdry)
# raster over the bounding rectangle
minx,miny,maxx,maxy = map(int,list(polygon1.bounds))
pts = []
for i in range(minx,maxx+1):
for j in range(miny,maxy+1):
pts.append((i,j))
multipt = MultiPoint(pts)
# intersection as list
intersection = np.array(multipt.intersection(polygon1),dtype=np.int).tolist()
# cut out the bounded image cube
cube = np.zeros((maxy-miny+1,maxx-minx+1,len(rasterBands)))
k=0
for band in rasterBands:
cube[:,:,k] = band.ReadAsArray(minx,miny,maxx-minx+1,maxy-miny+1)
k += 1
# get the training vectors
for (x,y) in intersection:
Gs.append(cube[y-miny,x-minx,:])
ls.append(l)
polygon = None
polygon1 = None
feature.Destroy()
trnDatasource.Destroy()
m = len(ls)
print str(m) + ' training pixel vectors were read in'
Gs = np.array(Gs)
ls = np.array(ls)
# stretch the pixel vectors to [-1,1]
maxx = np.max(Gs,0)
minx = np.min(Gs,0)
for j in range(N):
Gs[:,j] = 2*(Gs[:,j]-minx[j])/(maxx[j]-minx[j]) - 1.0
# random permutation of training data
idx = np.random.permutation(m)
Gs = Gs[idx,:]
ls = ls[idx,:]
# setup output dataset
driver = gdal.GetDriverByName(fmt)
outDataset = driver.Create(outfile,cols,rows,1,GDT_Byte)
projection = inDataset.GetProjection()
geotransform = inDataset.GetGeoTransform()
if geotransform is not None:
outDataset.SetGeoTransform(tuple(gt))
if projection is not None:
outDataset.SetProjection(projection)
outBand = outDataset.GetRasterBand(1)
# train on 9/10 training examples
Gstrn = Gs[0:9*m//10,:]
lstrn = ls[0:9*m//10,:]
affn = Ffncg(Gstrn,lstrn,L)
print 'training on %i pixel vectors...' % np.shape(Gstrn)[0]
start = time.time()
cost = affn.train(epochs=epochs)
print 'elapsed time %s' %str(time.time()-start)
if cost is not None:
# cost = np.log10(cost)
ymax = np.max(cost)
ymin = np.min(cost)
xmax = len(cost)
plt.plot(range(xmax),cost,'k')
plt.axis([0,xmax,ymin-1,ymax])
plt.title('Cross entropy')
plt.xlabel('Epoch')
# classify the image
print 'classifying...'
tile = np.zeros((cols,N))
for row in range(rows):
for j in range(N):
tile[:,j] = rasterBands[j].ReadAsArray(0,row,cols,1)
tile[:,j] = 2*(tile[:,j]-minx[j])/(maxx[j]-minx[j]) - 1.0
cls, _ = affn.classify(tile)
outBand.WriteArray(np.reshape(cls,(1,cols)),0,row)
outBand.FlushCache()
outDataset = None
inDataset = None
print 'thematic map written to: ' + outfile
print 'please close the cross entropy plot to continue'
plt.show()
else:
print 'an error occured'
return
print 'submitting cross-validation to multyvac'
start = time.time()
jid = mv.submit(traintst,Gs,ls,L,_layer='ms_image_analysis')
print 'submission time: %s' %str(time.time()-start)
start = time.time()
job = mv.get(jid)
result = job.get_result(job)
print 'execution time: %s' %str(time.time()-start)
print 'misclassification rate: %f' %np.mean(result)
print 'standard deviation: %f' %np.std(result)
print '--------done---------------------'
def calculate(self, k=3):
"""
Calculates the convex hull of the data set as an array of points
:param k: Number of nearest neighbors
:return: Array of points (N, 2) with the concave hull of the data set
"""
if self.data_set.shape[0] < 3:
return None
if self.data_set.shape[0] == 3:
return self.data_set
# Make sure that k neighbors can be found
kk = min(k, self.data_set.shape[0])
first_point = self.get_lowest_latitude_index(self.data_set)
current_point = first_point
# Note that hull and test_hull are matrices (N, 2)
hull = np.reshape(np.array(self.data_set[first_point, :]), (1, 2))
test_hull = hull
# Remove the first point
self.indices[first_point] = False
prev_angle = 270 # Initial reference id due west. North is zero, measured clockwise.
step = 2
stop = 2 + kk
while ((current_point != first_point) or
(step == 2)) and len(self.indices[self.indices]) > 0:
if step == stop:
self.indices[first_point] = True
knn = self.get_k_nearest(current_point, kk)
# Calculates the headings between first_point and the knn points
# Returns angles in the same indexing sequence as in knn
angles = self.calculate_headings(current_point, knn, prev_angle)
# Calculate the candidate indexes (largest angles first)
candidates = np.argsort(-angles)
i = 0
invalid_hull = True
while invalid_hull and i < len(candidates):
candidate = candidates[i]
# Create a test hull to check if there are any self-intersections
next_point = np.reshape(self.data_set[knn[candidate]], (1, 2))
test_hull = np.append(hull, next_point, axis=0)
line = asLineString(test_hull)
invalid_hull = not line.is_simple
i += 1
if invalid_hull:
return self.recurse_calculate()
# prev_angle = self.calculate_headings(current_point, np.array([knn[candidate]]))
prev_angle = self.calculate_headings(knn[candidate],
np.array([current_point]))
current_point = knn[candidate]
hull = test_hull
# write_line_string(hull)
self.indices[current_point] = False
step += 1
poly = asPolygon(hull)
count = 0
total = self.data_set.shape[0]
for ix in range(total):
pt = asPoint(self.data_set[ix, :])
if poly.intersects(pt) or pt.within(poly):
count += 1
else:
d = poly.distance(pt)
if d < 1e-5:
count += 1
if count == total:
return hull
else:
return self.recurse_calculate()
def show_polygon(ax, polygon, facecolor=None, alpha=1.):
ax.add_artist(
PolygonPatch(geom.asPolygon(polygon),
facecolor=facecolor,
alpha=alpha))
def main():
usage = '''
Usage:
---------------------------------------------------------
python %s [-p bandPositions] [- a algorithm] [-L number of hidden neurons]
[-P generate class probabilities image] filename trainShapefile
bandPositions is a list, e.g., -p [1,2,4]
algorithm 1=MaxLike
2=NNet(backprop)
3=NNet(congrad)
4=SVM
If the input file is named
path/filenbasename.ext then
The output classification file is named
path/filebasename_class.ext
the class probabilities output file is named
path/filebasename_classprobs.ext
and the test results file is named
path/filebasename_<classifier>.tst
--------------------------------------------------------''' %sys.argv[0]
options, args = getopt.getopt(sys.argv[1:],'hnPp:a:L:')
pos = None
probs = False
L = 8
graphics = True
trainalg = 1
for option, value in options:
if option == '-h':
print usage
return
elif option == '-p':
pos = eval(value)
elif option == '-n':
graphics = False
elif option == '-a':
trainalg = eval(value)
elif option == '-L':
L = eval(value)
elif option == '-P':
probs = True
if len(args) != 2:
print 'Incorrect number of arguments'
print usage
sys.exit(1)
if trainalg == 1:
algorithm = 'MaxLike'
elif trainalg == 2:
algorithm = 'NNet(Backprop)'
elif trainalg == 3:
algorithm = 'NNet(Congrad)'
elif trainalg == 4:
algorithm = 'SVM'
infile = args[0]
trnfile = args[1]
gdal.AllRegister()
if infile:
inDataset = gdal.Open(infile,GA_ReadOnly)
cols = inDataset.RasterXSize
rows = inDataset.RasterYSize
bands = inDataset.RasterCount
projection = inDataset.GetProjection()
geotransform = inDataset.GetGeoTransform()
if geotransform is not None:
gt = list(geotransform)
else:
print 'No geotransform available'
return
imsr = osr.SpatialReference()
imsr.ImportFromWkt(projection)
else:
return
if pos is None:
pos = range(1,bands+1)
N = len(pos)
rasterBands = []
for b in pos:
rasterBands.append(inDataset.GetRasterBand(b))
# output files
path = os.path.dirname(infile)
basename = os.path.basename(infile)
root, ext = os.path.splitext(basename)
outfile = '%s/%s_class%s'%(path,root,ext)
tstfile = '%s/%s_%s.tst'%(path,root,algorithm)
if (trainalg in (2,3,4)) and probs:
# class probabilities file
probfile = '%s/%s_classprobs%s'%(path,root,ext)
else:
probfile = None
# training data
trnDriver = ogr.GetDriverByName('ESRI Shapefile')
trnDatasource = trnDriver.Open(trnfile,0)
trnLayer = trnDatasource.GetLayer()
trnsr = trnLayer.GetSpatialRef()
# coordinate transformation from training to image projection
ct = osr.CoordinateTransformation(trnsr,imsr)
# number of classes
K = 1
feature = trnLayer.GetNextFeature()
while feature:
classid = feature.GetField('CLASS_ID')
if int(classid)>K:
K = int(classid)
feature = trnLayer.GetNextFeature()
trnLayer.ResetReading()
K += 1
# es kann losgehen
print '========================='
print 'supervised classification'
print '========================='
print time.asctime()
print 'image: '+infile
print 'training: '+trnfile
print 'algorithm: '+algorithm
# loop through the polygons
Gs = [] # train observations
ls = [] # class labels
classnames = '{unclassified'
classids = set()
print 'reading training data...'
for i in range(trnLayer.GetFeatureCount()):
feature = trnLayer.GetFeature(i)
classid = str(feature.GetField('CLASS_ID'))
classname = feature.GetField('CLASS_NAME')
if classid not in classids:
classnames += ', '+ classname
classids = classids | set(classid)
# label for this ROI
l = [0 for i in range(K)]
l[int(classid)] = 1.0
polygon = feature.GetGeometryRef()
# transform to same projection as image
polygon.Transform(ct)
# convert to a Shapely object
poly = shapely.wkt.loads(polygon.ExportToWkt())
# transform the boundary to pixel coords in numpy
bdry = np.array(poly.boundary)
bdry[:,0] = bdry[:,0]-gt[0]
bdry[:,1] = bdry[:,1]-gt[3]
GT = np.mat([[gt[1],gt[2]],[gt[4],gt[5]]])
bdry = bdry*np.linalg.inv(GT)
# polygon in pixel coords
polygon1 = asPolygon(bdry)
# raster over the bounding rectangle
minx,miny,maxx,maxy = map(int,list(polygon1.bounds))
pts = []
for i in range(minx,maxx+1):
for j in range(miny,maxy+1):
pts.append((i,j))
multipt = MultiPoint(pts)
# intersection as list
intersection = np.array(multipt.intersection(polygon1),dtype=np.int).tolist()
# cut out the bounded image cube
cube = np.zeros((maxy-miny+1,maxx-minx+1,len(rasterBands)))
k=0
for band in rasterBands:
cube[:,:,k] = band.ReadAsArray(minx,miny,maxx-minx+1,maxy-miny+1)
k += 1
# get the training vectors
for (x,y) in intersection:
Gs.append(cube[y-miny,x-minx,:])
ls.append(l)
polygon = None
polygon1 = None
feature.Destroy()
trnDatasource.Destroy()
classnames += '}'
m = len(ls)
print str(m) + ' training pixel vectors were read in'
Gs = np.array(Gs)
ls = np.array(ls)
# stretch the pixel vectors to [-1,1] (for ffn)
maxx = np.max(Gs,0)
minx = np.min(Gs,0)
for j in range(N):
Gs[:,j] = 2*(Gs[:,j]-minx[j])/(maxx[j]-minx[j]) - 1.0
# random permutation of training data
idx = np.random.permutation(m)
Gs = Gs[idx,:]
ls = ls[idx,:]
# setup output datasets
driver = inDataset.GetDriver()
outDataset = driver.Create(outfile,cols,rows,1,GDT_Byte)
projection = inDataset.GetProjection()
geotransform = inDataset.GetGeoTransform()
if geotransform is not None:
outDataset.SetGeoTransform(tuple(gt))
if projection is not None:
outDataset.SetProjection(projection)
outBand = outDataset.GetRasterBand(1)
if probfile:
probDataset = driver.Create(probfile,cols,rows,K,GDT_Byte)
if geotransform is not None:
probDataset.SetGeoTransform(tuple(gt))
if projection is not None:
probDataset.SetProjection(projection)
probBands = []
for k in range(K):
probBands.append(probDataset.GetRasterBand(k+1))
# initialize classifier
if trainalg == 1:
classifier = sc.Maxlike(Gs,ls)
elif trainalg == 2:
classifier = sc.Ffnbp(Gs,ls,L)
elif trainalg == 3:
classifier = sc.Ffncg(Gs,ls,L)
elif trainalg == 4:
classifier = sc.Svm(Gs,ls)
# train it
print 'training on %i pixel vectors...' % np.shape(Gs)[0]
start = time.time()
result = classifier.train()
print 'elapsed time %s' %str(time.time()-start)
if result:
if (trainalg in [2,3]) and graphics:
cost = np.log10(result)
ymax = np.max(cost)
ymin = np.min(cost)
xmax = len(cost)
plt.plot(range(xmax),cost,'k')
plt.axis([0,xmax,ymin-1,ymax])
plt.title('Log(Cross entropy)')
plt.xlabel('Epoch')
plt.show()
# classify the image
print 'classifying...'
start = time.time()
tile = np.zeros((cols,N),dtype=np.float32)
for row in range(rows):
for j in range(N):
tile[:,j] = rasterBands[j].ReadAsArray(0,row,cols,1)
tile[:,j] = 2*(tile[:,j]-minx[j])/(maxx[j]-minx[j]) - 1.0
cls, Ms = classifier.classify(tile)
outBand.WriteArray(np.reshape(cls,(1,cols)),0,row)
if probfile:
Ms = np.byte(Ms*255)
for k in range(K):
probBands[k].WriteArray(np.reshape(Ms[k,:],(1,cols)),0,row)
outBand.FlushCache()
print 'elapsed time %s' %str(time.time()-start)
outDataset = None
inDataset = None
if probfile:
for probBand in probBands:
probBand.FlushCache()
probDataset = None
print 'class probabilities written to: %s'%probfile
K = ls.shape[1]+1
print 'thematic map written to: %s'%outfile
else:
print 'an error occured'
return
# cross-validation
start = time.time()
rc = Client()
print 'submitting cross-validation to %i IPython engines'%len(rc)
m = np.shape(Gs)[0]
traintest = []
for i in range(10):
sl = slice(i*m//10,(i+1)*m//10)
traintest.append( (np.delete(Gs,sl,0),np.delete(ls,sl,0), \
Gs[sl,:],ls[sl,:],L,trainalg) )
v = rc[:]
v.execute('import auxil.supervisedclass as sc')
result = v.map(crossvalidate,traintest).get()
print 'parallel execution time: %s' %str(time.time()-start)
print 'misclassification rate: %f' %np.mean(result)
print 'standard deviation: %f' %np.std(result)
def setup(self, *, map_size_x=map_size_x, map_size_y=map_size_y, n_obstacles=0, reset_always=True,
max_timestep=1000, threshold_dist=40, threshold_vel=4, reward_sparsity=True):
self.map_size_x = 160
self.map_size_y = 240
self.map_min_x = - self.map_size_x * 0.1
self.map_min_y = - self.map_size_y * 0.1
self.map_max_x = self.map_size_x * 1.1
self.map_max_y = self.map_size_y * 1.1
self.reset_always = False
self.max_timestep = 1500
self.threshold_dist = 15
self.threshold_vel = 4
self.n_obstacles = 9
# True is sparse reward, False is a dense reward
self.reward_sparsity = reward_sparsity
self.dense_reward = not reward_sparsity
self.get_observation = self.get_airsim_observation
self._take_action = self._airsim_action # Discrete cartesian
# Obstacles of the block env
scaled_points = \
[[160., 0., 140., 20.],
[20., 0., 0., 20.],
[30., 60., 20., 70.],
[130., 52.5, 110., 70.],
[80., 80., 60., 100.],
[160., 100., 120., 140.],
[80., 140., 60., 160.],
[30., 170., 20., 180.],
[130., 170., 110., 190.],
[160., 220., 140., 240.],
[20., 220., 0., 240.]]
for obstacle in scaled_points:
x0, y0 = obstacle[2], obstacle[1]
w = obstacle[0] - obstacle[2]
h = obstacle[3] - obstacle[1]
p1, p2, p3, p4 = [(x0, y0), (x0 + w, y0), (x0 + w, y0 + h), (x0, y0 + h)]
# print([(x0, y0), (x0 + w, y0), (x0 + w, y0 + h), (x0, y0 + h)])
self.add_obstacle(asPolygon([p1, p2, p3, p4]))
# Added these 2 lines to reduce number of polys and increase performance
# self.obstacles = cascaded_union(self.obstacles)
# self.prep_obstacles = [prep(polygon) for polygon in self.obstacles]
self.prep_obstacles = self.obstacles
self.generate_map()
self.s['origin_x'], self.s['origin_y'] = [35.], [117.39583333] # Scaled old [0, 0]
self.s['target_x'], self.s['target_y'] = [35.], [117.39583333] # Scaled old [0, 0]
self.client = MultirotorClient()
self.client.confirmConnection()
self.client.enableApiControl(True)
self.client.armDisarm(True)
self.move_to(35. , 117.39583333)
self.client.hover()
