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);
}
}
//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();
}
