/// <summary>
/// Costruttore
/// </summary>
/// <param name="pt"></param>
/// <param name="par1"></param>
/// <param name="par2"></param>
/// <param name="tratto1"></param>
/// <param name="tratto2"></param>
/// <param name="tang1"></param>
/// <param name="tang2"></param>
public Intersection(Point2D pt, double par1, double par2, Tratto tratto1, Tratto tratto2, bool tang1=false, bool tang2 = false)
{
p = pt;
t1 = par1;
t2 = par2;
tg1 = tang1;
tg2 = tang2;
tr1 = tratto1;
tr2 = tratto2;
}
/// <summary>
/// Controlla se due tratti sono connessi
/// </summary>
/// <param name="t1"></param>
/// <param name="t2"></param>
/// <returns></returns>
public static bool AreConnected(Tratto t1, Tratto t2)
{
bool conn = false;
int i,j;
for(i=0; i<2; i++)
for(j=0; j<2; j++)
{
if ( Function2D.Distance(t1.P12[i],t2.P12[j]) <= Function2D.CoincidenceDistance)
{
conn = true; // Imposta flag
i=j=2; // e uscita dai cicli
}
}
return conn;
}
/// <summary>
/// Distanza punto - tratto generico
/// </summary>
/// <param name="p">Punto</param>
/// <param name="te">Tratto</param>
/// <returns></returns>
public static double Distance(Point2D p, Tratto te)
{
Type tp;
tp = te.GetType();
if(tp == typeof(Line2D))
{
return Distance( p, (Line2D) te);
}
if(tp == typeof(Arc2D))
{
throw new Exception("Tipo non implementato");
// return Distance(p, (Arc2D) te);
}
throw new Exception("Tipo non implementato");
}
/// <summary>
/// Verifica se i due tratti sono tangenti all'estremo
/// </summary>
/// <param name="t1">Tratto 1</param>
/// <param name="t2">Tratto 2</param>
/// <returns></returns>
protected bool Tangenti(Tratto t1, Tratto t2)
{
bool tg = false;
bool conn = false;
int i,j, itrov, jtrov;
itrov = jtrov = -1;
for(i=0; i<2; i++)
for(j=0; j<2; j++)
{
if ( Function2D.Distance(t1.P12[i],t2.P12[j]) <= Function2D.CoincidenceDistance)
{
conn = true; // Imposta indici trovati, flag...
itrov = i;
jtrov = j;
i=j=2; // ...e uscita dai cicli
}
}
if(conn) // Se connessi ai vertici indicati...
{
Point2D norm1 = Function2D.VersorOut(t1.P12[itrov],t1); // Trova le normali
Point2D norm2 = Function2D.VersorOut(t2.P12[jtrov],t2);
if( Math.Abs(norm1^norm2) >= 1 - 2 * Function2D.CoincidenceDistance )
{
tg = true;
}
}
return tg;
}
/// <summary>
/// Trova il contorno costituito dal tratto
/// </summary>
/// <param name="tr">Tratto</param>
/// <returns></returns>
public Contorno Contorno(Tratto tr)
{
Contorno cf = null;
foreach(Contorno c in contorni)
{
if(c.Tratto == tr)
{
cf = c;
break;
}
}
return cf;
}
//public Contorno(Line2D line, StatoSuperficie stato = StatoSuperficie.Trasparente)
// {
// Inizializza();
// obj = line;
// stat = stato;
// }
//public Contorno(Arc2D arc, StatoSuperficie stato = StatoSuperficie.Trasparente)
// {
// Inizializza();
// obj = arc;
// stat = stato;
// }
/// <summary>
/// Costruttore
/// </summary>
/// <param name="tr"></param>
/// <param name="stato"></param>
public Contorno(Tratto tr, StatoSuperficie stato = StatoSuperficie.Trasparente)
{
Inizializza();
obj = tr;
stat = stato;
}
#pragma warning restore 1591
/// <summary>
/// Costruttore
/// </summary>
/// <param name="tr">Tratto</param>
/// <param name="pen">Indice della penna</param>
public DisplayListElement(Tratto tr, int pen)
{
tratto = tr;
penna = pen;
}
/// <summary>
/// Versore uscente
/// </summary>
/// <param name="p">Punto sul tratto</param>
/// <param name="te">Tratto</param>
/// <param name="ext">Punto esterno opzionale</param>
/// <returns></returns>
public static Point2D VersorOut( Point2D p, Tratto te, Point2D ext = null)
{
Type tp;
tp = te.GetType();
if(tp == typeof(Line2D))
{
return VersorOut( p, (Line2D) te, ext);
}
if(tp == typeof(Arc2D))
{
return VersorOut( p, (Arc2D) te, ext);
}
throw new Exception("Tipo non implementato");
}
/// <summary>
/// Linea uscente
/// </summary>
/// <param name="p">Punto sul tratto</param>
/// <param name="te">Tratto</param>
/// <param name="vOut">Versore uscente (parametro out)</param>
/// <param name="ext">Punto esterno opzionale</param>
/// <returns>bool</returns>
public static bool LineOut( Point2D p, Tratto te, out Line2D vOut, Point2D ext = null)
{
Type tp;
tp = te.GetType();
if(tp == typeof(Line2D))
{
return LineOut( p, (Line2D) te, out vOut, ext);
}
if(tp == typeof(Arc2D))
{
return LineOut( p, (Arc2D) te, out vOut, ext);
}
throw new Exception("Tipo non implementato");
}
/// <summary>
/// Proiezione di un punto su un tratto generico
/// </summary>
/// <param name="p">Punto</param>
/// <param name="te">Tratto</param>
/// <param name="bInside">true se richiesta appartenenza proiezione all'interno del tratto</param>
/// <returns>La proiezione</returns>
public static Point2D Projection( Point2D p, Tratto te, bool bInside = false)
{
Type tp;
tp = te.GetType();
if(tp == typeof(Line2D))
{
return Projection( p, (Line2D) te, bInside);
}
if(tp == typeof(Arc2D))
{
return Projection( p, (Arc2D) te, bInside);
}
throw new Exception("Tipo non implementato");
}
/// <summary>
/// Punto piu` vicino, su un tratto generico
/// </summary>
/// <param name="p">Punto</param>
/// <param name="te">Tratto</param>
/// <param name="nearest">Punto trovato (parametro out)</param>
/// <param name="distance">Distanza (parametro out)</param>
/// <param name="bInside">true se richiesta intersezione interna al tratto</param>
/// <returns>true se trovato</returns>
public static bool Nearest( Point2D p, Tratto te, out Point2D nearest, out double distance, bool bInside = false)
{
Type tp;
tp = te.GetType();
if(tp == typeof(Line2D))
{
return Nearest( p, (Line2D)te, out nearest, out distance, bInside);
}
if(tp == typeof(Arc2D))
{
return Nearest(p, (Arc2D)te, out nearest, out distance, bInside);
}
throw new Exception("Tipo non implementato");
}
/// <summary>
/// Intersezione tra linea e tratto generico
/// </summary>
/// <param name="l1">Linea</param>
/// <param name="te">Tratto</param>
/// <param name="bCheckInside1">Richiesta intersezione interna alla linea</param>
/// <param name="bCheckInside2">Richiesta intersezione interna al tratto</param>
/// <returns></returns>
public static List<Intersection> Intersect( Line2D l1, Tratto te, bool bCheckInside1 = false, bool bCheckInside2 = false)
{
Type tp;
tp = te.GetType();
if(tp == typeof(Line2D))
{
return Intersect( l1, (Line2D)te, bCheckInside1 , bCheckInside2 );
}
if(tp == typeof(Arc2D))
{
return Intersect( l1, (Arc2D)te, bCheckInside1 , bCheckInside2 );
}
throw new Exception("Tipo non implementato");
}