import datetime as dt from Tierra_2.core.connect import Connector """ CONSTANTES """ _MULTI = "MULTI" FORMATO_FECHA = "%Y-%m-%d %H:%M:%S:" """ SQL COMUN """ GET_COLUMNS = "SELECT \"column_name\", \"udt_name\" FROM information_schema.columns" \ " WHERE table_schema = '{esquema}' AND (table_name) = '{origen}'" GET_SRID = "SELECT find_srid('{esquema}', '{origen}', '{geom}')" GET_SRID_GEOM = "SELECT ST_SRID({geom}) from \"{esquema}\".\"{origen}\"" ACTULIZA_SRID = "SELECT UpdateGeometrySRID('{esquema}', '{origen}', '{geom}', {srid})" GET_TIPO_GEOM = "SELECT type FROM geometry_columns WHERE f_table_schema = '{esquema}' AND f_table_name = " \ "'{origen}' and f_geometry_column = '{geom}'" VALIDA_GEOM = "SELECT *, ST_IsValidReason({geom}) razon_invalidez FROM \"{esquema}\".\"{origen}\" " \ "WHERE NOT ST_IsValid({geom}) OR {geom} IS NULL" CLONAR_TABLA = "CREATE TABLE \"{esquema_dest}\".\"{destino}\" (LIKE \"{esquema}\".\"{origen}\" INCLUDING ALL)" CREATE_TABLA_2D = "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS SELECT {columnas}, " \ "ST_FORCE2D({geom})::geometry({tipo_geom},{srid}) AS {geom} " \ "FROM \"{esquema}\".\"{origen}\" WHERE ST_IsValid({geom}) and {geom} IS NOT NULL" COPIA_DATOS = "INSERT INTO \"{esquema_dest}\".\"{destino}\" ({columnas},{geom}) SELECT {columnas},{geom} FROM " \ " \"{esquema}\".\"{origen}\" " \ "WHERE ST_IsValid({geom}) AND {geom} IS NOT NULL" BORRA_TABLA_ANTERIOR = "DROP TABLE IF EXISTS \"{esquema}\".\"{destino}\";" CREA_INDICE_GEOM = "create index IF NOT EXISTS \"idx_{destino}_gist_geom\" on \"{esquema_dest}\".\"{destino}\" using gist({geom})" CONTAR_DATOS = "SELECT count(*) num_geom, SUM(ST_Npoints({geom})) num_puntos FROM \"{esquema}\".\"{tabla}\"" COMPARA_GEOM = "SELECT '{origen}' as tabla, {columnas}, {geom} FROM \"{esquema}\".\"{origen}\" Union " \ "SELECT '{destino}' as tabla, {columnas}, {geom} FROM \"{esquema_dest}\".\"{destino}\"" SQL_COUNT = "SELECT COUNT(*) FROM \"{esquema}\".\"{origen}\"" ADD_ID = "ALTER TABLE \"{esquema}\".\"{destino}\" ADD COLUMN {id} SERIAL PRIMARY KEY" CREATE_GEOM_IDX = "CREATE INDEX IF NOT EXISTS \"{geom_chk}_{nombre}_idx\" ON \"{esquema}\".\"{destino}\" USING gist ({geom_chk});" GET_CAMPO_ID = "SELECT \"column_name\" from INFORMATION_SCHEMA.KEY_COLUMN_USAGE" \ " WHERE table_name = '{origen}' AND table_schema = '{esquema}'" SELECT = "SELECT * FROM \"{esquema}\".\"{origen}\"" SELECT_DIM = "select st_ndims({geom}) as dimension from \"{esquema}\".\"{origen}\" GROUP BY dimension" CREATE_COLUMN_PK = "ALTER TABLE \"{esquema}\".\"{origen}\" ADD COLUMN {pk} SERIAL PRIMARY KEY" GET_REGISTROS = "SELECT COUNT(*) FROM \"{esquema}\".\"{origen}\"" """ SQL PARA SUAVIZAR GEOMETRÍA (SMOOTHHING) """ COPIA_DATOS_SUAV = "INSERT INTO \"{esquema_dest}\".\"{destino}\" ({columnas},{geom})" \ " select {columnas}, ST_ChaikinSmoothing({geom},{iteraciones}) as {geom} " \ "from \"{esquema}\".\"{origen}\" WHERE ST_IsValid({geom}) AND {geom} IS NOT NULL" """ SQL PARA SIMPLIFICACION TOPOGRAFICA """ CREA_TOPO = "select topology.CreateTopology('{destino}',{srid},0)" CHECK_TOPO = "SELECT exists(select schema_name FROM information_schema.schemata WHERE schema_name = '{destino}')" BORRA_TOPO = "SELECT topology.DropTopology('{destino}')" ADD_GEOM_TOPO = "select topology.ST_CreateTopoGeo('{destino}',ST_Collect({geom})) from \"{esquema}\".\"{origen}\"" \ " WHERE ST_IsValid({geom}) AND {geom} IS NOT NULL" ADD_GEOM_TOPO_3D = "select topology.ST_CreateTopoGeo('{destino}',ST_Collect({geom})) from \"{esquema}\".\"{origen}\"" \ " WHERE ST_IsValid({geom}) AND {geom} IS NOT NULL" SIMPLIFICA_A_TOPO = "select topology.ST_CreateTopoGeo('{destino2}', {geom}) from (" \ " select ST_Collect(st_simplifyPreserveTopology(geom, {tolerancia})) as {geom}" \ " from \"{destino}\".edge_data ) as geom_simp" ASIGNA_GEOM_SIMPLE = "with simple_face as (" \ " select topology.st_getFaceGeometry('topo_{destino}_2', face_id) as geom" \ " from topo_{destino}_2.face" \ " where face_id > 0" \ ")" \ "update \"{esquema}\".\"{destino}\" d set {geom} = sf.geom " \ "from simple_face sf " \ "where st_intersects(d.{geom}, sf.geom) " \ " and st_area(st_intersection(sf.geom, d.{geom}))/st_area(sf.geom) > 0.5" ASIGNA_GEOM_MULTI = "with simple_face as (" \ " select ST_Multi(topology.st_getFaceGeometry('topo_{destino}_2', face_id)) as geom" \ " from topo_{destino}_2.face" \ " where face_id > 0" \ ")" \ "update \"{esquema}\".\"{destino}\" d set {geom} = sf.geom " \ "from simple_face sf " \ "where st_intersects(d.{geom}, sf.geom) " \ " and st_area(st_intersection(sf.geom, d.{geom}))/st_area(sf.geom) > 0.5" """ SQL PARA SIMPLIFICACION GEOGRAFICA """ COPIA_DATOS_SIMP = "INSERT INTO \"{esquema_dest}\".\"{destino}\" ({columnas},{geom})" \ " SELECT {columnas}," \ " CASE" \ " WHEN ST_IsValid(ST_Simplify({geom},{tolerancia})) AND ST_Simplify({geom},{tolerancia}) IS NOT NULL THEN ST_Simplify({geom},{tolerancia})" \ " WHEN ST_IsValid(ST_Simplify({geom},{tolerancia}*0.75)) AND ST_Simplify({geom},{tolerancia}*0.75) IS NOT NULL THEN ST_Simplify({geom},{tolerancia}*0.75)" \ " WHEN ST_IsValid(ST_Simplify({geom},{tolerancia}*0.5)) AND ST_Simplify({geom},{tolerancia}*0.5) IS NOT NULL THEN ST_Simplify({geom},{tolerancia}*0.5)" \ " WHEN ST_IsValid(ST_Simplify({geom},{tolerancia}*0.25)) AND ST_Simplify({geom},{tolerancia}*0.25) IS NOT NULL THEN ST_Simplify({geom},{tolerancia}*0.25)" \ " ELSE {geom} END as {geom}" \ " FROM \"{esquema}\".\"{origen}\"" \ " WHERE ST_IsValid({geom}) AND {geom} IS NOT NULL" """ SQL PARA DISOLVER (FUSIONAR) GEOMETRIAS Y AÑADIR DATOS ESTADISTICOS HEREDADOS""" CREAR_TABLA_DIS_SIMPLE = "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS (" \ " SELECT {campos_comunes} {campos_sum} {campos_avg} {campos_min} {campos_max}," \ " (ST_Dump(ST_Union({geom}))).geom::geometry({tipo_geom},{srid}) AS {geom} " \ " FROM \"{esquema}\".\"{origen}\" " \ " WHERE ST_IsValid({geom}) AND {geom} IS NOT NULL" \ " GROUP BY {campos_comunes})" CREAR_TABLA_DIS_MULTI = "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS (SELECT {campos_finales}, " \ "ST_Multi(ST_Collect(geom))::geometry({tipo_geom},{srid}) AS {geom}" \ " FROM (SELECT {campos_comunes} {campos_sum} {campos_avg} {campos_min} {campos_max}," \ "(ST_Dump(ST_Union({geom}))).geom " \ "FROM \"{esquema}\".\"{origen}\" " \ "WHERE ST_IsValid({geom}) AND {geom} IS NOT NULL GROUP BY {campos_comunes} ) s " \ "GROUP BY {campos_finales})" CREAR_TABLA_DIS_SIMPLE_3D = "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS (" \ "SELECT {campos_comunes} {campos_sum} {campos_avg} {campos_min} {campos_max}, " \ "(ST_Dump(ST_Union({geom}))).geom::geometry({tipo_geom}Z,{srid}) AS {geom} " \ "FROM \"{esquema}\".\"{origen}\" " \ "WHERE ST_IsValid({geom}) AND {geom} IS NOT NULL " \ "GROUP BY {campos_comunes})" CREAR_TABLA_DIS_MULTI_3D = "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS (SELECT {campos_finales}, " \ "ST_Multi(ST_Collect(geom))::geometry({tipo_geom}Z,{srid}) AS {geom} FROM (SELECT " \ "{campos_comunes} {campos_sum} {campos_avg} {campos_min} {campos_max}," \ "(ST_Dump(ST_Union({geom}))).geom FROM \"{esquema}\".\"{origen}\" WHERE ST_IsValid({geom})" \ " AND {geom} IS NOT NULL GROUP BY {campos_comunes} ) s GROUP BY {campos_finales})" """ SQL PARA LIPIAR GEOMETRÍAS """ COPIA_DATOS_LIMPIOS = "INSERT INTO \"{esquema_dest}\".\"{destino}\" ({columnas},{geom})" \ " SELECT {columnas}, {geom} from \"{esquema}\".\"{origen}\" " \ " WHERE ST_IsValid({geom}) AND {geom} IS NOT NULL" WHERE_DATOS_LIMPIOS_FILTRO = " AND {filtro}" WHERE_DATOS_LIMPIOS_TOLERANCIA = " AND ( " \ " (ST_GeometryType({geom}) IN ('ST_Polygon', 'ST_MultiPolygon') " \ " AND ST_Area({geom})>={tolerancia}) " \ " OR (ST_GeometryType({geom}) IN ('ST_LineString', 'ST_MultiLineString') " \ " AND ST_Length({geom})>={tolerancia})" \ " OR ST_GeometryType({geom}) IN ('ST_Point', 'ST_MultiPoint') " \ ")" """ SQL PARA CHECK INTERFERENCIAS """ # ESTADOS VALIDOS: PENDIENTE, ARREGLADA, IGNORADA CHECK_ESTADO_PENDIENTE = "PENDIENTE" CHECK_ESTADO_ARREGLADA = "ARREGLADA" CHECK_ESTADO_IGNORADA = "IGNORADA" CHECK_CREATE_ESTADO_INTERFERENCIAS = "CREATE TABLE IF NOT EXISTS \"{esquema_chk}\".ESTADO_INTERFERENCIAS(" \ " capa_itf varchar(100) NOT NULL," \ " id_itf numeric NOT NULL," \ " \"esquema_org\" varchar(63) NOT NULL," \ " \"capa_org\" varchar(63) NOT NULL," \ " \"esquema_chk\" varchar(63) NOT NULL," \ " \"capa_chk\" varchar(63) NOT NULL," \ " \"estado_itf\" varchar(10) NOT NULL DEFAULT 'PENDIENTE', " \ " fecha_mod TIMESTAMP NOT NULL DEFAULT now(), " \ " PRIMARY KEY (capa_itf, id_itf))" CHECK_INSERT_ESTADO_INTERFERENCIAS = "INSERT INTO \"{esquema_chk}\".ESTADO_INTERFERENCIAS " \ "(capa_itf, id_itf, esquema_org, capa_org, esquema_chk, capa_chk)" \ " SELECT SUBSTRING('{capa_itf}', 0, 64) as capa_itf, id_itf," \ " '{esquema_org}' as esquema_org, '{capa_org}' as capa_org," \ " '{esquema_chk}' as esquema_chk, '{capa_chk}' as capa_chk" \ " FROM \"{esquema_chk}\".\"{capa_itf}\"" CHECK_DROP_TABLE = "DROP TABLE if exists \"{esquema}\".\"{origen}\" CASCADE" CHECK_CREATE_TABLE = "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS"\ " SELECT {campos_org}, {campos_chk}, ST_Intersection(a.{geom_origen},b.{geom_chk}) as {geom_chk}"\ " FROM \"{esquema}\".\"{origen}\" a {join} {where}" CHECK_CAPA_JOIN = " INNER JOIN \"{esquema}\".\"{capa_chk}\" b ON a.{geom_origen} && b.{geom_chk}" \ " AND ST_Relate(a.{geom_origen}, b.{geom_chk}, '{DE9IM}')" CHECK_CAPA_JOIN_BUFFER = " INNER JOIN \"{esquema}\".\"{capa_chk}\" b ON a.{geom_origen} && b.{geom_chk}" \ " AND ST_Relate(ST_Buffer(a.{geom_origen}, {buffer}), b.{geom_chk},'{DE9IM}')" CHECK_WHERE = "WHERE NOT EXISTS (" \ " SELECT 1 FROM \"{esquema_no_trasnf}\".\"{capa_no_trasnf}\" o" \ " WHERE o.{geom_no_trasnf} && b.{geom_chk} AND ST_Relate(o.{geom_no_trasnf}, b.{geom_chk}, 'T********')" \ " AND ((ST_GeometryType(ST_Intersection(o.{geom_no_trasnf}, b.{geom_chk})) IN ('ST_LineString','ST_MultiLineString') AND ST_Length(ST_Intersection(o.{geom_no_trasnf}, b.{geom_chk}))>0.0001)" \ " OR (ST_GeometryType(ST_Intersection(o.{geom_no_trasnf}, b.{geom_chk})) IN ('ST_Polygon','ST_MultiPolygon') AND ST_Area(ST_Intersection(o.{geom_no_trasnf}, b.{geom_chk}))>0.0001)" \ "))" CHECK_BUSCA_ITF_DESCARTAR = "SELECT id_itf FROM \"{esquema}\".\"{capa_itf}\"" \ " WHERE ({campos}) IN (SELECT {campos} FROM \"{esquema}\".\"{origen_itf}\")" CHECK_BORRA_ITF_DESCARTAR = "DELETE FROM \"{esquema}\".\"{capa_itf}\" WHERE id_itf IN ({ids})" CHECK_INTERF = "SELECT exists(select schema_name FROM information_schema.schemata WHERE schema_name = '{destino}')" BORRAR_INTER = "DROP TABLE IF EXISTS \"{esquema}\".{capa_interferencia}" BORRAR_REGISTRO_INTER = "DELETE FROM \"{esquema}\".ESTADO_INTERFERENCIAS WHERE capa_itf LIKE '{capa_interferencia}' " BORRAR_REGISTRO_INTER_IDS = "DELETE FROM \"{esquema}\".ESTADO_INTERFERENCIAS WHERE capa_itf LIKE"\ " '{capa_interferencia}' AND id_itf IN ({ids})" CHECK_CREATE_CORRECT_LIN = "CREATE TEMP VIEW ITF_AUTOREPAIR_{dest_temp} AS"\ " SELECT {claves_a}, calc_geometry FROM ("\ " SELECT {claves_a}, ST_MakeLine(puntos) calc_geometry FROM ("\ " SELECT id_itf, {claves_a}, pos, puntos FROM ("\ " SELECT id_itf, {claves_a}, ST_LineLocatePoint(ST_LineMerge(a.{geom_a}),(ST_DumpPoints(a.{geom_a})).geom) pos, (ST_DumpPoints(a.{geom_a})).geom puntos"\ " FROM \"{esquema}\".\"{capa_itf}\" i2 LEFT JOIN \"{esquema}\".\"{destino}\" a ON {on_claves_aa}"\ " UNION"\ " SELECT id_itf, {claves_a}, ST_LineLocatePoint(ST_LineMerge(a_geometry),(ST_DumpPoints(geometry_itf)).geom) pos, (ST_DumpPoints(geometry_desp)).geom puntos" \ " FROM ("\ " SELECT id_itf, {claves_a}, a_geometry, "\ " CASE WHEN direccion THEN geometry_desp_cre ELSE geometry_desp_dec END geometry_desp,"\ " CASE WHEN direccion_itf THEN geometry_itf_cre ELSE geometry_itf_dec END geometry_itf"\ " FROM (" \ " SELECT id_itf, {claves_a}, a.{geom_a} a_geometry,"\ " ST_Distance(ST_StartPoint(i2.geometry), ST_StartPoint((ST_Dump(a.{geom_a})).geom)) < ST_Distance(ST_EndPoint(i2.geometry),ST_StartPoint((ST_Dump(a.{geom_a})).geom)) as direccion,"\ " ST_MakeLine(ARRAY[ST_StartPoint(i2.geometry),ST_EndPoint(i2.geometry)]) geometry_desp_cre,"\ " ST_MakeLine(ARRAY[ST_EndPoint(i2.geometry),ST_StartPoint(i2.geometry)]) geometry_desp_dec,"\ " ST_Distance(ST_StartPoint(i2.itf_geometry), ST_StartPoint((ST_Dump(a.{geom_a})).geom)) < ST_Distance(ST_EndPoint(i2.itf_geometry),ST_StartPoint((ST_Dump(a.{geom_a})).geom)) as direccion_itf,"\ " ST_MakeLine(ARRAY[ST_StartPoint(i2.itf_geometry),ST_EndPoint(i2.itf_geometry)]) geometry_itf_cre,"\ " ST_MakeLine(ARRAY[ST_EndPoint(i2.itf_geometry),ST_StartPoint(i2.itf_geometry)]) geometry_itf_dec"\ " FROM ("\ " SELECT i.id_itf, {i_claves_a}, {i_claves_b}, i.geometry itf_geometry,"\ " CASE"\ " WHEN ST_Distance(ST_StartPoint(ST_OffsetCurve(i.geometry,1)), ST_ClosestPoint(o.{geom_o},ST_StartPoint(i.geometry))) <= ST_Distance(ST_EndPoint(ST_OffsetCurve(i.geometry,-1)), ST_ClosestPoint(o.{geom_o},ST_StartPoint(i.geometry))) THEN"\ " CASE "\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,1), b.{geom_chk}) THEN ST_OffsetCurve(i.geometry,1)"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,2), b.{geom_chk}) THEN ST_OffsetCurve(i.geometry,2)"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,3), b.{geom_chk}) THEN ST_OffsetCurve(i.geometry,3)"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,4), b.{geom_chk}) THEN ST_OffsetCurve(i.geometry,4)"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,5), b.{geom_chk}) THEN ST_OffsetCurve(i.geometry,5)"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,6), b.{geom_chk}) THEN ST_OffsetCurve(i.geometry,6)"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,7), b.{geom_chk}) THEN ST_OffsetCurve(i.geometry,7)"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,8), b.{geom_chk}) THEN ST_OffsetCurve(i.geometry,8)"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,9), b.{geom_chk}) THEN ST_OffsetCurve(i.geometry,9)"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,10), b.{geom_chk}) THEN ST_OffsetCurve(i.geometry,10)"\ " ELSE i.geometry"\ " END"\ " ELSE"\ " CASE "\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,-1), b.{geom_chk}) THEN ST_Reverse(ST_OffsetCurve(i.geometry,-1))"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,-2), b.{geom_chk}) THEN ST_Reverse(ST_OffsetCurve(i.geometry,-2))"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,-3), b.{geom_chk}) THEN ST_Reverse(ST_OffsetCurve(i.geometry,-3))"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,-4), b.{geom_chk}) THEN ST_Reverse(ST_OffsetCurve(i.geometry,-4))"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,-5), b.{geom_chk}) THEN ST_Reverse(ST_OffsetCurve(i.geometry,-5))"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,-6), b.{geom_chk}) THEN ST_Reverse(ST_OffsetCurve(i.geometry,-6))"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,-7), b.{geom_chk}) THEN ST_Reverse(ST_OffsetCurve(i.geometry,-7))"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,-8), b.{geom_chk}) THEN ST_Reverse(ST_OffsetCurve(i.geometry,-8))"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,-9), b.{geom_chk}) THEN ST_Reverse(ST_OffsetCurve(i.geometry,-9))"\ " WHEN NOT ST_Intersects(ST_OffsetCurve(i.geometry,-10), b.{geom_chk}) THEN ST_Reverse(ST_OffsetCurve(i.geometry,-10))"\ " ELSE i.geometry"\ " END"\ " END as geometry"\ " FROM ("\ " SELECT id_itf, {claves_a}, {claves_b}, (ST_Dump({geom_itf})).geom geometry"\ " FROM \"{esquema}\".\"{capa_itf}\""\ " WHERE ST_GeometryType({geom_itf}) IN ('ST_LineString','ST_MultiLineString')" \ " ) i"\ " LEFT JOIN \"{esquema}\".\"{capa_chk}\" b ON {on_claves_bb}"\ " LEFT JOIN \"{esquema}\".\"{origen}\" o ON {on_claves_ao}"\ " ) i2 LEFT JOIN \"{esquema}\".\"{destino}\" a ON {on_claves_aa}"\ " ) i3"\ " ) i4"\ " ) i5 order by {claves_a}, pos"\ " ) i6 group by {claves_a}"\ " ) i7"\ " WHERE NOT EXISTS (" \ " SELECT 1 " \ " FROM \"{esquema}\".\"{capa_chk}\" b2 " \ " WHERE ST_Intersects(b2.{geom_chk},i7.calc_geometry))" CHECK_AUTOREPAIR_LIN = "UPDATE \"{esquema}\".{dest} a" \ " SET {geom} = CASE " \ " WHEN ST_GeometryType({geom}) = ST_GeometryType(ITF.calc_geometry) THEN ITF.calc_geometry" \ " WHEN ST_GeometryType({geom}) = 'ST_LineString' AND ST_GeometryType(ITF.calc_geometry) = 'ST_MultiLineString' THEN ST_LineMerge(ITF.calc_geometry)" \ " WHEN ST_GeometryType({geom}) = 'ST_MultiLineString' AND ST_GeometryType(ITF.calc_geometry) = 'ST_LineString' THEN ST_Multi(ITF.calc_geometry)" \ " END FROM ITF_AUTOREPAIR_{dest_temp} ITF WHERE {where}" CHECK_CREATE_CORRECT_POL = "CREATE TEMP VIEW ITF_AUTOREPAIR_{dest_temp} AS"\ " SELECT {claves_a}, calc_geometry " \ " FROM ( " \ " SELECT {claves_a},ST_Translate(da_geom,x_dir * x_offset,y_dir * y_offset) calc_geometry" \ " FROM (" \ " SELECT {claves_a}, da_geom, itf_geometry, offset_geometry, -1 x_dir, -1 y_dir," \ " ST_X(itf_geometry) - ST_X(offset_geometry) x_offset, ST_Y(itf_geometry) - ST_Y(offset_geometry) y_offset" \ " FROM (" \ " SELECT DISTINCT ON ({claves_a}) {claves_a}, ST_StartPoint(itf_line) itf_geometry,da_geom," \ " CASE " \ " WHEN NOT ST_Intersects(ST_OffsetCurve(itf_line, ST_Distance(offset_geometry, ST_ClosestPoint(itf_geometry, offset_geometry))), db_geom) THEN ST_StartPoint(ST_OffsetCurve(itf_line, ST_Distance(offset_geometry, ST_ClosestPoint(itf_geometry, offset_geometry))))" \ " WHEN NOT ST_Intersects(ST_OffsetCurve(itf_line, -1*ST_Distance(offset_geometry, ST_ClosestPoint(itf_geometry, offset_geometry))), db_geom) THEN ST_StartPoint(ST_Reverse(ST_OffsetCurve(itf_line, -1*ST_Distance(offset_geometry, ST_ClosestPoint(itf_geometry, offset_geometry))))) " \ " ELSE db_geom END offset_geometry" \ " FROM(" \ " SELECT {claves_a}, offset_geometry, itf_geometry, db_geom, da_geom, (ST_Dump(itf_line)).geom itf_line" \ " FROM(" \ " SELECT {claves_a}, (ST_DumpPoints(ST_Difference(ST_Union(puntos), ST_Union(itf_points)))).geom offset_geometry, " \ " ST_UNION(itf_points) itf_geometry, ST_Union(db_geom) db_geom, " \ " ST_Union(itf_line) itf_line, ST_Union(da_geom) da_geom" \ " FROM ( " \ " SELECT {claves_a}, da_geom, ST_Intersection(db_geom, ST_Boundary(da_geom)) itf_line," \ " (st_dumppoints(ST_Intersection(db_geom, ST_Boundary(da_geom)))).geom itf_points," \ " (st_dumppoints(di_geom)).geom puntos, db_geom " \ " FROM ( " \ " SELECT {claves_a}, {claves_b}, di_geom, da_geom, db_geom" \ " FROM (" \ " SELECT id_itf, {claves_a}, {claves_b}, (st_dump({geom_itf})).geom di_geom" \ " FROM \"{esquema}\".\"{capa_itf}\"" \ " ) i LEFT JOIN (" \ " SELECT {clave_a}, (ST_Dump({geom_a})).geom da_geom FROM \"{esquema}\".\"{destino}\"" \ " ) a ON {on_claves_aa} LEFT JOIN (" \ " SELECT {clave_b}, (ST_Dump({geom_chk})).geom db_geom FROM \"{esquema}\".\"{capa_chk}\" " \ " ) b ON {on_claves_bb} WHERE ST_GeometryType(di_geom) IN ('ST_Polygon', 'ST_MultiPolygon')" \ " ) i2 WHERE ST_Intersects(di_geom, da_geom) AND ST_Intersects(di_geom, db_geom)" \ " ) i3 GROUP BY {claves_a}" \ " ) i4 ORDER BY {claves_a}, ST_Distance(itf_line, offset_geometry) DESC" \ " ) i5 ORDER BY {claves_a}, ST_Length(itf_line) DESC" \ " ) i6 WHERE ST_GeometryType(offset_geometry)='ST_Point'" \ " ) i7" \ " ) i8 WHERE NOT EXISTS (" \ " SELECT 1 FROM \"{esquema}\".\"{capa_chk}\" b2 " \ " WHERE ST_Intersects(b2.{geom_chk},calc_geometry))" CHECK_AUTOREPAIR_POL = "UPDATE \"{esquema}\".\"{dest}\" a " \ "SET {geom}=CASE WHEN ST_NDims({geom})=4 THEN ST_Force4D(ITF.geom) WHEN ST_NDims({geom})=3 THEN ST_Force3D(ITF.geom) WHEN ST_NDims({geom})=2 THEN ST_Force2D(ITF.geom) END " \ "FROM (" \ " SELECT {itf_claves_a}, CASE" \ " WHEN ST_GeometryType({geom_chk}) = ST_GeometryType(ITF.calc_geometry) THEN ITF.calc_geometry" \ " WHEN ST_GeometryType({geom_chk}) = 'ST_Polygon' AND ST_GeometryType(ITF.calc_geometry) = 'ST_MultiPolygon' THEN ST_Geometryn(ITF.calc_geometry,0)" \ " WHEN ST_GeometryType({geom_chk}) = 'ST_MultiPolygon' AND ST_GeometryType(ITF.calc_geometry) = 'ST_Polygon' THEN ST_Multi(ITF.calc_geometry)" \ " END geom" \ " FROM(" \ " SELECT {itf_claves_a}, ST_Collect(ITF.calc_geometry, da_geom) calc_geometry" \ " FROM ITF_AUTOREPAIR_{dest_temp} ITF LEFT JOIN(" \ " SELECT {claves_itf_a}, ST_Collect(da_geom) da_geom" \ " FROM ITF_AUTOREPAIR_{dest_temp} ITF" \ " LEFT JOIN (" \ " SELECT {claves_b}, (ST_Dump({geom_chk})).geom da_geom" \ " FROM \"{esquema}\".\"{dest}\"" \ " ) a1 ON {on_claves_itf1}" \ " WHERE ST_Area(da_geom)<>ST_Area(ITF.calc_geometry)" \ " GROUP BY {claves_itf_a}" \ " ) a2 ON {on_claves_itf2}" \ " ) ITF, \"{esquema}\".\"{dest}\" a" \ " WHERE {where}" \ ")ITF WHERE {where}" """ CAMBIAR ESTADO """ UPDATE_ESTADO_ITF = "UPDATE \"{esquema}\".ESTADO_INTERFERENCIAS SET ESTADO_ITF = '{estado_itf}', FECHA_MOD = NOW() WHERE " \ "capa_itf = '{capa_itf}' " WHERE_IDITF = "AND id_itf = {id_itf}" WHERE_IDITF_IN_AUTOREPAIR = "AND id_itf IN (" \ " SELECT DISTINCT id_itf FROM \"{esquema}\".\"{capa_itf}\" WHERE {claves_a} IN (" \ " SELECT {claves_a} FROM ITF_AUTOREPAIR_{dest_temp}))" """ DISOLVER GEOM """ CREAR_TABLA_DIS_GEO = "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS(SELECT min(a.{nombre_id}) as id," \ " array_agg(a.{nombre_id}) as ids, b.geometry FROM \"{esquema}\".\"{origen}\" a," \ "(SELECT (ST_Dump(St_multi(ST_Union({geom})))).geom as geometry FROM " \ "\"{esquema}\".\"{origen}\") b WHERE st_intersects(a.{geom}, b.geometry) GROUP BY " \ "b.geometry)" CREAR_TABLA_DIS_BUF_GEO = "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS(SELECT min(a.{nombre_id}) as id, " \ "array_agg(a.{nombre_id})as ids, b.geometry FROM \"{esquema}\".\"{origen}\" a," \ "(SELECT (ST_Dump(St_multi(ST_Union(ST_Buffer({geom}, {buffer}))))).geom as geometry" \ " FROM \"{esquema}\".\"{origen}\") b WHERE st_intersects(a.{geom}, b.geometry)" \ " GROUP BY b.geometry);" CREATE_TABLE_DIS_GEO_ID = "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS(SELECT b.geometry FROM" \ " \"{esquema}\".\"{origen}\" a," \ "(SELECT (ST_Dump(St_multi(ST_Union({geom})))).geom as geometry FROM " \ "\"{esquema}\".\"{origen}\") b WHERE st_intersects(a.{geom}, b.geometry)" \ " GROUP BY b.geometry);" CREATE_TABLE_DIS_GEO_ID_BFF = "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS(SELECT b.geometry FROM" \ " \"{esquema}\".\"{origen}\" a," \ "(SELECT (ST_Dump(St_multi(ST_Union(ST_Buffer({geom}, {buffer}))))).geom as geometry " \ "FROM \"{esquema}\".\"{origen}\") b WHERE st_intersects(a.{geom}, b.geometry)" \ " GROUP BY b.geometry);" GET_IDS = "SELECT ids FROM \"{esquema}\".\"{destino}\"" FUNCTION_ST_DILATE = "CREATE OR REPLACE FUNCTION ST_Dilate(in_geom GEOMETRY,scale_factor FLOAT,tol FLOAT DEFAULT 0.001,guess FLOAT DEFAULT 1,safety INTEGER DEFAULT 1000)" \ "RETURNS GEOMETRY AS " \ " $$ " \ " DECLARE " \ "step FLOAT = guess/2;" \ " current_area FLOAT = ST_Area(ST_Buffer(in_geom, guess));" \ " desired_area FLOAT = ST_Area(in_geom)*scale_factor;" \ " dev FLOAT = (current_area-desired_area)/desired_area;" \ " old_dev FLOAT;" \ " safety_counter INTEGER = 0;" \ "BEGIN" \ " IF scale_factor < 0 THEN" \ " RAISE NOTICE 'Negative scale factor encountered (%) when dilating geom %, NULL geometry returned instead.', scale_factor, in_geom;" \ " RETURN NULL;" \ " END IF;" \ " WHILE ABS(dev) > tol LOOP" \ " safety_counter = safety_counter + 1;" \ " /* Save the old deviation to be compared later to the new one later, calculate the current area and the new deviation from the desired area. */" \ " old_dev = dev;" \ " current_area = ST_Area(ST_Buffer(in_geom, guess));" \ " dev = (current_area - desired_area) / desired_area;" \ " IF dev < 0 THEN /* Current area is smaller than desired area, increase the buffer distance by the step. */" \ " guess = guess + step;" \ " ELSIF dev > 0 THEN /* Current area is larger than desired area, decrease the buffer distance by the step. */" \ " guess = guess - step;" \ " ELSE /* Technically shouldn't ever happen because then ABS(dev) is indeed lesser than tol but here just in case. */" \ " EXIT;" \ " END IF;" \ " IF dev * old_dev < 0 THEN /* Negative value indicates difference of sign, which means we just overestimated the area after underestimating it or vice versa, need to half the step. */" \ " step = step * 0.5;" \ " END IF;" \ " END LOOP;" \ " RETURN ST_Buffer(in_geom, guess);" \ "END" \ "$$" \ "LANGUAGE plpgsql IMMUTABLE COST 100;" CREATE_TABLE_DILATE = "CREATE TABLE if not exists \"{esquema_dest}\".\"{destino}\" AS (SELECT " \ " ST_DILATE({geom}, {escala}) as {geom} from \"{esquema}\".\"{origen}\" {where})" CREATE_TABLE_TRANSLATE = "CREATE TABLE if not exists \"{esquema_dest}\".\"{destino}\" AS (SELECT " \ " ST_TRANSLATE({geom}, {desplazamientoX}, {desplazamientoY}) as {geom} FROM " \ "\"{esquema}\".\"{origen}\" {where})" """ AGGREGATE GEOM """ CREATE_TABLE_CLUSTER = "CREATE TABLE if not exists \"{esquema_dest}\".\"{destino}\" AS (SELECT cluster_id, " \ "array_agg({id}) as ids_in_cluster, st_multi(st_union({geom})) as geom FROM (SELECT {id}, " \ "ST_ClusterDBScan({geom}, {dist}, {minp}) OVER () AS cluster_id, geom FROM" \ " \"{esquema}\".\"{origen}\") as p GROUP BY cluster_id)" SELECT_IDS_NO_IN_CLUSTER = "select array_agg({id}) as ids_in_cluster FROM (SELECT {id}," \ "ST_ClusterDBScan({geom}, {dist}, {minp}) OVER () AS cid, {geom} FROM" \ " \"{esquema}\".\"{origen}\") as p where cid is null group by cid" CREATE_TABLE_AGREGADOS = "create table if not exists \"{esquema_dest}\".\"{destino}\" as(SELECT {campos_comunes}, cluster_id, " \ "array_agg({id}) as ids_in_cluster, ST_ConcaveHull(st_multi(st_union({geom})), {ajuste})" \ " as geom FROM (SELECT ST_ClusterDBScan({geom}, {dist}, {minp}) OVER () AS cluster_id, {campos_comunes}, " \ "{geom} FROM \"{esquema}\".\"{origen}\") sq where cluster_id is not null group " \ "by {campos_comunes}, cluster_id);" CREATE_TABLE_INTER = "drop table if exists \"{esquema_dest}\".\"{destino}_sin_int\";" \ "create table \"{esquema_dest}\".\"{destino}_sin_int\" as select gid_a as gid, array_agg(gid_b) " \ "as gid_union, st_union(geom) as geom from (Select a.cluster_id as gid_a, b.cluster_id as gid_b, " \ "st_union(a.geom, b.geom) as geom from \"{esquema_dest}\".\"{destino}\" a, " \ "\"{esquema_dest}\".\"{destino}\" b where st_intersects(a.geom, b.geom)) as interferencias " \ "group by gid_a" """ HERRAMIENTAS DE GENERALIZACION TEMATICAS """ GROUP_BY_TIPO = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo\";" \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_tipo\" AS SELECT st_union({geom}) " \ "AS geom FROM \"{esquema}\".\"{origen}\" GROUP BY id_tipo;" GROUP_BY_TIPO_BFF = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo\";" \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_tipo\" AS SELECT id_tipo, st_union(st_buffer(st_force2d({geom}),0.001)) " \ "AS {geom} FROM \"{esquema}\".\"{origen}\" GROUP BY id_tipo;" CREATE_TABLE_DIS_POL = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo_diss\";" \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_tipo_diss\" as select {campos_comunes}, (st_dump({geom})).geom as " \ "geom FROM \"{esquema}\".\"{origen}\";" CREATE_TABLA_DIS_POL_AREA = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo_diss\"; " \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_tipo_diss\" as select {campos_comunes},(st_dump({geom})).geom as " \ "{geom}, st_area((st_dump({geom})).geom) as {area} FROM \"{esquema}\".\"{origen}\";" CREATE_TABLE_DIS_SIM_POL = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo_diss_simply\" ;" \ "create table \"{esquema_dest}\".\"{destino}_tipo_diss_simply\" as select {campos_comunes}," \ "st_simplify(geom, {tolerancia}) as geom FROM \"{esquema_dest}\".\"{destino}_tipo_diss\";" ADD_COLUMN_AREA = "alter table \"{esquema}\".\"{origen}_tipo_diss_simply\" ADD {area} double precision;" \ "update \"{esquema}\".\"{origen}_tipo_diss_simply\" SET {area} = st_area(geom); " ADD_COLUMN_AREA_3D = "alter table \"{esquema}\".\"{origen}_tipo_diss_simply\" ADD {area} double precision; " \ "update \"{esquema}\".\"{origen}_tipo_diss_simply\" SET {area} = st_3darea(geom); " CREATE_TABLE_DUMP = "drop table if exists \"{esquema_dest}\".\"{destino}_tipo_diss_simply2\"; " \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_tipo_diss_simply2\" AS SELECT {campos_comunes}," \ " ST_GeomFromText(ST_AsText((ST_Dump(geom)).geom )) as geom, {area} " \ "FROM \"{esquema_dest}\".\"{destino}_tipo_diss_simply\";" CREATE_TABLE_FILTER_AREA_POL = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}\"; " \ "CREATE TABLE \"{esquema_dest}\".\"{destino}\" as SELECT {campos_comunes}, row_number() OVER ()" \ " AS fid_, ST_GeomFromText(ST_AsText((st_dump(geom)).geom)) as geom, {area} FROM" \ " \"{esquema_dest}\".\"{destino}_tipo_diss_simply2\" {filtro};" EXTRAER_ANILLOS = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_anillos\"; " \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_anillos\" AS SELECT {campos_comunes}, " \ "(ST_DUMPRINGS(ST_FORCE2D(geom))).geom as geom, ST_AREA((ST_DUMPRINGS(ST_FORCE2D(geom))).geom) AS " \ "{area} FROM \"{esquema_dest}\".\"{destino}_tipo_diss_simply2\";" CREATE_TABLE_FILTER_AREA_ED = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_filtro\"; " \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_filtro\" as SELECT {campos_comunes}," \ " st_perimeter(geom) as perimetro, {area}, geom FROM" \ " \"{esquema_dest}\".\"{destino}_anillos\" {filtro};" CREATE_TABLE_FILTER_AREA_HI = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_filtro\";" \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_filtro\" as SELECT *, st_perimeter({geom}) " \ "as {perimetro} FROM \"{esquema_dest}\".\"{destino}_tipo_diss\" {filtro};" CREATE_ANILLOS_GEOM_ORIGINAL = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}\"; " \ "CREATE TABLE \"{esquema_dest}\".\"{destino}\" as SELECT {campos_comunes}," \ "ST_FORCE2D(geom) as geom, {area} FROM \"{esquema_dest}\".\"{destino}_tipo_diss_simply2\" " \ "UNION SELECT {campos_comunes}, ST_BUFFER(geom, 0.0001), {area} FROM \"{esquema_dest}\".\"{destino}_filtro\" ;" \ "UPDATE \"{esquema_dest}\".\"{destino}\" " \ "SET geom = ST_MAKEVALID(geom) WHERE NOT ST_ISVALID(geom);" CREATE_TABLE_UNION = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}\"; " \ "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS SELECT {campos_comunes}, ST_CollectionExtract" \ "(st_union(geom),3) AS geom, ST_AREA(ST_CollectionExtract(st_union(geom),3)) " \ "FROM \"{esquema_dest}\".\"{destino}_union_simply_anillos\" GROUP BY {pk}" DELETE_FILTRO = "DELETE FROM \"{esquema_dest}\".\"{destino}\" WHERE ST_AREA(geom) {filtro};" BORRAR_TABLAS_INTERMEDIAS_POL = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo\"; " \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo_diss\"; " \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo_diss_simply\"; " \ "drop table if exists \"{esquema_dest}\".\"{destino}_tipo_diss_simply2\";" BORRAR_TABLAS_INTERMEDIAS_ED = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo\"; " \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo_diss\"; " \ "drop table if exists \"{esquema_dest}\".\"{destino}_tipo_diss_simply\"; " \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_union_simply_anillos\"; " \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_filtro\"; " \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_anillos\";" \ "drop table if exists \"{esquema_dest}\".\"{destino}_tipo_diss_simply2\";" BORRAR_TABLAS_INTERMEDIAS_PR = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_cluster\" CASCADE; " \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo_diss\" CASCADE; " \ "drop table if exists \"{esquema_dest}\".\"{destino}_centroide\" CASCADE;" \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_dwithin\" CASCADE;" BORRAR_TABLAS_INTERMEDIAS_HI = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_filtro\" CASCADE;" \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo\" CASCADE;" \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_tipo_diss\" CASCADE;" \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_division\" CASCADE;" CREATE_TABLE_CLUSTER_PR = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_cluster\"; " \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_cluster\" as " \ "SELECT ST_AsText(unnest(ST_ClusterWithin((ST_Force2D({geom})), {dist}))) as {geom} " \ "FROM \"{esquema}\".\"{origen}\";" CREATE_TABLE_CENTROID_PR = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_centroide\"; " \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_centroide\" as SELECT " \ "ST_Centroid({geom}) FROM \"{esquema_dest}\".\"{destino}_cluster\";" CREATE_TABLE_DWITHIN = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_dwithin\"" \ ";CREATE TABLE \"{esquema_dest}\".\"{destino}_dwithin\" as " \ "SELECT \"{esquema_dest}\".\"{destino}_centroide\".st_centroid, " \ "\"{esquema}\".\"{origen}\".* FROM \"{esquema_dest}\".\"{destino}_centroide\"" \ " INNER JOIN \"{esquema}\".\"{origen}\" ON ST_DWithin(ST_SetSRID(\"{destino}_centroide\".st_centroid,{srid}), " \ "\"{origen}\".{geom}, {dist});" CREATE_TABLE_CENTROID = "DELETE FROM \"{esquema_dest}\".\"{destino}_dwithin\" WHERE st_centroid IN " \ "(SELECT st_centroid FROM \"{esquema_dest}\".\"{destino}_dwithin\" GROUP BY st_centroid " \ "HAVING COUNT(*) > 1); DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}\"; " \ "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS SELECT * " \ "FROM \"{esquema_dest}\".\"{destino}_dwithin\";" CLEAR_TABLE_CENTROID = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_limpio\";" \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_limpio\" AS SELECT * FROM \"{esquema_dest}\".\"{destino}\";" \ "DELETE FROM \"{esquema_dest}\".\"{destino}_limpio\" a WHERE a.st_centroid <> (SELECT min(b.st_centroid) " \ "FROM \"{esquema_dest}\".\"{destino}\" b WHERE a.st_centroid = b.st_centroid);" CREATE_TABLE_PERIMETER = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_division\";" \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_division\" AS SELECT *, {area}/{perimetro} as {division} FROM" \ "\"{esquema_dest}\".\"{destino}_filtro\";" \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}\";" \ "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS SELECT * FROM \"{esquema_dest}\".\"{destino}_division\"" \ "WHERE {division} > 1; " CREATE_SET_LINES = "CREATE TABLE \"{esquema_dest}\".\"{destino}_lineas\" AS SELECT {campos_comunes}, " \ "st_linemerge({geom}) AS geom FROM \"{esquema}\".\"{origen}\";" CREATE_BFF_LINES = "CREATE TABLE \"{esquema_dest}\".\"{destino}_bff\" AS SELECT " \ "{campos_comunes}, st_buffer(\"{destino}_lineas\".geom," \ " {buffer}::double precision) AS geom FROM \"{esquema_dest}\".\"{destino}_lineas\"; " CREATE_INT_LINES = "CREATE TABLE \"{esquema_dest}\".\"{destino}_med\" AS SELECT {campos_comunes}, " \ "st_intersection(a.geom, b.geom) AS st_intersection FROM \"{esquema_dest}\".\"{destino}_bff\" a," \ " \"{esquema_dest}\".\"{destino}_bff\" b WHERE st_intersects(a.geom, b.geom)" \ " AND a.{pk} < b.{pk} WITH DATA;" CREATE_MED_LINES = "CREATE TABLE \"{esquema_dest}\".\"{destino}_med2\" AS SELECT {campos_comunes}, " \ "st_approximatemedialaxis(\"{destino}_med\".st_intersection) AS geom " \ "FROM \"{esquema_dest}\".\"{destino}_med\"; " DELETE_NOISE_LEN = "CREATE TABLE \"{esquema_dest}\".\"{destino}_dist\" AS SELECT " \ "{campos_comunes}, \"{destino}_med2\".geom, st_length(\"{destino}_med2\".geom) " \ "AS distancia FROM \"{esquema_dest}\".\"{destino}_med2\";" \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_fil\" AS " \ "SELECT {campos_comunes}, \"{destino}_dist\".geom, \"{destino}_dist\".distancia " \ "FROM \"{esquema_dest}\".\"{destino}_dist\" WHERE " \ "\"{destino}_dist\".distancia > {dist}::double precision WITH DATA;" DELETE_NOISE_UN_LIN = "CREATE TABLE \"{esquema_dest}\".\"{destino}_union\" AS SELECT {campos_comunes}, " \ "st_union(\"{destino}_fil\".geom) AS geom FROM \"{esquema_dest}\".\"{destino}_fil\";" CREATE_UNION_LINES = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_lin\";" \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_lin\" AS SELECT {campos_comunes}, " \ "st_linemerge(\"{destino}_fil\".geom) AS st_linemerge FROM \"{esquema_dest}\".\"{destino}_fil\"" \ " WITH DATA;" CREATE_DUMP_LINES = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_lin_dump\" , " \ "\"{esquema_dest}\".\"{destino}_lin_dump_dist\", \"{esquema_dest}\".\"{destino}_lin_dump_corte\";" \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_lin_dump\" AS SELECT " \ "{campos_comunes}, (st_dump(\"{destino}_lin\".st_linemerge)).geom " \ "AS geom FROM \"{esquema_dest}\".\"{destino}_lin\" WITH DATA;" \ " CREATE TABLE \"{esquema_dest}\".\"{destino}_lin_dump_dist\" AS SELECT" \ " {campos_comunes}, \"{destino}_lin_dump\".geom, st_length(\"{destino}_lin_dump\".geom) " \ "AS distancia FROM \"{esquema_dest}\".\"{destino}_lin_dump\" WITH DATA;" \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_lin_dump_corte\" AS " \ "SELECT {campos_comunes}, \"{destino}_lin_dump_dist\".geom, " \ "\"{destino}_lin_dump_dist\".distancia FROM \"{esquema_dest}\".\"{destino}_lin_dump_dist\" " \ " WHERE \"{destino}_lin_dump_dist\".distancia > ({dist} * 8) WITH DATA;" CREATE_TOPO_LAYER = "DROP SCHEMA IF EXISTS topo_{destino} CASCADE;" \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_topo\"; " \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_topo\" AS SELECT * FROM " \ "\"{esquema_dest}\".\"{destino}_lin_dump_corte\"; " \ "delete from topology.layer where table_name ='{destino}_topo'; " \ "delete from topology.topology where name LIKE 'topo_{destino}'; " \ "SELECT topology.CreateTopology('topo_{destino}',{srid}); " \ "SELECT topology.AddTopoGeometryColumn('topo_{destino}', '{esquema_dest}', '{destino}_topo', " \ "'topo_geom', 'linestring');" \ "select funciones.topotoleranceloop('{esquema_dest}','{destino}', '1', '{dist}' ); "\ "CREATE TABLE \"{esquema_dest}\".\"{destino}_topo_clean_1\" AS (SELECT ST_INTERSECTION(pol3.geom, pol6.geom) " \ "AS geom, pol6.geoml , pol3.id_propio "\ "FROM (select st_buffer(geom,5) as geom, geom as geoml, id_propio from \"{esquema}\".\"{origen}\") AS pol3, "\ "(select st_buffer(geom,5)as geom, geom as geoml from \"topo_{destino}\".\"edge_data\") AS pol6 "\ "WHERE ST_INTERSECTS(pol3.geom, pol6.geom)); " \ "CREATE INDEX \"{destino}_topo_clean_11k_geom_gidx\" on \"{esquema_dest}\".\"{destino}_topo_clean_1\" using gist(geoml); " \ "create TABLE \"{esquema_dest}\".\"{destino}_topo_clean_2\" as select distinct on (geoml) rt.* from(select re.* from " \ "(select re.id_propio as id_propio2, re.geoml, max(st_area(re.geom)) as area "\ "from (select id_propio, geoml, (st_dump(geom)).geom from \"{esquema_dest}\".\"{destino}_topo_clean_1\") re "\ "group by re.id_propio, re.geoml order by re.id_propio, area desc) re, "\ "(select max(ru.area) as maxarea, ru.geoml as cod2 from (select re.id_propio, re.geoml, max(st_area(re.geom)) as area "\ "from (select id_propio, geoml, (st_dump(geom)).geom from \"{esquema_dest}\".\"{destino}_topo_clean_1\") re "\ "group by re.id_propio, re.geoml order by re.id_propio, area desc)ru group by ru.geoml) ra "\ "where ra.maxarea=re.area) rt; " \ "create table \"{esquema_dest}\".\"{destino}_topo_clean\" as select a.*,b.* from " \ "\"{esquema_dest}\".\"{destino}_topo_clean_2\" a inner join\"{esquema}\".\"{origen}\" b on " \ "a.id_propio2 = b.id_propio; " \ "alter table \"{esquema_dest}\".\"{destino}_topo_clean\" drop column id_propio2; "\ "alter table \"{esquema_dest}\".\"{destino}_topo_clean\" drop column geom; "\ "alter table \"{esquema_dest}\".\"{destino}_topo_clean\" drop column area; "\ "alter table \"{esquema_dest}\".\"{destino}_topo_clean\" rename geoml to geom; "\ "CREATE TABLE \"{esquema_dest}\".\"{destino}_topo_dump\" AS " \ "SELECT *, (st_dump(geom)).geom AS topo_geom FROM \"{esquema_dest}\".\"{destino}_topo_clean\"; " \ "alter table \"{esquema_dest}\".\"{destino}_topo_dump\" drop column geom; " \ "alter table \"{esquema_dest}\".\"{destino}_topo_dump\" rename topo_geom to geom;" \ "CREATE TABLE \"{esquema_dest}\".\"{destino}_topo_dist\" AS SELECT *, " \ "st_length(geom) AS distancia FROM \"{esquema_dest}\".\"{destino}_topo_dump\"; " \ "CREATE TABLE \"{esquema_dest}\".\"{destino}\" AS SELECT * FROM " \ " \"{esquema_dest}\".\"{destino}_topo_dist\" WHERE distancia > ({dist} * 3.5) " DELETE_EJESFERROCARRIL = "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_lineas\", " \ "\"{esquema_dest}\".\"{destino}_med\", \"{esquema_dest}\".\"{destino}_bff\"," \ "\"{esquema_dest}\".\"{destino}_med2\", \"{esquema_dest}\".\"{destino}_dist\"," \ "\"{esquema_dest}\".\"{destino}_fil\", \"{esquema_dest}\".\"{destino}_union\"," \ "\"{esquema_dest}\".\"{destino}_lin_dump\", \"{esquema_dest}\".\"{destino}_lin\"," \ "\"{esquema_dest}\".\"{destino}_topo_dump\", \"{esquema_dest}\".\"{destino}_topo_dist\"," \ "\"{esquema_dest}\".\"{destino}_lin_dump_dist\", \"{esquema_dest}\".\"{destino}_lin_dump_corte\"" \ " CASCADE;" \ "DROP TABLE IF EXISTS \"{esquema_dest}\".\"{destino}_topo\", \"{esquema_dest}\".\"{destino}_topo_clean\"" \ " CASCADE;" def init_datos(): """DATOS COMUNES DE GENERALIZACIÓN""" return { "ini": dt.datetime.now(), "fin": None, "duracion": None, "metodo": "", "esquema": "public", "esquema_dest": "public", "capa_origen": None, "srid": None, "campos": "", "geom": "geom", "tipo_geom": None, # POINT,LINE, POLYGON, ... "resultado": "OK", # OK, ERROR, AVISO "geom_ignorada": [], "mensajes": [] } def init_suavizar(): """DATOS DE LA EJECUCION DE SUAVIZAR""" datos = init_datos() datos["metodo"] = "suavizar" datos["iteraciones"] = None datos["features_orig"] = None datos["puntos_orig"] = None datos["capa_suav"] = None datos["features_suav"] = None datos["puntos_suav"] = None return datos def init_simplificar(): """DATOS DE LA EJECUCION DE SIMPLIFICAR""" datos = init_datos() datos["metodo"] = "simplificar" datos["tolerancia"] = 0 datos["ignorar_topo"] = True datos["features_orig"] = None datos["puntos_orig"] = None datos["capa_simp"] = None datos["features_simp"] = None datos["puntos_simp"] = None return datos def init_disolver(): """DATOS DE LA EJECUCION DE DISOLVER""" datos = init_datos() datos["metodo"] = "disolver" datos["capa_dis"] = None datos["campos_comunes"] = None datos["campos_sum"] = None datos["campos_avg"] = None datos["campos_min"] = None datos["campos_max"] = None return datos def init_disolver_geo(): """DATOS DE LA EJECUCION DE DISOLVER INTERFERENCIAS""" datos = init_datos() datos["metodo"] = "disolver_geo" datos["name_id"] = None datos["ids"] = None return datos def init_limpiar(): datos = init_datos() datos["metodo"] = "limpiar_tolerancia" datos["tolerancia"] = 0 datos["features_orig"] = None datos["puntos_orig"] = None datos["capa_limp"] = None datos["features_limp"] = None datos["puntos_limp"] = None return datos def init_check(): datos = init_datos() datos["metodo"] = "check_interferencias" datos["filtro"] = "" datos["buffer"] = "" return datos def init_estado(): datos = init_datos() datos["metodo"] = "cambiar_estado" return datos def init_exagerar(): """DATOS DE LA EJECUCION DE EXAGERAR""" datos = init_datos() datos["metodo"] = "exagerar" datos["escala"] = 0 return datos def init_desplazar(): """DATOS DE LA EJECUCION DE DESPLAZAR""" datos = init_datos() datos["metodo"] = "desplazar" datos["desplazamientoX"] = 0 datos["desplazamientoY"] = 0 return datos def init_agregar(): """DATOS DE LA EJECUCION DE AGREGAR""" datos = init_datos() datos["metodo"] = "agregar" return datos def init_poligonos(): datos = init_datos() datos["metodo"] = "generar_poligonos" return datos def init_edificaciones(): datos = init_datos() datos["metodo"] = "generar_edificaciones" datos["tolerancia"] = 0 datos["filtro"] = "" datos["dist_filtro"] = "" datos["borrar_capas"] = True return datos def init_rpuntos(): datos = init_datos() datos["metodo"] = "generar_ptorelieve" datos["distancia_cluster"] = 0 datos["campo_elevacion"] = "" datos["borrar_capas"] = True return datos def init_hpoligonos(): datos = init_datos() datos["metodo"] = "generar_polhidro" datos["borrar_capas"] = True return datos def init_ejesferrocarril(): datos = init_datos() datos["metodo"] = "generar_ejesferrocarril" datos["buffer"] = 0 datos["distancia"] = 0 datos["borrar_capas"] = True return datos def init_curvasnivel(): datos = init_datos() datos["metodo"] = "generar_curvasnivel" datos["borrar_capas"] = True return datos def add_msg(datos: object, msg: object = "") -> object: """ Añade un nuevo mensaje a los datos y lo muestra en pantalla """ datos["mensajes"].append((dt.datetime.now().strftime(FORMATO_FECHA) + "::" + msg)) print(datos["mensajes"][len(datos["mensajes"]) - 1]) def carga_datos_capa(capa, datos, cursor, check_valid=True): """ Devuelve los siguientes datos de una capa: colummas, campo de geometría, tipo de geometría, srid """ add_msg(datos, "CARGA_DATOS_CAPA: {}".format(capa)) cursor.execute(GET_COLUMNS.format(esquema=datos["esquema"], origen=capa)) arr_columns = cursor.fetchall() add_msg(datos, "columnas de capa: " + str(arr_columns)) result = {"geom": "", "campos": "", "capa_origen": capa, "pk": []} if len(arr_columns) == 0: raise Exception("No se encuentra la tabla o no tiene columnas") for column in arr_columns: if column[1] == "geometry": # Si es columna de geometría result["geom"] = column[0] else: result["campos"] += "\"" + column[0] + "\" , " result["campos"] = result["campos"][:-2] # Quitar última ", " add_msg(datos, "columns:" + result["campos"]) add_msg(datos, "geom:" + result["geom"]) if not result["geom"]: raise Exception("No se encuentra la columna de geometría") cursor.execute(GET_CAMPO_ID.format(esquema=datos["esquema"], origen=capa)) result["pk"] = [pk[0] for pk in cursor.fetchall()] add_msg(datos, "pk:" + str(result["pk"])) cursor.execute(GET_SRID.format(esquema=datos["esquema"], origen=capa, geom=result["geom"])) result["srid"] = cursor.fetchone()[0] if result["srid"] == 0: cursor.execute(GET_REGISTROS.format(esquema=datos["esquema"], origen=capa)) registros = cursor.fetchall()[0] if registros[0] == 0: add_msg(datos, "No hay interferencias entre la capa origen y destino") else: cursor.execute(GET_SRID_GEOM.format(esquema=datos["esquema"], origen=capa, geom=result["geom"])) result["srid"] = cursor.fetchone()[0] #cursor.execute(ACTULIZA_SRID.format(esquema=datos["esquema"], origen=capa, geom=result["geom"], # srid=result["srid"])) datos["srid"] = result["srid"] add_msg(datos, "srid:" + str(result["srid"])) cursor.execute(GET_TIPO_GEOM.format(esquema=datos["esquema"], origen=capa, geom=result["geom"])) print(GET_TIPO_GEOM.format(esquema=datos["esquema"], origen=capa, geom=result["geom"])) result["tipo_geom"] = cursor.fetchone()[0] add_msg(datos, "Recuperada tipo geometría:" + result["tipo_geom"]) if not result["tipo_geom"]: raise Exception("No se encuentra el tipo de geometría de la capa ", capa) if check_valid: cursor.execute(VALIDA_GEOM.format(esquema=datos["esquema"], origen=result["capa_origen"], geom=result["geom"])) result["geom_ignorada"] = cursor.fetchall() add_msg(datos, "Geometrias invalidas: " + str(len(result["geom_ignorada"]))) return result def carga_datos_origen(datos, cursor, check_valid=True): """ Carga los siguientes datos de la capa origen: colummas, campo de geometría, tipo de geometría, srid """ add_msg(datos, "CARGA_DATOS_ORIGEN: {}".format(datos["capa_origen"])) cursor.execute(GET_COLUMNS.format(esquema=datos["esquema"], origen=datos["capa_origen"])) arr_columns = cursor.fetchall() add_msg(datos, "columnas de origen: " + str(arr_columns)) datos["geom"] = "" datos["campos"] = "" if len(arr_columns) == 0: raise Exception("No se encuentra la tabla o no tiene columnas") for column in arr_columns: if column[1] == "geometry": # Si es columna de geometría datos["geom"] = column[0] else: datos["campos"] += "\"" + column[0] + "\" , " datos["campos"] = datos["campos"][:-2] # Quitar última ", " add_msg(datos, "columns:" + datos["campos"]) add_msg(datos, "geom:" + datos["geom"]) if not datos["geom"]: raise Exception("No se encuentra la columna de geometría") cursor.execute(GET_CAMPO_ID.format(esquema=datos["esquema"], origen=datos["capa_origen"])) datos["pk"] = [pk[0] for pk in cursor.fetchall()] add_msg(datos, "pk:" + str(datos["pk"])) print(GET_SRID.format(esquema=datos["esquema"], origen=datos["capa_origen"], geom=datos["geom"])) cursor.execute(GET_SRID.format(esquema=datos["esquema"], origen=datos["capa_origen"], geom=datos["geom"])) datos["srid"] = cursor.fetchone()[0] if datos["srid"] == 0: cursor.execute(GET_SRID_GEOM.format(esquema=datos["esquema"], origen=datos["capa_origen"], geom=datos["geom"])) datos["srid"] = cursor.fetchone()[0] #cursor.execute(ACTULIZA_SRID.format(esquema=datos["esquema"], origen=datos["capa_origen"], geom=datos["geom"], # srid=datos["srid"])) add_msg(datos, "srid:" + str(datos["srid"])) cursor.execute(GET_TIPO_GEOM.format(esquema=datos["esquema"], origen=datos["capa_origen"], geom=datos["geom"])) datos["tipo_geom"] = cursor.fetchone()[0] add_msg(datos, "Recuperada tipo geometría:" + datos["tipo_geom"]) if not datos["tipo_geom"]: add_msg(datos, "No se encuentra el tipo de geometría de la capa origen:" + datos["tipo_geom"]) raise Exception("No se encuentra el tipo de geometría de la capa origen") if check_valid: print(VALIDA_GEOM.format(esquema=datos["esquema"], origen=datos["capa_origen"], geom=datos["geom"])) cursor.execute(VALIDA_GEOM.format(esquema=datos["esquema"], origen=datos["capa_origen"], geom=datos["geom"])) datos["geom_ignorada"] = cursor.fetchall() add_msg(datos, "Geometrias invalidas: " + str(len(datos["geom_ignorada"]))) def comparar_resultados(datos, cursor, tipo_resultado="simp"): """ Obtiene los datos finales del proceso para su comparación""" datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) # Comparar geometría original y simplificada sql = CONTAR_DATOS.format(geom=datos["geom"], esquema=datos["esquema"], tabla=datos["capa_origen"]) # add_msg(datos, ("Obtener elementos y puntos de origen:" + sql)) cursor.execute(sql) result_orig = cursor.fetchone() datos["features_orig"] = result_orig[0] datos["puntos_orig"] = result_orig[1] sql = CONTAR_DATOS.format(geom=datos["geom"], esquema=datos["esquema_dest"], tabla=datos["capa_" + tipo_resultado]) # add_msg(datos, "Obtener elementos y puntos de resultantes:" + sql) cursor.execute(sql) result_dest = cursor.fetchone() datos["features_" + tipo_resultado] = result_dest[0] datos["puntos_" + tipo_resultado] = result_dest[1] datos["duracion"] = dt.datetime.now() - datos["ini"] # CONSULTA PARA COMPARAR GEOMETRIAS add_msg(datos, ("Comparar geom: " + COMPARA_GEOM.format(esquema=datos["esquema"], origen=datos["capa_origen"], destino=datos["capa_" + tipo_resultado], columnas=datos["campos"], geom=datos["geom"], esquema_dest=datos["esquema_dest"]))) add_msg(datos, ("PROCESO FINALIZADO OK: Elementos originales:{}({}). Elementos ignorados: {}. " "Elementos resultantes: {}({})" .format(datos["features_orig"], datos["puntos_orig"], str(len(datos["geom_ignorada"])), datos["features_" + tipo_resultado], datos["puntos_" + tipo_resultado]))) def suavizar(params, esquema, origen, esquema_dest, destino, iteraciones=1, task=None): """ Crea una copia suavizada de la geometría de una capa """ datos = init_suavizar() datos["esquema"] = esquema datos["capa_origen"] = origen datos["esquema_dest"] = esquema_dest datos["capa_suav"] = destino datos["iteraciones"] = iteraciones borrar_datos_anteriores = True add_msg(datos, "suavizar:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, iteraciones:{}" .format(esquema, origen, esquema_dest, destino, iteraciones)) conn = Connector() try: if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(origen.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_dis"] = destino.split(".")[1] cursor = conn.openParams(params) # CARGAR DATOS ORIGEN carga_datos_origen(datos, cursor) task.set_progress(25) # BORRAR DATOS ANTERIORES CAPA DESTINO if borrar_datos_anteriores: sql = BORRA_TABLA_ANTERIOR.format(destino=datos["capa_suav"], esquema=datos["esquema_dest"]) add_msg(datos, "Borra tabla destino anterior si existe: " + sql) cursor.execute(sql) task.set_progress(50) # CREAR DE NUEVO CAPA DESTINO sql = CLONAR_TABLA.format(esquema= datos["esquema"], esquema_dest=datos["esquema_dest"], destino=datos["capa_suav"], origen=datos["capa_origen"]) add_msg(datos, "Creada tabla destino: " + sql) cursor.execute(sql) task.set_progress(75) # RELLENAR CAPA SUAVIZADA sql = COPIA_DATOS_SUAV.format(destino=datos["capa_suav"], origen=datos["capa_origen"], columnas=datos["campos"], geom=datos["geom"], iteraciones=iteraciones, esquema= datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Copiados datos originales con geometría suavizada: " + sql) cursor.execute(sql) task.set_progress(100) conn.commit() # comparar_resultados(datos, cursor) except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def simplificar(params, esquema, origen, esquema_dest, destino, tolerancia=0, ignorar_topo=True, check_interferencias=None, task=None): """ Crea una copia simplificada de una capa Si ignorar_topo es True llama a simplificar_geo si no, llama a simplificar_topo Si al llamar a simplificar_topo falla, intenta llamar a simplificar_geo """ datos = init_simplificar() datos["ignorar_topo"] = ignorar_topo add_msg(datos, "SIMPLIFICAR:: esquema:{}, origen:{}, esquema_dest:{}," " destino:{}, tolerancia:{}, ignorar_topo:{}, " "check_interferencias:{}".format(esquema, origen, esquema_dest, destino, tolerancia, ignorar_topo, check_interferencias)) if ignorar_topo is None or ignorar_topo is True: return simplificar_geo(params, datos, esquema, origen, esquema_dest, destino, tolerancia, check_interferencias, task) else: try: datos = simplificar_topo(params, datos, esquema, origen, esquema_dest, destino, tolerancia, check_interferencias, task) if datos["resultado"] != "ERROR": return datos else: add_msg(datos, "Error al simplificar con topología. Iniciando simplificación ignorando topología") datos = simplificar_geo(params, datos, esquema, origen, esquema_dest, destino, tolerancia, check_interferencias, task) datos["resultado"] = "AVISO" except Exception as error: add_msg(datos, "Error al simplificar:ERROR:" + str(error)) datos["resultado"] = "ERROR" finally: return datos def simplificar_topo(params, datos, esquema, origen, esquema_dest, destino, tolerancia=0, check_interferencias=None, task=None): """ Crea una copia simplificada de una capa manteniendo las reglas topograficas """ if datos is None: datos = init_simplificar() datos["metodo"] = "simplificar_topo" datos["esquema"] = esquema datos["capa_origen"] = origen datos["esquema_dest"] = esquema_dest datos["capa_simp"] = destino datos["tolerancia"] = tolerancia datos["check"] = check_interferencias add_msg(datos, "SIMPLIFICAR_TOPO:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, tolerancia:{}, " "check_interferencias:{}".format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_simp"], datos["tolerancia"], datos["check"])) borrar_datos_anteriores = True conn = Connector() try: if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_simp"] = destino.split(".")[1] cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(10) if borrar_datos_anteriores: sql = BORRA_TABLA_ANTERIOR.format(destino=datos["capa_simp"], esquema=datos["esquema_dest"]) add_msg(datos, "Borra tabla destino anterior si existe: " + sql) cursor.execute(sql) task.set_progress(15) # COMPROBAR DIMENSIONES GEOM sql = SELECT_DIM.format(esquema=datos["esquema"], origen=datos["capa_origen"], geom=datos["geom"]) cursor.execute(sql) dim = cursor.fetchall()[0][0] # add_msg(datos, "Dimension de geometria: " + str(dim) + "D") if dim >= 3: add_msg(datos, "No se puede calcular la topología para geometrías 3D") add_msg(datos, "Para el cálculo se conviertirá la capa a 2D y se perderá la información correspondiente") sql = CREATE_TABLA_2D.format(destino=datos["capa_simp"], origen=datos["capa_origen"], esquema=datos["esquema"], columnas= datos["campos"], geom=datos["geom"], srid=datos["srid"], esquema_dest=datos["esquema_dest"], tipo_geom=datos["tipo_geom"]) add_msg(datos, "Creada tabla destino con los datos originales con geometría 2D: " + sql) cursor.execute(sql) task.set_progress(30) else: sql = CLONAR_TABLA.format(destino=datos["capa_simp"], origen=datos["capa_origen"],esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Creada tabla destino: " + sql) cursor.execute(sql) task.set_progress(20) sql = COPIA_DATOS.format(destino=datos["capa_simp"], origen=datos["capa_origen"], columnas=datos["campos"], geom=datos["geom"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Copiados datos originales: " + sql) cursor.execute(sql) task.set_progress(30) # sql = CREA_INDICE_GEOM.format(destino=datos["capa_simp"], geom=datos["geom"]) # add_msg(datos, "Creado indice:" + sql) # cursor.execute(sql) # Comprobar si existe la topografia anterior con el mismo nombre y borrarla antes de crear la de esta ejecución if borrar_datos_anteriores: sql = CHECK_TOPO.format(destino="topo_" + datos["capa_simp"] + "_1") add_msg(datos, "Check topología 1 anterior:" + sql) cursor.execute(sql) existe_topo = cursor.fetchone() if len(existe_topo) > 0 and existe_topo[0]: sql = BORRA_TOPO.format(destino="topo_" + datos["capa_simp"] + "_1") add_msg(datos, "Borrar topología 1 anterior:" + sql) cursor.execute(sql) else: add_msg(datos, "No existe topología 1 anterior") task.set_progress(40) # Creates a topology from the origen. Create new empty topology structure sql = CREA_TOPO.format(destino="topo_" + datos["capa_simp"] + "_1", srid=datos["srid"]) add_msg(datos, ("Crea Topo_1:" + sql)) cursor.execute(sql) task.set_progress(50) # add all polygons to topology in one operation as a collection if dim >= 3: sql = ADD_GEOM_TOPO.format(destino="topo_" + datos["capa_simp"] + "_1", geom=datos["geom"], origen=datos["capa_simp"], esquema=datos["esquema_dest"]) else: sql = ADD_GEOM_TOPO.format(destino="topo_" + datos["capa_simp"] + "_1", geom=datos["geom"], origen=datos["capa_origen"], esquema=datos["esquema"]) add_msg(datos, "Añadida geometría a topo_1:" + sql) cursor.execute(sql) task.set_progress(60) # Comprobar si existe la topografia anterior con el mismo nombre y borrarla antes de crear la de esta ejecución if borrar_datos_anteriores: sql = CHECK_TOPO.format(destino="topo_" + datos["capa_simp"] + "_2" ) add_msg(datos, "Check topología 2 anterior:" + sql) cursor.execute(sql) existe_topo = cursor.fetchone() if len(existe_topo) > 0 and existe_topo[0]: sql = BORRA_TOPO.format(destino="topo_" + datos["capa_simp"] + "_2") add_msg(datos, "Borrar topología 2 anterior:" + sql) cursor.execute(sql) else: add_msg(datos, "No existe topología 2 anterior") task.set_progress(70) # Create a new topology based on the simplification of existing one. # (should not be the right way to do it, but calling ST_ChangeEdgeGeom) sql = CREA_TOPO.format(destino="topo_" + datos["capa_simp"] + "_2", srid=datos["srid"]) add_msg(datos, "Crea Topo_2:" + sql) cursor.execute(sql) task.set_progress(80) sql = SIMPLIFICA_A_TOPO.format(destino2="topo_" + datos["capa_simp"] + "_2", geom=datos["geom"], destino="topo_" + datos["capa_simp"] + "_1", tolerancia=tolerancia) add_msg(datos, "Simplificar geometría:" + sql) cursor.execute(sql) task.set_progress(90) # Retrieves polygons by comparing surfaces (pip is not enough for odd-shaped polygons) if _MULTI not in datos["tipo_geom"]: sql = ASIGNA_GEOM_SIMPLE.format(destino=datos["capa_simp"], geom=datos["geom"], esquema=datos["esquema"]) add_msg(datos, "Asignar datos a geometría(simple) simplificada:" + sql) else: tipo_geom_simple = datos["tipo_geom"][5:] # Quitar el "MULTI" sql = ASIGNA_GEOM_MULTI.format(destino=datos["capa_simp"], geom=datos["geom"], tipo_geom_simple=tipo_geom_simple, tipo_geom=datos["tipo_geom"], srid=datos["srid"], esquema=datos["esquema_dest"]) add_msg(datos, "Asignar datos a geometría(multi) simplificada:" + sql) cursor.execute(sql) if datos["check"] is not None: check(params, datos["esquema"], datos["capa_simp"], datos["esquema_dest"], datos["check"]["destinos"], datos["esquema"], datos["capa_origen"], datos["capa_origen"], datos["geom"], datos["check"]["buffer"], datos["check"]["filtro"], datos["check"]["de9im"], task, cursor) task.set_progress(100) # GUARDAR conn.commit() comparar_resultados(datos, cursor) except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def simplificar_geo(params, datos, esquema, origen, esquema_dest, destino, tolerancia=0, check_interferencias=None, task=None): """crea una copia simplificada de una capa""" if datos is None: datos = init_simplificar() datos["metodo"] = "simplificar_geo" datos["esquema"] = esquema datos["capa_origen"] = origen datos["esquema_dest"] = esquema_dest datos["capa_simp"] = destino datos["tolerancia"] = tolerancia datos["check"] = check_interferencias borrar_datos_anteriores = True add_msg(datos, "SIMPLIFICAR_GEO:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, tolerancia:{}, " "check_interferencias:{}".format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_simp"], datos["tolerancia"], datos["check"])) conn = Connector() try: if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_simp"] = destino.split(".")[1] cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(25) if borrar_datos_anteriores: sql = BORRA_TABLA_ANTERIOR.format(destino=datos["capa_simp"], esquema=datos["esquema_dest"]) add_msg(datos, "Borra tabla destino anterior si existe: " + sql) cursor.execute(sql) task.set_progress(50) sql = CLONAR_TABLA.format(destino=datos["capa_simp"], origen=datos["capa_origen"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Creada tabla destino: " + sql) cursor.execute(sql) task.set_progress(75) sql = COPIA_DATOS_SIMP.format(destino=datos["capa_simp"], origen=datos["capa_origen"], columnas=datos["campos"], geom=datos["geom"], tolerancia=tolerancia, esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Copiados datos originales con geometría simplificada: " + sql) cursor.execute(sql) # sql = CREA_INDICE_GEOM.format(destino=datos["capa_simp"], geom=datos["geom"]) # add_msg(datos, "Creado indice:" + sql) # cursor.execute(sql) if datos["check"] is not None and datos["check"]["destinos"] is not None: itfs_destino = check(params, datos["esquema_dest"], datos["capa_simp"], datos["esquema"], datos["check"]["destinos"], datos["esquema"], datos["capa_origen"], datos["geom"], datos["check"]["buffer"], datos["check"]["filtro"], datos["check"]["de9im"], task, cursor) datos["itfs"] = itfs_destino task.set_progress(100) conn.commit() comparar_resultados(datos, cursor) except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def disolver(params, esquema, origen, esquema_dest, destino, campos_comunes, campos_sum="", campos_avg="", campos_min="", campos_max="", forzar_geom_simple=False, task=None): datos = init_disolver() datos["esquema"] = esquema datos["esquema_dest"] = esquema_dest datos["capa_origen"] = origen datos["capa_dis"] = destino datos["campos_comunes"] = campos_comunes datos["campos_sum"] = "" if campos_sum is None else campos_sum datos["campos_avg"] = "" if campos_avg is None else campos_avg datos["campos_min"] = "" if campos_min is None else campos_min datos["campos_max"] = "" if campos_max is None else campos_max datos["forzar_geom_simple"] = False if forzar_geom_simple is None else forzar_geom_simple add_msg(datos, "DISOLVER:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, campos_comunes:{}, " "campos_sum:{}, campos_avg:{}, campos_min:{}, campos_max:{}" .format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_dis"], datos["campos_comunes"], datos["campos_sum"], datos["campos_avg"], datos["campos_min"], datos["campos_max"])) conn = Connector() try: borrar_datos_anteriores = True a_campos_sum = [] a_campos_avg = [] a_campos_min = [] a_campos_max = [] if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_dis"] = destino.split(".")[1] cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(25) # VALIDAR PARAMETROS if datos["campos_comunes"] is None or datos["campos_comunes"] == "": raise Exception("No se han definido los campos comunes por los que unir las geometrías") else: a_campos_comunes = datos["campos_comunes"].replace(" ", "").split(",") num_encontrados = len(set(a_campos_comunes).intersection(datos["campos"].replace(" ", "").replace("\"", "").split(","))) if len(a_campos_comunes) != num_encontrados: raise Exception("Algunos de los campos comunes no existe en la capa origen") if datos["campos_sum"] is not None and datos["campos_sum"] != "": a_campos_sum = datos["campos_sum"].split(",") num_encontrados = len(set(a_campos_sum).intersection(datos["campos"].split(", "))) if len(a_campos_sum) != num_encontrados: raise Exception("Algunos de los campos de sumatorio no existe en la capa origen") if datos["campos_avg"] is not None and datos["campos_avg"] != "": a_campos_avg = datos["campos_avg"].split(",") num_encontrados = len(set(a_campos_avg).intersection(datos["campos"].split(", "))) if len(a_campos_avg) != num_encontrados: raise Exception("Algunos de los campos de mínimos no existe en la capa origen") if datos["campos_min"] is not None and datos["campos_min"] != "": a_campos_min = datos["campos_min"].split(",") num_encontrados = len(set(a_campos_min).intersection(datos["campos"].split(", "))) if len(a_campos_min) != num_encontrados: raise Exception("Algunos de los campos de mínimos no existe en la capa origen") if datos["campos_max"] is not None and datos["campos_max"] != "": a_campos_max = datos["campos_max"].split(",") num_encontrados = len(set(a_campos_max).intersection(datos["campos"].split(", "))) if len(a_campos_max) != num_encontrados: raise Exception("Algunos de los campos de máximos no existe en la capa origen") # BORRAR TABLA DESTINO SI YA EXISTE if borrar_datos_anteriores: sql = BORRA_TABLA_ANTERIOR.format(destino=datos["capa_dis"], esquema=datos["esquema_dest"]) add_msg(datos, "Borra tabla destino anterior si existe: " + sql) cursor.execute(sql) task.set_progress(50) # PREPARAMOS LA SQL PARA CREAR LA CAPA DISUELTA campos_finales = sql_campos_comunes = ", ".join(("\"" + campo + "\"") for campo in a_campos_comunes) # CREAR SQL PARA CAMPOS SUMATORIO: "SUM(campo) as sum_campo," sql_campos_sum = "" sql_campos_avg = "" sql_campos_min = "" sql_campos_max = "" for campo in a_campos_sum: sql_campos_sum += ", SUM({campo}) as sum_{campo} ".format(campo=campo) campos_finales += ", sum_{campo}".format(campo=campo) # CREAR SQL PARA CAMPOS MEDIA: "AVG(campo) as avg_campo," for campo in a_campos_avg: sql_campos_avg += ", AVG({campo}) as avg_{campo} ".format(campo=campo) campos_finales += ", avg_{campo}".format(campo=campo) # CREAR SQL PARA CAMPOS MINIMOS: "MIN(campo) as min_campo," for campo in a_campos_min: sql_campos_min += ", MIN({campo}) as min_{campo} ".format(campo=campo) campos_finales += ", min_{campo}".format(campo=campo) # CREAR SQL PARA CAMPOS MAXIMOS: "MAX(campo) as max_campo," for campo in a_campos_max: sql_campos_max += ", MAX({campo}) as max_{campo} ".format(campo=campo) campos_finales += ", max_{campo}".format(campo=campo) # COMPROBAR DIMENSIONES GEOM sql = SELECT_DIM.format(esquema=datos["esquema"], origen=datos["capa_origen"], geom=datos["geom"]) cursor.execute(sql) dim = cursor.fetchall()[0][0] add_msg(datos, "Dimension de geometria: " + str(dim) + "D") if forzar_geom_simple is not None and forzar_geom_simple is True: tipo_geom_simple = datos["tipo_geom"] if _MULTI in datos["tipo_geom"]: tipo_geom_simple = datos["tipo_geom"][5:] if dim >= 3: sql = CREAR_TABLA_DIS_SIMPLE_3D.format(destino=datos["capa_dis"], tipo_geom=tipo_geom_simple, origen=datos["capa_origen"], geom=datos["geom"], campos_comunes=sql_campos_comunes, campos_sum=sql_campos_sum, campos_avg=sql_campos_avg, campos_min=sql_campos_min, campos_max=sql_campos_max, esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) else: sql = CREAR_TABLA_DIS_SIMPLE.format(destino=datos["capa_dis"],origen=datos["capa_origen"], tipo_geom=tipo_geom_simple, srid=datos["srid"], geom=datos["geom"], campos_comunes=sql_campos_comunes, campos_sum=sql_campos_sum, campos_avg=sql_campos_avg, campos_min=sql_campos_min, campos_max=sql_campos_max, esquema=datos["esquema"],esquema_dest=datos["esquema_dest"]) else: tipo_geom_multi = datos["tipo_geom"] if _MULTI not in datos["tipo_geom"] and datos["tipo_geom"] != 'GEOMETRY': tipo_geom_multi = _MULTI + datos["tipo_geom"] if dim >= 3: sql = CREAR_TABLA_DIS_MULTI_3D.format(destino=datos["capa_dis"],origen=datos["capa_origen"], tipo_geom=tipo_geom_multi, srid=datos["srid"], geom=datos["geom"], campos_comunes=sql_campos_comunes, campos_sum=sql_campos_sum, campos_avg=sql_campos_avg, campos_min=sql_campos_min, campos_max=sql_campos_max, campos_finales=campos_finales, esquema= datos["esquema"], esquema_dest=datos["esquema_dest"]) else: sql = CREAR_TABLA_DIS_MULTI.format(destino=datos["capa_dis"], origen=datos["capa_origen"], tipo_geom=tipo_geom_multi, srid=datos["srid"], geom=datos["geom"], campos_comunes=sql_campos_comunes, campos_sum=sql_campos_sum, campos_avg=sql_campos_avg, campos_min=sql_campos_min, campos_max=sql_campos_max, campos_finales=campos_finales, esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Creada tabla destino: " + sql) cursor.execute(sql) task.set_progress(75) sql = CREA_INDICE_GEOM.format(destino=datos["capa_dis"], geom=datos["geom"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Creado indice:" + sql) cursor.execute(sql) task.set_progress(100) conn.commit() comparar_resultados(datos, cursor, "dis") except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def limpiar_tolerancia(params, esquema, origen, esquema_dest, destino, tolerancia=1, task=None): datos = init_limpiar() datos["esquema"] = esquema datos["capa_origen"] = origen datos["esquema_dest"] = esquema_dest datos["capa_limp"] = destino datos["tolerancia"] = tolerancia add_msg(datos, "LIMPIAR_TOLERANCIA:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, tolerancia:{}" .format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_limp"], datos["tolerancia"])) conn = Connector() try: borrar_datos_anteriores = True if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_limp"] = destino.split(".")[1] cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(25) if datos["tipo_geom"] == "POINT" or datos["tipo_geom"] == "MULTIPOINT": raise Exception("La herramienta Limpiar no soporta geometrías de puntos") # BORRAR TABLA DESTINO SI YA EXISTE if borrar_datos_anteriores: sql = BORRA_TABLA_ANTERIOR.format(destino= datos["capa_limp"], esquema= datos["esquema_dest"]) add_msg(datos, "Borra tabla destino anterior si existe: " + sql) cursor.execute(sql) task.set_progress(50) sql = CLONAR_TABLA.format(destino=datos["capa_limp"], origen=datos["capa_origen"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Creada tabla destino: " + sql) cursor.execute(sql) task.set_progress(75) sql = COPIA_DATOS_LIMPIOS.format(destino=datos["capa_limp"], origen=datos["capa_origen"], columnas=datos["campos"], geom=datos["geom"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) sql += WHERE_DATOS_LIMPIOS_TOLERANCIA.format(tolerancia=datos["tolerancia"], geom=datos["geom"]) add_msg(datos, "Copiados datos originales filtrando por tolerancia: " + sql) cursor.execute(sql) task.set_progress(100) conn.commit() comparar_resultados(datos, cursor, "limp") except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def limpiar_param(params, esquema, origen, esquema_dest, destino, tolerancia, filtro, task=None): datos = init_limpiar() datos["esquema"] = esquema datos["capa_origen"] = origen datos["esquema_dest"] = esquema_dest datos["capa_limp"] = destino datos["tolerancia"] = tolerancia datos["filtro"] = filtro add_msg(datos, "LIMPIAR_PARAM:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, tolerancia:{}, filtro:{}" .format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_limp"], datos["tolerancia"], datos["filtro"])) conn = Connector() try: borrar_datos_anteriores = True if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_limp"] = destino.split(".")[1] cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(25) # BORRAR TABLA DESTINO SI YA EXISTE if borrar_datos_anteriores: sql = BORRA_TABLA_ANTERIOR.format(destino=datos["capa_limp"], esquema=datos["esquema_dest"]) add_msg(datos, "Borra tabla destino anterior si existe: " + sql) cursor.execute(sql) task.set_progress(50) sql = CLONAR_TABLA.format(destino=datos["capa_limp"], origen=datos["capa_origen"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Creada tabla destino: " + sql) cursor.execute(sql) task.set_progress(75) sql = COPIA_DATOS_LIMPIOS.format(destino=datos["capa_limp"], origen=datos["capa_origen"], columnas=datos["campos"], geom=datos["geom"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) if filtro is not None and len(filtro) > 0: sql += WHERE_DATOS_LIMPIOS_FILTRO.format(filtro=datos["filtro"]) if tolerancia is not None: sql += WHERE_DATOS_LIMPIOS_TOLERANCIA.format(tolerancia=datos["tolerancia"], geom=datos["geom"]) add_msg(datos, "Copiados datos originales filtrados : " + sql) cursor.execute(sql) task.set_progress(100) conn.commit() comparar_resultados(datos, cursor, "limp") except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def check(params, esquema, origen, esquema_dest, destinos, esquema_no_trasnf, capa_no_trasnf, geom_no_transf, buffer, filtro, de9im='T********', task=None, _cursor=None): datos = init_check() datos["capa_origen"] = origen datos["esquema"] = esquema if esquema is not None else "public" datos["destinos"] = destinos datos["esquema_dest"] = esquema_dest if esquema_dest is not None else "public" datos["capa_no_trasnf"] = capa_no_trasnf datos["esquema_no_trasnf"] = esquema_no_trasnf if esquema_no_trasnf is not None else "public" datos["geom_no_transf"] = geom_no_transf datos["buffer"] = buffer if buffer is not None and buffer != '' else None datos["filtro"] = filtro if filtro is not None and len(filtro) > 0 else None datos["de9im"] = de9im if de9im is not None and len(de9im) > 0 else 'T********' datos["capas_itf"] = [] datos["check_inteferencias"] = [] add_msg(datos, "CHECK:: esquema:{}, origen:{}, esquema_dest:{}, destinos:{}, buffer:{}, filtro:{}, de9im:{}" .format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["destinos"], datos["buffer"], datos["filtro"], datos["de9im"])) conn = None if _cursor is None: conn = Connector() try: if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(origen.split(".")) > 1: datos["esquema_dest"] = destinos.split(".")[0] datos["destinos"] = destinos.split(".")[1] if _cursor is None: cursor = conn.openParams(params) else: cursor = _cursor carga_datos_origen(datos, cursor, False) datos_dest = {} inc = float(100 / len(datos["destinos"])) progreso = 0 str_hora = dt.datetime.now().strftime("%Y%m%d%H%M%S") campos_org = ",".join([("a."+campo+" as a_"+campo.replace("\"", ""))for campo in datos["campos"].split(", ")]) for capas in datos["destinos"]: capa = capas[0] datos_dest[capa] = carga_datos_capa(capa, datos, cursor, False) campos_chk = ",".join( [("b." + campo + " as b_" + campo.replace("\"", "")) for campo in datos_dest[capa]["campos"].split(", ")]) capa_interferencia = capas[1] add_msg(datos, "Capa interferencias: " + capa_interferencia) #capa_interferencia = "itf{}_{}_{}".format(str_hora, datos["capa_origen"], capa)[0:63] datos["capas_itf"].append(capa_interferencia) if datos["buffer"] is not None and float(datos["buffer"]) > 0: datos_dest[capa]["sql"] = CHECK_CAPA_JOIN_BUFFER.format(capa_chk=capa, origen=datos["capa_origen"], esquema=datos["esquema"], geom_origen=datos["geom"], geom_chk=datos_dest[capa]["geom"], buffer=buffer, DE9IM=datos["de9im"]) else: datos_dest[capa]["sql"] = CHECK_CAPA_JOIN.format(capa_chk=capa, origen=datos["capa_origen"], esquema=datos["esquema"], geom_origen=datos["geom"], geom_chk=datos_dest[capa]["geom"], DE9IM=datos["de9im"]) if datos["capa_no_trasnf"] is not None: where = CHECK_WHERE.format(esquema_no_trasnf=datos["esquema_no_trasnf"], capa_no_trasnf=datos["capa_no_trasnf"], geom_chk=datos_dest[capa]["geom"], geom_no_trasnf=datos["geom_no_transf"]) if filtro is not None and len(filtro) > 0: where = WHERE_DATOS_LIMPIOS_FILTRO.format(filtro=datos["filtro"]) cursor.execute(CHECK_DROP_TABLE.format(origen=capa_interferencia, esquema=datos["esquema_dest"])) sql = CHECK_CREATE_TABLE.format(campos_org=campos_org, campos_chk=campos_chk, origen=datos["capa_origen"], capa_chk=capa, esquema=datos["esquema"], destino=capa_interferencia, esquema_dest=datos["esquema_dest"], join=datos_dest[capa]["sql"], where=where, geom_origen=datos["geom"], geom_chk=datos_dest[capa]["geom"]) add_msg(datos, "Check interferencias: " + sql) cursor.execute(sql) add_msg(datos, "Creada capa de interferencias: {}".format(capa_interferencia)) sql = ADD_ID.format(esquema=datos["esquema_dest"], destino=capa_interferencia, id="id_itf") add_msg(datos, "Añadido id_itf de interferencias: "+sql) cursor.execute(sql) sql = CREATE_GEOM_IDX.format(esquema=datos["esquema_dest"], destino=capa_interferencia, geom_chk=datos_dest[capa]["geom"], nombre=dt.datetime.now().strftime("%Y%m%d%H%M%S")) add_msg(datos, "Creado indice espacial: " + sql) cursor.execute(sql) sql = SQL_COUNT.format(esquema=datos["esquema_dest"], origen=capa_interferencia) cursor.execute(sql) add_msg(datos, "La capa {} tiene {} interferencias".format(capa_interferencia, str(cursor.fetchone()[0]))) registra_interferencias(capa_interferencia, datos["esquema"], datos["capa_origen"], datos["esquema_dest"], capa, datos, cursor) datos["check_inteferencias"].append(datos_dest) if task is not None: progreso += inc task.set_progress(int(progreso)) if datos["capa_no_trasnf"] is not None: add_msg(datos, "check::autoreparar interferencias:: capa_interferencia:{}, esquema:{}" .format(capa_interferencia, esquema, datos)) try: if "LINE" in datos["tipo_geom"] or "POLYGON" in datos["tipo_geom"]: # i.b_gid = b.gid AND ... on_claves_bb = " AND ".join( ["i.\"b_{}\"=b.\"{}\"".format(campo, campo) for campo in datos_dest[capa]["pk"]]) # i.a_gid = o.gid AND ... on_claves_ao = " AND ".join( ["i.\"a_{}\"=o.\"{}\"".format(campo, campo) for campo in datos["pk"]]) # i2.a_gid = a.gid AND ... on_claves_aa = " AND ".join( ["i2.\"a_{}\"=a.\"{}\"".format(campo, campo) for campo in datos["pk"]]) on_claves_ia_a = " AND ".join( ["i.\"a_{}\"=a.\"{}\"".format(campo, campo) for campo in datos["pk"]]) # ITF.a_gid = a1.a_gid on_claves_itf1 = " AND ".join( ["ITF.\"a_{}\"=a1.\"{}\"".format(campo, campo) for campo in datos["pk"]]) on_claves_itf2 = " AND ".join( ["ITF.\"a_{}\"=a2.\"a_{}\"".format(campo, campo) for campo in datos["pk"]]) # i0.a_gid, i0.a_gid2,... i0_claves_a = ", ".join(["i0.\"a_{}\"".format(campo) for campo in datos["pk"]]) # ITF.a_gid itf_claves_a = ", ".join(["ITF.\"a_{}\"".format(campo) for campo in datos["pk"]]) # i0.b_gid, i0.b_gid2,... i0_claves_b = ", ".join(["i0.\"b_{}\"".format(campo) for campo in datos_dest[capa]["pk"]]) # i.a_gid, i.a_gid2,... i_claves_a = ", ".join(["i.\"a_{}\"".format(campo) for campo in datos["pk"]]) # i.b_gid, i.b_gid2,... i_claves_b = ", ".join(["i.\"b_{}\"".format(campo) for campo in datos_dest[capa]["pk"]]) # a_gid, a_gid2,... claves_itf_a = ", ".join(["\"a_{}\"".format(campo) for campo in datos["pk"]]) claves_a = ", ".join(["\"{}\"".format(campo) for campo in datos["pk"]]) # b_gid, b_gid2,... claves_itf_b = ", ".join(["\"b_{}\"".format(campo) for campo in datos_dest[capa]["pk"]]) claves_b = ", ".join(["\"{}\"".format(campo) for campo in datos_dest[capa]["pk"]]) if "LINE" in datos["tipo_geom"]: # LINE OR MULTILINE sql = CHECK_CREATE_CORRECT_LIN.format(dest_temp=str_hora, esquema=datos["esquema"], capa_itf=capa_interferencia, capa_chk=datos_dest[capa]["capa_origen"], origen=datos["capa_no_trasnf"], destino=datos["capa_origen"], i0_claves_a=i0_claves_a, i0_claves_b=i0_claves_b, i_claves_a=i_claves_a, i_claves_b=i_claves_b, claves_a=claves_itf_a, claves_b=claves_itf_b, on_claves_bb=on_claves_bb, on_claves_ao=on_claves_ao, on_claves_aa=on_claves_aa, geom_a=datos["geom"], geom_o=datos["geom_no_transf"], geom_itf=datos["geom"], geom_chk=datos_dest[capa]["geom"]) add_msg(datos, "Consulta capa de interferencia: " + sql) cursor.execute(sql) where = " AND ".join(["a.\"{}\" = ITF.\"a_{}\"".format(campo, campo) for campo in datos["pk"]]) sql = CHECK_AUTOREPAIR_LIN.format(dest_temp=str_hora, esquema=datos["esquema"], geom=datos["geom"], dest=datos["capa_origen"], where=where) add_msg(datos, "Acualizadas geometrías reparadas: " + sql) cursor.execute(sql) else: # POLIGON OR MULTIPOLIGON sql = CHECK_CREATE_CORRECT_POL.format(dest_temp=str_hora, esquema=datos["esquema"], capa_itf=capa_interferencia, capa_chk=datos_dest[capa]["capa_origen"], destino=datos["capa_origen"], claves_a=claves_itf_a, claves_b=claves_itf_b, clave_a=claves_a, clave_b=claves_b, on_claves_bb=on_claves_bb, on_claves_aa=on_claves_ia_a, geom_a=datos["geom"], geom_itf=datos["geom"], geom_chk=datos_dest[capa]["geom"]) add_msg(datos, "Consulta capa de interferencia: " + sql) cursor.execute(sql) where = " AND ".join(["a.\"{}\" = ITF.\"a_{}\"".format(campo, campo) for campo in datos["pk"]]) sql = CHECK_AUTOREPAIR_POL.format(dest_temp=str_hora, esquema=datos["esquema"], geom=datos["geom"], dest=datos["capa_origen"], where=where, claves_itf_a=claves_itf_a, claves_b=claves_b, itf_claves_a=itf_claves_a, geom_chk=datos_dest[capa]["geom"], on_claves_itf1=on_claves_itf1, on_claves_itf2=on_claves_itf2) add_msg(datos, "Acualizadas geometrías reparadas: " + sql) cursor.execute(sql) add_msg(datos, "Nº de geometrías reparadas: {}".format(cursor.rowcount)) sql = UPDATE_ESTADO_ITF.format(esquema=datos["esquema"], capa_itf=capa_interferencia, estado_itf=CHECK_ESTADO_ARREGLADA) sql += WHERE_IDITF_IN_AUTOREPAIR.format(dest_temp=str_hora, claves_a=claves_itf_a, esquema=datos["esquema"], capa_itf=capa_interferencia) add_msg(datos, "Actualizar estados de interferencias reparadas: " + sql) cursor.execute(sql) else: add_msg(datos, "Tipo de geometria no soportada para autoreparación de interferencias: " + datos["tipo_geom"]) except Exception as error: add_msg(datos, "ERROR::check::intenta_desplaza_interferencias::" + str(error)) raise error finally: pass if conn is not None: conn.commit() except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() task.set_progress(100) return datos def borrar_itf_origen(capa_itf, origen_itf, datos, cursor): add_msg(datos, "BORRAR_ITF_ORIGEN:: capa_itf:{}, origen_itf:{}".format(capa_itf, origen_itf)) try: datos_capa = carga_datos_capa(origen_itf, datos, cursor, False) campos_comunes = [] # genera el where comparando todos los campos excepto el id_itf for campo in datos_capa['campos'].split(" , "): if campo not in("id_itf", '"id_itf"','"id_itf" '): campo = campo.replace("\"", "") campos_comunes.append(campo) campos = ", ".join(["a_{}, b_{}".format(campo, campo) for campo in campos_comunes]) sql = CHECK_BUSCA_ITF_DESCARTAR.format(capa_itf=capa_itf, origen_itf=origen_itf, esquema=datos["esquema"], campos=datos_capa['campos']) add_msg(datos, "Consultar interferencias a descartar: " + sql) cursor.execute(sql) arr_descartados = cursor.fetchall() # add_msg(datos, "columnas de capa: " + str(arr_descartados)) if len(arr_descartados) > 0: ids = ",".join(["'{}'".format(id_descartado[0]) for id_descartado in arr_descartados]) sql = CHECK_BORRA_ITF_DESCARTAR.format(ids=ids, esquema=datos["esquema"], capa_itf=capa_itf) add_msg(datos, "Borrar interferencia presentes en origen: " + sql) cursor.execute(sql) sql = BORRAR_REGISTRO_INTER_IDS.format(capa_interferencia=capa_itf, ids=ids, esquema=datos["esquema_dest"]) add_msg(datos, "Borrar registro de interferencia presentes en origen: " + sql) cursor.execute(sql) except Exception as error: add_msg(datos, "ERROR::borrar_itf_origen::" + str(error)) raise error finally: pass def registra_interferencias(capa_interferencia, esquema_org, capa_org, esquema_chk, capa_chk, datos, cursor): add_msg(datos, "REGISTRA_INTERFERENCIAS:: capa_interferencia:{}, " "esquema_org:{}, capa_org:{}, esquema_dest:{}, capa_dest:{}" .format(capa_interferencia, esquema_org, capa_org, esquema_chk, capa_chk)) try: sql = CHECK_CREATE_ESTADO_INTERFERENCIAS.format(esquema_chk=esquema_chk) add_msg(datos, "Crear tabla de estado de interferencia: " + sql) cursor.execute(sql) sql = CHECK_INSERT_ESTADO_INTERFERENCIAS.format(capa_itf=capa_interferencia, esquema_org=esquema_org, capa_org=capa_org, esquema_chk=esquema_chk, capa_chk=capa_chk) add_msg(datos, "Insert interferencias: " + sql) cursor.execute(sql) except Exception as error: add_msg(datos, "ERROR::registra_interferencias::" + str(error)) finally: pass def elimina_interferencias(capa_interferencia, esquema, datos, cursor): add_msg(datos, "ELIMINAR_INTERFERENCIAS:: capa_interferencia:{}, " "esquema:{}" .format(capa_interferencia, esquema, datos)) try: # BORRO CAPA_INTERFERENCIAS sql = BORRAR_INTER.format(capa_interferencia=capa_interferencia, esquema=esquema) add_msg(datos, "Borrar tabla de interferencia: " + sql) cursor.execute(sql) # BORRAR REGISTRO sql = BORRAR_REGISTRO_INTER.format(capa_interferencia=capa_interferencia, esquema=esquema) add_msg(datos, "Borrar registro de interferencia: " + sql) cursor.execute(sql) except Exception as error: add_msg(datos, "ERROR::elimina_interferencias::" + str(error)) raise error finally: pass def cambiar_estado(params, capa_itf, id_itf, estado_itf, task=None): datos = init_estado() datos["capa_itf"] = capa_itf datos["id_itf"] = id_itf datos["estado_itf"] = estado_itf task.set_progress(50) add_msg(datos, "CAMBIAR_ESTADO_INTERFERENCIAS:: id_itf:{}, capa_itf:{}, estado_itf:{}" .format(id_itf, capa_itf, estado_itf)) conn = Connector() try: # CONTROL PARAMETROS estado_itf = str(estado_itf.upper()) add_msg(datos, "ESTADO ES :: id_itf:{}, capa_itf:{}, estado_itf:{}" .format(id_itf, capa_itf, estado_itf)) if estado_itf in (CHECK_ESTADO_PENDIENTE, CHECK_ESTADO_ARREGLADA, CHECK_ESTADO_IGNORADA): cursor = conn.openParams(params) # CAMBIO ESTADO sql = UPDATE_ESTADO_ITF.format(esquema=datos["esquema_dest"], capa_itf=capa_itf, estado_itf=estado_itf) # COMPRUEBO ID_ITF if id_itf is not None: sql += WHERE_IDITF.format(id_itf=id_itf) add_msg(datos, "Actualizo estado y fecha modificación: " + sql) task.set_progress(100) cursor.execute(sql) conn.commit() else: raise Exception("No se ha introducido un estado válido") except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() task.set_progress(100) return datos def disolver_geo(params, esquema, esquema_dest, origen, destino, buffer, task=None): datos = init_disolver_geo() datos["esquema"] = esquema datos["esquema_dest"] = esquema_dest datos["capa_origen"] = origen datos["capa_dis"] = destino datos["buffer"] = buffer add_msg(datos, "disolver_geo:: esquema_origen:{}, origen:{}, esquema_destino:{}, destino:{}, buffer:{}" .format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_dis"], datos["buffer"])) conn = Connector() try: borrar_datos_anteriores = True if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_dis"] = origen.split(".")[1] cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(25) # BORRAR TABLA DESTINO SI YA EXISTE if borrar_datos_anteriores: sql = BORRA_TABLA_ANTERIOR.format(destino=datos["capa_dis"], esquema=datos["esquema_dest"]) add_msg(datos, "Borra tabla destino anterior si existe: " + sql) cursor.execute(sql) task.set_progress(50) # COMPRUEBO NOMBRE CAMPO PK (PRIMARY KEY) sql = GET_CAMPO_ID.format(esquema=datos["esquema"], origen=datos["capa_origen"]) cursor.execute(sql) add_msg(datos, "Selecciono el campo ID: " + sql) if cursor.rowcount == 0: # CREO TABLA SIN ID if datos["buffer"] is not None and float(datos["buffer"]) > 0: sql = CREATE_TABLE_DIS_GEO_ID_BFF.format(esquema=datos["esquema"], esquema_dest=datos["esquema_dest"], destino=datos["capa_dis"], origen=datos["capa_origen"], buffer=datos["buffer"], geom=datos["geom"]) else: sql = CREATE_TABLE_DIS_GEO_ID.format(esquema=datos["esquema"], esquema_dest=datos["esquema_dest"], destino=datos["capa_dis"], origen=datos["capa_origen"], geom=datos["geom"]) add_msg(datos, "Creada tabla destino: " + sql) cursor.execute(sql) # AGREGO IDS sql = ADD_ID.format(esquema=datos["esquema_dest"], destino=datos["capa_dis"], id="id") cursor.execute(sql) task.set_progress(75) else: if cursor.rowcount == 1: name_id = cursor.fetchall() datos["name_id"] = (name_id[0][0]) #print(name_id[0][0]) # sql para disolver if datos["buffer"] is not None and float(datos["buffer"]) > 0: sql = CREAR_TABLA_DIS_BUF_GEO.format(esquema=datos["esquema"], esquema_dest=datos["esquema_dest"], destino=datos["capa_dis"], origen=datos["capa_origen"], nombre_id=datos["name_id"], buffer=datos["buffer"], geom=datos["geom"]) else: sql = CREAR_TABLA_DIS_GEO.format(esquema=datos["esquema"], esquema_dest=datos["esquema_dest"], destino=datos["capa_dis"], nombre_id=datos["name_id"], origen=datos["capa_origen"], geom=datos["geom"]) cursor.execute(sql) task.set_progress(75) add_msg(datos, "Creada tabla destino: " + sql) cursor.execute(GET_IDS.format(esquema=datos["esquema_dest"], destino=datos["capa_dis"])) datos["ids"] = cursor.fetchall() task.set_progress(100) conn.commit() except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def exagerar(params, esquema, origen, esquema_dest, destino, escala, where, task=None): datos = init_exagerar() datos["esquema"] = esquema datos["esquema_dest"] = esquema_dest datos["capa_origen"] = origen datos["capa_dis"] = destino datos["escala"] = escala if where == "": datos["where"] = where else: datos["where"] = " where " + where add_msg(datos, "EXAGERAR:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, scale:{}, where:{}" .format(datos["esquema"], datos["capa_origen"],datos["esquema_dest"], datos["capa_dis"], datos["escala"], where)) conn = Connector() try: borrar_datos_anteriores = True if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_dis"] = destino.split(".")[1] cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(25) cursor.execute(FUNCTION_ST_DILATE) task.set_progress(50) # BORRAR TABLA DESTINO SI YA EXISTE if borrar_datos_anteriores: sql = BORRA_TABLA_ANTERIOR.format(destino=datos["capa_dis"], esquema=datos["esquema_dest"]) add_msg(datos, "Borra tabla destino anterior si existe: " + sql) cursor.execute(sql) task.set_progress(75) sql = CREATE_TABLE_DILATE.format(destino=datos["capa_dis"], origen=datos["capa_origen"], geom=datos["geom"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"], escala=datos["escala"], where=datos["where"]) add_msg(datos, "Creada tabla destino: " + sql) cursor.execute(sql) task.set_progress(100) conn.commit() comparar_resultados(datos, cursor, "dis") except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def desplazar(params, esquema, origen, esquema_dest, destino, desplazamientoX, desplazamientoY, where, task=None): datos = init_desplazar() datos["esquema"] = esquema datos["esquema_dest"] = esquema_dest datos["capa_origen"] = origen datos["capa_dis"] = destino datos["desplazamientoX"] = desplazamientoX datos["desplazamientoY"] = desplazamientoY if where == "": datos["where"] = where else: datos["where"] = " where " + where add_msg(datos, "DESPLAZAR:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, desplazamientoX:{}, desplazamientoY:{}, where:{}" .format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_dis"], datos["desplazamientoX"], datos["desplazamientoY"], where)) conn = Connector() try: borrar_datos_anteriores = True if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_dis"] = destino.split(".")[1] cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(25) # BORRAR TABLA DESTINO SI YA EXISTE if borrar_datos_anteriores: sql = BORRA_TABLA_ANTERIOR.format(destino=datos["capa_dis"], esquema=datos["esquema_dest"]) add_msg(datos, "Borra tabla destino anterior si existe: " + sql) cursor.execute(sql) task.set_progress(75) sql = CREATE_TABLE_TRANSLATE.format(destino=datos["capa_dis"], origen=datos["capa_origen"], geom=datos["geom"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"], desplazamientoX=datos["desplazamientoX"], desplazamientoY=datos["desplazamientoY"], where=datos["where"]) add_msg(datos, "Creada tabla destino: " + sql) cursor.execute(sql) task.set_progress(100) conn.commit() comparar_resultados(datos, cursor, "dis") except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def agregar(params, esquema, origen, esquema_dest, destino, dist, minp, ajuste, task=None): datos = init_agregar() datos["esquema"] = esquema datos["esquema_dest"] = esquema_dest datos["capa_origen"] = origen datos["capa_agr"] = destino datos["distancia"] = dist datos["minp"] = minp datos["ajuste"] = ajuste add_msg(datos, "AGREGAR:: esquema{}, origen:{}, esquema_dest{}, destino:{}, distancia:{}, min_puntos:{}" .format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_agr"], datos["distancia"], datos["minp"])) conn = Connector() try: borrar_datos_anteriores = True if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_agr"] = destino.split(".")[1] cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(25) # BORRAR TABLA DESTINO SI YA EXISTE if borrar_datos_anteriores: sql = BORRA_TABLA_ANTERIOR.format(destino=datos["capa_agr"], esquema=datos["esquema_dest"]) add_msg(datos, "Borra tabla destino anterior si existe: " + sql) cursor.execute(sql) task.set_progress(75) # CAMPO ID if datos["pk"] == '' or datos["pk"] == None or datos["pk"] == []: # cursor.execute(CREATE_COLUMN_PK.format(esquema=datos["esquema"], origen=datos["capa_origen"], pk="id")) datos["pk"] = ['id'] # TABLA AGREGADO sql = CREATE_TABLE_AGREGADOS.format(destino=datos["capa_agr"], origen=datos["capa_origen"], campos_comunes=datos["campos"], geom=datos["geom"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"], id=datos["pk"][0], dist=datos["distancia"], minp=datos["minp"], ajuste=datos["ajuste"]) add_msg(datos, "Creada tabla de agregados: " + sql) cursor.execute(sql) # Geometrías nulas sql = SELECT_IDS_NO_IN_CLUSTER.format(origen=datos["capa_origen"],geom=datos["geom"], esquema=datos["esquema"], id=datos["pk"][0], dist=datos["distancia"], minp=datos["minp"]) cursor.execute(sql) ids_nulos = cursor.fetchall() add_msg(datos, "Ids de geometrías sin grupo: " + str(ids_nulos)) # CONTROLAR GEOMETRIA sql = CREATE_TABLE_INTER.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_agr"]) cursor.execute(sql) add_msg(datos, "Creada la capa " + str(datos["capa_agr"]) + "_sin_int con las interferencias corregidas: " + str(sql)) task.set_progress(100) conn.commit() except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def generar_poligonos(params, esquema, origen, esquema_dest, destino, tolerancia, filtro, borrar_capas, task=None): datos = init_poligonos() datos["esquema"] = esquema datos["esquema_dest"] = esquema_dest datos["capa_origen"] = origen datos["capa_destino"] = destino datos["tolerancia"] = tolerancia datos["filtro"] = filtro if borrar_capas is None or str(borrar_capas).strip() == "": borrar_capas = True else: borrar_capas = False add_msg(datos, "GENERAR REDES DE TRANSPORTE DE POLÍGONOS:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, " "tolerancia:{}, filtro_area:{}, borrar_capas:{}".format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_destino"], datos["tolerancia"], datos["filtro"], borrar_capas)) conn = Connector() try: if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_destino"] = destino.split(".")[1] if datos["tolerancia"].strip() == "": datos["tolerancia"] = None if datos["filtro"].strip() == "": datos["filtro"] = None else: datos["filtro"] = " where area_pol " + datos["filtro"] cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(15) """ # SE CREA NUEVA CAPA COMO LA CAPA ORIGINAL PERO AGRUPANDO GEOM POR ID_TIPO sql = GROUP_BY_TIPO.format(destino=datos["capa_destino"], origen=datos["capa_origen"], geom=datos["geom"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Nueva capa con geometría agrupada por id_tipo: " + sql) cursor.execute(sql) task.set_progress(30) """ # DISOLVER sql = CREATE_TABLE_DIS_POL.format(esquema=datos["esquema"], origen=datos["capa_origen"], destino=datos["capa_destino"], esquema_dest=datos["esquema_dest"], campos_comunes=datos["campos"], geom=datos["geom"]) add_msg(datos, "Disolver: " + sql) cursor.execute(sql) task.set_progress(45) # SIMPLIFICAR sql = CREATE_TABLE_DIS_SIM_POL.format(destino=datos["capa_destino"], esquema_dest=datos["esquema_dest"], tolerancia=datos["tolerancia"], campos_comunes=datos["campos"], geom=datos["geom"]) add_msg(datos, "Simplificación: " + sql) cursor.execute(sql) task.set_progress(60) # SE CALCULA EL AREA DE LAS GEOMETRIAS sql = SELECT_DIM.format(esquema=datos["esquema"], origen=datos["capa_origen"], geom=datos["geom"]) cursor.execute(sql) dim = cursor.fetchall()[0][0] # add_msg(datos, "Dimension de geometria: " + str(dim) + "D") if dim >= 3: sql = ADD_COLUMN_AREA_3D.format(esquema=datos["esquema_dest"], origen=datos["capa_destino"], area='area_pol') else: sql = ADD_COLUMN_AREA.format(esquema=datos["esquema_dest"], origen=datos["capa_destino"], area='area_pol') add_msg(datos, "Cálculo del área: " + sql) cursor.execute(sql) task.set_progress(70) # SE SEPARAN LAS GEOMETRIAS DEL NUEVO sql = CREATE_TABLE_DUMP.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], campos_comunes=datos["campos"], area='area_pol') add_msg(datos, "Separación de geometrías: " + sql) cursor.execute(sql) task.set_progress(85) # TABLA FINAL CON FILTRO DE AREA if datos["filtro"] is None: sql = CREATE_TABLE_FILTER_AREA_POL.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], filtro="", campos_comunes=datos["campos"], area='area_pol') else: sql = CREATE_TABLE_FILTER_AREA_POL.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], filtro=datos["filtro"], campos_comunes=datos["campos"], area='area_pol') add_msg(datos, "Tabla final: " + sql) cursor.execute(sql) # SE BORRAN CAPAS INTERMEDIAS if borrar_capas: sql = BORRAR_TABLAS_INTERMEDIAS_POL.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"]) add_msg(datos, "Se borran todas las capas intermedias: " + sql) cursor.execute(sql) else: add_msg(datos, "No se borran las capas intermedias") task.set_progress(100) conn.commit() except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def generar_edificaciones(params, esquema, origen, esquema_dest, destino, tolerancia, filtro, borrar_capas, task=None): datos = init_edificaciones() datos["esquema"] = esquema datos["esquema_dest"] = esquema_dest datos["capa_origen"] = origen datos["capa_destino"] = destino datos["tolerancia"] = tolerancia datos["filtro"] = filtro add_msg(datos, "GENERAR EDIFICACIONES:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, tolerancia:{}, " "filtro_area:{}, borrar_capas_intermedias:{}".format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"],datos["capa_destino"], datos["tolerancia"], datos["filtro"], borrar_capas)) conn = Connector() try: if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_destino"] = destino.split(".")[1] if datos["tolerancia"].strip() == "": datos["tolerancia"] = None if datos["filtro"].strip() == "": datos["filtro"] = None else: if ">" in datos["filtro"]: datos["dist_filtro"] = datos["filtro"].replace(">", "<") elif "<" in datos["filtro"]: datos["dist_filtro"] = datos["filtro"].replace("<", ">") elif "=" in datos["filtro"]: datos["dist_filtro"] = datos["filtro"].replace("=", "!=") elif "!=" in datos["filtro"]: datos["dist_filtro"] = datos["filtro"].replace("!=", "=") else: raise Exception("No se ha introducido un filtro de área válido") datos["filtro"] = " where area_edif " + datos["filtro"] if borrar_capas is None or str(borrar_capas).strip() == "": borrar_capas = True else: borrar_capas = False cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(10) # DISOLVER sql = CREATE_TABLE_DIS_POL.format(destino=datos["capa_destino"], esquema_dest=datos["esquema_dest"], esquema=datos["esquema"], origen=datos["capa_origen"], campos_comunes=datos["campos"], geom=datos["geom"]) add_msg(datos, "Disolver: " + sql) cursor.execute(sql) task.set_progress(30) # SIMPLIFICAR sql = CREATE_TABLE_DIS_SIM_POL.format(destino=datos["capa_destino"], esquema_dest=datos["esquema_dest"], tolerancia=datos["tolerancia"], campos_comunes=datos["campos"]) add_msg(datos, "Simplificación: " + sql) cursor.execute(sql) task.set_progress(40) # SE CALCULA EL AREA DE LAS GEOMETRIAS sql = ADD_COLUMN_AREA.format(esquema=datos["esquema_dest"], origen=datos["capa_destino"], area='area_edif') add_msg(datos, "Cálculo del área: " + sql) cursor.execute(sql) task.set_progress(50) # SE SEPARAN LAS GEOMETRIAS DEL NUEVO sql = CREATE_TABLE_DUMP.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], campos_comunes=datos["campos"], area='area_edif') add_msg(datos, "Separación de geometrías: " + sql) cursor.execute(sql) task.set_progress(60) # SE EXTRAEN LOS ANILLOS INTERIORES Y SE CALCULA EL AREA DE ESTOS sql = EXTRAER_ANILLOS.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], campos_comunes=datos["campos"], area='area_edif') add_msg(datos, "Se extraen los anillos y se calcula su área: " + sql) cursor.execute(sql) task.set_progress(70) # TABLA FINAL CON FILTRO DE AREA if datos["filtro"] is None: sql = CREATE_TABLE_FILTER_AREA_ED.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], filtro="", campos_comunes=datos["campos"], area='area_edif') else: sql = CREATE_TABLE_FILTER_AREA_ED.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], filtro=datos["filtro"], campos_comunes=datos["campos"], area='area_edif') add_msg(datos, "Tabla con filtro por área: " + sql) task.set_progress(80) cursor.execute(sql) # SE UNEN LA CAPA DE ANILLOS FILTRADOS CON CAPA DE LAS GEOMETRÍAS ORIGINALES SIMPLIFICADAS sql = CREATE_ANILLOS_GEOM_ORIGINAL.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], campos_comunes=datos["campos"], area='area_edif') add_msg(datos, "Se une la capa de anillos filtrados con la capa de geometrías originales simplifcada: " + sql) cursor.execute(sql) task.set_progress(90) # SI HAY FILTRO, SE ELIMINAN GEOMETRIAS DIF AL FILTRO if datos["filtro"] is not None: sql = DELETE_FILTRO.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], filtro=datos["dist_filtro"]) add_msg(datos, "Se borran los registros que no cumplen el filtro: " + sql) cursor.execute(sql) # SE BORRAN CAPAS INTERMEDIAS if borrar_capas: sql = BORRAR_TABLAS_INTERMEDIAS_ED.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"]) add_msg(datos, "Se borran todas las capas intermedias: " + sql) cursor.execute(sql) else: add_msg(datos, "No se borran las capas intermedias") task.set_progress(100) conn.commit() except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def generar_ejesferrocarril(params, esquema, origen, esquema_dest, destino, buffer, dist, borrar_capas, task=None): datos = init_ejesferrocarril() datos["esquema"] = esquema datos["esquema_dest"] = esquema_dest datos["capa_origen"] = origen datos["capa_destino"] = destino datos["distancia"] = dist datos["buffer"] = buffer add_msg(datos, "GENERAR EJES FERROCARRIL:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, distancia:{}, " "buffer:{}, borrar_capas_intermedias:{}".format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_destino"], datos["distancia"], datos["buffer"], borrar_capas)) conn = Connector() try: if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_destino"] = destino.split(".")[1] if datos["buffer"].strip() == "": datos["buffer"] = 0 if datos["distancia"].strip() == "": datos["distancia"] = 0 if borrar_capas is None or str(borrar_capas).strip() == "": borrar_capas = True else: borrar_capas = False cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(10) # BORRO CAPAS SI EXISTEN cursor.execute(DELETE_EJESFERROCARRIL.format(destino=datos["capa_destino"], esquema_dest=datos["esquema_dest"])) # COMPRUEBO NOMBRE CAMPO PK (PRIMARY KEY) sql = GET_CAMPO_ID.format(esquema=datos["esquema"], origen=datos["capa_origen"]) cursor.execute(sql) # CAMPO ID if datos["pk"] == '' or datos["pk"] == None or datos["pk"] == []: raise Exception("La capa de entrada no tiene campo con clave primaria") # datos["pk"] = ['id'] # Se crea una línea a partir de la geometría original para evitar cortes en líneas continuas sql = CREATE_SET_LINES.format(destino=datos["capa_destino"], origen=datos["capa_origen"], campos_comunes=datos["campos"], geom=datos["geom"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Copia de la geometría original: " + sql) cursor.execute(sql) task.set_progress(20) # BUFFER DE LA MEDIDA A LA QUE SE QUIERE OBTENER LA NUEVA GEOM sql = CREATE_BFF_LINES.format(destino=datos["capa_destino"], esquema_dest=datos["esquema_dest"], buffer=datos["buffer"], campos_comunes=datos["campos"]) add_msg(datos, "Buffer a la distancia indicada: " + sql) cursor.execute(sql) task.set_progress(30) # EXTRACCIÓN DE LA MASA POR LA SUPERPOSICIÓN DEL BUFFER campos = [] for campo in datos["campos"].split(','): campo = 'a.' + campo.strip() campos.append(campo) sql = CREATE_INT_LINES.format(destino=datos["capa_destino"], esquema_dest=datos["esquema_dest"], campos_comunes=",".join(campos), pk=datos["pk"][0]) add_msg(datos, "Extracción de la masa formada por la superposición del buffer: " + sql) cursor.execute(sql) task.set_progress(40) # EXTRACCIÓN DE EJES DE LOS POLÍGONOS GENERADOS sql = CREATE_MED_LINES.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], campos_comunes=datos["campos"]) add_msg(datos, "Extracción de los ejes de los poligonos: " + sql) cursor.execute(sql) task.set_progress(50) # Eliminación de ruido sql = DELETE_NOISE_LEN.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], pk=datos["pk"][0], dist=datos["distancia"], campos_comunes=datos["campos"]) add_msg(datos, "Eliminando ruido longitud: " + sql) cursor.execute(sql) # sql = DELETE_NOISE_UN_LIN.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], # pk=datos["pk"][0], campos_comunes=datos["campos"]) # # add_msg(datos, "Eliminación de ruido: " + sql) # cursor.execute(sql) task.set_progress(60) # UNION sql = CREATE_UNION_LINES.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], pk=datos["pk"][0], campos_comunes=datos["campos"]) add_msg(datos, "Unión de líneas: " + sql) cursor.execute(sql) task.set_progress(70) # SEPARACION DE LINEAS sql = CREATE_DUMP_LINES.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], pk=datos["pk"][0], dist=datos["distancia"], campos_comunes=datos["campos"]) add_msg(datos, "Separación de líneas: " + sql) cursor.execute(sql) task.set_progress(80) # TOPOLOGIA sql = CREATE_TOPO_LAYER.format(esquema=datos["esquema"], origen=datos["capa_origen"], esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], pk=datos["pk"][0], dist=datos["distancia"], srid=datos["srid"], campos_comunes=datos["campos"]) add_msg(datos, "Comprobación de topología: " + sql) task.set_progress(90) cursor.execute(sql) # SE BORRAN CAPAS INTERMEDIAS if borrar_capas: sql = DELETE_EJESFERROCARRIL.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"]) add_msg(datos, "Se borran todas las capas intermedias: " + sql) cursor.execute(sql) else: add_msg(datos, "No se borran las capas intermedias") task.set_progress(100) conn.commit() except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def generar_ptorelieve(params, esquema, origen, esquema_dest, destino, elev, dist, borrar_capas, task=None): datos = init_rpuntos() datos["esquema"] = esquema datos["esquema_dest"] = esquema_dest datos["capa_origen"] = origen datos["capa_destino"] = destino datos["campo_elevacion"] = elev datos["distancia_cluster"] = dist add_msg(datos, "GENERAR PUNTOS RELIEVE:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, " "distancia cluster:{}".format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_destino"], datos["distancia_cluster"])) conn = Connector() try: if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_destino"] = destino.split(".")[1] if datos["distancia_cluster"].strip() == "": datos["distancia_cluster"] = None if borrar_capas is None or str(borrar_capas).strip() == "": borrar_capas = True else: borrar_capas = False cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(15) # COMPRUEBO CAMPO ELEVACION if datos["campo_elevacion"] not in datos["campos"]: raise Exception ("No se encuentra el campo de elevacion indicado") # CAMPO ID if datos["pk"] == '' or datos["pk"] == None or datos["pk"] == []: #raise Exception("La capa de entrada no tiene campo con clave primaria") datos["pk"] = ['id'] sql = BORRAR_TABLAS_INTERMEDIAS_PR.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"]) cursor.execute(sql) # SE CREA TABLA CLUSTER CON DIST ACORDADA sql = CREATE_TABLE_CLUSTER_PR.format(destino=datos["capa_destino"], origen=datos["capa_origen"], geom=datos["geom"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"], dist=datos["distancia_cluster"]) add_msg(datos, "Creada tabla de clusters: " + sql) cursor.execute(sql) task.set_progress(30) # CENTROIDES sql =CREATE_TABLE_CENTROID_PR.format(destino=datos["capa_destino"], esquema_dest=datos["esquema_dest"], geom=datos["geom"]) add_msg(datos, "Creada tabla de centroides: " + sql) cursor.execute(sql) task.set_progress(45) # DWITHIN sql = CREATE_TABLE_DWITHIN.format(destino=datos["capa_destino"], esquema_dest=datos["esquema_dest"], origen=datos["capa_origen"], esquema=datos["esquema"], elev=datos["campo_elevacion"], srid=datos["srid"], geom=datos["geom"], dist=datos["distancia_cluster"], ) add_msg(datos, sql) cursor.execute(sql) task.set_progress(60) # CREATE TABLE CENTROID sql = CREATE_TABLE_CENTROID.format(destino=datos["capa_destino"], esquema_dest=datos["esquema_dest"], origen=datos["capa_origen"], esquema=datos["esquema"], geom=datos["geom"], srid=datos["srid"], elev=datos["campo_elevacion"]) cursor.execute(sql) task.set_progress(75) # SE LIMPIA LA TABLA CREADA sql = CLEAR_TABLE_CENTROID.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"]) add_msg(datos, "Separación de geometrías: " + sql) cursor.execute(sql) # SE BORRAN CAPAS INTERMEDIAS if borrar_capas: sql = BORRAR_TABLAS_INTERMEDIAS_PR.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"]) add_msg(datos, "Se borran todas las capas intermedias: " + sql) cursor.execute(sql) else: add_msg(datos, "No se borran las capas intermedias") task.set_progress(100) conn.commit() except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def generar_polhidro(params, esquema, origen, esquema_dest, destino, filtro, borrar_capas, task=None): datos = init_hpoligonos() datos["esquema"] = esquema datos["esquema_dest"] = esquema_dest datos["capa_origen"] = origen datos["capa_destino"] = destino datos["filtro"] = filtro add_msg(datos, "GENERAR POLÍGONO HIDROGRAFÍA:: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, " "filtro:{}".format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_destino"], datos["filtro"])) conn = Connector() try: if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino.split(".")) > 1: datos["esquema_dest"] = destino.split(".")[0] datos["capa_destino"] = destino.split(".")[1] if borrar_capas is None or str(borrar_capas).strip() == "": borrar_capas = True else: borrar_capas = False if datos["filtro"].strip() == "": datos["filtro"] = None else: datos["filtro"] = " where area_polhidro " + datos["filtro"] cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(15) """ # SE CREA TABLA CON UNION DE POLIGONOS POR ID_TIPO CON ST_BUFFER sql = GROUP_BY_TIPO_BFF.format(destino=datos["capa_destino"], origen=datos["capa_origen"], geom=datos["geom"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Nueva capa con geometría agrupada por id_tipo: " + sql) cursor.execute(sql) task.set_progress(30) """ # CAMPO ID if datos["pk"] == '' or datos["pk"] == None or datos["pk"] == []: #raise Exception("La capa de entrada no tiene campo con clave primaria") datos["pk"] = ['id'] # DISOLVER sql = CREATE_TABLA_DIS_POL_AREA.format(esquema=datos["esquema"], origen=datos["capa_origen"], destino=datos["capa_destino"], esquema_dest=datos["esquema_dest"], geom=datos["geom"], campos_comunes=datos["campos"], area='area_polhidro') add_msg(datos, "Disolver: " + sql) cursor.execute(sql) task.set_progress(45) # FILTRO CON CALCULO DE PERIMETRO if datos["filtro"] is None: sql = CREATE_TABLE_FILTER_AREA_HI.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], filtro="", geom=datos["geom"], perimetro='perim_polhidro') else: sql = CREATE_TABLE_FILTER_AREA_HI.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], filtro=datos["filtro"], geom=datos["geom"], perimetro='perim_polhidro') add_msg(datos, "Tabla con filtro por área: " + sql) task.set_progress(80) cursor.execute(sql) # Resultado final sql = CREATE_TABLE_PERIMETER.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"], area='area_polhidro', perimetro='perim_polhidro', division="division_ap") cursor.execute(sql) # SE BORRAN CAPAS INTERMEDIAS if borrar_capas: sql = BORRAR_TABLAS_INTERMEDIAS_HI.format(esquema_dest=datos["esquema_dest"], destino=datos["capa_destino"]) add_msg(datos, "Se borran todas las capas intermedias: " + sql) cursor.execute(sql) else: add_msg(datos, "No se borran las capas intermedias") task.set_progress(100) conn.commit() except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos def simplificar_suavizar(params, esquema, origen, esquema_dest, destino_simplificado, destino_suavizado, escala, task=None): datos = init_curvasnivel() datos["esquema"] = esquema datos["esquema_dest"] = esquema_dest datos["capa_origen"] = origen datos["capa_destino"] = destino_suavizado datos["capa_simp"] = destino_simplificado datos["capa_suav"] = destino_suavizado escalaInt = int(escala) """if escalaInt <= 1000: datos["tolerancia"] = "1" elif escalaInt > 1000 and escalaInt <= 5000: datos["tolerancia"] = "2" elif escalaInt > 5000 and escalaInt <= 20000: datos["tolerancia"] = "3" else: datos["tolerancia"] = "4""" datos["tolerancia"] = str(escalaInt * 0.000265) print("TOLERANCIA --> " + datos["tolerancia"]) add_msg(datos, "GENERAR CURVAS NIVEL :: esquema:{}, origen:{}, esquema_dest:{}, destino:{}, tolerancia:{}" .format(datos["esquema"], datos["capa_origen"], datos["esquema_dest"], datos["capa_destino"], datos["tolerancia"])) """ Crea una copia simplificada de una capa """ conn = Connector() try: if len(origen.split(".")) > 1: datos["esquema"] = origen.split(".")[0] datos["capa_origen"] = origen.split(".")[1] if len(destino_simplificado.split(".")) > 1: datos["capa_simp"] = destino_simplificado.split(".")[1] if len(destino_suavizado.split(".")) > 1: datos["esquema_dest"] = destino_suavizado.split(".")[0] datos["capa_suav"] = destino_suavizado.split(".")[1] cursor = conn.openParams(params) carga_datos_origen(datos, cursor) task.set_progress(10) sql = BORRA_TABLA_ANTERIOR.format(destino=datos["capa_simp"], esquema=datos["esquema_dest"]) add_msg(datos, "Borra tabla destino anterior si existe: " + sql) cursor.execute(sql) task.set_progress(20) sql = CLONAR_TABLA.format(destino=datos["capa_simp"], origen=datos["capa_origen"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Creada tabla destino: " + sql) cursor.execute(sql) task.set_progress(30) sql = COPIA_DATOS_SIMP.format(destino=datos["capa_simp"], origen=datos["capa_origen"], columnas=datos["campos"], geom=datos["geom"], tolerancia=datos["tolerancia"], esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Copiados datos originales con geometría simplificada: " + sql) cursor.execute(sql) task.set_progress(50) datos["capa_origen"] = destino_simplificado datos["iteraciones"] = "3" carga_datos_origen(datos, cursor) task.set_progress(60) sql = BORRA_TABLA_ANTERIOR.format(destino=datos["capa_suav"], esquema=datos["esquema_dest"]) add_msg(datos, "Borra tabla destino anterior si existe: " + sql) cursor.execute(sql) task.set_progress(70) # CREAR DE NUEVO CAPA DESTINO sql = CLONAR_TABLA.format(esquema=datos["esquema"], esquema_dest=datos["esquema_dest"], destino=datos["capa_suav"], origen=datos["capa_origen"]) add_msg(datos, "Creada tabla destino: " + sql) cursor.execute(sql) task.set_progress(80) # RELLENAR CAPA SUAVIZADA sql = COPIA_DATOS_SUAV.format(destino=datos["capa_suav"], origen=datos["capa_origen"], columnas=datos["campos"], geom=datos["geom"], iteraciones="3", esquema=datos["esquema"], esquema_dest=datos["esquema_dest"]) add_msg(datos, "Copiados datos originales con geometría suavizada: " + sql) cursor.execute(sql) conn.commit() #comparar_resultados(datos, cursor) except Exception as error: datos["fin"] = dt.datetime.now() datos["duracion"] = str(datos["fin"] - datos["ini"]) datos["resultado"] = "ERROR" add_msg(datos, "ERROR:" + str(error)) if conn is not None: conn.rollback() finally: if conn is not None: conn.close() return datos