def WriteExpect(expected):
# fname = tempfile.mktemp(dir=tempfile.gettempdir(), suffix='.opl')
fname = './aaa.osm'
writer = osmium.SimpleWriter(fname)
try:
yield writer
finally:
writer.close()
def _WriteExpect(filename, expected):
writer = o.SimpleWriter(str(filename), 1024*1024)
try:
yield writer
finally:
writer.close()
assert filename.read_text().strip() == expected
def __init__(self, out_path):
"""
Writes nodes, ways (and relations) to a user defined OSM file.
:param out_path: Full path for the output file. The file ending determines the file format, .xml/.pbf.
:type out_path: str
"""
super(OSMWriter, self).__init__()
self.writer = osmium.SimpleWriter(str(out_path))
def write_data(filename, nodes, ways, ex=0.002):
delete_file(filename)
writer = osmium.SimpleWriter(filename)
for n in nodes:
writer.add_node(n)
for w in ways:
writer.add_way(w)
writer.close()
min_lat, min_lon, max_lat, max_lon = get_bounds(nodes, ex)
insert_bounds(filename, min_lat, min_lon, max_lat, max_lon)
def main():
if len(sys.argv) != 3:
print("Usage: python %s <infile> <outfile>" % sys.argv[0])
sys.exit(-1)
infile = sys.argv[1]
outfile = sys.argv[2]
writer = osmium.SimpleWriter(outfile)
handler = GPXHandler(writer)
handler.apply_file(infile)
writer.close()
def WriteExpect(expected):
fname = tempfile.mktemp(dir='/tmp', suffix='.opl')
writer = o.SimpleWriter(fname, 1024 * 1024)
try:
yield writer
finally:
writer.close()
with open(fname, 'r') as fd:
line = fd.readline().strip()
assert_equals(line, expected)
os.remove(fname)
def write(self, include_existing=False):
"""Generates file with new/modified and optionally existing data"""
writer = osmium.SimpleWriter(self.filename)
for node in self.nodes:
if include_existing or node.id < 0:
writer.add_node(node)
for way in self.ways:
if getattr(way, 'modified',
False) or include_existing or way.id < 0:
writer.add_way(way)
for rel in self.relations:
if include_existing or rel.id < 0:
writer.add_relation(rel)
writer.close()
def sort_and_write_to_osm_file(self, osm_file_name):
writer = osmium.SimpleWriter(osm_file_name)
nodes, ways, relations = self.batch_manager.get_batches_values_sorted_lists()
for dependency_way in ways:
writer.add_way(elements_transformer.get_osm_way_from_dict(dependency_way))
for dependency_node in nodes:
writer.add_node(elements_transformer.get_osm_node_from_dict(dependency_node))
for dependency_relation in relations:
try:
writer.add_relation(elements_transformer.get_osm_relation_from_dict(dependency_relation))
except Exception as e:
logging.info(dependency_relation)
raise e
writer.close()
def main():
if len(sys.argv) != 3:
print("Usage: python %s <infile> <outfile>" % sys.argv[0])
sys.exit(-1)
infile = sys.argv[1]
outfile = sys.argv[2]
nknetwork_loader = HknetworkLoader()
nknetwork_loader.apply_file('hknetworks.osm')
national_park_loader = NationalParkLoader()
national_park_loader.apply_file('national_park.osm')
writer = osmium.SimpleWriter(outfile)
mapsforge_handler = MapsforgeHandler(writer)
mapsforge_handler.apply_file(infile)
writer.close()
def main():
if len(sys.argv) != 3:
print("Usage: python OSM_parser.py <infile> <outfile>")
sys.exit(-1)
# go through the ways to find all relevant nodes
ways = WaterwayFilter()
ways.apply_file(sys.argv[1])
# go through the file again and write out the data
writer = o.SimpleWriter(sys.argv[2])
WaterwayWriter(writer, ways.nodes).apply_file(sys.argv[1])
writer.close()
nodes = WaterwayCollector(ways.nodes)
nodes.apply_file(sys.argv[2])
boundFinder = BoundsFinder(sys.argv[1])
boundFinder.find()
def to_osm_pbf(self, pbf_path="data/data.osm.pbf", overwrite=True):
counter = defaultdict(int)
if overwrite and os.path.exists(pbf_path):
os.remove(pbf_path)
writer = osmium.SimpleWriter(pbf_path)
for node in self.nodes.values():
writer.add_node(node.to_osm())
counter["nodes"] += 1
for edge in self.edges.values():
writer.add_way(edge.to_osm_way())
counter["ways"] += 1
for relation in getattr(self, "relations", {}).values():
writer.add_relation(relation.to_osm())
counter["relations"] += 1
writer.close()
if __name__ == '__main__':
start = timeit.default_timer()
parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('-o',
dest='filename',
type=argparse.FileType('r', encoding='UTF-8'),
default="../../volumes/next.osm",
help='name of osm file')
args = parser.parse_args()
filename = args.filename.name
print(filename)
outfile = filename + 'out.osm'
if os.path.exists(outfile):
os.remove(outfile)
writer = osmium.SimpleWriter(outfile)
h = CounterHandler(writer)
h.apply_file(filename, locations=True, idx='flex_mem')
print("Number of nodes: %d" % h.num_nodes)
print("Number of ways : %d" % h.num_ways)
print("Number of rels : %d" % h.num_rels)
stop = timeit.default_timer()
print('Time: ', stop - start)
import sys
class Convert(o.SimpleHandler):
def __init__(self, writer):
o.SimpleHandler.__init__(self)
self.writer = writer
def node(self, n):
self.writer.add_node(n)
def way(self, w):
self.writer.add_way(w)
def relation(self, r):
self.writer.add_relation(r)
if __name__ == '__main__':
if len(sys.argv) != 3:
print("Usage: python convert.py <infile> <outfile>")
sys.exit(-1)
writer = o.SimpleWriter(sys.argv[2])
handler = Convert(writer)
handler.apply_file(sys.argv[1])
writer.close()
sfrom = '/home/pengfei/Europe/europe-latest-transport.osm.pbf'
sto = '/home/pengfei/Europe/europe-latest-transport-station.osm.pbf'
#sfrom = '/run/media/pengfei/OTHERS/OSMData/China/china-latest-transport.osm.pbf'
#sto = '/run/media/pengfei/OTHERS/OSMData/China/china-latest-transport-station.osm.pbf'
t1 = time.time()
print("Start to extract railway stations..")
tf = RelationFilter()
tf.apply_file(sfrom)
print("RelationFilter finish, R:%d W:%d N:%d"%(len(keepd["r"]),len(keepd["w"]),len(keepd["n"])))
print("Time used: %ds"%int(time.time()-t1))
tf = WayFilter()
tf.apply_file(sfrom)
print("WayFilter finish, R:%d W:%d N:%d"%(len(keepd["r"]),len(keepd["w"]),len(keepd["n"])))
print("Time used: %ds"%int(time.time()-t1))
tf = NodeFilter()
tf.apply_file(sfrom)
print("NodeFilter finish, R:%d W:%d N:%d"%(len(keepd["r"]),len(keepd["w"]),len(keepd["n"])))
print("Time used: %ds"%int(time.time()-t1))
#try:
# os.remove(sto)
#except OSError:
# pass
writer = o.SimpleWriter(sto)
handler = Convert(writer)
handler.apply_file(sfrom)
writer.close()
class Convert(o.SimpleHandler):
def __init__(self, writer):
super(Convert, self).__init__()
self.writer = writer
def node(self, n):
self.writer.add_node(n)
def way(self, w):
self.writer.add_way(w)
def relation(self, r):
self.writer.add_relation(r)
if __name__ == '__main__':
in_osm = './test.osm'
out_osm = './new_test.osm'
if os.path.isfile(out_osm):
os.remove(out_osm)
writer = o.SimpleWriter(out_osm)
handler = Convert(writer)
handler.apply_file(in_osm)
writer.close()
import osmium as osm
# Class xuất dữ liệu ra file OSM, PBF
class WriteTag(osm.SimpleHandler):
def __init__(self, writer):
super(WriteTag, self).__init__()
self.writer = writer
#hàm xuất dữ liệu node
def node(self, o):
self.writer.add_node(o)
#hàm xuất dữ liệu way
def way(self, o):
self.writer.add_way(processor.AddTag().add_tag(o))
#hàm xuất dữ liệu relation
def relation(self, o):
self.writer.add_relation(o)
if __name__ == '__main__':
# path to the output file (OSM or PBF)
writer = osm.SimpleWriter("VN1.osm")
# path to the input file (PBF)
WriteTag(writer).apply_file("VN.osm")
writer.close()
print("Write Success!")
import osmium as o
input_file = 'ontario-latest.osm.pbf'
output_file = '3-input-ontario-nwr.osm'
class Convert(o.SimpleHandler):
def __init__(self, writer):
super(Convert, self).__init__()
self.writer = writer
def node(self, n):
self.writer.add_node(n)
def way(self, w):
self.writer.add_way(w)
def relation(self, r):
self.writer.add_relation(r)
if os.path.isfile(output_file):
print('File with name output_file already exists.')
else:
writer = o.SimpleWriter(output_file)
handler = Convert(writer)
handler.apply_file(input_file)
writer.close()
print('Done.')
parser.add_argument('--min_lng',
type=float,
default=116.2810,
help='the min lng of the interested region')
parser.add_argument('--max_lat',
type=float,
default=39.9890,
help='the max lat of the interested region')
parser.add_argument('--max_lng',
type=float,
default=116.4684,
help='the max lng of the interested region')
parser.add_argument('--input_path',
help='the input path of the original osm data')
parser.add_argument('--output_path',
help='the output path of the clipped osm data')
opt = parser.parse_args()
print(opt)
# go through the ways to find all relevant nodes
nh = NodeRetrievingHandler(opt.min_lat, opt.min_lng, opt.max_lat,
opt.max_lng)
nh.apply_file(opt.input_path, locations=True)
# go through the file again and write out the data
writer = o.SimpleWriter(opt.output_path)
hh = HighwayRetrievingHandler(opt.min_lat, opt.min_lng, opt.max_lat,
opt.max_lng, nh.nodes, writer)
hh.apply_file(opt.input_path, locations=True)
writer.close()
def __init__(self, sections, stations, lines, output):
self._features = sections + stations
self.writer = osmium.SimpleWriter(output)
self.transport_modes_provider = TransportModesProvider(lines)
class Normalizer(osm.SimpleHandler):
def __init__(self, writer):
super(Normalizer, self).__init__()
self.writer = writer
def node(self, o):
self.writer.add_node(node_normalizer.NodeNormalizer().normalize(o))
def way(self, o):
# polygons
if "addr:street" in o.tags:
self.writer.add_way(node_normalizer.NodeNormalizer().normalize(o))
# streets
else:
self.writer.add_way(
street_normalizer.StreetNormalizer().normalize(o))
def relation(self, o):
self.writer.add_relation(o)
if __name__ == '__main__':
# path to the output file (OSM or PBF)
# writer = osm.SimpleWriter("/home/likk/data/vietnam-normalizer.osm")
writer = osm.SimpleWriter("/home/likk/data/vietnam-normalizer.osm.pbf")
# path to the input file (PBF)
Normalizer(writer).apply_file("/home/likk/data/vietnam.osm.pbf")
writer.close()
print('done!')
self.writer.add_node(n)
except:
pass
def way_centroid(self, w):
nodes_lnglat = list(
wkt.loads(wkt_factory.create_linestring(w.nodes)).coords)
nodes_xy = list(itransform(p1, p2, nodes_lnglat, switch=True))
centroid_xy = LineString(nodes_xy).centroid
centroid_xy = Point(round(centroid_xy.x, 7), round(centroid_xy.y, 7))
return centroid_xy
def way(self, w):
try:
way_centroid_point_xy = self.way_centroid(w)
if way_centroid_point_xy.within(boundary_poly_xy):
self.writer.add_way(w)
except:
pass
if os.path.isfile(output_subregion_osm_data):
print('File with name output_subregion_osm_data already exists.')
else:
wkt_factory = o.geom.WKTFactory()
writer = o.SimpleWriter(output_subregion_osm_data)
h = DataWriter(writer)
h.apply_file(input_osm_data, locations=True)
writer.close()
print('Done.')
self.writer.add_node(node)
def way(self, way):
self.writer.add_way(way)
def relation(self, relation):
print('relation')
self.writer.add_relation(relation)
if (__name__ == "__main__"):
input_file = 'data/greater-london-input.osm.pbf'
output_file = 'data/greater-london-output.osm.pbf'
writer = osmium.SimpleWriter(output_file)
idx = osmium.index.create_map(
'sparse_file_array,data/node-cache.nodecache')
handler = Handler(idx, writer)
locations = osmium.NodeLocationsForWays(idx)
locations.ignore_errors()
nodes = osmium.io.Reader(input_file, osmium.osm.osm_entity_bits.NODE)
osmium.apply(nodes, locations, handler)
nodes.close()
ways = osmium.io.Reader(input_file, osmium.osm.osm_entity_bits.WAY)
osmium.apply(ways, handler)
ways.close()
