コード例 #1
0
ファイル: Delaunay.cs プロジェクト: Supitto/Metria-Legacy
        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();
        }
コード例 #2
0
 public ArestaDelaunay(Ponto A, Ponto B)
 {
     this._origem = A;
     this._pontoB = B;
     referente = 0;
     vizinho = null;
 }
コード例 #3
0
ファイル: Triangulo.cs プロジェクト: Supitto/Metria-Legacy
 /// <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();
 }
コード例 #4
0
ファイル: Circulo.cs プロジェクト: Supitto/Metria-Legacy
 /// <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;
 }
コード例 #5
0
 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);
 }
コード例 #6
0
ファイル: Triangulo.cs プロジェクト: Supitto/Metria-Legacy
 /// <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));
 }
コード例 #7
0
 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));
 }
コード例 #8
0
ファイル: Reta.cs プロジェクト: Supitto/Metria-Legacy
 /// <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");
 }
コード例 #9
0
ファイル: Reta.cs プロジェクト: Supitto/Metria-Legacy
 /// <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");
     }
 }
コード例 #10
0
ファイル: Delaunay.cs プロジェクト: Supitto/Metria-Legacy
        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));
            }
        }
コード例 #11
0
ファイル: Ponto.cs プロジェクト: Supitto/Metria-Legacy
 public Ponto Transladado(Ponto P)
 {
     return new Ponto(this.X + P.X, this.Y + P.Y);
 }
コード例 #12
0
ファイル: Ponto.cs プロジェクト: Supitto/Metria-Legacy
 /// <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;
 }
コード例 #13
0
ファイル: Ponto.cs プロジェクト: Supitto/Metria-Legacy
 /// <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));
 }
コード例 #14
0
 public SegmentoDeReta(Ponto Origem, Vetor Diretor)
 {
     _origem = Origem;
     _pontoB = Origem.Transladado(Diretor);
 }
コード例 #15
0
ファイル: Reta.cs プロジェクト: Supitto/Metria-Legacy
 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;
 }
コード例 #16
0
 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;
 }
コード例 #17
0
ファイル: Circulo.cs プロジェクト: Supitto/Metria-Legacy
 public Circulo(float raio)
 {
     this._origem = new Ponto();
     this._raio = raio;
 }
コード例 #18
0
ファイル: Circulo.cs プロジェクト: Supitto/Metria-Legacy
 /// <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;
 }
コード例 #19
0
ファイル: Reta.cs プロジェクト: Supitto/Metria-Legacy
 protected Reta()
 {
     _diretor= new Vetor(1,1);
     _origem= new Ponto();
     calculaCoeficiente();
 }
コード例 #20
0
ファイル: Plano.cs プロジェクト: Supitto/Metria-Legacy
        List<Ponto> FechoConvexo = new List<Ponto>(); // convex hull

        #endregion Fields

        #region Constructors

        public Plano(Ponto Dimensao)
        {
        }
コード例 #21
0
 public SegmentoDeReta(Ponto A, Ponto B)
 {
     _origem = A;
     _pontoB = B;
     Diretor = new Vetor(_origem,PontoB);
 }
コード例 #22
0
ファイル: Reta.cs プロジェクト: Supitto/Metria-Legacy
 /// <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;
 }
コード例 #23
0
ファイル: Triangulo.cs プロジェクト: Supitto/Metria-Legacy
 /// <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)
     ;
 }
コード例 #24
0
ファイル: Vetor.cs プロジェクト: Supitto/Metria-Legacy
 /// <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();
 }
コード例 #25
0
ファイル: Vetor.cs プロジェクト: Supitto/Metria-Legacy
 /// <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();
 }
コード例 #26
0
 public SegmentoDeReta()
 {
     _origem = null;
     _pontoB = null;
 }