/*****************************************************************************
 UNIVERSIDAD DE ZARAGOZA
 DEPARTAMENTO DE INFORMATICA E INGENIERIA DE SISTEMAS
 AREA DE LENGUAJES Y SISTEMAS INFORMATICOS
******************************************************************************
******************************************************************************
 Fichero     :  rle.h
 Asignatura  :  Vision por Computador
 Fecha       :  2003-02
 Autor       :
******************************************************************************/

/*****************************************************************************
                               D E F I N E S
******************************************************************************/
#define FALSE         0
#define TRUE          1

#define BLANCO        255
#define NEGRO         0

#define MAXSEGS       100000
#define MAXBLOBS      10000
#define NULO          -1

/* 1: algunos mensajes informativos,0: ningun mensaje */
#define DEBUG         1

/*****************************************************************************
                          D E F I N I C I O N E S
******************************************************************************/

/* registro para almacenar la informacion de un segmento */

   typedef struct
      {
      int fila,
      columna,
      longitud;
      int blob;
      int siguiente;
      } SEGMENTO;

/* registro para almacenar un vector de segmentos y un contador (run-length)*/

   typedef struct
      {
      int cantidad;
      SEGMENTO segmento[MAXSEGS];
      } SEGMENTOS;

/* registro para almacenar la informacion de un blob */

   typedef struct
      {
      int primero;
      int ultimo;
      int tamano;
      } BLOB;

/* registro para almacenar un vector de blobs y un contador(conectividad)*/

   typedef struct
      {
      int cantidad;
      BLOB blob[MAXBLOBS];
      int usados;
      } BLOBS;

/* registro para almacenar un run-length y el resultado de la conectividad */

   typedef struct
      {
      int filas;
      int primero[MAX_FILAS];
      int ultimo[MAX_FILAS];
      SEGMENTOS segmentos;
      BLOBS blobs;
      } RLE;

/*
variable estatica donde se hacen todas las operaciones de
codificacion run-length y de analisis de conectividad
*/

   RLE rle;

/*****************************************************************************
                                M A C R O S
******************************************************************************/

/* para acceso a informacion de una rle */

#define NBLOBS                (rle.blobs.cantidad)
#define USADOS                (rle.blobs.usados)
#define NSEGMENTOS            (rle.segmentos.cantidad)
#define NFILAS                (rle.filas)
#define PRIMER_SEGMENTO(f)    (rle.primero[f])
#define ULTIMO_SEGMENTO(f)    (rle.ultimo[f])

/* para acceso a informacion de un segmento */

#define FILA(s)               ((rle.segmentos.segmento[s]).fila)
#define COLUMNA(s)            ((rle.segmentos.segmento[s]).columna)
#define LONGITUD(s)           ((rle.segmentos.segmento[s]).longitud)
#define BLOB(s)               ((rle.segmentos.segmento[s]).blob)
#define COMIENZO(s)           (COLUMNA(s))
#define FINAL(s)              (COLUMNA(s) + LONGITUD(s) - 1)
#define SIGUIENTE(s)          ((rle.segmentos.segmento[s]).siguiente)

/* para acceso a informacion de un blob */

#define PRIMERO(b)            ((rle.blobs.blob[b]).primero)
#define ULTIMO(b)             ((rle.blobs.blob[b]).ultimo)
#define TAMANO(b)             ((rle.blobs.blob[b]).tamano)

/* para analisis de 4-conectividad */

#define A_LA_IZQUIERDA(s1,s2) (FINAL(s1) < COMIENZO(s2))
#define A_LA_DERECHA(s1,s2)   (A_LA_IZQUIERDA(s2,s1))
#define SE_SOLAPAN(s1, s2)    (!A_LA_IZQUIERDA(s1, s2)&&!A_LA_DERECHA(s1, s2))

