BITS

[NericSain]

Código (c) [Seleccionar] Expandir

[MAFUS]

Explícate bastante mejor, con ejemplos por pasos y dibujos, a ser posible.

[NericSain]

Listo Lo acabo de modificar hermano, ojala tengas alguna idea, te lo agradecería mucho

[MAFUS]

Sí, se me ha ocurrido algo.

Mediante desplazamiento de bits y AND puedes sacar uno a uno los bits de cada carácter.
Por otra parte hay 4 formas diferentes de rellenar los rectángulos con esos bits, por tanto prepararía 4 funciones diferentes que recibieran los siguientes argumentos: posición X, dentro de QR de su primer bit; posición Y, dentro de QR de su primer bit; carácter que debe codificar. La función retornará la posición X e Y calculada después de que este 'cursor' salga del recuadro (que será usado por la siguiente función para escribir el siguiente carácter).

Ejemplo de uso de esas funciones, la implementación te la dejo para tí:

Código [Seleccionar] Expandir


int x = 20;
int y = 14;

up(&x, &y, 'P'); // Se rellena desde abajo hacia arriba
frombottom(&x, &y, 'E); // Se rellena hacia la izquierda desde abajo
down(&x, &y, 'G'); // Se rellena desde arriba hacia abajo
down(&x, &y, 'A');
// ...


Dentro de cada función, mediante AND y desplazamientos a la derecha >> puedes sacar cada bit para saber en esa posición del QR hay un 1 o un 0.
Como todas las funciones son parecidas, solo cambia el patrón de movimiento, puedes hacerlo todo en una única función y que el patrón se de como un argumento más. Por ejemplo:
void writedata(int *x, int *y, char *c, PATH p);
Siendo PATH un enum con los cuatro caminos diferentes que pueden tomar los datos.

[NericSain]

No Lo entiendo muy bien; porque la verdad nunca había trabajado con '>>' ese operador, que es para desplazar bits.

y la Parte del cursor no la entiendo muy bien.

muchas gracias, ojala tengan más ideas

[MAFUS]

Si nunca has usado ese operador puedes usar x /= 2. Al dividir un número por dos estás desplazando una vez a la derecha ese número (a nivel de bits).

Pero bueno, si explicas hasta donde has llegado en C tal vez podamos ajustar la respuesta a tus conocimientos.

[NericSain]

TIENES MUCHA RAZÓN. ESTO ES LO QUE LLEVO, (OSEA NADA ).
LO QUE HACE EL CÓDIGO DE ABAJO ES ESTO:
Y LO QUE QUIERO ES QUE EN LA PARTE DONDE HAY UNOS(1), TENGO QUE DIVIDIR EN CASILLAS DE 4*2,ES DECIR 8, DE TAL FORMA QUE META NUMEROS BINARIOS, PERO DE FORMA INDIVIDUAL.

POR EJEMPLO, EN LA SIG. IMAGEN:
LAS ÁREAS EN ROJO ES UN EJEMPLO DE COMO DEBO DE DIVIDIR  ESAS MINI-MATRICES, Y EN CADA UNA METER ESOS NÚMEROS BINARIOS, EL PROBLEMA ES
QUE PARA LLENAR ESA ÁREA, TENGO QUE HACERLO DE ESTA FORMA:

[MAFUS]

Veo, por otros mensajes, que sigue sin salirte. Sin saber como se trabaja a nivel de bits no podrás resolver este problema.

Te paso un código que he realizado que solo realiza hasta la codificación de la cadena e imprime los recuadros de posición.

El programa es básico pues se puede optimizar bastante más, pero para mejorar la sencillez te lo dejo así, está comentado. Espero que te sirva:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <string.h> // strlen
#include <ctype.h> // isprint

#define tamQR 21
#define info "www.elhacker.net"

// Ya que la tabla QR es el objeto principal de este programa
// lo hago global, para ahorrarme trabajo con las funciones.
// Cada posición x y guardará un 0, si no ese bit no debe estar
// activo o un valor distino a 0 si ese bit debe tener información.
int QR[tamQR][tamQR];

// Nota: Voy a llamar cursor a la posición x e y dentro del QR
// donde se vaya a escribir un dato.

// Una ayuda para manejar las cosas dentro de las funciones
typedef enum {
   ABAJO,
   ARRIBA,
   DESDE_ABAJO,
   DESDE_ARRIBA
} DIRECCION;

// --------------------------------------------------------------
// TODO ESTO NO CODIFICA TUS BYTES, SOLO REPRESENTA EL
// DIBUJO BÁSICO DEL QR
// Crea el cuadrado exterior de los recuadros de posición
void cuadrado_exterior(int x, int y) {
   // Variables auxiliares para mover el cursor
   // de dibujo por todo el recuadro
   int xc, yc;

   // Dibujo las líneas horizontales superior e inferior
   for(xc = x; xc < x+7; ++xc) {
       QR[y][xc] = 1;
       QR[y+6][xc] = 1;
   }

   // Dibujo las líneas verticales
   for(yc = y; yc < y+6; ++yc) {
       QR[yc][x] = 1;
       QR[yc][x+6] = 1;
   }
}

// Crea el cuadrado interior de los recuadros de posición
void cuadrado_interior(int x, int y) {
   int xc, yc;

   for(yc = y; yc < y+3; ++yc)
       for(xc = x; xc < x+3; ++xc)
           QR[yc][xc] = 1;
}

// La función que se debe llamar para dibujar los cuadrados
// pasándole la posición de la esquina superior izquierda
void cuadrado(int x, int y) {
   cuadrado_exterior(x, y);
   cuadrado_interior(x+2, y+2);
}

void QR_inicializar() {
   int x, y;

   // Borrar todo el QR
   for(y = 0; y < tamQR; ++y)
       for(x = 0; x < tamQR; ++x)
           QR[y][x] = 0;

   // Escribir en el los recuadros de posición
cuadrado(0, 0);
cuadrado(14, 0);
cuadrado(0, 14);
}

void QR_imprimir() {
   int x, y;

   // Se escribirá el carácter 219 o el 176 en la consola
   // según si QR[y][x] es no 0 o 0 respectivamente
   for(y = 0; y < tamQR; ++y) {
       for(x = 0; x < tamQR; ++x) {
           char c = QR[y][x]? 219:176;
           printf("%c", c);
       }
       printf("\n");
   }
}
// --------------------------------------------------------------

// La idea es que solo hay dos caminos que se repiten de cada grupo de
// cuatro bits:
//  De abajo a arriba (4 pasos)
//    1) ..   2) ..  3) .o  4) o.
//       .o      o.     ..     ..
//
//  De arriba a abajo (4 pasos)
//    1) .o   2) o.  3) ..  4) ..
//       ..      ..     .o     o.
//
// A cada posición le corresponde un bit del nibble (grupo de 4 bits)
// desde el bit de mayor peso al bit de menor peso.
// Además se dejará el cursor a la siguiente posición (la que seguiría
// el patrón si hubiera continuado una vez más) dejándolo preparado
// para que el próximo nibble se escriba en él sin hacer más cálculos
// (cómo se vera esto se consigue de forma natural con el bucle).
void codificar_nibble(int *x, int *y, char nibble, DIRECCION partida) {
   // La máscara sirve para para conseguir trabajar con los bits
   // que quieres dentro de un dato (si eso búscalo en Google para
   // comprender más). En este caso como es un nibble (conjunto de 4 bits)
   // el bit de mayor peso, dentro de un byte está aquí 00001000 en binario
   // (que es igual a 8 decimal).
   char mascara = 8;
   // La bandera cambiará entre falso (0) y cierto (no 0) para controlar el
   // cursor, si debe ir en una dirección u otra.
   int bandera = 0;

   // El desplazamiento de bits sobre la máscara (busca que es eso) irá
   // desplazando el 1 hacia la derecha hasta que mascara tendrá todo 0,
   // momento en que mascara valdrá 0 en decimal y el while se detendrá.
   while(mascara) {
       // Escribe donde se encuentre el cursor el dato del bit mascara
       // del nibble
       QR[*y][*x] = nibble & mascara;
       // Muevo el bit de la mascara un lugar a la derecha
       mascara >>= 1;

       // Actualizo el cursor para la siguiente posición
       switch(partida) {
           case ABAJO:
               // No se necesita. Usado para evitar el warning del compilador.
               break;

           case ARRIBA:
               // No se necesita. Usado para evitar el warning del compilador.
               break;

           // Sacado de tus dibujos
           case DESDE_ABAJO:
               if(!bandera)
                   --*x; // A la izquierda
               else {
                   ++*x; // A la derecha
                   --*y; // y a arriba
               }
               break;

           case DESDE_ARRIBA:
               if(!bandera)
                   --*x; // A la izquierda
               else {
                   ++*x; // A la derecha
                   ++*y; // Y abajo
               }
               break;
       }
       bandera = !bandera;
   }
}

void codificar_byte(int *x, int *y, unsigned char c, DIRECCION direcc) {
   // La siguiente línea tan solo es para depuración. No es necesaria para
   // crear el QR
   printf("x: %2i, y: %2i, c: %3i ( %c )\n", *x, *y, c, isprint(c)? c : ' ');

   // Cada byte se compone de 2 nibbles.
   // La expresión c>>4 & 0xF toma los cuatro bits de más peso del byte.
   // La expresión c & 0xF toma los cuatro bits de menos peso del byte.
   // (En verdad, todo esto del trabajo con bits es necesario para hacer
   // este ejercicio).
   switch(direcc) {
       case ABAJO:
           codificar_nibble(x, y, c>>4 & 0xF, DESDE_ARRIBA);
           codificar_nibble(x, y, c & 0xF, DESDE_ARRIBA);
           break;

       case ARRIBA:
           codificar_nibble(x, y, c>>4 & 0xF, DESDE_ABAJO);
           codificar_nibble(x, y, c & 0xF, DESDE_ABAJO);
           break;

       case DESDE_ABAJO:
           codificar_nibble(x, y, c>>4 & 0xF, DESDE_ABAJO);
           *x -= 2; // Estas dos expresiones para actualizar el cursor son necesarias
           ++*y;    // pues donde lo deja la función codificar_nibble solo sirve para
                    // ABAJO y ARRIBA. Si miras tu dibujo lo comprenderás
           codificar_nibble(x, y, c & 0xF, DESDE_ARRIBA);
           break;

       case DESDE_ARRIBA:
           codificar_nibble(x, y, c>>4 & 0xF, DESDE_ARRIBA);
           *x -= 2; // Ídem al caso anterior
           --*y;
           codificar_nibble(x, y, c & 0xF, DESDE_ABAJO);
           break;
   }
}

void codificar_cadena(char *cadena) {
    size_t tam = strlen(cadena); // Tamaño de la cadena.
    int x = 20; // Posición de inicio. Se necesita meter en una variable.
    int y = 14; // porqué las mismas funciones lo irán actualizando.
    int pos = 0; // Serve para indicar qué caracter de la cadena estamos operando.
    int i;

    if(tam > 17) tam = 17; // Limitar el tamaño de la cadena a los 17 caracteres inicales.

    // Se codifican los caracteres dentro del QR
    for(i = 0; i < 2; ++i) {
        codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ARRIBA);
        codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, DESDE_ABAJO);
        codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ABAJO);
        codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ABAJO);
        codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, DESDE_ARRIBA);
        codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ARRIBA);
    }
    codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ARRIBA);
    codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ARRIBA);
    --y; // Necesario para saltar una línea de bits (ver tu dibujo)
    codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ARRIBA);
    codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, DESDE_ABAJO);
    codificar_byte(&x, &y, tam > pos? cadena[pos++] : 0, ABAJO);
}

int main() {
QR_inicializar();
codificar_cadena(info);
QR_imprimir();

return 0;
}

[NericSain]

MAFUS, muchisimas gracias, neta en verdad. no puedo creer, que algo tan basico, como el manejo de bits, no se enseñe en las escuelas, pero peor aun, nosotros alumnos, como yo, no busquemos estas herramientas, y terrible que , desvaloremos esto.
Neta muchas gracias, todavía no termino mi problema, pero creo que lo más dificil lo hiciste tu. Pero lo mejor que hiciste por mi, es darme conocimiento distinto, una leccion de que me falta mucho por aprender, y sobre todo; la idea más sencilla, resuelve los problemas más complejos. WOW, te MAMASTE, GRACIAS
ESPERO SEGUIR APRENDIENDO DE TI, Y DE LAS DEMAS PERSONAS

PDT: ME LLEVO TODO EL DÍA ENTENDERLE