Narvaling
/
OliviaAddInPro
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Modificaciones varias última versión

Gerardo/Compilacion.net
Elena 2023-01-12 01:05:54 +01:00
parent dd2c58667d
commit a056f6d78b
4 changed files with 259 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

175
Helper/HelperGdb.cs
View File

@ -435,44 +435,124 @@ namespace OliviaAddInPro.Helper
}
//Dado un path de una feature class devuelve la ftclass abierta directamente,
//o null si ha habido algún problema o no lo ha encontrado
public static FeatureClass GetFtClass(string pathFtClss)
{
FeatureClass ftclss = null;
if (string.IsNullOrEmpty(pathFtClss))
return null;
Geodatabase gdb = GetGdb(pathFtClss).Result;
ReiniciaOutStr();
if (gdb != null)
{
ftclss = GetFtClass(System.IO.Path.GetFileNameWithoutExtension(pathFtClss), gdb).Result;
}
else //mira a ver si es shapefile
{
ftclss = GetFtClassFromShp(pathFtClss).Result;
}
Free(gdb);
return ftclss;
}
//Dado un path de una feature class devuelve la ftclass abierta directamente,
//o null si ha habido algún problema o no lo ha encontrado
public static FeatureClass GetFtClassSync(string pathFtClss)
{
FeatureClass ftclss = null;
FeatureDataset dtset = null;
if (string.IsNullOrEmpty(pathFtClss))
return null;
Geodatabase gdb = GetGdbSync(pathFtClss);
ReiniciaOutStr();
if (gdb != null)
{
ftclss = GetFtClassSync(System.IO.Path.GetFileNameWithoutExtension(pathFtClss), gdb);
string dtsetName = new DirectoryInfo(System.IO.Path.GetDirectoryName(pathFtClss)).Name;
try
{
dtset = gdb.OpenDataset<FeatureDataset>(dtsetName);
}
catch (Exception ex)
{
HelperGdb.OutStr = "Error al abrir Dataset " + dtsetName + ": " + ex.Message;
dtset= null;
}
string ftclassName = System.IO.Path.GetFileNameWithoutExtension(pathFtClss);
if (dtset != null)
{
try
{
ftclss = dtset.OpenDataset<FeatureClass>(ftclassName);
}
catch (Exception ex)
{
ftclss = null;
}
}
else
{
try
{
ftclss = gdb.OpenDataset<FeatureClass>(ftclassName);
}
catch (Exception ex)
{
ftclss = null;
}
}
if(ftclss==null)
HelperGdb.OutStr = "Error al abrir Feature Class " + ftclassName;
}
else //mira a ver si es shapefile
{
ftclss = GetFtClassFromShpSync(pathFtClss);
}
Free(gdb);
Free(dtset);
return ftclss;
}
//Dado un path de una feature class devuelve la ftclass abierta directamente,
//o null si ha habido algún problema o no lo ha encontrado
public static FeatureClass GetFtClass(string pathFtClss)
{
FeatureClass ftclss = null;
FeatureDataset dtset = null;
if (string.IsNullOrEmpty(pathFtClss))
return null;
Geodatabase gdb = GetGdb(pathFtClss).Result;
ReiniciaOutStr();
if (gdb != null)
{
var task = ArcGIS.Desktop.Framework.Threading.Tasks.QueuedTask.Run((Func<FeatureClass>)(() =>
{
string dtsetName = new DirectoryInfo(System.IO.Path.GetDirectoryName(pathFtClss)).Name;
try
{
dtset = gdb.OpenDataset<FeatureDataset>(dtsetName);
}
catch (Exception ex)
{
HelperGdb.OutStr = "Error al abrir Dataset " + dtsetName + ": " + ex.Message;
dtset = null;
}
string ftclassName = System.IO.Path.GetFileNameWithoutExtension(pathFtClss);
if (dtset != null)
{
try
{
ftclss = dtset.OpenDataset<FeatureClass>(ftclassName);
}
catch (Exception ex)
{
ftclss = null;
}
}
else
{
try
{
ftclss = gdb.OpenDataset<FeatureClass>(ftclassName);
}
catch (Exception ex)
{
ftclss = null;
}
}
if (ftclss == null)
HelperGdb.OutStr = "Error al abrir Feature Class " + ftclassName;
return ftclss;
}));
task.Wait();
}
else //mira a ver si es shapefile
{
ftclss = GetFtClassFromShp(pathFtClss).Result;
}
Free(gdb);
Free(dtset);
return ftclss;
}
//Dado el path de una gdb y el nombre de una feature class, devuelve la
@ -487,7 +567,7 @@ namespace OliviaAddInPro.Helper
{
try
{
ftclss = gdb.OpenDataset<FeatureClass>(nameFtclss);
ftclss = gdb.OpenDataset<FeatureClass>(nameFtclss);
}
catch (Exception ex)
{
@ -1164,25 +1244,7 @@ namespace OliviaAddInPro.Helper
return geomsal;
}));
}
/**
* Devuelve el número de entidades de una FeatureClass que cumplen la consulta, o todos si la consulta es empty
*/
public static int GetNumElems(string pathGdb, string ftclssName, string consulta = "")
{
Geodatabase gdb = GetGdb(pathGdb).Result;
FeatureClass fc = null;
int n = -1;
if (gdb != null)
{
fc = GetFtClass(ftclssName, gdb).Result;
if (fc != null)
n = GetNumElems(fc, consulta).Result;
}
Free(fc);
Free(gdb);
return n;
}
/**
* Devuelve los valores únicos de un campo dado
*/
@ -2090,7 +2152,8 @@ namespace OliviaAddInPro.Helper
try
{
FeatureDatasetDefinition featureDatasetDefinition = gdb.GetDefinition<FeatureDatasetDefinition>(datasetName);
if(featureDatasetDefinition.GetSpatialReference().Equals(spatref))
ArcGIS.Core.Geometry.SpatialReference entr = featureDatasetDefinition.GetSpatialReference();
if (entr.Wkid==spatref.Wkid)
return 0;
return 2;
}
@ -2103,7 +2166,10 @@ namespace OliviaAddInPro.Helper
/**
* Crea un FeatureDataset con el nombre dado y la spatialrefernece dada en la gdb dada
* Devuelve 0 si no hay que crear nada o si lo ha creado bien, 2 si existe el dataset pero con otra referencia espacial, 1 si da error
* Devuelve 0 si no hay que crear nada, existe y coincide ref espac
* 2 si existe el dataset pero con otra referencia espacial, así que se crea otro
* 1 si da error
* 4 si no existe así que se crea
*/
public static Respuesta<int> CreateDataset(string gdbPath, string datasetName, ArcGIS.Core.Geometry.SpatialReference spatref, out string datasetNameOut)
{
@ -2125,6 +2191,7 @@ namespace OliviaAddInPro.Helper
bool crea = false;
int idat = 1;
int r = 2;
bool refspatdif = false;
while(r==2)
{
var task1 = CheckDataset(gdb, datasetName);
@ -2142,7 +2209,8 @@ namespace OliviaAddInPro.Helper
{
//existe ese nombre, pero con otra ref espacial
//crea un nuevo dataset y avisa
datasetName = string.Format("{0}_{1}",datasetName,idat);
datasetName = string.Format("{0}_{1}",datasetName,idat);
refspatdif = true;
idat++;
}
else//r==1
@ -2188,10 +2256,11 @@ namespace OliviaAddInPro.Helper
task.Wait();
if (task.Result.Value)//ha ido bien
{
if (string.IsNullOrEmpty(datasetNameOut))
res.Value = 0;
//avisa
if (refspatdif)
res.Value = 2;
else
res.Value = 2;//avisa
res.Value = 4;
//actualiza la gdb
Refresh(gdbPath);
}
@ -2319,18 +2388,18 @@ namespace OliviaAddInPro.Helper
* Devuelve -1 si da error al abrir la gdb, -2 si da error al abrir el ftclass (igual porque no existe)
* y 0 si da error el proceso de borrar, y 1 si va todo bien
*/
public static Respuesta<int> DeleteFeatureClassSync(string gdbPath, string featureClassName)
public static Respuesta<int> DeleteFeatureClassSync(string gdbPathDataset, string featureClassName)
{
var res = new Respuesta<int> { Value = 0 };
Geodatabase gdb = GetGdbSync(gdbPath);
Geodatabase gdb = GetGdbSync(gdbPathDataset);
if (gdb == null)
{
res.Value = -1;
return res;
}
FeatureClass ftclss = GetFtClassSync(featureClassName, gdb);
FeatureClass ftclss = GetFtClassSync(gdbPathDataset + " \\"+ featureClassName);
if (ftclss == null)
{
res.Value = -2;
@ -2371,15 +2440,15 @@ namespace OliviaAddInPro.Helper
/**
* Borrar una feature class de un dataset
*/
public static Respuesta<bool> DeleteFeatureClass(string gdbPath, string featureClassName)
public static Respuesta<bool> DeleteFeatureClass(string gdbPathDataset, string featureClassName)
{
var res = new Respuesta<bool> { Value = false };
Geodatabase gdb = GetGdb(gdbPath).Result;
Geodatabase gdb = GetGdb(gdbPathDataset).Result;
if (gdb == null)
return res;
FeatureClass ftclss = GetFtClass(featureClassName,gdb).Result;
FeatureClass ftclss = GetFtClass(gdbPathDataset + " \\" + featureClassName);
if (ftclss == null)
return res;

154
Services/EjecServ.cs
View File

@ -175,6 +175,14 @@ namespace OliviaAddInPro.Services
return false;
}
/////////////////////////////////////////////////////////////////////
///Comprueba si está la columna de ObjectId y si no, la crea
if(!ComprCreaColOid(OliviaGlob.Paths.PathData, com.CapaElems, filtroEspacial))
{
ErrStr = "Error al exportar columna " + ComunDef.CamposCom.camp_oid;
return false;
}
///////////////////////////////////////////////////////////////////////
//ahora si está en modo planificación, ya ha hecho una ejec antes y la capa no tiene esa columna pero la tiene guardada de la ejec anterior, exporta la sectorización
if (modo==ModosEjec.Planifica && !string.IsNullOrEmpty(com.CapaPlanif) && OliviaGlob.IsConfig2())
@ -240,22 +248,7 @@ namespace OliviaAddInPro.Services
{
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;
}
}
if (com.ProgrSrc._ProgrSrc.Getcancelled())
{
ErrStr = Resource1.String_cancel_progreso;
return false;
}
}
//////////////////////////////////////////////////////////////
//comprueba si la geometría de exportación contiene a la instalación y a la planta de descarga
for (int i = 0; i < coords.Length; i++)
@ -288,13 +281,28 @@ namespace OliviaAddInPro.Services
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;
}
}
}
}
//quita las restricciones de circ
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;
}
}
if (com.ProgrSrc._ProgrSrc.Getcancelled())
{
ErrStr = Resource1.String_cancel_progreso;
return false;
}
//mira spatialreference del nw
/*FeatureClass fc = HelperGdb.GetFtClass(OliviaGlob.Paths.PathGdbNw);
@ -496,8 +504,103 @@ namespace OliviaAddInPro.Services
}
/**
* Prepara la geometría para exportar los ámbitos
* Comrpueba si existe la columna de oid y si no, la crea y la rellena
*/
public bool ComprCreaColOid(string pathCapa, string pathCapaOrig, SpatialQueryFilter filter)
{
//comprueba si está el campo
int NCAMPS = 1;
string[] camps;
camps = new string[NCAMPS];
camps[0] = ComunDef.CamposCom.camp_oid;
int compCamp = HelperGdb.CheckFileds(pathCapa, camps);
ErrStr = HelperGdb.OutStr;
if (compCamp == 0)
return true; //tiene el campo
//no lo tiene, lo crea
//Añade al shp exportado la columna de sector y secuencia
HelperGdb.FieldToAdd[] fields = new HelperGdb.FieldToAdd[1];
//campo
fields[0].Name = ComunDef.CamposCom.camp_oid;
fields[0].Alias = ComunDef.CamposCom.camp_oid;
fields[0].Tipo = "LONG";
fields[0].Length = 0;
if (!HelperGdb.AddFieldsSync(pathCapa, fields))
return false;
//vuelve a cerrar la capa
string capa_principal = System.IO.Path.GetFileNameWithoutExtension(pathCapa);
HelperGdb.CloseLayer(capa_principal);
/////////////////////////////////////////////////////
//Coge los ids de la capa de la que ha exportado
FeatureClass fc_orig = HelperGdb.GetFtClassSync(pathCapaOrig);
if (fc_orig == null)
return false;
List<long> ids = new List<long>();
//Añade a la lista los ids que cumplen el filtro espacial
try
{
ids = fc_orig.Select(filter, SelectionType.ObjectID, SelectionOption.Normal).GetObjectIDs().ToList();
}
catch
{
ids = new List<long>();
}
//Comprueba que hay tantos ids como elementos en el shp
FeatureClass fc_shp = HelperGdb.GetFtClassSync(pathCapa);
if (fc_shp == null)
return false;
int nelem_shp = HelperGdb.GetNumElemsSync(fc_shp);
if (nelem_shp != ids.Count)
return false;
/////////////////////////////////////////////////////
//ahora rellena las columnas
try
{
using (RowCursor rc_shp = fc_shp.Search())
{
if (rc_shp == null)
return false;
var modifyOp = new ArcGIS.Desktop.Editing.EditOperation();
modifyOp.Name = "Actualiza OID";
bool ex = false;
//modifyOp.Callback((context) =>
//{
int i = 0;
while (rc_shp.MoveNext() && i < ids.Count)
{
using (Row rowshp = rc_shp.Current)
{
//context.Invalidate(rowshp);
// modify and execute
modifyOp.Modify(rowshp, ComunDef.CamposCom.camp_oid, ids[i++]);
rowshp.Store();
//context.Invalidate(rowshp);
}
}
//}, fc_shp);
ex = modifyOp.Execute();
ArcGIS.Desktop.Core.Project.Current.SaveEditsAsync();
if (ex && modifyOp.IsDone)
return true;
else
return false;
}
}
catch
{
return false;
}
return true;
}
/**
* Prepara la geometría para exportar los ámbitos
*/
public Geometry GetGeomAmbitsExport()
{
Geometry geomAux = null;
@ -539,7 +642,7 @@ namespace OliviaAddInPro.Services
//if (geomAux == null)
{
//Ahora hace la geometría de los ámbitos que cumplen la consulta
geomAmbits = HelperGdb.GetGeomConvexHullSync(fc, filtro);
geomAmbits = HelperGdb.GetGeomUnique(fc, filtro);
if (geomAmbits == null || geomAmbits.IsEmpty)
{
ErrStr = "No se ha podido generar geometría de los ámbitos" + com.ConsultaAmbs + HelperGdb.OutStr;
@ -550,7 +653,7 @@ namespace OliviaAddInPro.Services
else
{
geomAux = HelperGdb.IntersectGeom(geomAux, geomAmbits);
geomAux = GeometryEngine.Instance.ConvexHull(geomAux);
//geomAux = GeometryEngine.Instance.ConvexHull(geomAux);
}
}
//le quita las restricciones
@ -773,7 +876,7 @@ namespace OliviaAddInPro.Services
//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==0)
{
//avisa
@ -786,10 +889,13 @@ namespace OliviaAddInPro.Services
res.Error.Add("Error al crear el Dataset para importar " + tratamiento);
return res;
}
else if (resp.Value == 2)
else //2 o 4 if (resp.Value == 2)
{
//avisa
msg_avisa = err_spatref + ", se ha creado un nuevo dataset " + datasetNameOut;
string err_spatref = string.Empty;
if (resp.Value==2)
err_spatref = "Atención, no coincide la proyección de las FeatureClass del Dataset ya creado con la del FeatureClass a importar. ";
msg_avisa = err_spatref + "Se ha creado un nuevo dataset " + datasetNameOut;
//HelperGlobal.ponMsg(err_spatref +", se ha creado un nuevo dataset "+ datasetNameOut );
tratamiento = datasetNameOut;
}
@ -875,7 +981,7 @@ namespace OliviaAddInPro.Services
//mira a ver si hay que borrar para reemplazar
if (sobreescribe)
{
resp = HelperGdb.DeleteFeatureClassSync(GdbFileName, noms_gdb[i]);
resp = HelperGdb.DeleteFeatureClassSync(GdbFileName + "\\" + dataset, noms_gdb[i]);
if (resp.Value!=-2 && resp.Value!=1) //-2 porque puede ser que no pueda abrir la capa porque no existe
{
err_st = "Error al sobreescribir la capa " + noms_gdb[i];

9
Services/ProcesoEjecServ.cs
View File

@ -124,6 +124,7 @@ namespace OliviaAddInPro.Services
}
}
int result = Environment.TickCount & Int32.MaxValue; //para que el tickcount no sea negativo
if (cps.Getcancelled()) //mira a ver si ha cancelado el usuario
{
//se ha cancelado, lo envía al OliviaTask
@ -137,11 +138,11 @@ namespace OliviaAddInPro.Services
if(!fin) //si no ha finalizado normal, el usuario lo ha cancelado
res.Error.Add("Proceso Cancelado por el usuario");
}
else if (!first_send_cfg && ((Math.Abs(Environment.TickCount) - lastprog) >= m_tm_progr) && !fin) //en caso normal, todo va bien, pide el progreso y la tarea
else if (!first_send_cfg && ((result - lastprog) >= m_tm_progr) && !fin) //en caso normal, todo va bien, pide el progreso y la tarea
{
//solo pide la programación cada m_tm_progr milis
var pp = pide_progr();
if (pp .Value> TiposActu.ActuFinOk)
if (pp.Value> TiposActu.ActuFinOk)
fin = true;
if(pp.HasError)
{
@ -153,8 +154,10 @@ namespace OliviaAddInPro.Services
else
nint++;
}
if (pp.Value == TiposActu.ActuFinNOk)
res.Error.Add("Finalizado proceso con fallos");
actualiza(pp);
lastprog = Environment.TickCount;
lastprog = result;
}
} while (!sal);

1
ViewModel/Recogida/PaneRecogidaSub1ViewModel.cs
View File

@ -274,6 +274,7 @@ namespace OliviaAddInPro
TiposVehic.Clear();
TiposCapac.Clear();
OliviaGlob.AddFlagTipEjec(TiposEjecucion.Config); //lo reinicia, por si estaba después de planificar
OliviaGlob.RemoveFlagTipEjec(TiposEjecucion.Config2);
if (string.IsNullOrEmpty(capa))
return false;