using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using OliviaAddInPro.Model; using ArcGIS.Core.Data; using ArcGIS.Core.Geometry; using OliviaAddInPro.Helper; using ArcGIS.Core.Internal.Data; using ArcGIS.Desktop.Framework.Threading.Tasks; using System.Windows; namespace OliviaAddInPro.Services { public enum ModosEjec { Sectoriza, Planifica, SoloPlanifica } //Clase que realiza las funciones de la ejecución public class EjecServ { //Cadenas de nombres internos para la exportación/importación de los archivos public string PREF_NAME_EXPORT = "data_"; public string EXT_SHP = ".shp"; public string PREF_NAME_EXPORT_NW = "nw_"; public string NAME_CSV = "_L"; public string EXT_CSV = ".csv"; public string NAME_RUTA2 = "_R2"; public string NAME_RUTA2_OUT = "_Viajes"; public string NAME_AUX = "_aux"; public string NAME_SECT = "_Sector"; public string NAME_CONTROL_OUT = "_Control"; public string NAME_CONTROL = "_C"; public string NAME_RUTA_OUT = "_Ruta"; public string NAME_RUTA = "_R"; public string NAME_RUTA_AUX = "_Raux"; public string NAME_INSTAL = "_I"; public string NAME_INSTAL_OUT = "_Instalacion"; public string ErrStr = ""; SpatialQueryFilter filtroEspacial = null; SpatialReference spatRef = null; SpatialReference spatRefData = null; public TratamientoComun com; /** * Acciones para comenzar ejecución * Modo 0, sectorizar * Modo 1, planificar */ public bool ExportaEjec(ModosEjec modo, out string ErrStr) { ErrStr = string.Empty; try { com.ProgrSrc.Init("Exportando datos"); //Comprueba que tiene las columnas necesarias para planificar if ((modo == ModosEjec.Planifica) && !CompruebaPlanif()) { ErrStr = "En la capa de ámbitos seleccionada no se encuentran columnas de SECTOR y/o SECUENCIA, necesarias para planificar"; return false; } //Cuenta las filas que cumplen la consulta int nelems = HelperGdb.GetNumElemsSync(com.CapaElems, com.ConsultaAmbs); if (nelems <= 0) { ErrStr = "No existen ámbitos que cumplan las condiciones introducidas para la exportación " + com.ConsultaAmbs; return false; } com.ProgrSrc.IncMessage(0, "Exportando geometria"); //Obtiene la geometría que envuelve a los ámbitos Geometry geom_export = null; geom_export = GetGeomAmbitsExport(); if (geom_export == null || geom_export.IsEmpty) { ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + ErrStr; return false; } //mira spatialreference de los datos de entrada spatRefData = geom_export.SpatialReference; //crea el filtro de exportación filtroEspacial = HelperGdb.CreateFiler(com.ConsultaAmbs, geom_export); if (filtroEspacial == null) { ErrStr = "Error al crear el filtro de exportacion de los ámbitos"; return false; } //Termina de preparar nombre //Prepara nombre string fechaHora = string.Empty; //se consigue el tiempo en este instante para añadirlo a los nombres de los archivos de salida (shapefiles) fechaHora = DateTime.Now.ToString("yyyyMMdd_Hmmss"); //Pone nombre al shape en función de los ámbitos, el tratamiento, y los polígonos + timestamp com.NombreShpExport = PREF_NAME_EXPORT + com.NombreShpExp_PrefTto + "_" + fechaHora + EXT_SHP; com.ProgrSrc.IncMessage(10, "Exportando ámbitos de trabajo"); //exporta los datos de entrada if (!HelperGdb.ExportShp2(com.CapaElems, filtroEspacial, com.NombreShpExport, OliviaGlob.Paths.DirData, com.ProgrSrc._ProgrSrc, null, 40)) { ErrStr = "Error al exportar los ámbitos: " + HelperGdb.OutStr; return false; } if (com.ProgrSrc._ProgrSrc.Getcancelled()) { ErrStr = Resource1.String_cancel_progreso; return false; } //Guarda el nombre OliviaGlob.Paths.PathData = OliviaGlob.Paths.DirData + com.NombreShpExport; /////////////////////////////////////////////////////////////////////// //ahora si está en modo planificación y la capa no tiene esa columna, exporta la sectorización if (modo==ModosEjec.Planifica && !string.IsNullOrEmpty(com.CapaPlanif)) { string capa_principal = System.IO.Path.GetFileNameWithoutExtension(OliviaGlob.Paths.PathData); HelperGdb.CloseLayer(capa_principal); if (!ActualizaSecto(OliviaGlob.Paths.PathData, com.CapaPlanif)) { ErrStr = "Error al exportar campos de SECTOR y/o SECUENCIA de la capa " + com.CapaPlanif; return false; } } /////////////////////////////////////////////////////////////////////// /// com.ProgrSrc.IncMessage(10, "Preparando exportación de red navegable");//50% //hace intersecciones espaciales en caso de ámbitos lineales para quitar los que tienen más parte fuera de la zona que dentro //REVISAR /*if (((com.GeomNiv != null) || (com.GeomZon != null)) && (OliviaGlob.IsReco() || (OliviaGlob.IsLimp() && (com.TipoTto < (int)LimpiezaDef.TiposTto.TtoPapeVaci)))) { if (!HelperGdb.RemoveRowsGeom(OliviaGlob.Paths.PathData, geom_export, 0.4)) { ErrStr = "Error al quitar los ámbitos que sobresalen: " + HelperGdb.OutStr; return false; } }*/ /////////////////////////////////////////////////////////////////////////// //comprueba, si hay restricciones de circulación y hay instalación, que la instalación no está en ellas if (!com.CoordsInstal.IsEmpty && (com.CoordsInstal.X != 0) && (com.GeomRestr != null)) { Respuesta resp = HelperGdb.IsPtoInGeom(com.CoordsInstal, com.GeomRestr); if (!resp.Value && resp.HasError) { ErrStr = "Error al comprobar si la instalación está contenida en el polígono de restricciones: " + resp.Error.ElementAt(0); return false; } else if (resp.Value) //sí está contenido en las restricciones { ErrStr = "Error, la instalación está en la zona restringida a la circulación "; return false; } } /////////////////////////////////////////////////////////////////////////// //exporta la red navegable (buffer, le quita las restr...) //se obtiene la geometría a intersecar con la red, que será la que contiene //a todos los ámbitos y la instalación, ampliada un buffer, mayor si hay //restricciones de circulación geom_export = HelperGdb.BufferGeom(geom_export, com.BuffExport).Value; if (geom_export == null) { ErrStr = "Error al añadir buffer a la geometría"; return false; } //quita las restricciones if (com.GeomRestr != null) { geom_export = HelperGdb.QuitaGeom(geom_export, com.GeomRestr); if (geom_export == null) { ErrStr = "Error al intersecar con las restricciones."; return false; } } ////////////////////////////////////////////////////////////// //comprueba si la geometría de exportación contiene a la instalación y a la planta de descarga Coordinate2D[] coords = { com.CoordsInstal, com.CoordsPlanta }; for (int i = 0; i < coords.Length; i++) { if (!coords[i].IsEmpty && (coords[i].X != 0)) { Respuesta resp = HelperGdb.IsPtoInGeom(coords[i], geom_export); if (!resp.Value) //si no lo contiene { //ha ido mal if (resp.HasError) { ErrStr = "Error al comprobar si la instalación está contenida en el polígono de exportación: " + resp.Error.ElementAt(0); return false; } else { //amplía la geom Respuesta respGeom = HelperGdb.AddPtoInGeom(coords[i], geom_export); if (respGeom.Value == null) { //ha ido mal if (resp.HasError) ErrStr = resp.Error.ElementAt(0); else ErrStr = "Error al incluir punto de instalación en polígono de exportación."; return false; } //actualiza la geometría geom_export = respGeom.Value; } } } } //mira spatialreference del nw /*FeatureClass fc = HelperGdb.GetFtClass(OliviaGlob.Paths.PathGdbNw); if (fc != null) { spatRef = fc.GetDefinition().GetSpatialReference(); //AQUÍ COMPARAR SI ES IGUAL QUE SPATREFDEF Y SI NO, REPROYECTAR if (spatRef.Wkid != spatRefData.Wkid) { var sp_ref = SpatialReferenceBuilder.CreateSpatialReference(102629); // NAD83 SP AL E FIPS 0101 Feet var envi = Geoprocessing.MakeEnvironmentArray(outputCoordinateSystem: sp_ref); //https://pro.arcgis.com/es/pro-app/2.8/tool-reference/environment-settings/output-coordinate-system.htm //ProjectionTransformation transf_forTarget = ProjectionTransformation.Create(spatRef, spatRefData); //geom_export=GeometryEngine.Instance.ProjectEx(geom_export, transf_forTarget); //transf_forTarget.Transformation /* * FALTA HACER * / } }*/ //Hace el filtro con la geometría final filtroEspacial = HelperGdb.CreateFiler(String.Empty, geom_export); if (filtroEspacial == null) { ErrStr = "Error al crear el filtro de exportacion de la red navegable"; return false; } com.ProgrSrc.IncMessage(10, "Exportando red navegable");//60% //Prepara nombre de exportación com.NombreShpExportNw = PREF_NAME_EXPORT_NW + fechaHora + EXT_SHP; //exporta los datos de entrada if (!HelperGdb.ExportShp2(OliviaGlob.Paths.PathGdbNw, filtroEspacial, com.NombreShpExportNw, OliviaGlob.Paths.DirData, com.ProgrSrc._ProgrSrc, spatRefData,100)) { ErrStr = "Error al exportar la red navegable: " + HelperGdb.OutStr; return false; } //guarda los nombres del shape OliviaGlob.Paths.PathNW = OliviaGlob.Paths.DirData + com.NombreShpExportNw; if (com.ProgrSrc._ProgrSrc.Getcancelled()) { ErrStr = Resource1.String_cancel_progreso; return false; } } catch (Exception ex) { ErrStr = "Errores al exportar para comenzar la ejecución: " + ex.Message; return false; } return true; } /** * Actualiza la capa dada añadiendo una columna de sector y una de secuencia */ public bool ActualizaSecto(string path_shp, string path_secto) { //Añade al shp exportado la columna de sector y secuencia HelperGdb.FieldToAdd[] fields = new HelperGdb.FieldToAdd[2]; //campo SECTOR fields[0].Name = LimpiezaDef.Campos.consulta_sector; fields[0].Alias = LimpiezaDef.Campos.consulta_sector; fields[0].Tipo = "LONG"; fields[0].Length = 0; //campo SECUENCIA fields[1].Name = LimpiezaDef.Campos.consulta_secuen; fields[1].Alias = LimpiezaDef.Campos.consulta_secuen; fields[1].Tipo = "LONG"; fields[1].Length = 0; if (!HelperGdb.AddFieldsSync(path_shp, fields)) return false; //vuelve a cerrar la capa string capa_principal = System.IO.Path.GetFileNameWithoutExtension(OliviaGlob.Paths.PathData); HelperGdb.CloseLayer(capa_principal); ///////////////////////////////////////////////////// RowCursor rc_shp = null; RowCursor rc_secto = null; Row rowshp = null; Row rowsecto = null; FeatureClass fc_secto = null; FeatureClass fc_shp = null; bool bien = false; try { //ahora rellena las columnas fc_secto = HelperGdb.GetFtClassSync(path_secto); fc_shp = HelperGdb.GetFtClassSync(path_shp); if (fc_secto == null || fc_shp == null) return false; var modifyOp = new ArcGIS.Desktop.Editing.EditOperation(); modifyOp.Name = "Actualiza SECTOR y SECUENCIA"; //modifyOp.Callback((context) => //{ rc_shp = fc_shp.Search(); rc_secto = fc_secto.Search(); if (rc_shp == null || rc_secto == null) { HelperGdb.Free(rc_shp); HelperGdb.Free(rc_secto); HelperGdb.Free(fc_secto); HelperGdb.Free(fc_shp); return false; } while (rc_shp.MoveNext() && rc_secto.MoveNext()) { rowsecto = rc_secto.Current; rowshp = rc_shp.Current; // modify and execute modifyOp.Modify(rowshp, LimpiezaDef.Campos.consulta_sector,rowsecto[LimpiezaDef.Campos.consulta_sector]); modifyOp.Modify(rowshp, LimpiezaDef.Campos.consulta_secuen, rowsecto[LimpiezaDef.Campos.consulta_secuen]); } bien = true; //}, fc_shp.GetFeatureDataset()); modifyOp.Execute(); if (bien) return true; else return false; } catch { } finally { HelperGdb.Free(rowsecto); HelperGdb.Free(rowshp); HelperGdb.Free(rc_shp); HelperGdb.Free(rc_secto); HelperGdb.Free(fc_secto); HelperGdb.Free(fc_shp); } return false; } /** * Prepara la geometría para exportar los ámbitos */ public Geometry GetGeomAmbitsExport() { Geometry geomAux = null; Geometry geomAmbits = null; ErrStr = string.Empty; FeatureClass fc = HelperGdb.GetFtClassSync(com.CapaElems); if (fc == null) { ErrStr = "No se ha podido abrir la clase " + com.CapaElems; return null; } //Hace la intersección de zonas y niveles geomAux = null; if (com.GeomNiv != null || com.GeomZon != null) { geomAux = HelperGdb.IntersectGeom(com.GeomNiv, com.GeomZon); if (geomAux == null) { ErrStr = "Error al intersecar zonas y/o niveles."; return null; } if (geomAux.IsEmpty) { ErrStr = "No existen ámbitos en la intersección entre zonas y/o niveles."; return null; } } //comprueba que, en el caso de ejes de vía, hayan metido polígono de exportación if ((geomAux == null) && (com.CapaElems == OliviaGlob.Paths.PathGdbNw)) { ErrStr = "Al emplear ejes de calle como ámbitos es necesario indicar polígono de exportación"; return null; } //prepara el filtro con consulta y espacial SpatialQueryFilter filtro = HelperGdb.CreateFiler(com.ConsultaAmbs, geomAux); if (geomAux == null) { //Ahora hace la geometría de los ámbitos que cumplen la consulta, si no hay ya geometría geomAmbits = HelperGdb.GetGeomConvexHullSync(fc, filtro); if (geomAmbits == null || geomAmbits.IsEmpty) { ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + HelperGdb.OutStr; return null; } geomAux = geomAmbits; } //le quita las restricciones if (com.GeomRestr != null) { geomAux = HelperGdb.QuitaGeom(geomAux, com.GeomRestr); if (geomAux == null) { ErrStr = "Error al intersecar con las restricciones."; return null; } } HelperGdb.Free(fc); return geomAux; } /** * Devuelve el string a concatenar en el nombre del path dependiendo de los polígonos seleccionados (zonas, turnos... etc) */ public string DameStrPoligs() { string str = ""; if (com.TextGeomNiv != "" && com.GeomNiv != null) str += "_N" + com.TextGeomNiv; if (com.TextGeomZon != "" && com.GeomZon != null) str += "_Z" + com.TextGeomZon; if (com.TextGeomRestr != "" && com.GeomRestr != null) str += "_R" + com.TextGeomRestr; return str; } public bool ComprCamposPlanif(string pathCapa) { int NCAMPS = 2; string[] camps; camps = new string[NCAMPS]; camps[0] = LimpiezaDef.Campos.consulta_sector; camps[1] = LimpiezaDef.Campos.consulta_secuen; return HelperGdb.CheckFiledsSync(pathCapa, camps) == 0; } /** * Comprueba lo necesario para ver si hay campos para la planificación */ public bool CompruebaPlanif() { //comprueba capa if (ComprCamposPlanif(com.CapaElems)) { com.CapaPlanif = string.Empty;//reinicia para que coja la secto de la capa original return true; } //si ha importado seguro que las tiene if (OliviaGlob.IsConfig2() && !string.IsNullOrEmpty(com.CapaPlanif)) return true; return false; } /** * Realiza las funciones de importación de la sectorización */ public Respuesta ImportSecto(string GdbFileName) { var res = Import(GdbFileName, 0); if (res.HasError || string.IsNullOrEmpty(res.Value)) { return res; } ////////////////////////////////////////////////// //abre las capas, pintando los sectores bool mal = false; string path_import = res.Value; //abre con valor único string path_lyr = path_import; var resb = HelperGdb.OpenLayerUniqueValue(path_lyr, LimpiezaDef.Campos.consulta_sector); if (!resb.Value) { res.Error.Add("Error al abrir capa "+ path_lyr + " con Valor único. " + resb.Error.FirstOrDefault()); res.Value = string.Empty; mal = true; } if(!mal) res.Value = path_import; return res; } /** * Realiza las funciones de importación de la planificación */ public Respuesta ImportPlanif(string GdbFileName) { var res = Import(GdbFileName, 1); if (res.HasError || string.IsNullOrEmpty(res.Value)) { res.Value = string.Empty; return res; } ////////////////////////////////////////////////// //abre las capas, pintando los sectores string path_import = res.Value; int NOPEN = 6; int nopen_ = 4; string[] path_lyr_arr = new string[NOPEN]; //se añade la capa de ambitos original con la secto, y se pinta por sectores - shape path_lyr_arr[0] = path_import; //la primera capa que se añade es la de ruta, se le quita la visualización porque lo que interesa //de esa capa es poder acceder si fuera necesario a la tabla de atributos. shape + name_ruta_out path_lyr_arr[1]= path_import + NAME_RUTA_OUT; //se añade la capa de ruta_aux y se pinta por sectores - shape + name_ruta_out + name_aux path_lyr_arr[2] = path_import + NAME_RUTA_OUT + NAME_AUX; //se abre la capa de puntos de control y se pintan por el sector al que pertenecen - shape + name_control_out path_lyr_arr[3] = path_import + NAME_CONTROL_OUT; //la siguiente es la de ruta2, se le quita la visualización porque lo que interesa //de esa capa es poder acceder si fuera necesario a la tabla de atributos. shape + name_ruta2_out if (System.IO.File.Exists(path_import + NAME_RUTA2_OUT)) path_lyr_arr[nopen_++] = path_import + NAME_RUTA2_OUT; //se añade la capa de la ruta a las instalaciones, comprueba si hay configurada coordenadas de la instalación - shape + name_inst_out if (System.IO.File.Exists(path_import + NAME_INSTAL_OUT)) path_lyr_arr[nopen_++] = path_import + NAME_INSTAL_OUT; NOPEN = nopen_; bool[] visible_arr = {true,false,true,false,false,false }; int i; var resb = new Respuesta(); for(i =0;i Import(string GdbFileName, int modo) { var res = new Respuesta { Value = string.Empty }; ///////////////////////////////////////// string path_shape = OliviaGlob.Paths.PathData; string dir_shp = System.IO.Path.GetDirectoryName(path_shape); string shapefile = System.IO.Path.GetFileNameWithoutExtension(path_shape); int ind = shapefile.IndexOf("_", 0); string prefijo = shapefile.Substring(ind + 1, 1); ////////////////////////////////////////////////////////////////////////////////// //decodifica el nombre del shapefile para asignarle el correspondiente nombre en la GDB a la que se importa el shape string tratamiento = string.Empty; string ambitos = string.Empty; com.decode_gdb(shapefile, out tratamiento, out ambitos); //supsuestamente distingue si es limpieza o recogida if(string.IsNullOrEmpty(tratamiento) || string.IsNullOrEmpty(ambitos)) { res.Error.Add(string.Format("Nombre del archivo a importar erróneo. No se reconoce el prefijo introducido: {0}", prefijo)); return res; } bool reco_o_limp_con_instala = (prefijo == "F") || ((prefijo == "T") && !com.CoordsInstal.Equals(new Coordinate2D(0, 0))); bool reco_tramos = System.IO.File.Exists(System.IO.Path.Combine(dir_shp, shapefile + NAME_RUTA2 + EXT_SHP)); ///////////////////////////////////////// //crea el dataset o comprueba si existe string datasetNameOut = string.Empty; var resp = HelperGdb.CreateDataset(GdbFileName, tratamiento, spatRefData, out datasetNameOut); string err_spatref = "Atención, no coincide la proyección de las FeatureClass del Dataset ya creado con la del FeatureClass a importar"; if (resp.Value == 1) { res.Error.Add("Error al crear el Dataset para importar " + tratamiento); return res; } else if (resp.Value == 2) { //avisa HelperGlobal.ponMsg(err_spatref +", se ha creado un nuevo dataset "+ datasetNameOut ); tratamiento = datasetNameOut; } string dataset = tratamiento; ///////////////////////////////////////// //todo ok, se pone a importar string err_st =string.Empty; string name = ambitos; string path_import = GdbFileName + "\\" + dataset + "\\" + ambitos; int NIMPORT; string[] noms_shp = null; string[] noms_gdb = null; int i; int ii = 0; NIMPORT = 0; if (modo == 0) //sectoriza { NIMPORT = 1; noms_shp = new string[NIMPORT]; noms_gdb = new string[NIMPORT]; noms_shp[0] = shapefile; noms_gdb[0] = ambitos; /*noms_shp[1] = shapefile + NAME_AUX; noms_gdb[1] = ambitos + NAME_SECT;*/ } else if (modo == 1) //planifica { if (reco_o_limp_con_instala) NIMPORT = 5; else NIMPORT = 4; if (reco_tramos) NIMPORT++; noms_shp = new string[NIMPORT]; noms_gdb = new string[NIMPORT]; noms_shp[0] = shapefile; noms_gdb[0] = ambitos; /*noms_shp[1] = shapefile + NAME_AUX; noms_gdb[1] = ambitos + NAME_SECT;*/ noms_shp[1] = shapefile + NAME_CONTROL; noms_gdb[1] = ambitos + NAME_CONTROL_OUT; noms_shp[2] = shapefile + NAME_RUTA; noms_gdb[2] = ambitos + NAME_RUTA_OUT; noms_shp[3] = shapefile + NAME_RUTA_AUX; noms_gdb[3] = ambitos + NAME_RUTA_OUT + NAME_AUX; ii = 4; if (reco_o_limp_con_instala) { noms_shp[4] = shapefile + NAME_INSTAL; noms_gdb[4] = ambitos + NAME_INSTAL_OUT; ii++; } if (reco_tramos) { noms_shp[ii] = shapefile + NAME_RUTA2; noms_gdb[ii] = ambitos + NAME_RUTA2_OUT; } } if (noms_gdb == null || noms_shp==null) { res.Error.Add("Errores al crear los nombres de las Feature Class"); return res; } Respuesta resp2; try { ///////////////////////////////////////// //se embucla para hacer todas las importaciones necesarias for (i = 0; i < NIMPORT; i++) { resp2 = HelperGdb.ImportShp(dir_shp + "\\" + noms_shp[i] + HelperGdb.SHP_EXT, GdbFileName + "\\" + dataset, noms_gdb[i]); if (!resp2.Value) { err_st = "Error al importar la capa " + noms_gdb[i]; if (resp2.HasError) err_st += " " + resp2.Error.First(); break; } } if (i < NIMPORT) { res.Error.Add("Errores en la importación: "+err_st); return res; } //cambia el nombre de los campos que había truncado a 10 caracteres al exportar a shp //solo para la capa original resp2 = com.RestauraNomCampos(GdbFileName + "\\" + dataset + "\\" + noms_gdb[0]); if (!resp2.Value) { err_st = "Error al renombrar campos " + noms_gdb[i]; if (resp2.HasError) err_st += " " + resp2.Error.First(); res.Error.Add("Errores en la importación: " + err_st); return res; } } catch { res.Error.Add("Errores en la importación"); return res; } finally { } res.Value = path_import; return res; } /** * Cierra del mapa las capas de trabajo después de la exportación */ public void CierraCapas() { string capa_principal = System.IO.Path.GetFileNameWithoutExtension(OliviaGlob.Paths.PathData); string capa_principal_nw = System.IO.Path.GetFileNameWithoutExtension(OliviaGlob.Paths.PathNW); HelperGdb.CloseLayer(capa_principal); HelperGdb.CloseLayer(capa_principal_nw); } } }