[Tachikomaia]

Sigo intentando que se generen líneas "perfectas", en este caso quiero que siempre tengan 2 filas y estoy aumentando su cantidad de columnas, pero debido a errores no funciona como debe:


Explicaré el código:

Código: [Seleccionar]

// Determinar ubicación del punto 1:
FilaDePunto1 = 0;
ColumnaDePunto1 = 0;
// Punto 2:
FilaDePunto2 = 1;
ColumnaDePunto2 = NroDelCuadroaColocar+1;Todas las líneas empiezan en el punto 0,0 de los cuadros (u hojas), tienen 2 filas (terminan en la fila 1, contando la 0 son 2) y en cada cuadro se intenta que tengan una columna más. La cantidad de columnas de las líneas en los cuadros sería así:
2 3 4
5 6 7
8 9 10

Código: [Seleccionar]

// Para cálculos:
FilasDeDistancia = FilaDePunto2-FilaDePunto1;
FilasDeLinea = FilasDeDistancia+1;
ColumnasDeDistancia = ColumnaDePunto2-ColumnaDePunto1;
ColumnasDeLinea = ColumnasDeDistancia+1;
// Averiguar la distancia mayor y graficar en función de ella:
// Si hay más columnas que filas o son igual cantidad:
if (Math.abs(ColumnasDeDistancia) >= Math.abs(FilasDeDistancia)) {
PuntosPorFila = Math.floor(ColumnasDeLinea/FilasDeLinea);
// Puntos que no se pudieron repartir equitativamente...
// entre las filas:
Resto = ColumnasDeLinea%FilasDeLinea;
// Para repartirlos estéticamente:
DistanciaDeExtras = (ColumnasDeDistancia+1)/(Resto+1)-1;
ExtraaAgregar = 1;
if (Resto != 0) {
SiguienteFilaConExtra = DistanciaDeExtras;
} else {
// Para evitar que se ponga un punto extra...
// en la fila 0:
SiguienteFilaConExtra = FilaDePunto2+1;
}
ColumnasCompletas = 0;
FilaActual = FilaDePunto1;
// Mientras haya columnas que agregar:
while (ColumnasCompletas < ColumnasDeLinea) {
trace("Aún no se insertaron todas las columnas, van "+ColumnasCompletas);
PuntosEnFila = 0;
// Mientras se deba agregar puntos en la fila:
while (PuntosEnFila < PuntosPorFila) {
trace("Aún no se insertaron los puntos de esta fila, van "+PuntosEnFila);
NroDelCuadraditoaPintar = FilaActual * CuadraditosPorFila + ColumnaDePunto1 + ColumnasCompletas;
ColumnasCompletas++;
PuntosEnFila++;
// Pintar el punto.
}
// Si en esta fila debe agregarse un extra:
if (FilaActual == SiguienteFilaConExtra) {
trace("Agregando extra");
NroDelCuadraditoaPintar = FilaActual * CuadraditosPorFila + ColumnaDePunto1 + ColumnasCompletas;
ColumnasCompletas++;
ParaColorDeCuadradito = new Color(Cuadro_pCuadradito + NroDelCuadraditoaPintar);
ParaColorDeCuadradito.setRGB(ColorDeImagen);
ExtraaAgregar++;
SiguienteFilaConExtra = DistanciaDeExtras*ExtraaAgregar;
}
FilaActual++;
}
// OJO QUE QUIZÁ SE AGREGA UN PUNTO AL FINAL INCLUSO CON RESTO 0 PORQUE ES DISTANCIA/(RESTO+1)
// FALTA FLOOR, CEIL Y TODO ESO
} else {
}En los casos que intento hacer funcionar la cantidad de columnas es igual o mayor a la cantidad de filas así que no hay problema con el 1er if y con el else final vacío.

Con:
PuntosPorFila = Math.floor(ColumnasDeLinea/FilasDeLinea);
se está calculando cuántos puntos tendrá cada fila, sin contar el resto de la división en caso de que ColumnasDeLinea sea impar.

Se calcula el resto y lo siguiente es lo que falla:
Resto = ColumnasDeLinea%FilasDeLinea;
// Para repartirlos estéticamente:
DistanciaDeExtras = ColumnasDeLinea/(Resto+1)-1;

Más adelante sea hace:

Código: [Seleccionar]

if (Resto != 0) {
SiguienteFilaConExtra = DistanciaDeExtras;O sea que cuando hay resto, el punto extra se agrega en donde indique DistanciaDeExtras.

Entonces...
Cuando hay 3 columnas, el resultado debería ser así

Código: [Seleccionar]

**
  *o

Código: [Seleccionar]

*
 **O sea el extra debería estar en la fila 0 o 1.
Yo hago
DistanciaDeExtras = ColumnasDeLinea/(Resto+1)-1;
O sea en este caso 3/2-1, da 0.5, tendría que quitar los decimales para que sea 0.

Cuando hay 5 columnas, debe haber 2 filas con 2 puntos cada una, pero una de las filas debe tener 1 extra. Es lo mismo, el extra debe ir en la 0 o 1.
5/2-1 = 1.5
Quitando los decimales sería 1.

Cuando hay 7 columnas, sería 7/2-1 = 2.5, ya no se arregla quitando los decimales.

En definitiva tengo algo como C/2 y necesito que siempre de 0 o 1, supongo que no es la fórmula correcta...
Claro, estoy calculando algo parecido a dónde está el centro de la línea, pero no necesito eso, o está mal esto

Código: [Seleccionar]

if (Resto != 0) {
SiguienteFilaConExtra = DistanciaDeExtras;
la fila con el extra no es igual a la columna central.

Aunque sepa que en estos casos siempre va a ser 0 o 1, necesito que la fórmula sirva para más casos.

¿Quizá DistanciaDeExtras debería ser en columnas?

Si tienen alguna duda sobre el problema pregunten.

[Richard R Richard]

necesito que la fórmula sirva para más casos.

Hola, creo que algo te lo explique en otro hilo.
veo que haz dividido la pantalla para mostrar mas ejemplos por pantalla, pero que en realidad no buscas que se represente cortado como parecería de los ejemplos mas largos.


veamos  definamos algo que despues tu lo usas como quieras , yo te presento la idea y tu la adaptas a tu programa.


una recta va a tener  L pixeles  en horizontal y H en vertical


tienes que buscar en tu lenguaje de programacion la funcion "redondear"  por lo general es round(x)

Código: [Seleccionar]

para x = 1 hasta L
    y = 1 + redondear( (x-1)*(H-1)/(L-1) )
    dibujar_pixel(x,y)
fin

 en la función redondear , si algo esta mas cerca del numero entero  superior toma el numero superior y si esta mas cerca del inferior toma el entero inferior


ejemplos
round(1.0)=1
round(1.2)=1
round(1.49)=1
round(1.5)=2
round(1.8)=2

[Tachikomaia]

Richard más o menos intenté aplicar eso pero decidí seguir a mi modo, pero sigo sin avanzar mucho ¿tú o alguien podría
A: Indicarme qué está mal en mi código.
B: Poner tu método en mi código, quitando lo que no sirva.
?
En lo posible A, por curiosidad.

Acabo de modificarlo para que funcione si hay 3 filas pero ya con 4 me falla.

Código: [Seleccionar]

function GenerarLineas () {
// Pintar cuadraditos de modo que se forme una línea:
// Elegir un color distinto al color del cuadro:
do {
ColorDeImagen = PosiblesColores[random(PosiblesColores.length)];
} while (ColorDelCuadro == ColorDeImagen);
// Determinar ubicación del punto 1,
// llamado Punto en vez de Cuadradito porque...
// ese nombre puede que se esté usando en otra cosa:
FilaDePunto1 = 0;
ColumnaDePunto1 = 0;
trace("FilaDePunto1: "+FilaDePunto1);
trace("ColumnaDePunto1: "+ColumnaDePunto1);
// Punto 2 asegurando que no sea igual:
do {
ColumnaDePunto2 = Math.min(9, NroDelCuadroaColocar+2);
FilaDePunto2 = 3;
} while (ColumnaDePunto1 == ColumnaDePunto2 && FilaDePunto1 == FilaDePunto2);
trace("FilaDePunto2: "+FilaDePunto2);
trace("ColumnaDePunto2: "+ColumnaDePunto2);
// Para cálculos:
FilasDeDistancia = FilaDePunto2-FilaDePunto1;
FilasDeLinea = FilasDeDistancia+1;
ColumnasDeDistancia = ColumnaDePunto2-ColumnaDePunto1;
ColumnasDeLinea = ColumnasDeDistancia+1;
trace("FilasDeDistancia: "+FilasDeDistancia);
trace("ColumnasDeDistancia: "+ColumnasDeDistancia);
// Averiguar la distancia mayor y graficar en función de ella:
// Si hay más columnas que filas o son igual cantidad:
if (Math.abs(ColumnasDeDistancia) >= Math.abs(FilasDeDistancia)) {
PuntosPorFila = Math.floor(ColumnasDeLinea/FilasDeLinea);
trace("PuntosPorFila: "+PuntosPorFila);
// Puntos que no se pudieron repartir equitativamente...
// entre las filas:
Resto = ColumnasDeLinea%FilasDeLinea;
trace("Resto: "+Resto);
// Para repartirlos estéticamente:
FilaCentralDeLinea = FilasDeDistancia/2;
trace("FilaCentralDeLinea: "+FilaCentralDeLinea);
ExtraaAgregar = 1;
// Si el resto irá en el medio:
if (Resto == 1) {
// En caso de no haber se pone en la izquierda o...
// derecha, de él, decidido por azar:
if (random(2) == 0) {
SiguienteFilaConExtra = Math.floor(FilaCentralDeLinea);
} else {
SiguienteFilaConExtra = Math.ceil(FilaCentralDeLinea);
}
// ExtraCentral = 1;
// Para evitar que se ponga otro extra:
DistanciaDeExtras = FilaDePunto2+1;
trace("DistanciaDeExtras: "+DistanciaDeExtras);
} else if (Resto > 1) {
DistanciaDeExtras = FilasDeDistancia/(Resto+1);
trace("DistanciaDeExtras: "+DistanciaDeExtras);
SiguienteFilaConExtra = Math.floor(DistanciaDeExtras);
} else {
// Para evitar que se ponga un punto extra...
// en la fila 0:
// DistanciaDeExtras es irrelevante aquí?
DistanciaDeExtras = FilaDePunto2+1;
trace("DistanciaDeExtras: "+DistanciaDeExtras);
SiguienteFilaConExtra = FilaDePunto2+1;
}
trace("SiguienteFilaConExtra: "+SiguienteFilaConExtra);
ColumnasCompletas = 0;
FilaActual = FilaDePunto1;
// Mientras haya columnas que agregar:
while (ColumnasCompletas < ColumnasDeLinea) {
trace("Aún no se insertaron todas las columnas, van "+ColumnasCompletas);
PuntosEnFila = 0;
// Mientras se deba agregar puntos en la fila:
while (PuntosEnFila < PuntosPorFila) {
trace("Aún no se insertaron los puntos de esta fila, van "+PuntosEnFila);
NroDelCuadraditoaPintar = FilaActual * CuadraditosPorFila + ColumnaDePunto1 + ColumnasCompletas;
ColumnasCompletas++;
trace("ColumnasCompletas: "+ColumnasCompletas);
PuntosEnFila++;
trace("PuntosEnFila: "+PuntosEnFila);
ParaColorDeCuadradito = new Color(Cuadro_pCuadradito + NroDelCuadraditoaPintar);
ParaColorDeCuadradito.setRGB(ColorDeImagen);
}
// Si en esta fila debe agregarse un extra:
if (FilaActual == SiguienteFilaConExtra) {
trace("Agregando extra");
NroDelCuadraditoaPintar = FilaActual * CuadraditosPorFila + ColumnaDePunto1 + ColumnasCompletas;
ColumnasCompletas++;
trace("ColumnasCompletas: "+ColumnasCompletas);
ParaColorDeCuadradito = new Color(Cuadro_pCuadradito + NroDelCuadraditoaPintar);
ParaColorDeCuadradito.setRGB(ColorDeImagen);
ExtraaAgregar++;
SiguienteFilaConExtra = DistanciaDeExtras*ExtraaAgregar;
// Si el extra iría en una posición con decimales,
// se pone en la entera anterior, siguiente o...
// una de ellas al azar según el caso:
if (SiguienteFilaConExtra < FilaCentralDeLinea) {
SiguienteFilaConExtra = Math.floor(SiguienteFilaConExtra);
} else if (SiguienteFilaConExtra > FilaCentralDeLinea) {
SiguienteFilaConExtra = Math.ceil(SiguienteFilaConExtra);
} else if (random(2) == 0) {
SiguienteFilaConExtra = Math.floor(SiguienteFilaConExtra);
} else {
SiguienteFilaConExtra = Math.ceil(SiguienteFilaConExtra);
}
}
FilaActual++;
trace("FilaActual: "+FilaActual);
}
// OJO QUE QUIZÁ SE AGREGA UN PUNTO AL FINAL INCLUSO CON RESTO 0 PORQUE ES DISTANCIA/(RESTO+1)
} else {
}
}
En el señalado, los extras están las filas 1, 2 y 3, pero deberían estar en la 0, la 3, y 1 o 2. O sea, en este caso en los extremos y en el medio. Pero no es siempre así "en los extremos". Imagina una línea vertical de 40cm:
0
|-10
|-20
|-30
40
Las 3 mitades son 10, 20 y 30. Ahí irían los extras en este caso. La fórmula es MaxFila/(3+1)*ExtraaColocar. En mi código está con otros nombres pero es igual o esa es mi idea.
Probablemente a estas alturas es un problema de programación más que de matemáticas.
Céntrense en corregir el caso señalado, los demás luego vemos.

[Richard R Richard]

Lo siento, me pierdo entre tanto código,,
Lo que te propuse es sencillo.
Ni siquiera me doy cuenta cual es la instrucción que escribe un punto, y para recurrir a la IA, conviene
que esta te adapte mi código a tu programa y luego le pones todo lo auxiliar.

[Tachikomaia]

Con IA ya lo había intentado aunque no usando tu código.

Los cuadraditos ya están puestos, lo que se hace es darles un color diferente. Ciertamente mi Flash es confuso en eso, es algo que no me gusta de él.

ParaColorDeCuadradito = new Color(Cuadro_pCuadradito + NroDelCuadraditoaPintar);
ParaColorDeCuadradito.setRGB(ColorDeImagen);

La 1er línea digamos que crea la propiedad color en un objeto (dicho entre paréntsis). Es como si antes de eso no tuviera color, de hecho este color (aún no asignado) se va a asignar a todo el objeto (si fuese un coche verde de ruedas negras y le asignas rojo, te va a quedar todo rojo, salvo claro que se lo asignes a una parte, un subobjeto).

La 2nda línea asigna el color a dicha propiedad, lo cual es asignar color al objeto.

La ayuda de mi Flash ni siquiera lo explica, sólo te dice cómo hacerlo.

Aquí tienes una explicacion de la IA pero básicamente es lo que dije
https://share.google/aimode/Gmvwc4eos8KWVUdQX

[Tachikomaia]

Le pedí a una IA que aplique tu método. Este es el código quitando todo lo que te pueda parecer confuso, asumo:

Código: [Seleccionar]

function GenerarLineas () {
// Determinar ubicación del punto origen:
FilaDePunto1 = 0;
ColumnaDePunto1 = 0;

// Se definen los puntos finales, ColumnaDePunto2 y FilaDePunto2. No viene al caso.

// Distancias totales a recorrer en cada eje:
FilasDeDistancia = FilaDePunto2 - FilaDePunto1;
ColumnasDeDistancia = ColumnaDePunto2 - ColumnaDePunto1;

// Averiguar la distancia mayor y graficar en función de ella:
// Si la línea tiene más columnas que filas o son igual cantidad:
if (Math.abs(ColumnasDeDistancia) >= Math.abs(FilasDeDistancia)) {
// Recorremos la línea columna por columna (desde el inicio al fin)
// ColumnaActual representará el desplazamiento "x" desde el Punto 1
ColumnaActual = 0;
LimiteColumnas = Math.abs(ColumnasDeDistancia);
while (ColumnaActual <= LimiteColumnas) {
// Aplicamos la fórmula matemática para calcular la Fila exacta ("y") para esta columna.
// Usamos Math.round() para que tome el entero más cercano (superior o inferior)
FilaCalculada = FilaDePunto1 + Math.round(ColumnaActual * FilasDeDistancia / ColumnasDeDistancia);
// Calculamos la posición real en la cuadrícula
ColumnaReal = ColumnaDePunto1 + ColumnaActual;
// Pintar el cuadradito, no viene al caso.

// Avanzamos a la siguiente columna
ColumnaActual++;
}
} else {
// Lo que va aquí no viene al caso.
}
}
¿Te parece bien?

No funciona como quiero:

Las marcadas en amarillo están mal. Por ejemplo, la línea de arriba en el medio, debería ser
**
   *
    **

[Richard R Richard]

Hola, si la recta esta en una única  fila, el punto final y el inicial están en la.misma fila, es decir distancia entre filas debe dar 1, no cero,, si la recta fuera entre 2 filas, mitad queda en una y mitad en otra y distancia entre 2 filas sería 2.


Lo que quiero decirte es que si ese resultado  lo usas como numero de filas entre los cuales la recta debe dividirse, estaría mal le deberías agregar 1, con mas tiempo veré donde te desvías de lo que te explico.

[Richard R Richard]

Fijate si te sirve esto, lo hepasado por la IA para que te lo convierta a action Script

Código: [Seleccionar]

var dx:Number = ColumnaDePunto2 - ColumnaDePunto1;
var dy:Number = FilaDePunto2 - FilaDePunto1;
var pasos:Number = Math.max(Math.abs(dx), Math.abs(dy));


if (pasos == 0) {
    // Los puntos coinciden: dibujar un único punto.
} else {
    for (var i:Number = 0; i <= pasos; i++) {
        var columna:Number = ColumnaDePunto1 + Math.round(i * dx / pasos);
        var fila:Number = FilaDePunto1 + Math.round(i * dy / pasos);


        // Pintar el punto (columna, fila).
    }
}

[Tachikomaia]

Me costó hacer que ese código funcione.

Eliminé las "var" que hacen que las variables se declaren dentro de ciertas partes y no sirvan fuera, no entiendo bien.

No sé bien qué debo poner en el 1er if, o sea, cuales son las coordenadas del cuadradito.

Código: [Seleccionar]

function GenerarLineas () {
// acá cosas igual que antes
dx = ColumnaDePunto2 - ColumnaDePunto1;
dy = FilaDePunto2 - FilaDePunto1;
pasos = Math.max(Math.abs(dx), Math.abs(dy));
if (pasos == 0) {
    // Los puntos coinciden: dibujar un único punto.
NroDelCuadraditoaPintar = FilaDePunto1 * CuadraditosPorFila + ColumnaDePunto1;
ParaColorDeCuadradito = new Color(Cuadro_pCuadradito + NroDelCuadraditoaPintar);
ParaColorDeCuadradito.setRGB(ColorDeImagen);
} else {
    for (i = 0; i <= pasos; i++) {
        columna = ColumnaDePunto1 + Math.round(i * dx / pasos);
        fila = FilaDePunto1 + Math.round(i * dy / pasos);
        // Pintar el punto (columna, fila).
NroDelCuadraditoaPintar = fila * CuadraditosPorFila + columna;
ParaColorDeCuadradito = new Color(Cuadro_pCuadradito + NroDelCuadraditoaPintar);
ParaColorDeCuadradito.setRGB(ColorDeImagen);
    }
}
}
El resultado indicando los errores:


Por mi cuenta he seguido pensando y lo que veo es que con mi método los cuadraditos tienden a quedar en las filas del medio, lo cual en algunos casos no quiero, pero tampoco es que siempre deban ir en las esquinas.
Te explico el método por si no lo entiendes.
Es cuando hay más columnas que filas o es la misma cantidad.
1ero se calcula cuántos cuadraditos habrá como mínimo en cada fila. Columnas/Filas.
Eso puede que nos de un resto, lo cual es el problema.
Para decidir en qué filas deben ir los cuadraditos extras hacemos (Filas-1)/(Resto+1)
El -1 es porque las contamos desde 0, el +1 es porque cuando hay 1 extra va en el medio (1/2), cuando hay 2 van el 1ero en X/3 y el 2ndo en eso*2, o sea, siempre se divide por uno más.
Bueno, la siguiente imagen muestra varios casos, señalando en rojo los que con este método resultan un error.
Nota: Olvidé cambiar el 1 en la cabecera, es extra 1, extra 2, etc.

Hay como un patrón, si sumas 2 a las columnas y 1 a las filas, eso se sigue repitiendo ¿qué? Que los cuadraditos se asignan a las filas del medio, cuando en estos casos quisiera que en el medio haya menos. Lo puedo resolver creo pero a fin de cuentas puede haber otro tipo de casos y crear soluciones especiales para cada uno no parece viable, ni siquiera sé cuántos son. En fin, lo intentaré solucionar. El error ocurre cuando filas es > 3 y se determina que 1er extra debe ir en la fila 1. En tales casos los que estén antes de la fila central deben ir una fila antes y los que estén luego de la fila central deben ir una después.

[Richard R Richard]

Sigo sin ver donde te gace la diferencia el programa, quiza tu función  math.round() no devuelve exacto lo que se necesita
Fijate si puedes crear tu propia función  de redondeo por ejemplo

Código: [Seleccionar]


def funcion_redondeo(valor):
     if valor-valor//1<0.5:
          valor=valor//1
     else:
          valor=valor//1+1
      return valor


Creo que en action script sería

 

Código: [Seleccionar]

function funcion_redondeo(valor:Number):Number {
    if (valor - Math.floor(valor) < 0.5) {
        valor = Math.floor(valor);
    } else {
        valor = Math.floor(valor) + 1;
    }
    return valor;
}
Donde // devuelve la parte entera de una división,  así al hacer //1 te devuelve la parte entera del valor de la variable.

Entonces en vez de usar  en el programa math.round(variable) usas funcion_redondeo(variable)

Pruébalo y fijate si mejora.

Por otro lado probaría cambiar
for (i = 0; i <= pasos; i++)
Por
for (i = 0; i <= dx; i++)

Porque da lo misma que sea mas alta que ancha que que mas ancha que alta,  el algoritmo  lo resuelve igual. Usar el máximo para hallar pasos creo está  demás.
Además i es directamente el número  de columna a agregar a la primer columna

Pon
columna = ColumnaDePunto1 + i ;



Pd: hice un programita que hace las ventanas que muestras para cada recta y  usando la funcion de redondeo definida en el propio programa y funciono excelente, pero con round() daba ciertas curvas