Dudas sobre la lectura de un archivo .MAP o .FPG a pelo.

Started by Erkosone, December 31, 2015, 09:23:40 AM

Previous topic - Next topic

0 Members and 1 Guest are viewing this topic.

Erkosone

Hola gente, ando leyendo el formato de mapa de imagen de bennuGD desde Java, y me surge una duda, siguiendo las indicaciones de AmakaSoft he podido obtener el ancho, alto, y el numero de puntos de control de un archivo .map de bennuGD "muchisimas gracias tio por la info ;) ".


Pero como info de cabecera o identificador de archivo estoy obteniendo los chars "m16", esto es correcto? que significan?
bueno.. es una duda algo tonta pero abro el hilo para ir comentando futuras dudas que me vayan surgiendo  :)



Erkosone

Bueno me autorespondo, haciendo mas pruebas parece que 'm16' indica que es un archivo .map a 16 bit de profundidad de color, y si obtengo 'm32' indica que está a 32 bits de profundidad de color.


Ale una cosa menos jeje..





Erkosone

muchas gracias joseba, voy a hecharles un vistazo ya!!
Esto va viento en popa a toda vela, la verdad es que está siendo un ejercicio muy chulo este.

Erkosone

Asi mirando el código del formato map.. jeje.. ahora recuerdo por que odio tanto programar en c++ jajajjajajajajajajjajajajajajajajajaja
Gracias de nuevo Joseba!

Erkosone

Ya he conseguido leer el archivo .map al completo yuhheuuuu!!!!


Pero me sale el color con diarrea XD..  en que orden vienen los bytes de color? creo haber entendido que estan en R G B A pero no se si estoy en lo cierto la verdad, estoy haciendo combinaciones haber si acierto pero vaya tela XD..

AmakaSt

Quote from: Erkosone on December 31, 2015, 11:09:48 AM
Ya he conseguido leer el archivo .map al completo yuhheuuuu!!!!


Pero me sale el color con diarrea XD..  en que orden vienen los bytes de color? creo haber entendido que estan en R G B A pero no se si estoy en lo cierto la verdad, estoy haciendo combinaciones haber si acierto pero vaya tela XD..

xD Lo del color me paso también a mi, el orden es ARGB, primero el alpha. xD

Un saludo.

AmakaSt

Otra cosa es si el alpha lo interpreta igual java que bennu, en javascript el alpha es decimal y va de 0 a 1, por lo que el valor alpha lo tuve que dividir en 255.

Erkosone

Gracias tio! creo que por ahí van los tiros jeje.. me suena de cuando hice el blitter que el alpha es de cero a 1 jejeje.. creo que ya lo tengo!

Erkosone


Erkosone

Solucionado! en java(processing) inyecto los bytes como (b,g,r,a) y listo.. por ahora me conformo asi jejeje....


Gracias!!!!

Erkosone

#11
Me pasa algo que no se arreglar, cuando el tamaño de la imagen supera en alto o ancho los 254 pixels me lee mal el ancho y alto, creo que tiene que ver con los byte´s de donde estoy leyendo el ancho y alto, pego el código que es bastante poco y sencillo de seguir, si no he entendido mal, los bytes 8 y 9 son el ancho y los 10 y 11 son el alto.
Lo hago así pero con imagenes de mas de ancho que lo que cabe en un byte hace puff.. haber si doy con el error..


EDIT: si en las variables ancho y alto coloco yo a mano los valores correctos todo funciona perfect.. que cosa mas curiosa.


PImage mapa;
int ST = 0;
//----------------------------------------------------------------------
void Setup() {
  setMode(1280, 900 );
  setVirtualResolution(640, 400);
  setFps(60);
  worldSetGravity(-90, 100);
}
//----------------------------------------------------------------------
void Main() {
  switch(ST) {
  case 0:
    mapa = loadMap("001.map");
    ST = 10;
    break;
    //----------------------------
  case 10:
    blitter.image(mapa, 150, 150);
    break;
  }
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
PImage loadMap(String fileName) {
  // datos del archivo de imagen..
  String header = "";                  // cabecera del archivo..
  String mapDesc = "";                 // descripcion del mapa..
  int ancho;                           // ancho del archivo..
  int alto;                            // alto del archivo..
  int numCPoints;                      // numero de puntos de control que contiene el archivo..
  byte[] map = loadBytes(fileName);    // bytes en raw del contenido del archivo..
  int offset;                          // posicion donde empieza la información RGBA de la imagen..
  int counter = 0;                     // usando en el dump de RAW BYTES al array de pixels..
  for(int i=0; i<7; i++){
    header += char(map[i]);
  }
  for(int i=13; i<45; i++){
    mapDesc += char(map[i]);
  }
  // paso de signed a unsigned bytes..
  ancho = (map[8] & 0xff) + (map[9] & 0xff);
  alto  = (map[10] & 0xff) + (map[11] & 0xff);
  numCPoints = (map[48] & 0xff);
  println("header: " + header);
  println("Description: " + mapDesc);
  println("ancho : " + ancho);
  println("alto  : " + alto);
  println("CP´s  : " + numCPoints);
  // crear el array de puntos de control..
  cPoint[] cp = new cPoint[numCPoints];
  // rellenar el array con las coordenadas de los puntos de control..
  for(int i=0; i<numCPoints; i++){
    cp[i] = new cPoint();
    cp[i].x = (map[49+i*4] & 0xff) + (map[50+i*4] & 0xff);
    cp[i].y = (map[51+i*4] & 0xff) + (map[52+i*4] & 0xff);
    println("CP[" + i + "] : " + cp[i].x + "    " + cp[i].y);
  }
  offset = (52 + numCPoints * 4) +1;
  // RGBA pixel´s load..
  PImage img = createImage(ancho, alto, ARGB);
  int r,g,b,a;
  colorMode(RGB, 255);
  for (int i=0; i+offset+4< map.length; i+=4) {
    a = (map[offset + i+0] & 0xff);
    r = (map[offset + i+1] & 0xff);
    g = (map[offset + i+2] & 0xff);
    b = (map[offset + i+3] & 0xff);
    img.pixels[counter] = color( b,g,r, a);
    counter ++;
  }
 
  img.updatePixels();
  return img;
}
//----------------------------------------------------------------------
class cPoint{
  int x = 0;
  int y = 0;
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------

AmakaSt

#12
Si, los bytes 8 y 9 son el ancho y los 10 y 11 el alto, pero no se deben sumar tal cual.

A ver si así te funciona:

ancho = (map[8] & 0xff);
alto    = (map[10] & 0xff);

if ((map[9] & 0xff) > 0) ancho += 256 * (map[9] & 0xff);
if ((map[11] & 0xff) > 0) alto += 256 * (map[11] & 0xff);


Un saludo.

P.d: Y esto es lo mismo para la posición x e y de los cpoints.

Erkosone

Dios si, acabo de despertar de la siesta y mi cerebro me ha dado una bofetada XD.. tienes toda la razón del mundo, se me ha ido la olla completamente jeje...
Gracias tio, ya te digo, me he despertado de dormir con el tipico "coño!, soy retrasado!".  :)

Erkosone

Vaya tela, gracias tio.. esto es un claro inicio de demencia senil jaja..


me he montado esto ya para el api que estoy construyendo:

int getWord(byte[] arr, int off) {
 
  //return arr[off]<<8 &0xFF00 | arr[off+1]&0xFF;
  if ((arr[off] & 0xff) > 0){
    return (arr[off] & 0xff) + (256 * (arr[off+1] & 0xff));
  }
  else{
    return (arr[off+1] & 0xff);
  }
}