/// <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");
}
public Base(Vetor vetor1, Vetor vetor2)
{
if(validaBase(vetor1,vetor2))
{
_vetor1 = vetor1;
_vetor2 = vetor2;
}
else
{
throw new Exception("O sistema tentou criar uma base invalida");
}
}
/// <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");
}
}
/// <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)
;
}
public Ponto Transladado(Vetor V)
{
return new Ponto(this._x + V.X,this._y + V.Y);
}
/// <summary>
/// Translado o ponto
/// </summary>
/// <param name="V">Vetor V da translação</param>
public void Translada(Vetor V)
{
this._x += V.X;
this._y += V.Y;
}
private bool validaBase(Vetor vetor1, Vetor vetor2)
{
if(vetor1.X / vetor2.X != vetor1.Y / vetor2.Y)
return true;
return false;
}
public float ProdutoEscalar(Vetor v)
{
return X*v.X+Y*v.Y;
}
/// <summary>
/// Retorna se V é LI
/// </summary>
/// <param name="V">Vetor V</param>
/// <returns>Retorna verdadeiro se V for LI</returns>
public bool LI(Vetor V)
{
if(_x/V.X == _y/V.Y)
return true;
return false;
}
protected Reta()
{
_diretor= new Vetor(1,1);
_origem= new Ponto();
calculaCoeficiente();
}
public SegmentoDeReta(Ponto Origem, Vetor Diretor)
{
_origem = Origem;
_pontoB = Origem.Transladado(Diretor);
}
public SegmentoDeReta(Ponto A, Ponto B)
{
_origem = A;
_pontoB = B;
Diretor = new Vetor(_origem,PontoB);
}