Example #1
0
        }//Selecciona los puntos mas extremos

        public PuntoConAngulo MaximoX(List <PuntoConAngulo> puntos)
        {
            //List<PuntoConAngulo> aux = new List<PuntoConAngulo>();

            //foreach (PuntoConAngulo k in puntos)
            //{
            //    aux.Add(k);
            //}
            //while (aux.Count > 1)
            //{
            //    if (aux[0].Punto.X >= aux[1].Punto.X)
            //    {
            //        aux.RemoveAt(1);
            //    }
            //    else
            //    {
            //        aux.RemoveAt(0);
            //    }
            //}
            //return aux[0];
            PuntoConAngulo aux = puntos[0];

            foreach (PuntoConAngulo l in puntos)
            {
                if (aux.Punto.X < l.Punto.X)
                {
                    aux = l;
                }
            }
            return(aux);
        }//Selecciona el punto con mas X
Example #2
0
        }//Redefine un punto dependiendo de que centro se le de

        public void CalculoLugar(PuntoConAngulo punto, Point pCentral) //Calcula el cuadrante correspondiente
        {
            Point aux = RedefinirPunto(punto.Punto, pCentral);

            if ((aux.X < 0) && (aux.Y >= 0) || (aux.X <= 0) && (aux.Y > 0))
            {
                punto.Lugar = "CuadranteII";
            }

            if ((aux.X > 0) && (aux.Y <= 0) || (aux.X >= 0) && (aux.Y < 0))
            {
                punto.Lugar = "CuadranteIV";
            }
            if ((aux.X < 0) && (aux.Y <= 0) || (aux.X <= 0) && (aux.Y < 0))
            {
                punto.Lugar = "CuadranteIII";
            }
            if ((aux.X > 0) && (aux.Y >= 0) || (aux.X >= 0) && (aux.Y > 0))
            {
                punto.Lugar = "CuadranteI";
            }

            if ((aux.X == 0) && (aux.Y == 0))
            {
                punto.Lugar = "Origen";
            }
        }
Example #3
0
        }//Crea puentos aleatoriamente

        public List <PuntoConAngulo> Extremos(List <PuntoConAngulo> puntos)
        {
            List <PuntoConAngulo> ListaDeExtremos = new List <PuntoConAngulo>();


            PuntoConAngulo maxX = MaximoX(puntos);
            PuntoConAngulo maxY = MaximoY(puntos);
            PuntoConAngulo minX = MinimoX(puntos);
            PuntoConAngulo minY = MinimoY(puntos);

            ListaDeExtremos.Add(minX);
            if (minX != minY)
            {
                ListaDeExtremos.Add(minY);
            }
            if (minY != maxX)
            {
                ListaDeExtremos.Add(maxX);
            }
            if (maxX != maxY)
            {
                ListaDeExtremos.Add(maxY);
            }
            if (maxY != minX)
            {
                ListaDeExtremos.Add(minX);
            }

            return(ListaDeExtremos);
        }//Selecciona los puntos mas extremos
Example #4
0
        int IComparable.CompareTo(object obj)
        {
            if (obj is PuntoConAngulo)
            {
                PuntoConAngulo temp = (PuntoConAngulo)obj;

                return(angulo.CompareTo(temp.angulo));
            }
            throw new NotImplementedException();
        }
Example #5
0
        }//ordena los primero 3 puntos dependiendo de la pendiente entre el primer y tercer punto

        public void Incremental(List <PuntoConAngulo> puntos, Pen lapiz, Graphics grafica)
        {
            //ordena los puntos por el X
            OrdenarPorX(puntos, 0, puntos.Count - 1);
            //Lista donde ira el ciere
            List <PuntoConAngulo> Cierre = new List <PuntoConAngulo>();

            //Ordena los primeros 3 puntos y los agrega al cierre
            Ordenar3Primeros(puntos[0], puntos[1], puntos[2], Cierre);
            //grafica el primer triangulo
            graficarpuntos(lapiz, Cierre, grafica);
            //pregunta punto por punto parte desde el tres porque ya se agregaron esos 3
            for (int i = 3; i < puntos.Count; i++)
            {
                //indice del primer punto del cierre
                int indiceP = 0;
                //Punto que apunta al primer punto del cierre
                PuntoConAngulo primero = Cierre[indiceP];
                //Puntos que apunta al centro del cierre actual
                Point centroCierre = CentroPromedio(Cierre);
                //Recorre todos los puntos del cierre para ir incluyendo los nuevos
                for (int j = 1; j < Cierre.Count; j++)
                {
                    //Si el determinante entre 2 puntos contiguos del cierre y un punto candidato da positivo lo agrega
                    if (Determinante(primero.Punto, puntos[i].Punto, Cierre[j].Punto, centroCierre) >= 0)
                    {
                        //Dibujar el primero con el punto
                        grafica.DrawLine(lapiz, primero.Punto, puntos[i].Punto);
                        // Buscar el siguiente
                        int indiceS = BuscarElSiguienteIndice(Cierre, puntos[i], indiceP, centroCierre);
                        // Borrar si es necesario
                        if (indiceS > 0)
                        {
                            Cierre.RemoveRange(indiceP + 1, indiceS);
                        }
                        //Inserta el nuevo punto
                        Cierre.Insert(indiceP + 1, puntos[i]);
                        //Grafica el nuevo punto con el ultimo que lo vio
                        grafica.DrawLine(lapiz, Cierre[indiceP + 1].Punto, Cierre[indiceP + 2].Punto);


                        //ya que agrego hace que termine el for
                        j = Cierre.Count;
                    }
                    else
                    {   //si no agrego ningun punto , primero avanza al siguiente punto del cierre para ver si puede ver al punto candidao
                        primero = Cierre[indiceP + 1];
                        //el indice aumenta
                        indiceP++;
                    }
                }
            }
        }//Cierra de forma incremental
Example #6
0
        //Metodos Comunes
        public List <PuntoConAngulo> CreaPuntos(int n, Graphics grafica)
        {
            List <PuntoConAngulo> Puntos = new List <PuntoConAngulo>();

            for (int i = 0; i < n; i++)
            {
                PuntoConAngulo aux2 = new PuntoConAngulo(new Point(random.Next(1, xfinal), random.Next(1, yfinal)));
                grafica.DrawRectangle(colorPunto, new Rectangle((aux2.Punto.X), (aux2.Punto.Y), 1, 1));
                Puntos.Add(aux2);
            }
            return(Puntos);
        }//Crea puentos aleatoriamente
Example #7
0
        }//Saca el promedio de todos los X y todos los Y y crea un punto

        public int BuscarElSiguienteIndice(List <PuntoConAngulo> cierre, PuntoConAngulo punto, int indiceP, Point centro)
        {
            int cont = 0;

            for (int i = indiceP + 1; i < cierre.Count - 1; i++)
            {
                if (Determinante(cierre[i].Punto, punto.Punto, cierre[i + 1].Punto, centro) >= 0)
                {
                    cont++;
                }
            }
            return(cont);
        }//Busca el indice del ultimo punto del cierre que vio al punto cuestionado
Example #8
0
        public int BuscarElSiguienteIndice(List<PuntoConAngulo> cierre, PuntoConAngulo punto, int indiceP, Point centro)
        {
            int cont = 0;
            for (int i = indiceP + 1; i < cierre.Count - 1; i++)
            {
                if (Determinante(cierre[i].Punto, punto.Punto, cierre[i + 1].Punto, centro) >= 0)
                {
                    cont++;

                }

            }
            return cont;
        }
Example #9
0
        //Cierre Envolvente

        public Point CalculoMenor(List <PuntoConAngulo> Aux, Point inicial)
        {
            PuntoConAngulo menor = Aux[0];

            foreach (PuntoConAngulo item in Aux)
            {
                //Point auxo = RedefinirPunto(item.Punto, inicial);
                item.Pendiente = CalculoPendiente(item, inicial);

                if (menor.Pendiente >= item.Pendiente)
                {
                    menor = item;
                }
            }


            return(menor.Punto);
        }//Calcula el punto con la menor pendiente
Example #10
0
        }//Ordena de manera quicksort desde el menor a mayor X

        public void Ordenar3Primeros(PuntoConAngulo uno, PuntoConAngulo dos, PuntoConAngulo tres, List <PuntoConAngulo> cierre)
        {
            Point centroUnoTres = new Point((uno.Punto.X + tres.Punto.X + dos.Punto.X) / 3, (uno.Punto.Y + dos.Punto.Y + tres.Punto.Y) / 3);


            if (Determinante(uno.Punto, dos.Punto, tres.Punto, centroUnoTres) > 0)
            {
                cierre.Add(uno);
                cierre.Add(dos);
                cierre.Add(tres);
                cierre.Add(uno);
            }
            else
            {
                cierre.Add(uno);
                cierre.Add(tres);
                cierre.Add(dos);
                cierre.Add(uno);
            }
        }//ordena los primero 3 puntos dependiendo de la pendiente entre el primer y tercer punto
Example #11
0
        }//Calcula el punto con la menor pendiente

        public double CalculoPendiente(PuntoConAngulo punto, Point inicial)
        {
            PuntoConAngulo aux       = new PuntoConAngulo(RedefinirPunto(punto.Punto, inicial));
            double         aretornar = 0;

            if (aux.Punto.X != 0)
            {
                aretornar = (Convert.ToDouble(aux.Punto.Y) / Convert.ToDouble(aux.Punto.X));
            }
            else
            {
                switch (punto.Lugar)
                {
                case "CuadranteI":
                {
                    aretornar = (Convert.ToDouble(aux.Punto.Y) + 1);
                    break;
                }

                case "CuadranteII":
                {
                    aretornar = (Convert.ToDouble(aux.Punto.Y) + 1) * -1;
                    break;
                }

                case "CuadranteIII":
                {
                    aretornar = (Convert.ToDouble(aux.Punto.Y) - 1) * -1;
                    break;
                }

                case "CuadranteIV":
                {
                    aretornar = (Convert.ToDouble(aux.Punto.Y) - 1);
                    break;
                }
                }
            }

            return(aretornar);
        }//calcula la pendiente de un punto
Example #12
0
        //Calcula el cuadrante correspondiente
        public void CalculoLugar(PuntoConAngulo punto, Point pCentral)
        {
            Point aux = RedefinirPunto(punto.Punto, pCentral);

            if ((aux.X < 0) && (aux.Y >= 0)||(aux.X <= 0) && (aux.Y > 0))
            {
                punto.Lugar = "CuadranteII";
            }

            if ((aux.X > 0) && (aux.Y <= 0)||(aux.X >= 0) && (aux.Y < 0))
            {
                punto.Lugar = "CuadranteIV";

            }
            if ((aux.X < 0) && (aux.Y <= 0)||(aux.X <= 0) && (aux.Y < 0))
            {
                punto.Lugar = "CuadranteIII";

            }
            if ((aux.X > 0) && (aux.Y >= 0)||(aux.X >= 0) && (aux.Y > 0))
            {
                punto.Lugar = "CuadranteI";

            }

            if ((aux.X == 0) && (aux.Y == 0))
            {
                punto.Lugar = "Origen";

            }
        }
Example #13
0
        public void Ordenar3Primeros(PuntoConAngulo uno, PuntoConAngulo dos, PuntoConAngulo tres,List<PuntoConAngulo> cierre)
        {
            Point centroUnoTres = new Point((uno.Punto.X + tres.Punto.X + dos.Punto.X) / 3, (uno.Punto.Y + dos.Punto.Y + tres.Punto.Y) / 3);

               if (Determinante(uno.Punto, dos.Punto, tres.Punto, centroUnoTres) > 0)
               {
                   cierre.Add(uno);
                   cierre.Add(dos);
                   cierre.Add(tres);
                   cierre.Add(uno);
               }
               else
               {
                   cierre.Add(uno);
                   cierre.Add(tres);
                   cierre.Add(dos);
                   cierre.Add(uno);

               }
        }
Example #14
0
        //Metodos Comunes
        public List<PuntoConAngulo> CreaPuntos(int n, Graphics grafica)
        {
            List<PuntoConAngulo> Puntos = new List<PuntoConAngulo>();
            for (int i = 0; i < n; i++)
            {

                PuntoConAngulo aux2 = new PuntoConAngulo(new Point(random.Next(1, xfinal), random.Next(1, yfinal)));
                grafica.DrawRectangle(colorPunto, new Rectangle((aux2.Punto.X), (aux2.Punto.Y), 1, 1));
                Puntos.Add(aux2);

            }
            return Puntos;
        }
Example #15
0
        public double CalculoPendiente(PuntoConAngulo punto, Point inicial)
        {
            PuntoConAngulo aux = new PuntoConAngulo(RedefinirPunto(punto.Punto, inicial));
            double aretornar = 0;
            if (aux.Punto.X != 0)
                aretornar = (Convert.ToDouble(aux.Punto.Y) / Convert.ToDouble(aux.Punto.X));
            else
            {
                switch (punto.Lugar)
                {
                    case "CuadranteI":
                        {
                            aretornar = (Convert.ToDouble(aux.Punto.Y) + 1);
                            break;
                        }
                    case "CuadranteII":
                        {
                            aretornar = (Convert.ToDouble(aux.Punto.Y) + 1) * -1;
                            break;
                        }
                    case "CuadranteIII":
                        {
                            aretornar = (Convert.ToDouble(aux.Punto.Y) - 1) * -1;
                            break;

                        }
                    case "CuadranteIV":
                        {
                            aretornar = (Convert.ToDouble(aux.Punto.Y) - 1);
                            break;
                        }
                }

            }

            return aretornar;
        }