/// <summary>
/// Calcula los extremos más cercanos de las dos líneas pasadas por parámetro.
/// </summary>
/// <param name="líneaA">Primera línea para analizar la distancia.</param>
/// <param name="líneaB">Segunda línea para analizar la distancia.</param>
/// <param name="vérticeA">Índice al vertice de la primera línea que está más cerca del extremo de la segunda línea.</param>
/// <param name="vérticeB">Índice al vertice de la segunda línea que está más cerca del extremo de la primera línea.</param>
public static void ExtremosMásCercanos(ReadOnlyLine líneaA, ReadOnlyLine líneaB, out int vérticeA, out int vérticeB)
{
var a = ((Point2D)líneaA.FirstVertex - (Point2D)líneaB.FirstVertex).Module;
var b = ((Point2D)líneaA.FirstVertex - (Point2D)líneaB.LastVertex).Module;
var c = ((Point2D)líneaA.LastVertex - (Point2D)líneaB.FirstVertex).Module;
var d = ((Point2D)líneaA.LastVertex - (Point2D)líneaB.LastVertex).Module;
var valores = new List <double> {
a, b, c, d
};
valores.Sort();
if (a.IsEqual(valores[0]))
{
vérticeA = 0;
vérticeB = 0;
}
else if (b.IsEqual(valores[0]))
{
vérticeA = 0;
vérticeB = líneaB.Points.Count - 1;
}
else if (c.IsEqual(valores[0]))
{
vérticeA = líneaA.Points.Count - 1;
vérticeB = 0;
}
else
{
vérticeA = líneaA.Points.Count - 1;
vérticeB = líneaB.Points.Count - 1;
}
}
/// <summary>
/// Devuelve el índice al segmento de la línea más cercano al punto pasado por parámetro.
/// </summary>
/// <param name="línea">Línea contra la cual se proyectará el punto para calcular su distancia.</param>
/// <param name="punto">Punto a calcular su distancia contra la línea.</param>
/// <returns>Índice al mejor segmento.</returns>
/// <exception cref="System.Exception">Si el punto no intersecciona con la línea.</exception>
public static int SegmentoMásCercano(this ReadOnlyLine línea, Point3D punto)
{
int? mejorSegmento = null;
double?mejorDistancia = null;
for (var i = 0; i < línea.Points.Count - 1; i++)
{
var segmento = new Segment(línea.Points[i], línea.Points[i + 1]);
if (!segmento.Window.Intersect2D(punto))
{
continue;
}
var distancia = segmento.Distance2D(punto);
if (mejorDistancia != null && distancia >= mejorDistancia.Value)
{
continue;
}
mejorSegmento = i;
mejorDistancia = distancia;
}
if (!mejorSegmento.HasValue)
{
throw new Exception(Recursos.ElPuntoNoInterseccionaConLaLinea);
}
return(mejorSegmento.Value);
}
/// <summary>
/// Devuelve la distancia mínima (en el plano XY) entre una línea y un punto.
/// </summary>
/// <param name="línea">Línea contra la cual se proyectará el punto para calcular su distancia.</param>
/// <param name="punto">Punto a calcular su distancia contra la línea.</param>
/// <returns>La menor distancia a la línea.</returns>
/// <exception cref="System.Exception">Si el punto no intersecciona con la línea.</exception>
public static double DistanciaMínima(this ReadOnlyLine línea, Point3D punto)
{
double?mejorDistancia = null;
for (var i = 0; i < línea.Points.Count - 1; i++)
{
var segmento = new Segment(línea.Points[i], línea.Points[i + 1]);
if (!segmento.Window.Intersect2D(punto))
{
continue;
}
var distancia = segmento.Distance2D(punto);
mejorDistancia = mejorDistancia == null ? distancia : System.Math.Min(mejorDistancia.Value, distancia);
}
if (!mejorDistancia.HasValue)
{
throw new Exception(Recursos.ElPuntoNoInterseccionaConLaLinea);
}
return(mejorDistancia.Value);
}
/// <summary>
/// Calcula los extremos más cercanos de las dos líneas pasadas por parámetro.
/// </summary>
/// <param name="líneaA">Primera línea para analizar la distancia.</param>
/// <param name="líneaB">Segunda línea para analizar la distancia.</param>
/// <param name="vérticeA">Índice al vertice de la primera línea que está más cerca del extremo de la segunda línea.</param>
/// <param name="vérticeB">Índice al vertice de la segunda línea que está más cerca del extremo de la primera línea.</param>
public static void ExtremosMásCercanos(ReadOnlyLine líneaA, ReadOnlyLine líneaB, out int vérticeA, out int vérticeB)
{
double a = ((Point2D)líneaA.FirstVertex - (Point2D)líneaB.FirstVertex).Module;
double b = ((Point2D)líneaA.FirstVertex - (Point2D)líneaB.LastVertex).Module;
double c = ((Point2D)líneaA.LastVertex - (Point2D)líneaB.FirstVertex).Module;
double d = ((Point2D)líneaA.LastVertex - (Point2D)líneaB.LastVertex).Module;
List<double> valores = new List<double> { a, b, c, d };
valores.Sort();
if (a == valores[0])
{
vérticeA = 0;
vérticeB = 0;
}
else if (b == valores[0])
{
vérticeA = 0;
vérticeB = líneaB.Points.Count - 1;
}
else if (c == valores[0])
{
vérticeA = líneaA.Points.Count - 1;
vérticeB = 0;
}
else
{
vérticeA = líneaA.Points.Count - 1;
vérticeB = líneaB.Points.Count - 1;
}
}
/// <summary>
/// Indica si las dos líneas son contínuas en el plano XYZ.
/// </summary>
/// <param name="líneaA">Primera línea para analizar la continuidad.</param>
/// <param name="líneaB">Segunda línea para analizar la continuidad.</param>
/// <returns>Verdadero si las dos líneas son contínuas. Falso en caso contrario.</returns>
public static bool TieneContinuidad2DCon(this ReadOnlyLine líneaA, ReadOnlyLine líneaB)
{
return((Point2D)líneaA.FirstVertex == (Point2D)líneaB.FirstVertex ||
(Point2D)líneaA.LastVertex == (Point2D)líneaB.FirstVertex ||
(Point2D)líneaA.FirstVertex == (Point2D)líneaB.LastVertex ||
(Point2D)líneaA.LastVertex == (Point2D)líneaB.LastVertex);
}
/// <summary>
/// Indica si las dos líneas son contínuas en el espacio.
/// </summary>
/// <param name="líneaA">Primera línea para analizar la continuidad.</param>
/// <param name="líneaB">Segunda línea para analizar la continuidad.</param>
/// <returns>Verdadero si las dos líneas son contínuas. Falso en caso contrario.</returns>
public static bool TieneContinuidadCon(this ReadOnlyLine líneaA, ReadOnlyLine líneaB)
{
return(líneaA.FirstVertex == líneaB.FirstVertex ||
líneaA.LastVertex == líneaB.FirstVertex ||
líneaA.FirstVertex == líneaB.LastVertex ||
líneaA.LastVertex == líneaB.LastVertex);
}
/// <summary>
/// Devuelve la distancia mínima en el plano XY entre los extremos de las dos líneas.
/// </summary>
/// <param name="líneaA">Primera línea para analizar la distancia.</param>
/// <param name="lineaB">Segunda línea para analizar la distancia.</param>
/// <returns>Menor de las distancias entre las dos líneas.</returns>
public static double DistanciaMínimaExtremo(this ReadOnlyLine líneaA, ReadOnlyLine lineaB)
{
var distancia = double.MaxValue;
distancia = System.Math.Min(distancia, ((Point2D)líneaA.FirstVertex - (Point2D)lineaB.FirstVertex).Module);
distancia = System.Math.Min(distancia, ((Point2D)líneaA.FirstVertex - (Point2D)lineaB.LastVertex).Module);
distancia = System.Math.Min(distancia, ((Point2D)líneaA.LastVertex - (Point2D)lineaB.FirstVertex).Module);
distancia = System.Math.Min(distancia, ((Point2D)líneaA.LastVertex - (Point2D)lineaB.LastVertex).Module);
return(distancia);
}
/// <summary>
/// Devuelve la distancia mínima en el plano XY entre los extremos de las dos líneas.
/// </summary>
/// <param name="líneaA">Primera línea para analizar la distancia.</param>
/// <param name="lineaB">Segunda línea para analizar la distancia.</param>
/// <returns>Menor de las distancias entre las dos líneas.</returns>
public static double DistanciaMínimaExtremo(this ReadOnlyLine líneaA, ReadOnlyLine lineaB)
{
double distancia = double.MaxValue;
distancia = System.Math.Min(distancia, ((Point2D)líneaA.FirstVertex - (Point2D)lineaB.FirstVertex).Module);
distancia = System.Math.Min(distancia, ((Point2D)líneaA.FirstVertex - (Point2D)lineaB.LastVertex).Module);
distancia = System.Math.Min(distancia, ((Point2D)líneaA.LastVertex - (Point2D)lineaB.FirstVertex).Module);
distancia = System.Math.Min(distancia, ((Point2D)líneaA.LastVertex - (Point2D)lineaB.LastVertex).Module);
return distancia;
}
public static IEnumerable<IGrouping<Point2D, SegmentPointer>> SoloDeSegmento(this IEnumerable<IGrouping<Point2D, SegmentPointer>> secuencia, ReadOnlyLine línea, int númeroSegmento )
{
foreach (var intersección in secuencia)
{
foreach (var segmento in intersección)
{
if (segmento.Line == línea && segmento.FirstVertex == númeroSegmento )
yield return intersección;
}
}
}
private static void CreaTareas(ReadOnlyLine línea, Point3D puntoGotoTareaPrincipal, IEnumerable<Point2D> coordenadasCercanas)
{
var tareasPuntos = new List<ITask>();
foreach (var coordenadaCercanaAlOrigen in coordenadasCercanas)
{
var mensaje = string.Format(Recursos.MagnitudX, (new Point2D(puntoGotoTareaPrincipal.X, puntoGotoTareaPrincipal.Y) - coordenadaCercanaAlOrigen).Module);
tareasPuntos.Add(new TaskGotoPoint(new Point3D(coordenadaCercanaAlOrigen.X, coordenadaCercanaAlOrigen.Y, 0.0), mensaje, TaskSeverity.Error));
}
var mensajeTareaPrincipal = string.Format(Recursos.LocalizadoUndershootEnLaLíneaConCódigoX, línea.Codes[0].Name);
var tareaPrincipal = new TaskEntityGotoPoint(
puntoGotoTareaPrincipal,
línea,
2,
mensajeTareaPrincipal,
TaskSeverity.Error,
DigiNG.DrawingFile.Path,
Recursos.DetectarUndershootName,
tareasPuntos.ToArray());
Digi3D.Tasks.Add(tareaPrincipal);
}
public static bool Within(ReadOnlyPoint point, ReadOnlyLine area) => throw null;
public static bool Coincident(ReadOnlyPoint point, ReadOnlyLine area) => throw null;
public static bool Disjoint(ReadOnlyPoint point, ReadOnlyLine area) => throw null;
public static bool Within(ReadOnlyLine line, ReadOnlyPolygon area) => throw null;
public static bool CoincidentAndTerminate(ReadOnlyPoint point, ReadOnlyLine line) => throw null;
/// <summary>
/// Indica si una determinada línea llega a un nodo de la secuencia original.
/// </summary>
/// <param name="secuencia">Secuencia a analizar.</param>
/// <param name="line">Línea a localizar.</param>
/// <returns></returns>
public static bool LíneaLlegaANodo(this IEnumerable <VertexPointer> secuencia, ReadOnlyLine line)
{
return(secuencia.Any(vp => vp.Line == line));
}
public static bool Join(ReadOnlyLine line, ReadOnlyLine area) => throw null;
public static bool Adjacent(ReadOnlyLine line, ReadOnlyPolygon area) => throw null;
public static bool Overlap(ReadOnlyPolygon a, ReadOnlyLine b, out Point3D coordinate) => throw null;
public static bool Disjoint(ReadOnlyLine a, ReadOnlyLine b) => throw null;
public static bool Across(ReadOnlyLine a, ReadOnlyLine b) => throw null;
public static bool EndpointJoinEndpoint(ReadOnlyLine a, ReadOnlyLine b) => throw null;
public static bool EndpointJoinExcludingEndpoints(ReadOnlyLine a, ReadOnlyLine b) => throw null;
public static bool Equal(ReadOnlyLine a, ReadOnlyLine b) => throw null;
public static bool Within(ReadOnlyPolygon a, ReadOnlyLine b) => throw null;
/// <summary>
/// Indica si las dos líneas son contínuas en el espacio.
/// </summary>
/// <param name="líneaA">Primera línea para analizar la continuidad.</param>
/// <param name="líneaB">Segunda línea para analizar la continuidad.</param>
/// <returns>Verdadero si las dos líneas son contínuas. Falso en caso contrario.</returns>
public static bool TieneContinuidadCon(this ReadOnlyLine líneaA, ReadOnlyLine líneaB)
{
if (líneaA.FirstVertex == líneaB.FirstVertex ||
líneaA.LastVertex == líneaB.FirstVertex ||
líneaA.FirstVertex == líneaB.LastVertex ||
líneaA.LastVertex == líneaB.LastVertex)
return true;
return false;
}
/// <summary>
/// Devuelve todas las intersecciones que pertenecen a una determinada línea pasada por parámetros para un determinado segmento de dicha línea.
/// </summary>
/// <param name="secuencia">Secuencia de intersecciones a analizar.</param>
/// <param name="línea">Línea a buscar en la secuencia de intersecciones.</param>
/// <param name="númeroSegmento">Número de segmento a localizar para la línea a buscar en la secuencia de intersecciones.</param>
/// <returns>Enumeración con las intersecciones que tiene el segmento de la línea pasados por parámetros en la secuencia original.</returns>
public static IEnumerable <IGrouping <Point2D, SegmentPointer> > SoloDeSegmento(this IEnumerable <IGrouping <Point2D, SegmentPointer> > secuencia, ReadOnlyLine línea, int númeroSegmento)
{
return
(from intersección in secuencia
from segmento in intersección
where segmento.Line == línea && segmento.FirstVertex == númeroSegmento
select intersección);
}
public static bool Overlap(ReadOnlyLine a, ReadOnlyLine b) => throw null;
public static bool EndpointJoin(ReadOnlyLine line, ReadOnlyPolygon area) => throw null;
public static bool Adjacent(ReadOnlyPolygon a, ReadOnlyLine b) => throw null;
public static bool TerminatesWithin(ReadOnlyLine line, ReadOnlyLine area) => throw null;
public SegmentPointer(ReadOnlyLine line, int firstVertex, int secondVertex) => throw null;
public static bool Across(ReadOnlyLine line, ReadOnlyPolygon area) => throw null;
public static bool Join(ReadOnlyLine a, ReadOnlyLine b) => throw null;
public static bool Disjoint(ReadOnlyLine line, ReadOnlyPolygon area) => throw null;
/// <summary>
/// Indica si las dos líneas son contínuas en el plano XYZ.
/// </summary>
/// <param name="líneaA">Primera línea para analizar la continuidad.</param>
/// <param name="líneaB">Segunda línea para analizar la continuidad.</param>
/// <returns>Verdadero si las dos líneas son contínuas. Falso en caso contrario.</returns>
public static bool TieneContinuidad2DCon(this ReadOnlyLine líneaA, ReadOnlyLine líneaB)
{
if ( (Point2D)líneaA.FirstVertex == (Point2D)líneaB.FirstVertex ||
(Point2D)líneaA.LastVertex == (Point2D)líneaB.FirstVertex ||
(Point2D)líneaA.FirstVertex == (Point2D)líneaB.LastVertex ||
(Point2D)líneaA.LastVertex == (Point2D)líneaB.LastVertex)
return true;
return false;
}