private static void ventanas_binarias(Info_forma informacion, PictureBox pintura)
        {
            Pen         ventana = new Pen(Color.Blue, informacion.grosor_pared);
            List <bool> marcar  = new List <bool>();

            for (int i = 0; i < informacion.contorno.Count - 1; i++)
            {
                if (i % 2 == 0)
                {
                    marcar.Add(false);
                }
                else
                {
                    marcar.Add(true);
                }
            }

            for (int i = 0; i < informacion.contorno.Count - 1; i++)
            {
                if (marcar[i])
                {
                    informacion.g.DrawLine(ventana, informacion.contorno[i], informacion.contorno[i + 1]);
                }
            }
        }
        private static void puerta(Info_forma informacion, PictureBox pintura)
        {
            //Por limitaciones de la API no se puede usar decimales para la puerta
            //debido a eso tendré que fijar una medida 1,2,3 m maximo
            int          cantidad = 0;
            List <Point> borrador = new List <Point>();

            do
            {
                Pen puerta = new Pen(Color.Purple, informacion.grosor_pared);


                int ubicacion_punto = azar.Next(0, informacion.contorno.Count - informacion.ancho_puerta - 1);

                Point punto_inicio;
                Point punto_fin;



                punto_inicio = informacion.contorno[ubicacion_punto];
                punto_fin    = informacion.contorno[ubicacion_punto + 1];
                informacion.g.DrawLine(puerta, punto_inicio, punto_fin);


                //Para que no se dibuje otro objeto encima, tendré que borrar los puntos
                borrador.Add(punto_inicio);
                borrador.Add(punto_fin);



                cantidad = cantidad + 1;
            } while (cantidad != informacion.cant_puerta);

            informacion.contorno = informacion.contorno.Except(borrador).ToList();
        }
        private static void rectangulo(Info_forma inf, PictureBox pintura)
        {
            inf.g = Graphics.FromImage((Bitmap)pintura.Image);
            List <Point> rectangulo = new List <Point>();

            // Se usan 4 listas para cada lado
            List <Point> lado_superior  = Herramienta.calcular_lado(inf.po, inf.ancho_forma, "x");
            List <Point> lado_izquierdo = Herramienta.calcular_lado(inf.po, inf.alto_forma, "y");
            List <Point> lado_derecho   = Herramienta.calcular_lado(new Point(inf.po.X + inf.ancho_forma * 100, inf.po.Y), inf.alto_forma, "y");
            List <Point> lado_inferior  = Herramienta.calcular_lado(new Point(inf.po.X, inf.po.Y + inf.alto_forma * 100), inf.ancho_forma, "x");

            rectangulo.AddRange(lado_superior);
            rectangulo.AddRange(lado_derecho);
            lado_inferior.Reverse();
            rectangulo.AddRange(lado_inferior);
            lado_izquierdo.Reverse();
            rectangulo.AddRange(lado_izquierdo);

            //Elimino los puntos repetidos
            rectangulo = rectangulo.Distinct().ToList();

            //Se dibuja la pared
            Pen borde = new Pen(Color.Black, inf.grosor_pared);

            rectangulo = Herramienta.rotar_puntos_figuras(rectangulo, inf.grados, inf.punto_medio);

            //Despues de rotar guardo los puntos en el objeto
            inf.contorno = rectangulo;

            inf.g.FillPolygon(Brocha, rectangulo.ToArray());
            inf.g.DrawPolygon(borde, rectangulo.ToArray());

            pintura.Refresh();
        }
        public static void objeto(List <String> seleccion_objeto, Info_forma datos, PictureBox lienzo)
        {
            for (int i = 0; i < seleccion_objeto.Count; i++)
            {
                String nombre_objeto = seleccion_objeto[i];

                if (nombre_objeto.Equals("ui_objetos_columna_cuadrada"))
                {
                    columna_cuadrada(datos, lienzo);
                }
                else if (nombre_objeto.Equals("ui_objetos_columna_redonda"))
                {
                    columna_circular(datos, lienzo);
                }
                else if (nombre_objeto.Equals("ui_objetos_ventana"))
                {
                    if (datos.vano_ventana.Equals("ui_objetos_ventana_ale"))
                    {
                        ventanas(datos, lienzo);
                    }
                    else if (datos.vano_ventana.Equals("ui_objetos_ventana_binaria"))
                    {
                        ventanas_binarias(datos, lienzo);
                    }
                    else if (datos.vano_ventana.Equals("ui_objetos_ventana_total"))
                    {
                        ventanas_totales(datos, lienzo);
                    }
                    else if (datos.vano_ventana.Equals("ui_objetos_ventana_todos"))
                    {
                        int s = azar.Next(0, 3);
                        if (s == 0)
                        {
                            ventanas_binarias(datos, lienzo);
                        }
                        else if (s == 1)
                        {
                            ventanas_binarias(datos, lienzo);
                        }
                        else if (s == 2)
                        {
                            ventanas_totales(datos, lienzo);
                        }
                    }
                }

                else if (nombre_objeto.Equals("ui_objetos_puerta") && datos.ubicacion_pb)
                {
                    puerta(datos, lienzo);
                }

                else if (nombre_objeto.Equals("ui_objetos_elevador"))
                {
                    elevador(datos, lienzo);
                }
            }
        }
        private static void columna_circular(Info_forma info, PictureBox pintura)
        {
            Brush dibujar   = new System.Drawing.SolidBrush(System.Drawing.Color.Black);
            int   mitad_col = info.columna_redonda_med / 2;

            for (int i = 0; i < info.contorno.Count - info.col_prox; i += info.col_prox)
            {
                Point     origen_columna = new Point(info.contorno[i].X - mitad_col, info.contorno[i].Y - mitad_col);
                Rectangle columna        = new Rectangle(origen_columna, new Size(info.columna_redonda_med, info.columna_redonda_med));
                info.g.FillEllipse(dibujar, columna);
            }
        }
 private static void elevador(Info_forma informacion, PictureBox pintura)
 {
     /*
      *
      * //Aqui se dibuja la pared
      * Brush brocha_pared = new System.Drawing.SolidBrush(System.Drawing.Color.Black);
      * Rectangle pared = new Rectangle(informacion.origen_elevador, new Size(2 * 100, 2 * 100));
      * informacion.g.FillRectangle(brocha_pared, pared);
      *
      * Point punto_origen_suelo = new Point(informacion.origen_elevador.X + informacion.grosor_pared, informacion.origen_elevador.Y + informacion.grosor_pared);
      *
      * //Aqui se dibuja el agujero del suelo
      * int ancho_suelo = 2 * 100 - informacion.grosor_pared * 2;
      * int alto_suelo = 2 * 100 - informacion.grosor_pared * 2;
      * Rectangle suelo = new Rectangle(punto_origen_suelo, new Size(ancho_suelo, alto_suelo));
      * Brush brocha_suelo = new System.Drawing.SolidBrush(System.Drawing.Color.Transparent);
      *
      * if (informacion.ubicacion_pb)
      * {
      *   brocha_suelo = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(209, 209, 135));
      * }
      * else
      * {
      *   //Cambiando el modo de composicion paso a modo forzado de pintado. Predeterminado: SourceOver
      *   informacion.g.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
      * }
      *
      * informacion.g.FillRectangle(brocha_suelo, suelo);
      *
      * //Aqui cambia el punto para que el agujero se desplace, vuelve a dibujar otro agujero
      * switch (informacion.mover_ascensor)
      * {
      *   case 1: punto_origen_suelo.Y = punto_origen_suelo.Y - informacion.grosor_pared; break;
      *   case 2: punto_origen_suelo.X = punto_origen_suelo.X + informacion.grosor_pared; break;
      *   case 3: punto_origen_suelo.Y = punto_origen_suelo.Y + informacion.grosor_pared; break;
      *   case 4: punto_origen_suelo.X = punto_origen_suelo.X - informacion.grosor_pared; break;
      * }
      * suelo = new Rectangle(punto_origen_suelo, new Size(ancho_suelo, alto_suelo));
      *
      * if (informacion.ubicacion_pb)
      * {  brocha_suelo = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(209, 209, 135));}
      * else { brocha_suelo = new System.Drawing.SolidBrush(System.Drawing.Color.Transparent); }
      *
      * informacion.g.FillRectangle(brocha_suelo, suelo); */
 }
        private static void hexagono(Info_forma informacion, PictureBox pintura)
        {
            informacion.g = Graphics.FromImage((Bitmap)pintura.Image);
            Point[] shape = new Point[6];
            Pen     borde = new Pen(Color.Black, informacion.grosor_pared);

            int[] array = { informacion.ancho_forma, informacion.alto_forma };
            int   r     = array.Min() * 100;

            //Create 6 points
            for (int a = 0; a < 6; a++)
            {
                shape[a] = new Point(
                    (int)(informacion.po.X + r * (float)Math.Cos(a * 60 * Math.PI / 180)),
                    (int)(informacion.po.Y + r * (float)Math.Sin(a * 60 * Math.PI / 180)));
            }
            informacion.contorno = shape.ToList();
            informacion.g.FillPolygon(Brocha, shape);
            informacion.g.DrawPolygon(borde, shape);
        }
 public static void forma(String seleccion_forma, Info_forma datos, PictureBox lienzo)
 {
     if (seleccion_forma.Equals("ui_forma_casa_rectangular"))
     {
         rectangulo(datos, lienzo);
     }
     else if (seleccion_forma.Equals("ui_forma_casa_deformada"))
     {
         rectangulo_deformado(datos, lienzo, 1);
     }
     else if (seleccion_forma.Equals("ui_forma_casa_deformada_chaflan"))
     {
         rectangulo_deformado(datos, lienzo, 2);
     }
     else if (seleccion_forma.Equals("ui_forma_casa_hexagonal"))
     {
         hexagono(datos, lienzo);
     }
     else if (seleccion_forma.Equals("ui_forma_casa_combinar"))
     {
         combinar(datos, lienzo);
     }
 }
Exemple #9
0
        //Sistema de dibujo
        //Objetivo: Dibujar los planos en todos los lienzos.

        private void dibujar()
        {
            //Cronometro de progress bar
            Stopwatch cropro = new Stopwatch();

            cropro.Start();



            Random azar = new Random();
            //Variable para busqueda de origen
            int x_ori = Convert.ToInt32(ui_min_ancho_casa.Value) * 100, y_ori = Convert.ToInt32(ui_min_alto_casa.Value) * 100;

            List <Info_forma>        lista_casas = new List <Info_forma>();
            List <Composicion_calle> lista_comp_calles = new List <Composicion_calle>();
            List <Point>             lista_puntos_calles = new List <Point>();

            //Subsitema #1: calculo de area ciudad

            //Calculo del margen del area de dibujo, para que las formas no sobresalgan
            int margen_ancho = Convert.ToInt32(ui_max_ancho_casa.Value) * 100;
            int margen_alto  = Convert.ToInt32(ui_max_alto_casa.Value) * 100;

            //-------

            int ancho_lienzo = 0, alto_lienzo = 0, area = 0;

            List <int> anchos = new List <int>();
            List <int> altos  = new List <int>();

            for (int i = 0; i < ui_cantidad_casas.Value; i++)
            {
                anchos.Add(azar.Next(Convert.ToInt32(ui_min_ancho_casa.Value), Convert.ToInt32(ui_max_ancho_casa.Value) + 1));
                altos.Add(azar.Next(Convert.ToInt32(ui_min_alto_casa.Value), Convert.ToInt32(ui_max_alto_casa.Value) + 1));
            }
            for (int x = 0; x < ui_cantidad_casas.Value; x++)
            {
                int precalculo = (anchos[x] * altos[x]) * 100;
                area = area + precalculo;
            }

            ancho_lienzo = alto_lienzo = (int)Math.Sqrt(area) * 10;

            float por_ancho = (float)(ancho_lienzo * (Convert.ToInt32(ui_porcentaje_sin_casas.Value) * 0.01));

            ancho_lienzo = (int)(ancho_lienzo + por_ancho);
            ancho_lienzo = ancho_lienzo + margen_ancho;

            float por_alto = (float)(alto_lienzo * (Convert.ToInt32(ui_porcentaje_sin_casas.Value) * 0.01));

            alto_lienzo = (int)(alto_lienzo + por_alto);
            alto_lienzo = alto_lienzo + margen_alto;

            //Mostrar area de ciudad

            ui_label_m2.Text = Convert.ToString((ancho_lienzo / 100 * alto_lienzo / 100));

            //Llamada a la función que crea los lienzos

            crear_pages_area_casas(ancho_lienzo, alto_lienzo);

            //Pintado en el fondo del picture box

            PictureBox primer_nivel = (PictureBox)TabControl.TabPages[0].Controls.Find("Planta 0", true)[0];
            Graphics   fondo        = Graphics.FromImage(primer_nivel.Image);
            Brush      brocha_fondo = new SolidBrush(Color.DarkGreen);

            fondo.FillRectangle(brocha_fondo, new Rectangle(new Point(0, 0), new Size(ancho_lienzo, alto_lienzo)));


            //Subsistema # 2 creación de calles

            if (ui_calle_cuadricula.Checked == true)
            {
                //Se dibujan las veredas (Calle base)
                int dist_entre_cll = Convert.ToInt32(ui_espacio_calles.Value) * 100;

                for (int y = dist_entre_cll; y < alto_lienzo; y += dist_entre_cll)
                {
                    int ancho_calle  = azar.Next(Convert.ToInt32(ui_min_ancho_calle.Value), Convert.ToInt32(ui_max_ancho_calle.Value));
                    int ancho_vereda = azar.Next(Convert.ToInt32(ui_min_ancho_ver.Value), Convert.ToInt32(ui_max_ancho_ver.Value));
                    lista_comp_calles.Add(new Composicion_calle(new Pen(Color.White, (ancho_calle + ancho_vereda) * 100), new Pen(Color.FromArgb(88, 88, 88), ancho_calle * 100), new Point(0, y), new Point(ancho_lienzo, y)));
                }
                for (int x = dist_entre_cll; x < ancho_lienzo; x += dist_entre_cll)
                {
                    int ancho_calle  = azar.Next(Convert.ToInt32(ui_min_ancho_calle.Value), Convert.ToInt32(ui_max_ancho_calle.Value));
                    int ancho_vereda = azar.Next(Convert.ToInt32(ui_min_ancho_ver.Value), Convert.ToInt32(ui_max_ancho_ver.Value));
                    lista_comp_calles.Add(new Composicion_calle(new Pen(Color.White, (ancho_calle + ancho_vereda) * 100), new Pen(Color.FromArgb(88, 88, 88), ancho_calle * 100), new Point(x, 0), new Point(x, alto_lienzo)));
                }
                for (int i = 0; i < lista_comp_calles.Count; i++)
                {
                    fondo.DrawLine(lista_comp_calles[i].calle_base, lista_comp_calles[i].inicio, lista_comp_calles[i].fin);
                    primer_nivel.Refresh();
                }

                //Subsistema # 2.1 Deteccion de pixeles blancos "Pixeles de linea base"
                lista_puntos_calles = Herramienta.obtener_coor_pixel_blancos((Bitmap)primer_nivel.Image);

                //Se dibujan las calles
                for (int i = 0; i < lista_comp_calles.Count; i++)
                {
                    fondo.DrawLine(lista_comp_calles[i].calle, lista_comp_calles[i].inicio, lista_comp_calles[i].fin);
                    primer_nivel.Refresh();
                }
            }
            else if (ui_calle_incompleta.Checked == true)
            {
                //Se dibujan las veredas (Calle base)
                int dist_entre_cll = Convert.ToInt32(ui_espacio_calles.Value) * 100;
                int longitud_x     = ancho_lienzo / dist_entre_cll;
                int longitud_y     = alto_lienzo / dist_entre_cll;
                //Pen dash_street = new Pen(Color.Yellow,20);
                //dash_street.DashStyle = DashStyle.Dash;

                for (int y = dist_entre_cll; y < alto_lienzo; y += dist_entre_cll)
                {
                    int ancho_calle  = azar.Next(Convert.ToInt32(ui_min_ancho_calle.Value), Convert.ToInt32(ui_max_ancho_calle.Value));
                    int ancho_vereda = azar.Next(Convert.ToInt32(ui_min_ancho_ver.Value), Convert.ToInt32(ui_max_ancho_ver.Value));
                    lista_comp_calles.Add(new Composicion_calle(new Pen(Color.White, (ancho_calle + ancho_vereda) * 100), new Pen(Color.FromArgb(88, 88, 88), ancho_calle * 100), new Point(azar.Next(0, longitud_x - 1) * dist_entre_cll, y), new Point(azar.Next(3, longitud_x + 2) * dist_entre_cll, y)));
                }
                for (int x = dist_entre_cll; x < ancho_lienzo; x += dist_entre_cll)
                {
                    int ancho_calle  = azar.Next(Convert.ToInt32(ui_min_ancho_calle.Value), Convert.ToInt32(ui_max_ancho_calle.Value));
                    int ancho_vereda = azar.Next(Convert.ToInt32(ui_min_ancho_ver.Value), Convert.ToInt32(ui_max_ancho_ver.Value));
                    lista_comp_calles.Add(new Composicion_calle(new Pen(Color.White, (ancho_calle + ancho_vereda) * 100), new Pen(Color.FromArgb(88, 88, 88), ancho_calle * 100), new Point(x, azar.Next(0, longitud_y - 1)), new Point(x, azar.Next(3, longitud_y + 2) * dist_entre_cll)));
                }
                for (int i = 0; i < lista_comp_calles.Count; i++)
                {
                    fondo.DrawLine(lista_comp_calles[i].calle_base, lista_comp_calles[i].inicio, lista_comp_calles[i].fin);
                    primer_nivel.Refresh();
                }

                //Subsistema # 2.1 Deteccion de pixeles blancos "Pixeles de linea base"
                lista_puntos_calles = Herramienta.obtener_coor_pixel_blancos((Bitmap)primer_nivel.Image);

                //Se dibujan las calles
                for (int i = 0; i < lista_comp_calles.Count; i++)
                {
                    fondo.DrawLine(lista_comp_calles[i].calle, lista_comp_calles[i].inicio, lista_comp_calles[i].fin);
                    //fondo.DrawLine(dash_street, lista_comp_calles[i].inicio, lista_comp_calles[i].fin);
                    primer_nivel.Refresh();
                }
            }
            else if (ui_calle_curvilineal.Checked == true)
            {
            }
            else if (ui_calle_callejones.Checked == true)
            {
            }



            //MessageBox.Show(Convert.ToString(lista_puntos_calles.Count));


            //Subsistema # 3 de recoleccion de datos: casas

            Stopwatch cronometro = new Stopwatch();

            cronometro.Start();



            for (int ubicacion_datos = 0; ubicacion_datos < ui_cantidad_casas.Value; ubicacion_datos++)
            {
                //Actualización del progress bar #1

                barra.Value = (int)cropro.Elapsed.TotalSeconds;



                if (cronometro.ElapsedMilliseconds >= Convert.ToInt32(ui_tiempo_espera.Value) * 1000)
                {
                    MessageBox.Show("Superó el tiempo limite ", "Operación cancelada", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    return;
                }


                //Guardo en una variable el valor para los grados
                int grados = 0;
                if (ui_checkbox_girar.Checked)
                {
                    grados = azar.Next(0, 361);
                }
                else
                {
                    int seleccionar = azar.Next(0, 4);
                    switch (seleccionar)
                    {
                    case 0: grados = 90;
                        break;

                    case 1: grados = 180;
                        break;

                    case 2: grados = 270;
                        break;

                    case 3: grados = 360;
                        break;
                    }
                }

                List <String> nombres_de_formas = new List <string>();
                nombres_de_formas.Add("ui_forma_casa_rectangular");
                //nombres_de_formas.Add("ui_forma_casa_hexagonal");
                nombres_de_formas.Add("ui_forma_casa_deformada");
                nombres_de_formas.Add("ui_forma_casa_deformada_chaflan");

                String vano_ventana_seleccionado = ui_group_box_vanos_ventanas.Controls.OfType <RadioButton>().FirstOrDefault(r => r.Checked).Name;

                //En caso de que una de las casas no encaje y pasaron mas de 10 segundos cambiara su tamaño

                if (cronometro.ElapsedMilliseconds > Convert.ToInt32(ui_tiempo_espera.Value) * 1000 - (Convert.ToInt32(ui_tiempo_espera.Value) * 1000 * 0.1)) //Espera el 90% del tiempo de respuesta
                {
                    anchos[ubicacion_datos] = azar.Next(Convert.ToInt32(ui_min_ancho_casa.Value), Convert.ToInt32(ui_max_ancho_casa.Value) + 1);
                    altos[ubicacion_datos]  = azar.Next(Convert.ToInt32(ui_min_alto_casa.Value), Convert.ToInt32(ui_max_alto_casa.Value) + 1);
                }

                //Subsistema 3.1 seleccion de punto origen segun la distribución

                Point origen = new Point();

                String distribucion_seleccionado = ui_group_box_distribucion.Controls.OfType <RadioButton>().FirstOrDefault(r => r.Checked).Name;

                switch (distribucion_seleccionado)
                {
                case "ui_distribucion_aleatoria":
                    origen = Herramienta.seleccionar_punto_cuadricula(ancho_lienzo - margen_ancho, alto_lienzo - margen_alto, 100, Convert.ToInt32(ui_min_ancho_casa.Value) * 100, Convert.ToInt32(ui_min_alto_casa.Value) * 100);
                    //100 es el multiplo
                    break;

                case "ui_distribucion_columnas":
                    if (y_ori >= (alto_lienzo - Convert.ToInt32(ui_max_alto_casa.Value) * 100) - 400)
                    {
                        x_ori = x_ori + 100;
                        y_ori = Convert.ToInt32(ui_min_alto_casa.Value) * 100;
                    }
                    origen = new Point(x_ori, y_ori);
                    y_ori  = y_ori + 100;
                    break;

                case "ui_distribucion_filas":
                    if (x_ori >= (ancho_lienzo - Convert.ToInt32(ui_max_ancho_casa.Value) * 100) - 400)
                    {
                        x_ori = Convert.ToInt32(ui_min_ancho_casa.Value) * 100;
                        y_ori = y_ori + 100;
                    }
                    origen = new Point(x_ori, y_ori);
                    x_ori  = x_ori + 100;
                    break;
                }

                //Aqui empieza la recollecion de la informacion para las casas

                Info_forma nueva_casa = new Info_forma
                                        (
                    ancho_lienzo,
                    alto_lienzo,
                    anchos[ubicacion_datos],
                    altos[ubicacion_datos],
                    azar.Next(Convert.ToInt32(ui_min_grosor_pared.Value), Convert.ToInt32(ui_max_grosor_pared.Value)),
                    origen, //origen de la forma (casa)
                    new Point(),
                    azar.Next(Convert.ToInt32(ui_pilar_cubico_med_min.Value), Convert.ToInt32(ui_pilar_cubico_med_max.Value)),
                    azar.Next(Convert.ToInt32(ui_pilar_round_med_min.Value), Convert.ToInt32(ui_pilar_round_med_max.Value)),
                    azar.Next(1, Convert.ToInt32(ui_cantidad_pisos.Value) + 1),
                    grados,
                    azar.Next(10, 20), // Este numero se multiplica por el valor de la columna Ej 3 espacio = 90 (30CM)
                    azar.Next(1, 5),
                    ui_checkbox_girar.Checked,
                    Posibilidad,
                    Distancia,
                    ui_pegar_casas.Checked,
                    vano_ventana_seleccionado,
                    nombres_de_formas[azar.Next(0, nombres_de_formas.Count)],
                    azar.Next(Convert.ToInt32(ui_pilar_prox_min.Value), Convert.ToInt32(ui_pilar_prox_max.Value)),
                    azar.Next(Convert.ToInt32(ui_vano_puerta_cant_min.Value), Convert.ToInt32(ui_vano_puerta_cant_max.Value))
                                        );

                nueva_casa.resp_alto_forma  = nueva_casa.alto_forma;
                nueva_casa.resp_ancho_forma = nueva_casa.ancho_forma;


                //Subsistema 3.2 #Filtros

                bool interruptor = false;

                //Verificar si existe interseccion entre casas
                //Esta verificación me deja una gran leccion 29/11/20 :)

                for (int x = 0; x < lista_casas.Count; x++)
                {
                    Parallel.For(0, nueva_casa.area_puntos.Count - 1, (i, state) =>
                    {
                        if (lista_casas[x].area_puntos.Contains(nueva_casa.area_puntos[i]))
                        {
                            //Existe interseccion
                            interruptor = true;
                            state.Break();
                        }
                    });
                }


                //Verifica si existe interseccion entre casas y calles

                if (nueva_casa != null)
                {
                    Parallel.For(0, nueva_casa.area_puntos.Count - 1, (i, state) =>
                    {
                        if (lista_puntos_calles.Contains(nueva_casa.area_puntos[i]))
                        {
                            //Existe interseccion
                            interruptor = true;
                            state.Break();
                        }
                    });
                }

                if (interruptor)
                {
                    ubicacion_datos--;
                    continue;
                }
                else
                {
                    // Si no se encontraron intersecciones agrega la info de forma
                    //nueva_casa.area_post();
                    lista_casas.Add(nueva_casa);

                    if (ui_objetos_elevador.Checked == true)
                    {
                        //Valida que el elevador este dentro del espacio de la forma
                        bool encontrado = false;
                        do
                        {
                            nueva_casa.origen_elevador  = Herramienta.seleccionar_punto_cuadricula(nueva_casa.po.X + nueva_casa.ancho_forma * 100, nueva_casa.po.Y + nueva_casa.alto_forma * 100, 100, nueva_casa.po.X, nueva_casa.po.Y);
                            nueva_casa.espacio_elevador = new Rectangle(nueva_casa.origen_elevador.X, nueva_casa.origen_elevador.Y, 2 * 100, 2 * 100);
                            Rectangle resultado = Rectangle.Intersect(nueva_casa.espacio_elevador, nueva_casa.espacio_forma);
                            if (resultado == nueva_casa.espacio_elevador)
                            {
                                encontrado = true;
                            }
                        } while (encontrado == false);
                    }
                }
            }

            //Subsistema #4 superposiciones
            //Encuentro el nombre del radiobutton de la forma que ha escogido el usuario

            String forma_seleccionada = ui_groupbox_forma_casas.Controls.OfType <RadioButton>().FirstOrDefault(r => r.Checked).Name;

            //Pintar lienzos con los datos almacenados, dependiedo de la superposicion

            if (ui_superposicion_esc_cons.Checked == true)
            {
                for (int i = 0; i < ui_cantidad_pisos.Value; i++)
                {
                    for (int recorrer = 0; recorrer < ui_cantidad_casas.Value; recorrer++)
                    {
                        string nombre_page = "Planta " + i;
                        Formas.forma(forma_seleccionada, lista_casas[recorrer], (PictureBox)TabControl.TabPages[i].Controls.Find(nombre_page, true)[0]);

                        //Primero se guardan los nombre de los checkbox activo es una lista

                        List <String> nombres_checkbox = new List <string>();
                        foreach (CheckBox c in ui_groupbox_objetos.Controls.OfType <CheckBox>())
                        {
                            if (c.Checked == true)
                            {
                                nombres_checkbox.Add(c.Name);
                            }
                        }

                        //Después de pintar las casas, se pintan los objetos
                        Objetos.objeto(nombres_checkbox, lista_casas[recorrer], (PictureBox)TabControl.TabPages[i].Controls.Find(nombre_page, true)[0]);

                        //Esta variable es modificada una vez que PB se haya dibujado
                        lista_casas[recorrer].ubicacion_pb = false;

                        //Actualización del progress bar #1

                        barra.Value = (int)cropro.Elapsed.TotalSeconds;
                    }
                }
            }
            else if (ui_superposicion_esc_cons_var.Checked == true)
            {
                for (int i = 0; i < ui_cantidad_pisos.Value; i++)
                {
                    for (int recorrer = 0; recorrer < ui_cantidad_casas.Value; recorrer++)
                    {
                        if (lista_casas[recorrer].pisos_reales > 0)
                        {
                            string nombre_page = "Planta " + i;
                            Formas.forma(forma_seleccionada, lista_casas[recorrer], (PictureBox)TabControl.TabPages[i].Controls.Find(nombre_page, true)[0]);

                            //Primero se guardan los nombre de los checkbox activo es una lista

                            List <String> nombres_checkbox = new List <string>();
                            foreach (CheckBox c in ui_groupbox_objetos.Controls.OfType <CheckBox>())
                            {
                                if (c.Checked == true)
                                {
                                    nombres_checkbox.Add(c.Name);
                                }
                            }

                            //Después de pintar las casas, se pintan los objetos
                            Objetos.objeto(nombres_checkbox, lista_casas[recorrer], (PictureBox)TabControl.TabPages[i].Controls.Find(nombre_page, true)[0]);

                            //Esta variable es modificada una vez que PB se haya dibujado
                            lista_casas[recorrer].ubicacion_pb = false;
                        }
                        lista_casas[recorrer].pisos_reales = lista_casas[recorrer].pisos_reales - 1;

                        //Actualización del progress bar #1

                        barra.Value = (int)cropro.Elapsed.TotalSeconds;
                    }
                }
            }
            else if (ui_superposicion_piramidal.Checked == true)
            {
                for (int i = 0; i < ui_cantidad_pisos.Value; i++)
                {
                    for (int recorrer = 0; recorrer < ui_cantidad_casas.Value; recorrer++)
                    {
                        if (i > 0)
                        {
                            int valor_reduccion = 0;
                            if (ui_superposicion_rad_valor_fijo.Checked == true)
                            {
                                valor_reduccion = Convert.ToInt32(ui_superposicion_valor_fijo.Value);
                            }
                            else if (ui_superposicion_rad_valor_por_rango.Checked == true)
                            {
                                int limite = Math.Min(lista_casas[recorrer].alto_forma, lista_casas[recorrer].ancho_forma);
                                //Esto es para manejar la excepcion probar un break
                                if (limite < 0)
                                {
                                    limite = 0;
                                }

                                int modo = 0;
                                valor_reduccion = azar.Next(modo, limite + 1);
                            }
                            lista_casas[recorrer].nuevo_origen = new Point(lista_casas[recorrer].po.X + ((valor_reduccion * 100) / 2), lista_casas[recorrer].po.Y + ((valor_reduccion * 100) / 2));
                            lista_casas[recorrer].po           = lista_casas[recorrer].nuevo_origen;
                            lista_casas[recorrer].ancho_forma  = lista_casas[recorrer].ancho_forma - valor_reduccion;
                            lista_casas[recorrer].alto_forma   = lista_casas[recorrer].alto_forma - valor_reduccion;
                        }

                        if (lista_casas[recorrer].ancho_forma > 2 && lista_casas[recorrer].alto_forma > 2)
                        {
                            string nombre_page = "Planta " + i;
                            Formas.forma(forma_seleccionada, lista_casas[recorrer], (PictureBox)TabControl.TabPages[i].Controls.Find(nombre_page, true)[0]);

                            //Después de pintar las casas, se pintan los objetos

                            //Primero se guardan los nombre de los checkbox activo es una lista

                            List <String> nombres_checkbox = new List <string>();
                            foreach (CheckBox c in ui_groupbox_objetos.Controls.OfType <CheckBox>())
                            {
                                if (c.Checked == true)
                                {
                                    nombres_checkbox.Add(c.Name);
                                }
                            }

                            Objetos.objeto(nombres_checkbox, lista_casas[recorrer], (PictureBox)TabControl.TabPages[i].Controls.Find(nombre_page, true)[0]);

                            //Esta variable es modificada una vez que PB se haya dibujado
                            lista_casas[recorrer].ubicacion_pb = false;
                        }


                        //Actualización del progress bar #1

                        barra.Value = (int)cropro.Elapsed.TotalSeconds;
                    }
                }
            }
            MessageBox.Show("Completado exitosamente", "Información", MessageBoxButtons.OK, MessageBoxIcon.Information);
            barra.Value = 0;
        }
 private static void combinar(Info_forma informacion, PictureBox pintura)
 {
     forma(informacion.forma, informacion, pintura);
 }
        private static void rectangulo_deformado(Info_forma info, PictureBox pintura, int modo)
        {
            info.g = Graphics.FromImage((Bitmap)pintura.Image);

            Random random = new Random();

            /* Está función la desarrollé en la primera versión en el 2019,
             * parametros originales que recibia la función:
             * float x, float y, float ancho, float alto, int tipo, List<PointF> pi*/
            int   inicioy, iniciox, ultimay, cierrex;
            int   x = info.po.X;
            int   y = info.po.Y;
            int   ancho = info.ancho_forma;
            int   alto = info.alto_forma;
            int   contador = 1;
            int   distancia_des_ancho = (int)Math.Truncate(alto * 0.30) + 1, distancia_des_alto = (int)Math.Truncate(ancho * 0.30) + 1;
            int   hund_izq = 0, hund_der = info.ancho_lienzo;
            Point point1   = new Point();
            Point point2   = new Point();
            Pen   contorno = new Pen(Color.Black, info.grosor_pared);

            // Se usan 4 listas para cada lado
            List <Point> lado_arriba    = new List <Point>();
            List <Point> lado_derecho   = new List <Point>();
            List <Point> lado_izquierdo = new List <Point>();
            List <Point> lado_abajo     = new List <Point>();

            /*
             * Una variable llamada "desplazar hacia el centro" determina si 2 puntos se mueven.
             * si es cualquier número a excepción de 0 no moverá los vertices
             * si es cero los vertices serán atraidos al centro
             * __________
             |        __|
             |       |__   <--- "desplazar_al_centro = 0"
             |          |
             |__________|
             */

            int conteo = 0, desplazar_al_centro = 0;
            int random_profundidad = 0;

            //Ancho superior
            while (contador <= ancho)
            {
                /*Esta parte fue agregada para controlar la distancia de deformacion
                 * y la posibilidad*/
                if (conteo == 0)
                {
                    conteo              = 1;
                    random_profundidad  = random.Next(1, distancia_des_ancho);
                    desplazar_al_centro = random.Next(0, info.posibilidad.Value);
                    if (conteo == info.distancia.Value)
                    {
                        conteo = 0;
                    }
                }
                else
                {
                    conteo = conteo + 1;
                    if (conteo == info.distancia.Value)
                    {
                        conteo = 0;
                    }
                }
                //-------------------------------------------
                if (desplazar_al_centro != 0)
                {
                    if (contador == 1)
                    {
                        point1.X = x;
                        point1.Y = y;
                        point2.X = (100 * contador) + x;
                        point2.Y = point1.Y;
                    }
                    else
                    {
                        point1.X = point2.X;
                        point1.Y = y;
                        point2.X = (100 * contador) + x;
                        point2.Y = point1.Y;
                    }
                }
                else
                {
                    if (contador == 1)
                    {
                        point1.X = x;
                        point1.Y = y + (random_profundidad * 100);
                        point2.X = (100 * contador) + x;
                        point2.Y = point1.Y;
                    }
                    else
                    {
                        point1.X = point2.X;
                        point1.Y = y + (random_profundidad * 100);
                        point2.X = (100 * contador) + x;
                        point2.Y = point1.Y;
                    }
                }
                contador = contador + 1;
                lado_arriba.Add(point1);
                lado_arriba.Add(point2);
            }
            // Guarda la Y del primer segmento
            inicioy = lado_arriba[0].Y;
            // Guarda la Y del ultimo segmento


            ultimay  = lado_arriba[lado_arriba.Count - 1].Y;
            contador = distancia_des_ancho;
            conteo   = 0;
            //lado derecho
            while (contador <= alto)
            {
                int punto_inicial_x = (100 * ancho) + x;
                //Esta parte fue agragada para la distancia
                if (conteo == 0)
                {
                    conteo              = 1;
                    random_profundidad  = random.Next(1, distancia_des_alto);
                    desplazar_al_centro = random.Next(0, info.posibilidad.Value);
                    if (conteo == info.distancia.Value)
                    {
                        conteo = 0;
                    }
                }
                else
                {
                    conteo = conteo + 1;
                    if (conteo == info.distancia.Value)
                    {
                        conteo = 0;
                    }
                }
                //-------------------------------------------
                if (contador == distancia_des_ancho)
                {
                    point1.X = punto_inicial_x;
                    point1.Y = ultimay;
                    point2.X = point1.X;
                    point2.Y = (100 * contador) + y;
                }
                else
                {
                    if (desplazar_al_centro != 0)
                    {
                        point1.X = punto_inicial_x;
                        point1.Y = point2.Y;
                        point2.X = point1.X;
                        point2.Y = (100 * contador) + y;
                    }
                    else
                    {
                        point1.X = punto_inicial_x - (random_profundidad * 100);
                        point1.Y = point2.Y;
                        point2.X = point1.X;
                        point2.Y = (100 * contador) + y;
                    }
                }
                if (point2.X <= hund_der)
                {
                    hund_der = point2.X - 100;
                }

                contador = contador + 1;
                lado_derecho.Add(point1);
                lado_derecho.Add(point2);
            }

            iniciox = lado_derecho[lado_derecho.Count - 1].X;
            cierrex = iniciox;

            contador = distancia_des_ancho;

            //lado izquierdo

            while (contador <= alto)
            {
                if (conteo == 0)
                {
                    conteo              = 1;
                    random_profundidad  = random.Next(1, distancia_des_alto);
                    desplazar_al_centro = random.Next(0, info.posibilidad.Value);
                    if (conteo == info.distancia.Value)
                    {
                        conteo = 0;
                    }
                }
                else
                {
                    conteo = conteo + 1;
                    if (conteo == info.distancia.Value)
                    {
                        conteo = 0;
                    }
                }
                //-------------------------------------------
                if (contador == distancia_des_ancho)
                {
                    point1.X = x;
                    point1.Y = inicioy;
                    point2.X = point1.X;
                    point2.Y = (100 * contador) + y;
                }
                else
                {
                    if (desplazar_al_centro != 0)
                    {
                        point1.X = x;
                        point1.Y = point2.Y;
                        point2.X = point1.X;
                        point2.Y = (100 * contador) + y;
                    }
                    else
                    {
                        point1.X = x + (random_profundidad * 100);
                        point1.Y = point2.Y;
                        point2.X = point1.X;
                        point2.Y = (100 * contador) + y;
                    }
                }
                if (point2.X >= hund_izq)
                {
                    hund_izq = point2.X + 100;
                }

                contador = contador + 1;
                lado_izquierdo.Add(point1);
                lado_izquierdo.Add(point2);
            }

            iniciox = lado_izquierdo[lado_izquierdo.Count - 1].X;
            ultimay = lado_izquierdo[lado_izquierdo.Count - 1].Y;

            contador = distancia_des_alto;
            conteo   = 0;

            //Ancho inferior

            while (contador <= ancho + 1)
            {
                int punto_inicial_y = (100 * alto) + y;
                //Esta parte fue agragada para la distancia
                if (conteo == 0)
                {
                    conteo              = 1;
                    random_profundidad  = random.Next(1, distancia_des_ancho);
                    desplazar_al_centro = random.Next(0, info.posibilidad.Value);
                    if (conteo == info.distancia.Value)
                    {
                        conteo = 0;
                    }
                }
                else
                {
                    conteo = conteo + 1;
                    if (conteo == info.distancia.Value)
                    {
                        conteo = 0;
                    }
                }
                //-------------------------------------------
                if (point2.X >= hund_der - 100)
                {
                    point1.X = point2.X;
                    point1.Y = punto_inicial_y;
                    point2.X = cierrex;
                    point2.Y = point1.Y;
                    lado_abajo.Add(point1);
                    lado_abajo.Add(point2);
                    break;
                }
                if (contador == distancia_des_alto)
                {
                    point1.X = iniciox;
                    point1.Y = punto_inicial_y;
                    point2.X = hund_izq;
                    point2.Y = point1.Y;
                }
                else
                {
                    if (desplazar_al_centro != 0)
                    {
                        point1.X = point2.X;
                        point1.Y = punto_inicial_y;
                        point2.X = (100 * contador) + x;
                        point2.Y = point1.Y;
                    }
                    else
                    {
                        point1.X = point2.X;
                        point1.Y = punto_inicial_y - (random_profundidad * 100);
                        point2.X = (100 * contador) + x;
                        point2.Y = point1.Y;
                    }
                }
                contador = contador + 1;
                lado_abajo.Add(point1);
                lado_abajo.Add(point2);
            }

            // Tipo de deformacion 2
            if (modo == 2)
            {
                //deformacion b, tiene un problema de estetica: en ocasiones los vertices de las esquinas desaparecen, en las siguientes lineas lo soluciono
                deformar_lados(lado_arriba);
                deformar_lados(lado_abajo);
                deformar_lados(lado_derecho);
                deformar_lados(lado_izquierdo);
            }

            List <Point> irregular = new List <Point>();

            for (int c = 0; c < lado_arriba.Count; c++)
            {
                irregular.Add(lado_arriba[c]);
            }
            for (int c = 0; c < lado_derecho.Count; c++)
            {
                irregular.Add(lado_derecho[c]);
            }
            for (int c = lado_abajo.Count - 1; c >= 0; c--)
            {
                irregular.Add(lado_abajo[c]);
            }
            for (int c = lado_izquierdo.Count - 1; c >= 0; c--)
            {
                irregular.Add(lado_izquierdo[c]);
            }

            //Limpio de la lista los elementos duplicados
            irregular = irregular.Distinct().ToList();

            //Se rotan los puntos
            irregular = Herramienta.rotar_puntos_figuras(irregular, info.grados, info.punto_medio);

            //Guardo los puntos en el objeto
            info.contorno = irregular;
            info.g.FillPolygon(Brocha, irregular.ToArray());
            info.g.DrawPolygon(contorno, irregular.ToArray());

            pintura.Refresh();
        }