 Autor
|
Tema: Contar cuántos cuadraditos pintados aislados hay en un dibujo. (Leído 2,424 veces)
|
Tachikomaia
 Desconectado
Mensajes: 1.273
Hackentifiko!
|
Por ejemplo aquí se considera que no hay:  En este contexto lo blanco no se considera pintado, es fondo. Todos los cuadraditos pintados tienen al menos 1 pintado al lado (diagonal también cuenta). Estoy haciendo un generador de dibujos así y quiero que no muestre (o que no genere, sería lo ideal) los que tengan cierta cantidad de cuadraditos pintados aislados. La cantidad depende del tamaño del dibujo, no importa aquí cual es. El dibujo se va modificando de a 1 cuadradito, se pinta uno, o se despinta uno (o más) y se pinta otro. Así, debo hacer algo como: - Cuando se pinte uno nuevo, mirar si al lado hay otro. Si no hay, incrementar el contador de aislados. Si hay, ver si ese o esos estaban aislados, en cuyo caso disminuir el contador cuanto corresponda (según cuantos eran los aislados). - Cuando se despinte uno, mirar si hay cuadraditos pintados al lado. Si no hay, disminuir el contador de aislados. Si hay, mirar al lado de cada uno y aumentar el contador de aislados por cada uno que haya quedado aislado. Mi pregunta es: ¿Hay un modo más fácil? ¿es posible que lo haga GPT o algo así? Es que es mucho código... Por ahora hice esto y luego vi que no sirven else ifs, sólo ifs: // Para juzgar: // ¿El dibujo tiene menos de Largo/2 cuadraditos aislados? // Se actualizará el contador de pintados aislados: // De cada pintado al lado del recién pintado, // se verá si estaba aislado, // en cuyo caso disminuirá el contador. // Si no hay pintados al lado del nuevo, aumentará. CuadraditoAislado = "Sí"; // ¿El modificado es el inferior derecho? if (Puntero == MaxPosiciondePuntero) { // Sí, ver el -1 (izquierdo), -L (up) y -L-1 (iu): // xSS // xS* if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero > MinCuadraditoInferior) { // Inferior no en una esquina, // contar el +1 (derecho), -1, -L+1 (du), -L y -L-1: // SSS // S*S if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero == MinCuadraditoInferior) { // Inferior izquierdo, // contar el +1, -L+1 y -L: // SSx // *Sx if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero > CuadraditosPorFila) { // No es superior. if (Puntero%CuadraditosPorFila == 0) { // Central derecho, // contar el +L, +L-1, -1, -L y -L-1: // xSS // xS* // xSS if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero%CuadraditosPorFila != 1) { // Central, contar todos los contiguos: // SSS // S*S // SSS if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } } else { // Central izquierdo, // contar el +L+1, +L, +1, -L+1 y -L: // SSx // *Sx // SSx if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } } } else if (Puntero == CuadraditosPorFila) { // Superior derecho, // contar el +L+1, +L y +1: // *Sx // SSx if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero > 1) { // Superior cemtral, // contar el +L+1, +L, +L-1, +1 y -1: // S*S // SSS if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } } else { // Superior izquierdo, // contar el +L+1, +L y +1: // *Sx // SSx if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } } if (CuadraditoAislado == "Sí") { CuadraditosAislados++; }
Es decir, ahí sólo estoy viendo si el cuadradito nuevo está aislado ¡me falta ver si sus contiguos lo estaban! (o si lo están sin contar al nuevo) y me falta el caso en que se despinta un cuadradito. ¿Tal vez se podrían usar functions para evitar repetir código? No sé bien cómo. Además, siendo tanto, puede que haya cometido algún error :/
|
|
|
|
|
En línea
|
|
|
|
|
Serapis
|
Hummm... otro de esos mensajes que da hasta pereza leerlo completo. Veamos, un 'cuadradito' es de cualquier tamaño?. Al menos se puede rechazar el cuadrado de 1x1 píxel?. Si un 'cuadradito', ya se contó, puede todavía formar parte de otro más grande?. Si el color blanco refiere al fondo, entonces solo se forman cuadraditos de color negro, o hay más colores?.... Como ves faltan muchos detalles (y no quiero ser exhaustivo), para poder decirte algo concreto y directo. No obstante si puedo decirte algo más simple y práctico, al menos para que puedas empezar a enforcarlo, indistintamente de las respuestas y lo que tengas en mente. Considera una imagen (si en tu caso es en B/N, mejor), como una tabla de 'Ceros' y 'Unos'... al ser una tabla, quier decir que con filas por columnas... funcion BuscarCandidatos(mapa, filas, columnas)
For cada fila desde 0 hasta filas-2
Por cada columna desde 0 columnas-1
Si mapa(fila, columna) = 0
Si (Contiguos >1) // Se asume que un cuadrado = al menos 2x2
si Llamada a función VerificarCuadrado(fila+1, columna-contiguos, contiguos)= true
Añadir cuadrado a la colecciónCuadrados.Add(fila, columna, contiguos)
o solo contarlos Cuadrados(contiguos) +=1 //contiguos denota el tamaño del lado.
fin si
fin si
contiguos =0
en otro caso
contiguos +=1
fin si
Siguiente
siguiente
fin funcion Un cuadrado será 'bueno', solo si está completamente delimitado por 'blancos a su alrededor (excepturando las 4 esquinas)... NOTA: La primera fila se verifica en la función de arriba, aqquí el resto de filas de 11111.... y los perímetros de 0000... buleano = Funcion Verificarcuadrado(filaY, columnaX, contiguos, filas, Columnas)
// 1 revisamos que la columna encima sean todo 0.
Si (filaY-2 > 0) // si existe en el mapa
por cada columna desde columnaX hasta ColumnaX + contiguos)
Si mapa(filaY-2, columna) = 1 devolver false // hay algo más adosado arriba del candidato...
siguiente
fin si
// 2 Revisamos que pueda existir un cuadrado de 'contiguos*contiguos'
por cada fila desde filaY hasta filaY+contiguos-1)
Si (columna >0) // 2a puede estar pegado a la pared izquierda el cuadrado
Si mapa(fila, columna-1) = 1 devolver false // hay algo más adosado a la izquierda del candidato...
fin si
// 2b comprobar el cuadrado en la zona vertical...
por cada columna desde columnaX hasta ColumnaX + contiguos-1)
Si mapa(fila, columna) = 0 devolver false // no es un cuadrado
siguiente
Si (columna no es la última (columnas)) //2c puede estar pegado a la pared derecha el cuadrado
Si mapa(fila, columnax+contiguos ) = 1 devolver false // hay algo más adosado a la derecha del candidato...
fin si
siguiente
// 3 Revisamos que la columna debajo sean todo 0.
Si (filaX+contiguos < filas) //si la fila existe en el mapa
por cada columna desde columnaX hasta ColumnaX + contiguos)
Si mapa(filax+contiguos, columna) = 1 devolver false
siguiente
fin si
// Si pasaron todas las pruebas, el candidato es un cuadrado.
devolver true
fin funcion Nota que trabajamos considerando una tabla, un mapa, un array bidimensional de valores 0-1, puede sustraerte de que son colores, así lo ves más sencillo, dibuja en un papel puntitos representando cada píxel negro, y como un valor 1, para comprender la sencillez del algoritmo... Un cuadrado será bueno, solo si está completamente delimitado por 'blancos a su completo alrededor... pero esto puede no ser tan restrictivo según tus necesidades, no obstante esto es lo que considera el algoritmo, por eso cuando se verifica un candidato, no solo se verifica que el cuadrado esté con todos '1', también que permitrealmente sean 0... (excepto diagonalmente sobre las 4 esquinas). NOTA: El algoritmo no está optimizado (ni considera cuadrados dentro de cuadrados), tras encontrar una 'cuadrado en una linea', las siguientes líneas de las que forma parte ese cuadrado se ven expuestas a ser buscadas de nuevo. ...pero así el algoritmo es mucho más sencillo de entender, aunque tarde más en calcular. Por último, te aclaro que esto es una aproximación genérica según los detalles que necesites (que no me he enterado bien, he tirado por lo lógico que uno puede aceptar como un 'cuadrado'), tendrás que modificarlo a tus necesidades.... y es fácil que a veces al escribir al vuelo se escape o falte un +1, -1... por algún lado.
|
|
|
|
« Última modificación: 4 Junio 2024, 18:39 pm por Serapis »
|
En línea
|
|
|
|
Tachikomaia
Desconectado
Mensajes: 1.273
Hackentifiko!
|
Hummm... otro de esos mensajes que da hasta pereza leerlo completo. ¿Te refieres al mío o al que escribiste? Si es el mío ¿por qué te da pereza? Veamos, un 'cuadradito' es de cualquier tamaño? Un espacio de XxX píxeles se divide en YxY cuadraditos. X no recuerdo cuánto es e Y va aumentando a medida que se muestran los dibujos posibles de 2 colores. Así, el tamaño de los cuadraditos va disminuyendo porque deben entrar cada vez más en el espacio pero el espacio disponible es fijo. Aquí tienes una pequeña muestra, algo antigua: https://www.youtube.com/watch?v=0x5fEw8LGP4Al menos se puede rechazar el cuadrado de 1x1 píxel? No entiendo la pregunta, pero si te refieres a que si habrá de esos, supongo pero cuando la cantidad de cuadraditos por fila sea igual al tamaño de la hoja, cosa que no he llegado a probar. Estoy intentando evitar ciertos dibujos indeseados antes de dejar que el programa llegue a tantos cuadraditos por fila. Si un 'cuadradito', ya se contó, puede todavía formar parte de otro más grande? No se cuentan así, se cuentan individualmente, un cuadradito es el mínimo tamaño en un dibujo, es una simulación de un pixel, simplemente se ve más grande. Si el color blanco refiere al fondo, entonces solo se forman cuadraditos de color negro, o hay más colores?.... Por ahora sólo negros, pero entiende que lo blanco también son cuadraditos de color blanco que pueden cambiar a negro y viceversa, digo que son fondo porque... cuando sean más colores (aún no), es así, como el fondo de la hoja, no es el dibujo... Como ves faltan muchos detalles (y no quiero ser exhaustivo), para poder decirte algo concreto y directo. Podía dar el código completo pero no creí que alguien quisiera leer tanto, además ya puse similares en temas anteriores. Lo subo a un txt para que no ocupe tanto espacio en el post: https://drive.google.com/file/d/13dSzreVp-WgV0RMKvaRTncqB84lMj3mJ/view?usp=sharingY aquí tienes el editable: https://drive.google.com/file/d/11ksgI1ZEgOSTf0o7X_TRVFLAXPmStT9F/view?usp=sharingNo funciona y aunque dice "ifs terminados", en realidad es sólo un grupo. Se me ocurrió una forma de simplificar la tarea, básicamente es tener guardado cuales coordenadas (filas y columnas) están pintadas, lo estaba evitando porque quería evitar crear variables innecesarias; si funciona como pienso cuando lo tenga hecho lo posteo. Ok, si no me funciona lo que se me ocurrió intento aplicar lo tuyo, no lo entiendo bien. Edit: Tras los cambios requeridos en el fotograma 2 que no vienen mucho al caso, tengo esto: function Variar () { ReferenciaAlColoraModificar = "ColordeCuadradito"+Puntero; ColoraModificar = eval(ReferenciaAlColoraModificar); // ¿El cuadradito puede cambiar de color? if (ColoraModificar<1) { // Sí, hacer los cambios: set (ReferenciaAlColoraModificar, ColoraModificar+1); NuevoColor = new Color("Cuadradito"+Puntero); NuevoColor.setRGB(0); // Obtener fila y columna del cuadradito: Fila = Math.ceil(Puntero/CuadraditosPorFila); Columna = (Puntero-1)%CuadraditosPorFila+1; set("Cuadradito"+Fila+"_"+Columna, 0); // Para juzgar: // ¿El dibujo tiene menos de Largo/2 cuadraditos aislados? // Se actualizará el contador de pintados aislados: // De cada pintado al lado del recién pintado, // se verá si estaba aislado, // en cuyo caso disminuirá el contador. // Si no hay pintados al lado del nuevo, aumentará. // Esta variable puede cambiar: CuadraditoAislado = "Sí"; Fila2 = Fila+1; Columna2 = Columna+1; // Si su inferior derecho existe y está pintado, // entonces el actual no está aislado, // y se mira si el infder estaba aislado: // Cuántos de sus contiguos están pintados. // Por practicidad se cuenta también el recién pintado. // Si la cantidad es 1, estaba aislado, // el contador de Aislados baja. // CONVERTIR EN FUNCIÓN: // ¿El contiguo indicado está pintado? if (eval("Cuadradito"+Fila2+"_"+Columna2) == 0 ) { // Sí, el recién pintado no está aislado: CuadraditoAislado = "No"; // Se contarán los contiguos de este (contiguo al recién...). ContiguosPintados = 0; Fila3 = Fila2+1; Columna3 = Columna2+1; // CONVERTIR EN FUNCIÓN2: // ¿El contiguo indicado está pintado? if (eval("Cuadradito"+Fila3+"_"+Columna3) == 0 ) { // Sí, aumentar contador: ContiguosPintados++; } // Columna3--; // APLICAR FUNCIÓN2 // Continuar modificando Col3 y fila3 y rellamando a la func2. } // Columna2--; // APLICAR FUNCIÓN // Continuar modificando Col2 y fila2 y rellamando a la func. // en vez de usar CuadraditoAislado = "Sí"; se podría definir // ContiguosPintados = 0; desde el inicio y si aumentó entonces // se entiende que ek recién pintado no estaba aislado. // Pero igual ese contador debe reiniciarse cada vez que se empieza a contar, // pero en esos casos siempre es 1 mínimo.
No sé si funciona bien pero ahí está la idea. Falta agregar lo que dije ahí. En unos días o algo así supongo que estará.
|
|
|
|
« Última modificación: 10 Junio 2024, 12:41 pm por Tachikomaia »
|
En línea
|
|
|
|
Tachikomaia
Desconectado
Mensajes: 1.273
Hackentifiko!
|
Aquí está pero aún no tiene sentido probarlo, o no es fácil, pues me falta aplicar algo parecido al caso en que se despintan. Además tengo un error en cuanto a cómo defino los colores. // En este programa hay cuadraditos nombrados así: // 123 // 456 // 789 // Se irán pintando diferentes combinaciones, // evitando resultados en que muchos queden aislados, // dibujos producibles en hojas más pequeñas, // y simétricos (espejo vertical) ya producidos. // El tamaño de la hoja irá aumentando. // Debido a que en cierto chequeo se asume que... // si el cuadradito no está en la parte inferior ni... // superior entonces está en la fila central, // conviene que CuadraditosPorFila comience siendo 2, // cambia enseguida a 3. // PorFila y porColumna: CuadraditosPorFila = 2; // Los cuadraditos están nombrados de modo que... // los de nombre mayor están abajo en la derecha, ejemplo: // 12 // 34 // Usada en ContarContiguosDeContiguoAlModificado: function ParteDeContarEtc () { // ¿El contiguo indicado está pintado? if (eval("Cuadradito"+Fila3+"_"+Columna3) == 0 ) { // Sí, aumentar contador: ContiguosPintados++; } } // Usada en Variar: function ContarContiguosDeContiguoAlModificado () { // ¿El contiguo indicado está pintado? if (eval("Cuadradito"+Fila2+"_"+Columna2) == 0 ) { // Sí, el recién pintado no está aislado: ElRecienPintadoEstaAislado = "No"; // Se contarán los contiguos de este (contiguo al recién...). ContiguosPintados = 0; // Para analizar a su inferior derecho: Fila3 = Fila2+1; Columna3 = Columna2+1; ParteDeContarEtc(); // Para analizar a su inferior: Columna3--; ParteDeContarEtc(); // Para analizar a su inferior izquierdo: Columna3--; ParteDeContarEtc(); // Para analizar a su derecho: Columna3 = Columna3+2; Fila3--; ParteDeContarEtc(); // Para analizar a su izquierdo: Columna3 = Columna3-2; ParteDeContarEtc(); // Para analizar a su superior derecho: Columna3 = Columna3+2; Fila3--; ParteDeContarEtc(); // Para analizar a su superior: Columna3--; ParteDeContarEtc(); // Para analizar a su superior izquierdo: Columna3--; ParteDeContarEtc(); // ¿Estaba aislado? if (ContiguosPintados == 1) { // Sí, reducir el contador: CuadraditosAislados--; } } } // En F3 se repite: function Variar () { ReferenciaAlColoraModificar = "ColordeCuadradito"+Puntero; ColoraModificar = eval(ReferenciaAlColoraModificar); // ¿El cuadradito puede cambiar de color? if (ColoraModificar < 1) { // Sí, hacer los cambios: set (ReferenciaAlColoraModificar, ColoraModificar+1); NuevoColor = new Color("Cuadradito"+Puntero); NuevoColor.setRGB(0); // Obtener fila y columna del cuadradito: Fila = Math.ceil(Puntero/CuadraditosPorFila); Columna = (Puntero-1)%CuadraditosPorFila+1; set("Cuadradito"+Fila+"_"+Columna, 0); // Para juzgar: // ¿Los cuadraditos aislados en el dibujo es... // menos de MaxCuadraditosAislados? // Se actualizará el contador de pintados aislados: // De cada pintado al lado del recién pintado, // se verá si estaba aislado, // en cuyo caso disminuirá el contador. // Si no hay pintados al lado del nuevo, aumentará. // Esta variable puede cambiar, se refiere al recién pintado: ElRecienPintadoEstaAislado = "Sí"; // en vez de usar CuadraditoAislado = "Sí"; se podría definir // ContiguosPintados = 0; desde el inicio y si aumentó entonces // se entiende que ek recién pintado no estaba aislado. // Pero igual ese contador debe reiniciarse cada vez que se empieza a contar, // pero en esos casos siempre es 1 mínimo. // Para analizar a su inferior derecho: Fila2 = Fila+1; Columna2 = Columna+1; // Si su inferior derecho existe y está pintado, // entonces el actual no está aislado, // y se mira si el infder estaba aislado: // Cuántos de sus contiguos están pintados. // Por practicidad se cuenta también el recién pintado. // Si la cantidad es 1, estaba aislado, // el contador de Aislados baja: ContarContiguosDeContiguoAlModificado(); // Para analizar a su inferior: Columna2--; ContarContiguosDeContiguoAlModificado(); // Para analizar a su inferior izquierdo: Columna2--; ContarContiguosDeContiguoAlModificado(); // Para analizar a su derecho: Columna2 = Columna2+2; Fila2--; ContarContiguosDeContiguoAlModificado(); // Para analizar a su izquierdo: Columna2 = Columna2-2; ContarContiguosDeContiguoAlModificado(); // Para analizar a su superior derecho: Columna2 = Columna2+2; Fila2--; ContarContiguosDeContiguoAlModificado(); // Para analizar a su superior: Columna2--; ContarContiguosDeContiguoAlModificado(); // Para analizar a su superior izquierdo: Columna2--; ContarContiguosDeContiguoAlModificado(); if (ElRecienPintadoEstaAislado == "Sí") { CuadraditosAislados++; }
El código sigue con cosas que no vienen al caso. Lo que hice no es una forma corta ni eficiente pero evita el caos de los ifs. Sólo hay 2 ifs, que se repiten luego de haber modificado variables. En fin, no sé cuando lo terminaré pero esta duda está resuelta. |
|
|
|
|
En línea
|
|
|
|
|
 |
