private List<ArestaDelaunay> encontraArestas(Ponto P, List<TrianguloDelaunay> morto)
{
List<ArestaDelaunay> temp = new List<ArestaDelaunay>();// lista temporaria
foreach (TrianguloDelaunay T in morto)
{
if (T.Vizinho1 == null || T.Vizinho1.Circunscrito.PosicaoRelativa(P) == 2)// se esta vivo
{
if (T.Vizinho1 == null)
temp.Add(new ArestaDelaunay(T.PontoC, T.PontoB));
else
temp.Add(new ArestaDelaunay(T.Vizinho1.PontoC, T.PontoB, T.Vizinho1, T.Vizinho1.qualVizinho(T)));
}
if(T.Vizinho2 == null || T.Vizinho2.Circunscrito.PosicaoRelativa( P)==2)// se esta vivo
{
if (T.Vizinho2 == null)
temp.Add(new ArestaDelaunay(T.PontoA,T.PontoC));
else
temp.Add(new ArestaDelaunay(T.Vizinho2.PontoA,T.PontoC,T.Vizinho2,T.Vizinho2.qualVizinho(T)));
}
if(T.Vizinho3 == null || T.Vizinho3.Circunscrito.PosicaoRelativa( P)==2)// se nao esta fora
{
if (T.Vizinho3 == null)
temp.Add(new ArestaDelaunay(T.PontoB, T.PontoA));
else
temp.Add(new ArestaDelaunay(T.Vizinho3.PontoB, T.PontoA, T.Vizinho3, T.Vizinho2.qualVizinho(T)));
}
}
return temp.Distinct().ToList();
}
public ArestaDelaunay(Ponto A, Ponto B)
{
this._origem = A;
this._pontoB = B;
referente = 0;
vizinho = null;
}
/// <summary>
/// Um triangulo composto por dois pontos
/// </summary>
/// <param name="A">Ponto A</param>
/// <param name="B">Ponto B</param>
/// <param name="C">Ponto C</param>
public Triangulo(Ponto A, Ponto B, Ponto C)
{
_pontoA = A;
_pontoB = B;
_pontoC = C;
_circuncentro = retornaCircuncentro();
}
/// <summary>
/// Retorna a posição relativa de um ponto P quanto ao circulo
/// </summary>
/// <param name="P">O ponto P</param>
/// <returns>Retorna 0 caso P esteja contido no circulo, 1 caso P esteja contido no bordo do circulo, e 2 caso P esteja fora do circulo</returns>
public int PosicaoRelativa(Ponto P)
{
if(Origem.RetornaDistancia(P)<Raio)
return 0;
if (Origem.RetornaDistancia(P) > Raio)
return 2;
return 1;
}
public ArestaDelaunay(Ponto A, Ponto B, TrianguloDelaunay T, int r)
{
vizinho = T;
referente = r;
this._origem = A;
this._pontoB = B;
this.Diretor = new Vetor(A,B);
}
/// <summary>
/// Um triangulo composto por um ponto e uma reta (reescrever de uma maneira melhor)
/// </summary>
/// <param name="P">Ponto P</param>
/// <param name="R">Reta R</param>
public Triangulo(Ponto P, Reta R)
{
_pontoA = P;
_pontoB = R.Origem;
_pontoC = R.Origem.Transladado(R.Diretor);
_circuncentro = retornaCircuncentro();
_circunscrito = new Circulo(Circuncentro,PontoA.RetornaDistancia(Circuncentro));
}
public TrianguloDelaunay(Ponto A, Ponto B, Ponto C)
{
_pontoA = A;
_pontoB = B;
_pontoC = C;
_vizinho1 = null;
_vizinho2 = null;
_vizinho3 = null;
_circuncentro = new SegmentoDeReta(A, B).Intersecta(new Reta(A, B));
_circunscrito = new Circulo(Circuncentro, A.RetornaDistancia(Circuncentro));
}
/// <summary>
/// Reta que parte de um ponto A e tem como direção o vetor formado pelos pontos A e B
/// </summary>
/// <param name="A">Ponto A</param>
/// <param name="B">Ponto B</param>
public Reta(Ponto A, Ponto B)
{
if(A!=B)
{
_origem = A;
_diretor = new Vetor(A,B);
calculaCoeficiente();
}
else
throw new Exception("Não é possivel criar uma reta com um vetor diretor nulo");
}
/// <summary>
/// Reta que parte de um ponto origem O e tem como direção o vetor diretor D
/// </summary>
/// <param name="Origem">Ponto origem O</param>
/// <param name="Diretor">Vetor diretor D</param>
public Reta(Ponto Origem, Vetor Diretor)
{
if(Diretor.X !=0 || Diretor.Y !=0)
{
_origem = Origem;
_diretor = Diretor;
calculaCoeficiente();
}
else
{
throw new Exception("Não é possivel criar uma reta com um vetor diretor nulo, a reta identidade foi criada no lugar");
}
}
public void adcionaPonto(Ponto P)
{
List<ArestaDelaunay> arestas = new List<ArestaDelaunay>();
List<TrianguloDelaunay> Morto = new List<TrianguloDelaunay>();
for(int i=0; i<_triangulos.Count; i++)
{
if(_triangulos[i].Circunscrito.PosicaoRelativa(P)!= 2)
Morto.Add(_triangulos[i]);
}
arestas = encontraArestas(P,Morto);// erase later -> working fine
arestas = ordenaAresta(arestas);// erase later -> working fine
for (int i = 0; i < Morto.Count; i++)
_triangulos.Remove(Morto[i]);
for (int i = 0; i < arestas.Count; i++)
{
_triangulos.Add(new TrianguloDelaunay(arestas[i].vizinho, P, arestas[i].Origem, arestas[i].PontoB));
}
}
public Ponto Transladado(Ponto P)
{
return new Ponto(this.X + P.X, this.Y + P.Y);
}
/// <summary>
/// Translado o ponto
/// </summary>
/// <param name="P">Ponto P da translação</param>
public void Translada(Ponto P)
{
this._x += P.X;
this._y += P.Y;
}
/// <summary>
/// Retorna distancia do ponto ao ponto P
/// </summary>
/// <param name="P">Ponto P</param>
/// <returns>Distancia</returns>
public float RetornaDistancia(Ponto P)
{
return (float)Math.Sqrt(Math.Pow(this.X-P.X,2) + Math.Pow(this.Y-P.Y,2));
}
public SegmentoDeReta(Ponto Origem, Vetor Diretor)
{
_origem = Origem;
_pontoB = Origem.Transladado(Diretor);
}
public float RetornaDistancia(Ponto P)
{
float numerador, denominador;
numerador = A*P.X+B*P.Y+C;
if (numerador<0)
numerador = - numerador;
denominador = (float)Math.Sqrt(A*A+B*B);
return numerador/denominador;
}
public int PosicaoPonto(Ponto P)
{
if((Diretor.Y>0 && P.X>Origem.X && P.X<PontoB.X)||(Diretor.Y <= 0 && P.X <= Origem.X && P.X >= PontoB.X))
{
float escalar = Diretor.RetornaOrtogonal().ProdutoEscalar(new Vetor(Origem, P));
if (escalar > 0)
return 0;
if (escalar < 0)
return 1;
if (escalar == 0)
return 2;
}
return 3;
}
public Circulo(float raio)
{
this._origem = new Ponto();
this._raio = raio;
}
/// <summary>
/// Um circulo com centro em P e de raio R
/// </summary>
/// <param name="origem">O centro P</param>
/// <param name="raio">O raio R</param>
public Circulo(Ponto origem, float raio)
{
this._origem = origem;
this._raio = raio;
}
protected Reta()
{
_diretor= new Vetor(1,1);
_origem= new Ponto();
calculaCoeficiente();
}
List<Ponto> FechoConvexo = new List<Ponto>(); // convex hull
#endregion Fields
#region Constructors
public Plano(Ponto Dimensao)
{
}
public SegmentoDeReta(Ponto A, Ponto B)
{
_origem = A;
_pontoB = B;
Diretor = new Vetor(_origem,PontoB);
}
/// <summary>
/// Posição relativa de um ponto P a reta
/// </summary>
/// <param name="P">Ponto O</param>
/// <returns>0 se estiver "acima da reta", 2 se estiver contido na reta, 1 se estiver "abaixo da reta"</returns>
public int PosicaoPonto(Ponto P)
{
float escalar = Diretor.RetornaOrtogonal().ProdutoEscalar(new Vetor(Origem,P));
if(escalar>0)
return 0;
if(escalar<0)
return 1;
if(escalar==0)
return 2;
return 3;
}
/// <summary>
/// Retorna a posição relativa de um ponto P em relação ao triangulo
/// O algoritimo foi retirado do site http://www.blackpawn.com/texts/pointinpoly/default.html (perguntar ao paiva a expliação correta)
/// </summary>
/// <param name="P">O ponto P</param>
/// <returns>Retorna verdadeiro se o ponto estiver dentro do triangulo, e falso se estiver fora</returns>
public bool PosicaoRelativa(Ponto P)
{
Vetor vet1 = new Vetor(PontoA,PontoB)
, vet2 = new Vetor(PontoA,PontoC)
, vet3 = new Vetor(PontoA,P);
float produto11 = vet1.ProdutoEscalar(vet1)
, produto12 = vet1.ProdutoEscalar(vet2)
, produto13 = vet1.ProdutoEscalar(vet3)
, produto22 = vet2.ProdutoEscalar(vet2)
, produto23 = vet2.ProdutoEscalar(vet3);
float invDenom = 1 / (produto11 * produto22 - produto12 * produto12);
float u = (produto22 * produto13 - produto13 * produto23) * invDenom,
v = (produto11 * produto23 - produto12 * produto13) * invDenom;
return (u >= 0) && (v >= 0) && (u + v < 1)
;
}
/// <summary>
/// Vetor que parte da origem e vai a um ponto diretor
/// </summary>
/// <param name="Diretor">Ponto diretor</param>
public Vetor(Ponto Diretor)
{
_x = Diretor.X;
_y = Diretor.Y;
calculaNorma();
}
/// <summary>
/// Vetor que parte de um ponto A e vai a um ponto B
/// </summary>
/// <param name="A">Ponto A</param>
/// <param name="B">Ponto B</param>
public Vetor(Ponto A, Ponto B)
{
_x = B.X - A.X;
_y = B.Y - A.Y;
calculaNorma();
}
public SegmentoDeReta()
{
_origem = null;
_pontoB = null;
}
