265 lines
10 KiB
C#
265 lines
10 KiB
C#
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
|
|
}
|
|
//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 prefNameExport = "data_";
|
|
public string extShp = ".shp";
|
|
public string name_export_nw = "nw_";
|
|
|
|
public string ErrStr = "";
|
|
SpatialQueryFilter filtroEspacial = null;
|
|
SpatialReference spatRef = null;
|
|
public TratamientoComun com;
|
|
/**
|
|
* Acciones para comenzar ejecución
|
|
* Modo 0, sectorizar
|
|
* Modo 1, planificar
|
|
*/
|
|
public bool ComienzaEjec(ModosEjec modo, CancelableProgressorSource cps, out string ErrStr)
|
|
{
|
|
bool fue_mal = false;
|
|
ErrStr = string.Empty;
|
|
//Cuenta las filas que cumplen la consulta
|
|
int nelems = HelperGdb.GetNumElems(com.CapaElems, com.ConsultaAmbs);
|
|
if (nelems <= 0)
|
|
{
|
|
ErrStr = "No existen ámbitos que cumplan las condiciones introducidas para la exportación " + com.ConsultaAmbs;
|
|
fue_mal = true;
|
|
}
|
|
|
|
cps.Status = "Exportando geometria";
|
|
|
|
//Obtiene la geometría que envuelve a los ámbitos
|
|
Geometry geom_export = null;
|
|
if (!fue_mal)
|
|
{
|
|
geom_export = GetGeomAmbitsExport(cps);
|
|
if (geom_export == null || geom_export.IsEmpty)
|
|
{
|
|
ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + ErrStr;
|
|
fue_mal = true;
|
|
}
|
|
}
|
|
//crea el filtro de exportación
|
|
if (!fue_mal)
|
|
{
|
|
//mira spatialreference de los datos de entrada
|
|
spatRef = geom_export.SpatialReference;
|
|
filtroEspacial = (SpatialQueryFilter) HelperGdb.CreateFiler(com.ConsultaAmbs, geom_export);
|
|
fue_mal = filtroEspacial == null;
|
|
if (fue_mal)
|
|
ErrStr = "Error al crear el filtro de exportacion";
|
|
|
|
if (!fue_mal)
|
|
fue_mal = Exporta(modo, cps, out ErrStr);
|
|
if (!fue_mal)
|
|
{
|
|
//Guarda el nombre
|
|
OliviaGlob.Paths.PathData = OliviaGlob.Paths.DirData + com.NombreShpExport;
|
|
}
|
|
}
|
|
cps.Value = 80;
|
|
if (!fue_mal)
|
|
{
|
|
//hace intersecciones espaciales en caso de ámbitos lineales para quitar los que tienen más parte fuera de la zona que dentro
|
|
if (geom_export != 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 que no se haya quedado sin ámbitos
|
|
using (FeatureClass fc = HelperGdb.GetFtClassFromShp(OliviaGlob.Paths.PathData).Result)
|
|
{
|
|
if (fc.GetCount() <= 0)
|
|
{
|
|
ErrStr = "No quedan ámbitos que cumplan la geometría seleccionada.";
|
|
return false;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//amplia la geom para englobar las instalaciones
|
|
geom_export = HelperGdb.GetGeomConvexHull(fc, null, cps).Result;
|
|
/*if (limp.coords_instala[0] != 0 && limp.coords_instala[1] != 0)
|
|
{
|
|
//hay instalación
|
|
if (!FunGDB.is_pto_in_geom(limp.coords_instala[0], limp.coords_instala[1], geom_ambits))
|
|
geom_ambits = FunGDB.amplia_geom_convexhull(geom_ambits, limp.coords_instala[0], limp.coords_instala[1]);
|
|
|
|
//comprueba, si hay restricciones de circulación, que la instalación no está en ellas
|
|
if (limp.geom_rest_acces != null)
|
|
{
|
|
if (FunGDB.is_pto_in_geom(limp.coords_instala[0], limp.coords_instala[1], limp.geom_rest_acces))
|
|
{
|
|
err_st = "Error, la instalación sal/lleg está en la zona restringida a la circulación";
|
|
return false;
|
|
}
|
|
}
|
|
}*/
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//exporta la red navegable (buffer, le quita las restr...)
|
|
|
|
//guarda los nombres del shape
|
|
OliviaGlob.Paths.PathNW = OliviaGlob.Paths.DirData + com.NombreShpExportNw;
|
|
|
|
return fue_mal;
|
|
}
|
|
|
|
/**
|
|
* Prepara la geometría para exportar los ámbitos
|
|
*/
|
|
public Geometry GetGeomAmbitsExport(CancelableProgressorSource cps)
|
|
{
|
|
Geometry geomAux = null;
|
|
Geometry geomAmbits = null;
|
|
|
|
ErrStr = string.Empty;
|
|
FeatureClass fc = HelperGdb.GetFtClass(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.Capas.ftclass_ejes))
|
|
{
|
|
ErrStr = "Al emplear ejes de calle como ámbitos es necesario indicar polígono de exportación";
|
|
return null;
|
|
}
|
|
cps.Value = 30;
|
|
|
|
//prepara el filtro con consulta y espacial
|
|
SpatialQueryFilter filtro = (SpatialQueryFilter)HelperGdb.CreateFiler(com.ConsultaAmbs, geomAux);
|
|
|
|
//Ahora hace la geometría de los ámbitos que cumplen la consulta
|
|
geomAmbits = HelperGdb.GetGeomConvexHull(fc, filtro, cps).Result;
|
|
if (geomAmbits == null || geomAmbits.IsEmpty)
|
|
{
|
|
ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + HelperGdb.OutStr;
|
|
return null;
|
|
}
|
|
geomAux = geomAmbits;
|
|
cps.Value = 60;
|
|
//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;
|
|
}
|
|
}
|
|
cps.Value = 75;
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* Exporta y lanza proceso y ventana de proceso
|
|
*/
|
|
public bool Exporta(ModosEjec modo, CancelableProgressorSource cps, out string msg)
|
|
{
|
|
msg = "";
|
|
//exporta los datos de entrada
|
|
return HelperGdb.ExportShp(com.CapaElems, filtroEspacial, com.NombreShpExport, OliviaGlob.Paths.DirData, cps, out msg);
|
|
}
|
|
/*
|
|
* Lee la capa que se ha seleccionzdo de recogida y se comprueba que contiene los campos necesarios
|
|
* Devuelve 0 si va todo bien, -1 si da error, y num>0 con los campos que no encuentra
|
|
*/
|
|
public int CompruebaCampos(string pathCapa, string[] camps)
|
|
{
|
|
int i;
|
|
|
|
if (string.IsNullOrEmpty(pathCapa))
|
|
{
|
|
ErrStr = "No se encuentra la capa";
|
|
return -1;
|
|
}
|
|
ErrStr = "No se encuentran el/los campo/s: ";
|
|
int mal = 0;
|
|
for (i = 0; i < camps.Length; i++)
|
|
{
|
|
if (!HelperGdb.CheckField(pathCapa, camps[i]))
|
|
{
|
|
ErrStr = ErrStr + camps[i] + " ";
|
|
mal++;
|
|
}
|
|
}
|
|
if(mal==0)
|
|
ErrStr = "";
|
|
return mal;
|
|
}
|
|
|
|
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 CompruebaCampos(pathCapa, camps) == 0;
|
|
}
|
|
}
|
|
}
|