def grs_vect_selbyarea(osmdb, polyTbl, UPPER=True, apidb='SQLITE'): """ Select features with area upper than. A field with threshold is needed in the database. """ import datetime from gasp.gt.gop.genze import dissolve from gasp.gt.tbl.grs import add_table from gasp.sds.osm2lulc import GEOM_AREA from gasp.sql.i import row_num as cnt_row from gasp.gt.toshp.db import dbtbl_to_shp as db_to_shp OPERATOR = ">" if UPPER else "<" DIRECTION = "upper" if UPPER else "lower" WHR = "{ga} {op} t_area_{r} and area_{r} IS NOT NULL".format(op=OPERATOR, r=DIRECTION, ga=GEOM_AREA) # Check if we have interest data time_a = datetime.datetime.now().replace(microsecond=0) N = cnt_row(osmdb, polyTbl, where=WHR, api='psql' if apidb == 'POSTGIS' else 'sqlite') time_b = datetime.datetime.now().replace(microsecond=0) if not N: return None, {0: ('count_rows', time_b - time_a)} # Data to GRASS GIS grsVect = db_to_shp(osmdb, polyTbl, "geometry", "area_{}".format(DIRECTION), where=WHR, inDB='psql' if apidb == 'POSTGIS' else 'sqlite', filterByReg=True, outShpIsGRASS=True) time_c = datetime.datetime.now().replace(microsecond=0) dissVect = dissolve(grsVect, "diss_area_{}".format(DIRECTION), "area_{}".format(DIRECTION), api="grass") add_table(dissVect, None, lyrN=1, asCMD=True) time_d = datetime.datetime.now().replace(microsecond=0) return dissVect, { 0: ('count_rows', time_b - time_a), 1: ('import', time_c - time_b), 2: ('dissolve', time_d - time_c) }
def grs_vect_bbuffer(osmdata, lineTbl, api_db='SQLITE'): """ Basic Buffer strategie """ import datetime from gasp.gt.prox.bf import _buffer from gasp.gt.gop.genze import dissolve from gasp.gt.tbl.grs import add_table from gasp.sql.i import row_num as cnt_row from gasp.gt.toshp.db import dbtbl_to_shp as db_to_shp WHR = "basic_buffer IS NOT NULL" # Check if we have data time_a = datetime.datetime.now().replace(microsecond=0) N = cnt_row(osmdata, lineTbl, where=WHR, api='psql' if api_db == 'POSTGIS' else 'sqlite') time_b = datetime.datetime.now().replace(microsecond=0) if not N: return None, {0: ('count_rows_roads', time_b - time_a)} grsVect = db_to_shp(osmdata, lineTbl, "geometry", "bb_lnh", where=WHR, filterByReg=True, inDB='psql' if api_db == 'POSTGIS' else 'sqlite', outShpIsGRASS=True) time_c = datetime.datetime.now().replace(microsecond=0) grsBuf = _buffer(grsVect, "bf_basic_buffer", "bb_poly", api="grass", geom_type="line") time_d = datetime.datetime.now().replace(microsecond=0) grsDiss = dissolve(grsBuf, "bb_diss", "basic_buffer", api="grass") add_table(grsDiss, None, lyrN=1, asCMD=True) time_e = datetime.datetime.now().replace(microsecond=0) return grsDiss, { 0: ('count_rows', time_b - time_a), 1: ('import', time_c - time_b), 2: ('buffer', time_d - time_c), 3: ('dissolve', time_e - time_d) }
def grs_vector(db, polyTable, apidb='SQLITE'): """ Simple Selection using GRASS GIS """ import datetime from gasp.gt.gop.genze import dissolve from gasp.gt.tbl.grs import add_table from gasp.sql.i import row_num as cont_row from gasp.gt.toshp.db import dbtbl_to_shp as db_to_grs WHR = "selection IS NOT NULL" # Check if we have interest data time_a = datetime.datetime.now().replace(microsecond=0) N = cont_row(db, polyTable, where=WHR, api='psql' if apidb == 'POSTGIS' else 'sqlite' ) time_b = datetime.datetime.now().replace(microsecond=0) if not N: return None, {0 : ('count_rows', time_b - time_a)} # Data to GRASS GIS grsVect = db_to_grs( db, polyTable, "geometry", "sel_rule", where=WHR, filterByReg=True, inDB='psql' if apidb == 'POSTGIS' else 'sqlite', outShpIsGRASS=True ) time_c = datetime.datetime.now().replace(microsecond=0) dissVect = dissolve( grsVect, "diss_sel_rule", "selection", api="grass") add_table(dissVect, None, lyrN=1, asCMD=True) time_d = datetime.datetime.now().replace(microsecond=0) return dissVect, { 0 : ('count_rows', time_b - time_a), 1 : ('import', time_c - time_b), 2 : ('dissolve', time_d - time_c) }
def vector_based(osmdata, nomenclature, refRaster, lulcShp, overwrite=None, dataStore=None, RoadsAPI='POSTGIS'): """ Convert OSM Data into Land Use/Land Cover Information An vector based approach. TODO: Add a detailed description. RoadsAPI Options: * GRASS * SQLITE * POSTGIS """ # ************************************************************************ # # Python Modules from Reference Packages # # ************************************************************************ # import datetime import os import copy # ************************************************************************ # # GASP dependencies # # ************************************************************************ # from gasp.pyt.oss import fprop, mkdir from gasp.gt.wenv.grs import run_grass if RoadsAPI == 'POSTGIS': from gasp.sql.db import create_db from gasp.gql.to.osm import osm_to_psql from gasp.sql.db import drop_db from gasp.sql.fm import dump_db else: from gasp.gt.toshp.osm import osm_to_sqdb from gasp.sds.osm2lulc.utils import osm_project, add_lulc_to_osmfeat, get_ref_raster from gasp.gt.toshp.mtos import shps_to_shp from gasp.sds.osm2lulc.mod1 import grs_vector if RoadsAPI == 'SQLITE' or RoadsAPI == 'POSTGIS': from gasp.sds.osm2lulc.mod2 import roads_sqdb else: from gasp.sds.osm2lulc.mod2 import grs_vec_roads from gasp.sds.osm2lulc.m3_4 import grs_vect_selbyarea from gasp.sds.osm2lulc.mod5 import grs_vect_bbuffer from gasp.sds.osm2lulc.mod6 import vector_assign_pntags_to_build from gasp.gt.toshp.mtos import same_attr_to_shp from gasp.gt.prj import def_prj # ************************************************************************ # # Global Settings # # ************************************************************************ # # Check if input parameters exists! if not os.path.exists(os.path.dirname(lulcShp)): raise ValueError('{} does not exist!'.format(os.path.dirname(lulcShp))) if not os.path.exists(osmdata): raise ValueError( 'File with OSM DATA ({}) does not exist!'.format(osmdata)) if not os.path.exists(refRaster): raise ValueError( 'File with reference area ({}) does not exist!'.format(refRaster)) # Check if Nomenclature is valid nomenclature = "URBAN_ATLAS" if nomenclature != "URBAN_ATLAS" and \ nomenclature != "CORINE_LAND_COVER" and \ nomenclature == "GLOBE_LAND_30" else nomenclature time_a = datetime.datetime.now().replace(microsecond=0) # Create workspace for temporary files workspace = os.path.join(os.path.dirname(lulcShp), 'osmtolulc') if not dataStore else dataStore # Check if workspace exists if os.path.exists(workspace): if overwrite: mkdir(workspace) else: raise ValueError('Path {} already exists'.format(workspace)) else: mkdir(workspace) # Get Reference Raster refRaster, epsg = get_ref_raster(refRaster, workspace, cellsize=10) from gasp.sds.osm2lulc import osmTableData, PRIORITIES, LEGEND __priorities = PRIORITIES[nomenclature] __legend = LEGEND[nomenclature] time_b = datetime.datetime.now().replace(microsecond=0) if RoadsAPI != 'POSTGIS': # ******************************************************************** # # Convert OSM file to SQLITE DB # # ******************************************************************** # osm_db = osm_to_sqdb(osmdata, os.path.join(workspace, 'osm.sqlite')) else: # Convert OSM file to POSTGRESQL DB # osm_db = create_db(fprop(osmdata, 'fn', forceLower=True), overwrite=True) osm_db = osm_to_psql(osmdata, osm_db) time_c = datetime.datetime.now().replace(microsecond=0) # ************************************************************************ # # Add Lulc Classes to OSM_FEATURES by rule # # ************************************************************************ # add_lulc_to_osmfeat(osm_db, osmTableData, nomenclature, api='SQLITE' if RoadsAPI != 'POSTGIS' else RoadsAPI) time_d = datetime.datetime.now().replace(microsecond=0) # ************************************************************************ # # Transform SRS of OSM Data # # ************************************************************************ # osmTableData = osm_project( osm_db, epsg, api='SQLITE' if RoadsAPI != 'POSTGIS' else RoadsAPI, isGlobeLand=None if nomenclature != 'GLOBE_LAND_30' else True) time_e = datetime.datetime.now().replace(microsecond=0) # ************************************************************************ # # Start a GRASS GIS Session # # ************************************************************************ # grass_base = run_grass(workspace, grassBIN='grass78', location='grloc', srs=epsg) #import grass.script as grass import grass.script.setup as gsetup gsetup.init(grass_base, workspace, 'grloc', 'PERMANENT') # ************************************************************************ # # IMPORT SOME GASP MODULES FOR GRASS GIS # # ************************************************************************ # from gasp.gt.gop.ovlay import erase from gasp.gt.wenv.grs import rst_to_region from gasp.gt.gop.genze import dissolve from gasp.gt.tbl.grs import add_and_update, reset_table, update_table from gasp.gt.tbl.fld import add_fields from gasp.gt.toshp.cff import shp_to_grs, grs_to_shp from gasp.gt.torst import rst_to_grs # ************************************************************************ # # SET GRASS GIS LOCATION EXTENT # # ************************************************************************ # extRst = rst_to_grs(refRaster, 'extent_raster') rst_to_region(extRst) time_f = datetime.datetime.now().replace(microsecond=0) # ************************************************************************ # # MapResults # # ************************************************************************ # osmShps = [] # ************************************************************************ # # 1 - Selection Rule # # ************************************************************************ # ruleOneShp, timeCheck1 = grs_vector(osm_db, osmTableData['polygons'], apidb=RoadsAPI) osmShps.append(ruleOneShp) time_g = datetime.datetime.now().replace(microsecond=0) # ************************************************************************ # # 2 - Get Information About Roads Location # # ************************************************************************ # ruleRowShp, timeCheck2 = roads_sqdb( osm_db, osmTableData['lines'], osmTableData['polygons'], apidb=RoadsAPI ) if RoadsAPI == 'SQLITE' or RoadsAPI == 'POSTGIS' else grs_vec_roads( osm_db, osmTableData['lines'], osmTableData['polygons']) osmShps.append(ruleRowShp) time_h = datetime.datetime.now().replace(microsecond=0) # ************************************************************************ # # 3 - Area Upper than # # ************************************************************************ # if nomenclature != "GLOBE_LAND_30": ruleThreeShp, timeCheck3 = grs_vect_selbyarea(osm_db, osmTableData['polygons'], UPPER=True, apidb=RoadsAPI) osmShps.append(ruleThreeShp) time_l = datetime.datetime.now().replace(microsecond=0) else: timeCheck3 = None time_l = None # ************************************************************************ # # 4 - Area Lower than # # ************************************************************************ # if nomenclature != "GLOBE_LAND_30": ruleFourShp, timeCheck4 = grs_vect_selbyarea(osm_db, osmTableData['polygons'], UPPER=False, apidb=RoadsAPI) osmShps.append(ruleFourShp) time_j = datetime.datetime.now().replace(microsecond=0) else: timeCheck4 = None time_j = None # ************************************************************************ # # 5 - Get data from lines table (railway | waterway) # # ************************************************************************ # ruleFiveShp, timeCheck5 = grs_vect_bbuffer(osm_db, osmTableData["lines"], api_db=RoadsAPI) osmShps.append(ruleFiveShp) time_m = datetime.datetime.now().replace(microsecond=0) # ************************************************************************ # # 7 - Assign untagged Buildings to tags # # ************************************************************************ # if nomenclature != "GLOBE_LAND_30": ruleSeven11, ruleSeven12, timeCheck7 = vector_assign_pntags_to_build( osm_db, osmTableData['points'], osmTableData['polygons'], apidb=RoadsAPI) if ruleSeven11: osmShps.append(ruleSeven11) if ruleSeven12: osmShps.append(ruleSeven12) time_n = datetime.datetime.now().replace(microsecond=0) else: timeCheck7 = None time_n = datetime.datetime.now().replace(microsecond=0) # ************************************************************************ # # Produce LULC Map # # ************************************************************************ # """ Get Shps with all geometries related with one class - One Shape for Classe """ _osmShps = [] for i in range(len(osmShps)): if not osmShps[i]: continue _osmShps.append( grs_to_shp(osmShps[i], os.path.join(workspace, osmShps[i] + '.shp'), 'auto', lyrN=1, asCMD=True, asMultiPart=None)) for shp in _osmShps: def_prj(os.path.splitext(shp)[0] + '.prj', epsg=epsg, api='epsgio') _osmShps = same_attr_to_shp(_osmShps, "cat", workspace, "osm_", resultDict=True) del osmShps time_o = datetime.datetime.now().replace(microsecond=0) """ Merge all Classes into one feature class using a priority rule """ osmShps = {} for cls in _osmShps: if cls == '1': osmShps[1221] = shp_to_grs(_osmShps[cls], "osm_1221", asCMD=True) else: osmShps[int(cls)] = shp_to_grs(_osmShps[cls], "osm_" + cls, asCMD=True) # Erase overlapping areas by priority osmNameRef = copy.deepcopy(osmShps) for e in range(len(__priorities)): if e + 1 == len(__priorities): break if __priorities[e] not in osmShps: continue else: for i in range(e + 1, len(__priorities)): if __priorities[i] not in osmShps: continue else: osmShps[__priorities[i]] = erase( osmShps[__priorities[i]], osmShps[__priorities[e]], "{}_{}".format(osmNameRef[__priorities[i]], e), notTbl=True, api='pygrass') time_p = datetime.datetime.now().replace(microsecond=0) # Export all classes lst_merge = [] a = None for i in range(len(__priorities)): if __priorities[i] not in osmShps: continue if not a: reset_table(osmShps[__priorities[i]], { 'cls': 'varchar(5)', 'leg': 'varchar(75)' }, { 'cls': str(__priorities[i]), 'leg': str(__legend[__priorities[i]]) }) a = 1 else: add_and_update(osmShps[__priorities[i]], {'cls': 'varchar(5)'}, {'cls': str(__priorities[i])}) ds = dissolve(osmShps[__priorities[i]], 'dl_{}'.format(str(__priorities[i])), 'cls', api="grass") add_fields(ds, {'leg': 'varchar(75)'}, api="grass") update_table(ds, 'leg', str(__legend[__priorities[i]]), 'leg is null') lst_merge.append( grs_to_shp(ds, os.path.join(workspace, "lulc_{}.shp".format( str(__priorities[i]))), 'auto', lyrN=1, asCMD=True, asMultiPart=None)) time_q = datetime.datetime.now().replace(microsecond=0) if fprop(lulcShp, 'ff') != '.shp': lulcShp = os.path.join(os.path.dirname(lulcShp), fprop(lulcShp, 'fn') + '.shp') shps_to_shp(lst_merge, lulcShp, api='pandas') # Check if prj of lulcShp exists and create it if necessary prj_ff = os.path.splitext(lulcShp)[0] + '.prj' if not os.path.exists(prj_ff): def_prj(prj_ff, epsg=epsg, api='epsgio') time_r = datetime.datetime.now().replace(microsecond=0) # Dump Database if PostGIS was used # Drop Database if PostGIS was used if RoadsAPI == 'POSTGIS': dump_db(osm_db, os.path.join(workspace, osm_db + '.sql'), api='psql') drop_db(osm_db) return lulcShp, { 0: ('set_settings', time_b - time_a), 1: ('osm_to_sqdb', time_c - time_b), 2: ('cls_in_sqdb', time_d - time_c), 3: ('proj_data', time_e - time_d), 4: ('set_grass', time_f - time_e), 5: ('rule_1', time_g - time_f, timeCheck1), 6: ('rule_2', time_h - time_g, timeCheck2), 7: None if not timeCheck3 else ('rule_3', time_l - time_h, timeCheck3), 8: None if not timeCheck4 else ('rule_4', time_j - time_l, timeCheck4), 9: ('rule_5', time_m - time_j if timeCheck4 else time_m - time_h, timeCheck5), 10: None if not timeCheck7 else ('rule_7', time_n - time_m, timeCheck7), 11: ('disj_cls', time_o - time_n), 12: ('priority_rule', time_p - time_o), 13: ('export_cls', time_q - time_p), 14: ('merge_cls', time_r - time_q) }
def vector_assign_pntags_to_build(osmdb, pntTable, polyTable, apidb='SQLITE'): """ Replace buildings with tag yes using the info in the Points Layer Only used for URBAN ATLAS and CORINE LAND COVER """ import datetime as dt from gasp.sql.i import row_num as cnt_row from gasp.gt.toshp.db import dbtbl_to_shp as db_to_shp from gasp.gql.ovly import feat_within, feat_not_within from gasp.gt.gop.genze import dissolve from gasp.gt.tbl.grs import add_table time_a = dt.datetime.now().replace(microsecond=0) new_build = feat_within( osmdb, ("(SELECT buildings AS pnt_build, geometry AS pnt_geom " "FROM {} WHERE buildings IS NOT NULL)").format(pntTable), "pnt_geom", ("(SELECT buildings AS poly_build, geometry AS poly_geom " "FROM {} WHERE buildings IS NOT NULL)").format(polyTable), "poly_geom", "new_buildings", inTblCols="pnt_build AS cls", withinCols="poly_geom AS geometry", outTblIsFile=None, apiToUse="OGR_SPATIALITE" if apidb != "POSTGIS" else apidb, geom_col="geometry") time_b = dt.datetime.now().replace(microsecond=0) yes_build = feat_not_within( osmdb, ("(SELECT buildings AS poly_build, geometry AS poly_geom " "FROM {} WHERE buildings IS NOT NULL)").format(polyTable), "poly_geom", ("(SELECT buildings AS pnt_build, geometry AS pnt_geom " "FROM {} WHERE buildings IS NOT NULL)").format(pntTable), "pnt_geom", "yes_builds", inTblCols="poly_geom AS geometry, 11 AS cls", outTblIsFile=None, apiToUse="OGR_SPATIALITE" if apidb != "POSTGIS" else apidb, geom_col="geometry") time_c = dt.datetime.now().replace(microsecond=0) N12 = cnt_row(osmdb, new_build, api='psql' if apidb == 'POSTGIS' else 'sqlite') time_d = dt.datetime.now().replace(microsecond=0) N11 = cnt_row(osmdb, yes_build, api='psql' if apidb == 'POSTGIS' else 'sqlite') time_e = dt.datetime.now().replace(microsecond=0) if N11: # Add data into grasss grsBuild11 = db_to_shp(osmdb, yes_build, "geometry", "yes_builds", filterByReg=True, inDB='psql' if apidb == 'POSTGIS' else 'sqlite', outShpIsGRASS=True) time_f = dt.datetime.now().replace(microsecond=0) # Dissolve dissVect = dissolve(grsBuild11, "dss_{}".format(grsBuild11), 'cls', api="grass") add_table(dissVect, None, lyrN=1, asCMD=True) time_g = dt.datetime.now().replace(microsecond=0) else: dissVect = None time_f = None time_g = None if N12: # Add data into GRASS GIS grsBuild12 = db_to_shp(osmdb, new_build, "geometry", "pnt_build", filterByReg=True, inDB='psql' if apidb == 'POSTGIS' else 'sqlite', outShpIsGRASS=True) time_h = dt.datetime.now().replace(microsecond=0) # Dissolve dissVect12 = dissolve(grsBuild12, "dss_{}".format(grsBuild12), 'cls', api="grass") add_table(dissVect12, None, lyrN=1, asCMD=True) time_i = dt.datetime.now().replace(microsecond=0) else: dissVect12 = None time_h = None time_i = None return dissVect, dissVect12, { 0: ('intersect', time_b - time_a), 1: ('disjoint', time_c - time_b), 2: ('count_b12', time_d - time_c), 3: ('count_b11', time_e - time_d), 4: None if not time_f else ('import_b11', time_f - time_e), 5: None if not time_g else ('dissolve_b11', time_g - time_f), 6: None if not time_h else ('import_b12', time_h - time_g if time_g else time_h - time_e), 7: None if not time_i else ('dissolve_b12', time_i - time_h) }
def grs_vec_roads(osmdb, lineTbl, polyTbl): """ Select Roads for GRASS GIS """ import datetime from gasp.sql.i import row_num from gasp.gt.toshp.db import dbtbl_to_shp from gasp.gt.prox.bf import _buffer from gasp.gt.gop.genze import dissolve from gasp.gt.tbl.grs import add_table # Roads to GRASS GIS time_a = datetime.datetime.now().replace(microsecond=0) NR = row_num(osmdb, lineTbl, where="roads IS NOT NULL", api='sqlite') time_b = datetime.datetime.now().replace(microsecond=0) if not NR: return None, {0 : ('count_rows_roads', time_b - time_a)} roadsVect = dbtbl_to_shp( osmdb, lineTbl, "geometry", "all_roads", where="roads IS NOT NULL", inDB='sqlite', outShpIsGRASS=True ) time_c = datetime.datetime.now().replace(microsecond=0) # Buildings to GRASS GIS NB = row_num(osmdb, polyTbl, where="building IS NOT NULL", api='sqlite') time_d = datetime.datetime.now().replace(microsecond=0) if NB: from gasp.gt.prox import grs_near as near from gasp.gt.tbl.grs import update_table builds = dbtbl_to_shp( osmdb, polyTbl, "geometry", "all_builds", where="building IS NOT NULL", filterByReg=True, inDB='sqlite', outShpIsGRASS=True ) time_e = datetime.datetime.now().replace(microsecond=0) near(roadsVect, builds, nearDistCol="todist", maxDist=12, as_cmd=True) time_f = datetime.datetime.now().replace(microsecond=0) update_table( roadsVect, "bf_roads", "round(todist,0)", "\"todist > 0\"", lyrN=1, ascmd=True ) time_g = datetime.datetime.now().replace(microsecond=0) else: time_e = None; time_f = None; time_g = None # Run Buffer tool roadsBf = _buffer( roadsVect, "bf_roads", "bf_roads", api='grass', geom_type="line" ) time_h = datetime.datetime.now().replace(microsecond=0) # Dissolve Roads roadsDiss = dissolve(roadsBf, "diss_roads", "roads", api="grass") add_table(roadsDiss, None, lyrN=1, asCMD=True) time_i = datetime.datetime.now().replace(microsecond=0) return roadsDiss, { 0 : ('count_rows_roads', time_b - time_a), 1 : ('import_roads', time_c - time_b), 2 : ('count_rows_build', time_d - time_c), 3 : None if not time_e else ('import_builds', time_e - time_d), 4 : None if not time_f else ('near_analysis', time_f - time_e), 5 : None if not time_g else ('update_buffer_tbl', time_g - time_f), 6 : ('buffer_roads', time_h - time_g if time_g else time_h - time_d), 7 : ('diss_roads', time_i - time_h) }
def lulc_by_cell(tid, boundary, lulc_shps, fishnet, result, workspace): bname = fprop(boundary, 'fn') # Boundary to Raster ref_rst = shp_to_rst(boundary, None, 10, 0, os.path.join(workspace, 'rst_{}.tif'.format(bname))) # Create GRASS GIS Session loc_name = 'loc_' + bname gbase = run_grass(workspace, location=loc_name, srs=ref_rst) import grass.script as grass import grass.script.setup as gsetup gsetup.init(gbase, workspace, loc_name, 'PERMANENT') # GRASS GIS Modules from gasp.gt.toshp.cff import shp_to_grs, grs_to_shp from gasp.gt.gop.ovlay import intersection from gasp.gt.tbl.attr import geomattr_to_db from gasp.gt.prop.feat import feat_count # Send Fishnet to GRASS GIS fnet = shp_to_grs(fishnet, fprop(fishnet, 'fn'), asCMD=True) # Processing ulst = [] l_lulc_grs = [] for shp in lulc_shps: iname = fprop(shp, 'fn') # LULC Class to GRASS GIS lulc_grs = shp_to_grs(shp, iname, filterByReg=True, asCMD=True) if not feat_count( lulc_grs, gisApi='grass', work=workspace, loc=loc_name): continue # Intersect Fishnet | LULC CLass union_grs = intersection(fnet, lulc_grs, iname + '_i', api="grass") # Get Areas geomattr_to_db(union_grs, "areav", "area", "boundary", unit='meters') # Export Table funion = grs_to_shp(union_grs, os.path.join(result, iname + '.shp'), 'area') ulst.append(funion) l_lulc_grs.append(lulc_grs) # Intersect between all LULC SHPS ist_shp = [] if len(l_lulc_grs) > 1: for i in range(len(l_lulc_grs)): for e in range(i + 1, len(l_lulc_grs)): ishp = intersection(l_lulc_grs[i], l_lulc_grs[e], 'lulcint_' + str(i) + '_' + str(e), api="grass") if not feat_count( ishp, gisApi='grass', work=workspace, loc=loc_name): continue else: ist_shp.append(ishp) if len(ist_shp): from gasp.gt.gop.genze import dissolve from gasp.gt.tbl.grs import reset_table if len(ist_shp) > 1: from gasp.gt.toshp.mtos import shps_to_shp # Export shapes _ist_shp = [ grs_to_shp(s, os.path.join(workspace, loc_name, s + '.shp'), 'area') for s in ist_shp ] # Merge Intersections merge_shp = shps_to_shp(_ist_shp, os.path.join(workspace, loc_name, 'merge_shp.shp'), api='pandas') # Import GRASS merge_shp = shp_to_grs(merge_shp, 'merge_shp') else: merge_shp = ist_shp[0] # Dissolve Shape reset_table(merge_shp, {'refid': 'varchar(2)'}, {'refid': '1'}) overlay_areas = dissolve(merge_shp, 'overlay_areas', 'refid', api='grass') # Union Fishnet | Overlay's union_ovl = intersection(fnet, overlay_areas, 'ovl_union', api="grass") funion_ovl = grs_to_shp(union_ovl, os.path.join(result, union_ovl + '.shp'), 'area') ulst.append(funion_ovl) # Export Tables return ulst