/*---------------------------------------------------------------------------*/

/* Vesione dell'Autofill aggiornata al 22.11.94 (Fabrizio Grisoli)           */

/*---------------------------------------------------------------------------*/

/* aggiornata il 20.8.98 per CM24 (W.T.) */

#include "autofill.h"

#include <stdio.h></stdio.h>

#include <stdlib.h></stdlib.h>

#include <math.h></math.h>

#include "toonz/toonzimageutils.h"

#include "tw/tw.h"

#include "toonz/fill.h"

#include "toonz/ttilesaver.h"

#include "toonz4.6/tmacro.h"

/*

#include "tropcm.h"

#include "timage_io.h"

#include "tlevel_io.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/tscenehandle.h"

#include "tools/tool.h"*/

#define PRINTF

struct s_segm {

  int xa, xb, region;

};

typedef struct big { UINT lo, hi; } BIG;

#define ADD_BIG(B, X)                                                          \

  ((B).lo += (UINT)(X), (B).hi += (B).lo >> 30, (B).lo &= 0x3fffffff, (B))

#define ASS_BIG(B, X)                                                          \

  ((B).lo = (UINT)(X), (B).hi = (B).lo >> 30, (B).lo &= 0x3fffffff, (B))

#define ADD_BIG_BIG(B1, B2)                                                    \

  ((B1).lo += (B2).lo, (B1).hi += (B2).hi, (B1).hi += (B1).lo >> 30,           \

   (B1).lo &= 0x3fffffff, (B1))

#define BIG_TO_DOUBLE(B) ((double)(B).hi * (double)0x40000000 + (double)(B).lo)

#define BORDER_TOO 1

#define NO_BORDER 0

#define DIM_TRESH 0.00005

#define AMB_TRESH 130000

#define MIN_SIZE 20

struct vicine {

  int region_id;

  struct vicine *next;

};

struct s_fabri_region {

  int active, nextfree, x, y, x1, y1, x2, y2, lx, ly, xm, ym, npix, lxa, lxb,

      tone, color_id, per, holes, match;

  BIG bx, by;

  BIG bx2, by2;

  struct vicine *vicini;

};

struct s_fabri_region_list {

  struct s_fabri_region *array;

  int size, n, lx, ly;

};

static struct s_fabri_region_list F_reference = {0, 0, 0}, F_work = {0, 0, 0};

static int F_ref_bx = 0;

static int F_ref_by = 0;

static int F_wor_bx = 0;

static int F_wor_by = 0;

static int Dx_f = 0, DP_f = 0, Df_f = 0;

static int Dx_t = 0, DP_t = 0, Df_t = 0;

/*---------------------------------------------------------------------------*/

/*-- Local Prototipes -------------------------------------------------------*/

static int trova_migliore_padre(int prob_vector[], int *att_best);

static int match(int prob[], int padre, int *fro, int *to);

static void scan_fabri_regions(TRasterCM32P ras,

                               struct s_fabri_region_list *rlst, int mode,

                               int x1, int y1, int x2, int y2);

static void rinomina(int r1, int r2, int r_num, struct s_fabri_region_list *rl);

static void aggiungi(int r1, int r2, struct s_fabri_region_list *rlst);

static void rimuovi_tutti(int r1, struct s_fabri_region_list *rlst);

static void fondi(struct s_fabri_region_list *rlst, int r1, int r2);

static void assign_prob3(int prob[], int i, int j);

static void find_best(int prob_vector[], int *col, int to);

static void free_list(struct vicine **vic);

static int somma_quadrati(int x, int y);

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

void rect_autofill_learn(const TToonzImageP &imgToLearn, int x1, int y1, int x2,

                         int y2)

/*---------------------------------------------------------------------------*/

{

  int i;

  double pbx, pby;

  double abx, aby;

  int tot_pix = 0;

  if ((x2 - x1) * (y2 - y1) < MIN_SIZE) return;

  pbx = pby = 0.0;

  abx = aby = 0.0;

  TRasterCM32P ras = imgToLearn->getRaster();

  if (F_reference.array) {

    for (i = 0; i < F_reference.n; i++) free_list(&F_reference.array[i].vicini);

    free(F_reference.array);

  }

  F_reference.array = 0;

  F_reference.size  = 0;

  F_reference.n     = 0;

  F_reference.lx    = 0;

  F_reference.ly    = 0;

  scan_fabri_regions(ras, &F_reference, 1, x1, y1, x2, y2);

  for (i = 0; i < F_reference.n; i++) {

    F_reference.array[i].match = -1;

    F_reference.array[i].color_id =

        ras->pixels(F_reference.array[i].y)[F_reference.array[i].x].getPaint();

    pbx += BIG_TO_DOUBLE(F_reference.array[i].bx);

    pby += BIG_TO_DOUBLE(F_reference.array[i].by);

    abx = BIG_TO_DOUBLE(F_reference.array[i].bx);

    aby = BIG_TO_DOUBLE(F_reference.array[i].by);

    tot_pix += F_reference.array[i].npix;

  }

  if (tot_pix) {

    F_ref_bx = pbx / tot_pix;

    F_ref_by = pby / tot_pix;

  } else {

    F_ref_bx = 0;

    F_ref_by = 0;

  }

}

/*----------------------------------------------------------------------------*/

bool rect_autofill_apply(const TToonzImageP &imgToApply, int x1, int y1, int x2,

                         int y2, bool selective, TTileSetCM32 *tileSet)

/*----------------------------------------------------------------------------*/

{

  double pbx, pby;

  double abx, aby;

  int i, j;

  int tot_pix = 0;

  int *prob_vector;

  int fro, to;

  int col;

  int valore;

  int padre;

  // int temp_prob, att_match;

  TRasterCM32P ras = imgToApply->getRaster();

  if ((x2 - x1) * (y2 - y1) < MIN_SIZE) return false;

  if (F_reference.n <= 0 || F_reference.array == 0) return false;

  pbx = pby = 0.0;

  abx = aby = 0.0;

  /* Resetta gli eventuali accoppiamenti fatti precedentemente */

  for (i = 0; i < F_reference.n; i++) F_reference.array[i].match = -1;

  if (F_work.array) {

    for (i = 0; i < F_work.n; i++) free_list(&F_work.array[i].vicini);

    free(F_work.array);

  }

  F_work.array = 0;

  F_work.size  = 0;

  F_work.n     = 0;

  F_work.lx    = 0;

  F_work.ly    = 0;

  scan_fabri_regions(ras, &F_work, 1, x1, y1, x2, y2);

  if (F_work.n <= 0 || F_work.array == 0) return false;

  if (abs(F_work.lx * F_work.ly - F_reference.lx * F_reference.ly) >

      0.1 * (F_work.lx * F_work.ly + F_reference.lx * F_reference.ly))

    return false;

  for (i = 0; i < F_work.n; i++) {

    F_work.array[i].match = -1;

    pbx += BIG_TO_DOUBLE(F_work.array[i].bx);

    pby += BIG_TO_DOUBLE(F_work.array[i].by);

    abx = BIG_TO_DOUBLE(F_work.array[i].bx);

    aby = BIG_TO_DOUBLE(F_work.array[i].by);

    tot_pix += F_work.array[i].npix;

  }

  F_wor_bx = pbx / tot_pix;

  F_wor_by = pby / tot_pix;

  prob_vector = (int *)calloc(3 * F_work.n * F_reference.n, sizeof(int));

  for (i = 0; i < F_reference.n; i++)

    for (j = 0; j < F_work.n; j++) assign_prob3(prob_vector, i, j);

  Dx_f = Dx_f / F_reference.n;

  DP_f = DP_f / F_reference.n;

  Df_f = Df_f / F_reference.n;

  Dx_t = Dx_t / F_work.n;

  DP_t = DP_t / F_work.n;

  Df_t = Df_t / F_work.n;

#ifdef SELECTIVE

  if (selective) {

    // Accoppia non trasparenti

    for (i = 0; i < F_work.n; i++)

      if (F_work.array[i].color_id != 0) {

        temp_prob = 0;

        att_match = F_reference.n;

        /* Se non verra' aggiornato in seguito non verra' *

* comunque piu' cambiato di colore               */

        for (j = 0; j < F_reference.n; j++)

          if ((F_reference.array[i].match < 0) &&

              ((prob_vector[i * F_reference.n + j] / 1000.0) *

                   (prob_vector[i * F_reference.n + j] / 1000.0) *

                   (prob_vector[2 * (F_work.n * F_reference.n) +

                                i * F_reference.n + j] /

                    1500.0) >

               temp_prob)) {

            att_match = j;

            temp_prob = (prob_vector[i * F_reference.n + j] / 1000.0) *

                        (prob_vector[i * F_reference.n + j] / 1000.0) *

                        (prob_vector[2 * (F_work.n * F_reference.n) +

                                     i * F_reference.n + j] /

                         1500.0);

          }

        F_work.array[i].match = att_match;

        if (att_match < F_reference.n) F_reference.array[att_match].match = i;

      }

    /*--------------------------------------------------------------------------*/

  }

#endif

  bool recomputeBBox = false;

  FillParameters params;

  params.m_emptyOnly = selective;

  for (i = 0; i < F_reference.n && i < F_work.n; i++) {

    padre  = trova_migliore_padre(prob_vector, &fro);

    valore = match(prob_vector, padre, &fro, &to);

    if (valore > AMB_TRESH) {

      F_work.array[to].match       = fro;

      F_reference.array[fro].match = to;

      F_work.array[to].color_id    = F_reference.array[fro].color_id;

      if ((F_work.array[to].color_id != 0) && (valore != 0)) {

        params.m_p       = TPoint(F_work.array[to].x, F_work.array[to].y);

        params.m_styleId = F_work.array[to].color_id;

        TTileSaverCM32 tileSaver(ras, tileSet);

        recomputeBBox = fill(ras, params, &tileSaver) || recomputeBBox;

      }

    }

  }

  /*..........................................................................*/

  /* Matching basato sulla probabilita' di colore                             */

  /*..........................................................................*/

  if (FALSE) {

    bool recomputeBBox = false;

    for (i = 0; i < F_work.n; i++) {

      if (F_work.array[i].match < 0) {

        find_best(prob_vector, &col, i);

        F_work.array[i].match    = 1;

        F_work.array[i].color_id = col;

        if (F_work.array[i].color_id != 0) {

          params.m_p       = TPoint(F_work.array[i].x, F_work.array[i].y);

          params.m_styleId = F_work.array[i].color_id;

          TTileSaverCM32 tileSaver(ras, tileSet);

          recomputeBBox = fill(ras, params, &tileSaver) || recomputeBBox;

        }

      }

    }

  }

  free(prob_vector);

  return recomputeBBox;

}

/*---------------------------------------------------------------------------*/

/* Versione del Learning delle aree di Fabrizio                              */

/*...........................................................................*/

void autofill_learn(const TToonzImageP &imgToLearn)

/*---------------------------------------------------------------------------*/

{

  int i;

  double pbx, pby;

  double abx, aby;

  int tot_pix = 0;

  pbx = pby = 0.0;

  abx = aby = 0.0;

  TRasterCM32P ras = imgToLearn->getRaster();

  if (F_reference.array) {

    for (i = 0; i < F_reference.n; i++) free_list(&F_reference.array[i].vicini);

    free(F_reference.array);

  }

  F_reference.array = 0;

  F_reference.size  = 0;

  F_reference.n     = 0;

  F_reference.lx    = 0;

  F_reference.ly    = 0;

  scan_fabri_regions(ras, &F_reference, 0, 0, 0, 0, 0);

  for (i = 0; i < F_reference.n; i++) {

    F_reference.array[i].match = -1;

    F_reference.array[i].color_id =

        ras->pixels(F_reference.array[i].y)[F_reference.array[i].y].getPaint();

    pbx += BIG_TO_DOUBLE(F_reference.array[i].bx);

    pby += BIG_TO_DOUBLE(F_reference.array[i].by);

    abx = BIG_TO_DOUBLE(F_reference.array[i].bx);

    aby = BIG_TO_DOUBLE(F_reference.array[i].by);

    tot_pix += F_reference.array[i].npix;

  }

  F_ref_bx = pbx / tot_pix;

  F_ref_by = pby / tot_pix;

}

/*-- end of learn_fabrizio --------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/* Versione del matching delle aree di Fabrizio                              */

/*...........................................................................*/

bool autofill_apply(const TToonzImageP &imgToApply, bool selective,

                    TTileSetCM32 *tileSet)

/*---------------------------------------------------------------------------*/

{

  double pbx, pby;

  double abx, aby;

  int i, j;

  int tot_pix = 0;

  int *prob_vector;

  int fro, to;

  int col;

  int valore;

  int padre;

  //  int  temp_prob, att_match;

  if (F_reference.n <= 0 || F_reference.array == 0) return false;

  pbx = pby = 0.0;

  abx = aby = 0.0;

  TRasterCM32P ras = imgToApply->getRaster();

  /* Resetta gli eventuali accoppiamenti fatti precedentemente */

  for (i = 0; i < F_reference.n; i++) F_reference.array[i].match = -1;

  if (F_work.array) {

    for (i = 0; i < F_work.n; i++) free_list(&F_work.array[i].vicini);

    free(F_work.array);

  }

  F_work.array = 0;

  F_work.size  = 0;

  F_work.n     = 0;

  F_work.lx    = 0;

  F_work.ly    = 0;

  scan_fabri_regions(ras, &F_work, 0, 0, 0, 0, 0);

  if (abs(F_work.lx * F_work.ly - F_reference.lx * F_reference.ly) >

      0.1 * (F_work.lx * F_work.ly + F_reference.lx * F_reference.ly))

    return false;

  for (i = 0; i < F_work.n; i++) {

    F_work.array[i].match = -1;

    pbx += BIG_TO_DOUBLE(F_work.array[i].bx);

    pby += BIG_TO_DOUBLE(F_work.array[i].by);

    abx = BIG_TO_DOUBLE(F_work.array[i].bx);

    aby = BIG_TO_DOUBLE(F_work.array[i].by);

    tot_pix += F_work.array[i].npix;

  }

  F_wor_bx = pbx / tot_pix;

  F_wor_by = pby / tot_pix;

  prob_vector = (int *)calloc(3 * F_work.n * F_reference.n, sizeof(int));

  for (i = 0; i < F_reference.n; i++)

    for (j = 0; j < F_work.n; j++) assign_prob3(prob_vector, i, j);

  Dx_f = Dx_f / F_reference.n;

  DP_f = DP_f / F_reference.n;

  Df_f = Df_f / F_reference.n;

  Dx_t = Dx_t / F_work.n;

  DP_t = DP_t / F_work.n;

  Df_t = Df_t / F_work.n;

#ifdef SELECTIVE

  if (selective) {

    // Accoppia non trasparenti

    for (i = 0; i < F_work.n; i++)

      if (F_work.array[i].color_id != 0) {

        temp_prob = 0;

        att_match = F_reference.n;

        /* Se non verra' aggiornato in seguito non verra' *

* comunque piu' cambiato di colore               */

        for (j = 0; j < F_reference.n; j++)

          if ((F_reference.array[i].match < 0) &&

              ((prob_vector[i * F_reference.n + j] / 1000.0) *

                   (prob_vector[i * F_reference.n + j] / 1000.0) *

                   (prob_vector[2 * (F_work.n * F_reference.n) +

                                i * F_reference.n + j] /

                    1500.0) >

               temp_prob)) {

            att_match = j;

            temp_prob = (prob_vector[i * F_reference.n + j] / 1000.0) *

                        (prob_vector[i * F_reference.n + j] / 1000.0) *

                        (prob_vector[2 * (F_work.n * F_reference.n) +

                                     i * F_reference.n + j] /

                         1500.0);

          }

        F_work.array[i].match = att_match;

        if (att_match < F_reference.n) F_reference.array[att_match].match = i;

      }

    /*--------------------------------------------------------------------------*/

  }

#endif

  bool recomputeBBox = false;

  FillParameters params;

  params.m_emptyOnly = selective;

  for (i = 0; i < F_reference.n && i < F_work.n; i++) {

    padre  = trova_migliore_padre(prob_vector, &fro);

    valore = match(prob_vector, padre, &fro, &to);

    if (valore > AMB_TRESH) {

      F_work.array[to].match       = fro;

      F_reference.array[fro].match = to;

      F_work.array[to].color_id    = F_reference.array[fro].color_id;

      if ((F_work.array[to].color_id != 0) && (valore != 0)) {

        params.m_p       = TPoint(F_work.array[to].x, F_work.array[to].y);

        params.m_styleId = F_work.array[to].color_id;

        TTileSaverCM32 tileSaver(ras, tileSet);

        recomputeBBox = fill(ras, params, &tileSaver) || recomputeBBox;

      }

    }

    /*..........................................................................*/

    /* Matching basato sulla probabilita' di colore */

    /*..........................................................................*/

    if (FALSE) {

      bool recomputeBBox = false;

      for (i = 0; i < F_work.n; i++) {

        if (F_work.array[i].match < 0) {

          find_best(prob_vector, &col, i);

          F_work.array[i].match    = 1;

          F_work.array[i].color_id = col;

          if (F_work.array[i].color_id != 0) {

            params.m_p       = TPoint(F_work.array[i].x, F_work.array[i].y);

            params.m_styleId = F_work.array[i].color_id;

            TTileSaverCM32 tileSaver(ras, tileSet);

            recomputeBBox = fill(ras, params, &tileSaver) || recomputeBBox;

          }

        }

      }

    }

  }

  free(prob_vector);

  return recomputeBBox;

}

/*-- end of apply_fabrizio --------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/* Scansione delle aree di Fabrizio                                          */

/*...........................................................................*/

static void scan_fabri_regions(TRasterCM32P ras,

                               struct s_fabri_region_list *rlst, int mode,

                               int ex1, int ey1, int ex2, int ey2)

/*---------------------------------------------------------------------------*/

{

  int firstfree;

  TPixelCM32 *pix;

  int xa, xb;

  int xp, x, y, x1, y1, x2, y2, tmp;

  int dx, dy, i, j, h, n, tone, maxtone;

  int rold, rcur, nold, ncur;

  int precedente;

  struct s_segm *row[2];

  int *ultima_zona;

  int region_id, region_old, keep, discard, vicina;

  bool border_tooX1, border_tooY1, border_tooX2, border_tooY2;

  x1           = ex1;

  x2           = ex2;

  y1           = ey1;

  y2           = ey2;

  TRect rect   = ras->getBounds();

  border_tooX1 = x1 == rect.x0;

  border_tooY1 = y1 == rect.y0;

  border_tooX2 = x2 == rect.x1;

  border_tooY2 = y2 == rect.y1;

  dx = x2 - x1 + 1;

  dy = y2 - y1 + 1;

  rlst->lx = dx;

  rlst->ly = dy;

  row[0]      = (struct s_segm *)calloc(dx, sizeof(struct s_segm));

  row[1]      = (struct s_segm *)calloc(dx, sizeof(struct s_segm));

  ultima_zona = (int *)calloc(dx, sizeof(int));

  rold        = 1;

  rcur        = 0;

  nold = ncur = 0;

  vicina      = -1;

  for (tmp = 0; tmp < dx; tmp++) ultima_zona[tmp] = -1;

  /*.. Inizializza la struttura

   * ...............................................*/

  rlst->size  = 100;

  rlst->array = (struct s_fabri_region *)calloc(rlst->size,

                                                sizeof(struct s_fabri_region));

  rlst->n   = 0;

  firstfree = -1;

  for (tmp = 0; tmp < rlst->size; tmp++) {

    rlst->array[tmp].vicini = NULL;

    rlst->array[tmp].holes  = 0;

  }

  /*...........................................................................*/

  for (y = y1; y <= y2; y++) {

    vicina = -1;

    pix    = ras->pixels(y) + x1;

    x      = x1;

    PRINTF("Cerca Area \n");

    while (x <= x2) {

      while (x <= x2 && pix->getTone() < pix->getMaxTone()) {

        pix++;

        x++;

      }              /*cerca una area */

      if (x <= x2) { /* non ho raggiunto il bordo */

        PRINTF("Prima del Bordo \n");

        xa      = x;

        maxtone = pix->getTone();

        xp      = x;

        while (x <= x2 && pix->getTone() >= pix->getMaxTone()) {

          tone = pix->getTone();

          if (tone > maxtone) {

            maxtone = tone;

            xp      = x;

          }

          pix++;

          x++;

        }

        xb = x - 1;

        PRINTF("Trovata Area \n");

        region_id = -1;

        for (j = 0; j < nold && row[rold][j].xa <= xb; j++) {

          if (row[rold][j].xb >= xa && row[rold][j].xa <= xb) {

            region_old = row[rold][j].region;

            if (region_id == region_old) rlst->array[region_id].holes++;

            if (region_id < 0) {

              region_id = region_old;

              rlst->array[region_id].per +=

                  2 * (xb - xa + 1) + 2 -

                  2 * (std::min(row[rold][j].xb, xb) -

                       std::max(row[rold][j].xa, xa) + 1);

            } else if (region_id != region_old) {

              /* CONTATTO FRA region_id E region_old */

              PRINTF("Contatto tra %d e %d \n", region_id, region_old);

              keep    = region_old;

              discard = region_id;

              if (keep > discard) {

                tmp     = keep;

                keep    = discard;

                discard = tmp;

              }

              /*.. UNISCO LE DUE REGIONI..................... */

              if (rlst->array[discard].x1 < rlst->array[keep].x1)

                rlst->array[keep].x1 = rlst->array[discard].x1;

              if (rlst->array[discard].y1 < rlst->array[keep].y1)

                rlst->array[keep].y1 = rlst->array[discard].y1;

              if (rlst->array[discard].x2 > rlst->array[keep].x2)

                rlst->array[keep].x2 = rlst->array[discard].x2;

              if (rlst->array[discard].y2 > rlst->array[keep].y2)

                rlst->array[keep].y2 = rlst->array[discard].y2;

              rlst->array[keep].holes += rlst->array[discard].holes;

              rlst->array[keep].npix += rlst->array[discard].npix;

              rlst->array[keep].per += rlst->array[discard].per -

                                       2 * (std::min(row[rold][j].xb, xb) -

                                            std::max(row[rold][j].xa, xa) + 1);

              fondi(rlst, keep, discard);

              ADD_BIG_BIG(rlst->array[keep].by, rlst->array[discard].by);

              ADD_BIG_BIG(rlst->array[keep].bx, rlst->array[discard].bx);

              ADD_BIG_BIG(rlst->array[keep].by2, rlst->array[discard].by2);

              ADD_BIG_BIG(rlst->array[keep].bx2, rlst->array[discard].bx2);

              if (rlst->array[keep].tone < rlst->array[discard].tone) {

                rlst->array[keep].x    = rlst->array[discard].x;

                rlst->array[keep].y    = rlst->array[discard].y;

                rlst->array[keep].tone = rlst->array[discard].tone;

              }

              /* OGNI RIFERIMENTO A 'discard' DIVENTA UN RIF.  A 'keep' */

              for (h = 0; h < nold; h++)

                if (row[rold][h].region == discard) row[rold][h].region = keep;

              for (h = 0; h < ncur; h++)

                if (row[rcur][h].region == discard) row[rcur][h].region = keep;

              region_id                                                 = keep;

              rinomina(discard, keep, rlst->n, rlst);

              for (tmp = 0; tmp < dx; tmp++)

                if (ultima_zona[tmp] == discard) ultima_zona[tmp] = keep;

              /* AGGIUNGO discard AL POOL DEI LIBERI */

              rlst->array[discard].active   = 0;

              rlst->array[discard].nextfree = firstfree;

              free_list(&rlst->array[discard].vicini);

              rlst->array[discard].vicini = NULL;

              firstfree = discard;

            } /* end elseif */

          }   /* end of if */

        }     /* end of for */

        PRINTF("Region ID %d %d %d %d \n", region_id, xa, xb, y);

        PRINTF("Memorizza Area \n");

        if (region_id >= 0) {

          rlst->array[region_id].lxb                                    = xb;

          rlst->array[region_id].lxa                                    = xa;

          if (xa < rlst->array[region_id].x1) rlst->array[region_id].x1 = xa;

          if (xb > rlst->array[region_id].x2) rlst->array[region_id].x2 = xb;

          if (y < rlst->array[region_id].y1) rlst->array[region_id].y1  = y;

          if (y > rlst->array[region_id].y2) rlst->array[region_id].y2  = y;

          rlst->array[region_id].npix += xb - xa + 1;

          ADD_BIG(rlst->array[region_id].by, (xb - xa + 1) * y);

          ADD_BIG(rlst->array[region_id].bx, (xb - xa + 1) * (xb + xa) / 2);

          ADD_BIG(rlst->array[region_id].by2, (xb - xa + 1) * y * y);

          ADD_BIG(rlst->array[region_id].bx2, somma_quadrati(xa, xb));

          if (rlst->array[region_id].tone < maxtone ||

              (rlst->array[region_id].x2 - rlst->array[region_id].x1) <

                  xb - xa) {

            rlst->array[region_id].x    = xp;

            rlst->array[region_id].y    = y;

            rlst->array[region_id].tone = maxtone;

          }

        } else {

          /* CREO UNA NUOVA REGIONE */

          if (firstfree < 0) {

            if (rlst->n >= rlst->size) {

              rlst->size += 50;

              rlst->array = (struct s_fabri_region *)realloc(

                  rlst->array, rlst->size * sizeof(struct s_fabri_region));

              for (tmp = rlst->size - 1; tmp >= rlst->size - 50; tmp--)

                rlst->array[tmp].vicini = NULL;

            }

            region_id = rlst->n++;

          } else {

            region_id = firstfree;

            firstfree = rlst->array[region_id].nextfree;

          }

          rlst->array[region_id].active   = 1;

          rlst->array[region_id].vicini   = NULL;

          rlst->array[region_id].nextfree = 0;

          rlst->array[region_id].x        = xp;

          rlst->array[region_id].y        = y;

          rlst->array[region_id].x1       = xa;

          rlst->array[region_id].y1       = y;

          rlst->array[region_id].x2       = xb;

          rlst->array[region_id].y2       = y;

          rlst->array[region_id].npix     = xb - xa + 1;

          rlst->array[region_id].holes    = 0;

          rlst->array[region_id].per      = 2 * (xb - xa + 1) + 2;

          rlst->array[region_id].lxb      = xb;

          rlst->array[region_id].lxa      = xa;

          ASS_BIG(rlst->array[region_id].by, (xb - xa + 1) * y);

          ASS_BIG(rlst->array[region_id].bx, (xb - xa + 1) * (xb + xa) / 2);

          ASS_BIG(rlst->array[region_id].by2, (xb - xa + 1) * y * y);

          ASS_BIG(rlst->array[region_id].bx2, somma_quadrati(xa, xb));

          rlst->array[region_id].tone     = maxtone;

          rlst->array[region_id].color_id = pix->getPaint();

        }

        /* MEMORIZZO LA REGIONE CORRENTE */

        precedente = -1;

        /*-----------------------------------------------------

.. Controlla se esiste vicinanza verticale ...........*/

        for (tmp = xa; tmp <= xb; tmp++) {

          if (ultima_zona[tmp - x1] != precedente) {

            aggiungi(ultima_zona[tmp - x1], region_id, rlst);

            precedente = ultima_zona[tmp - x1];

          }

          ultima_zona[tmp - x1] = region_id;

        }

        /*-----------------------------------------------------*/

        aggiungi(vicina, region_id, rlst);

        vicina = region_id;

        if (ncur >= dx - 1) {

          printf("autofill: row overflow dx=%d\n", dx);

          exit(1);

        }

        row[rcur][ncur].xa     = xa;

        row[rcur][ncur].xb     = xb;

        row[rcur][ncur].region = region_id;

        ncur++;

      } /* end of if#1 */

    }   /* end of while#1 */

    rcur = 1 - rcur;

    rold = 1 - rold;

    nold = ncur;

    ncur = 0;

  } /* end of for#1 */

  n = 0;

  /* mostra_vicini(rlst); */

  for (i = 0; i < rlst->n; i++)

    if ((rlst->array[i].active) && ((rlst->array[i].x1 > x1 || border_tooX1) &&

                                    (rlst->array[i].x2 < x2 || border_tooX2) &&

                                    (rlst->array[i].y1 > y1 || border_tooY1) &&

                                    (rlst->array[i].y2 < y2 || border_tooY2))) {

      if (n < i) {

        rlst->array[n]        = rlst->array[i];

        rlst->array[n].vicini = rlst->array[i].vicini;

        rinomina(i, n, rlst->n, rlst);

        for (tmp                                      = 0; tmp < dx; tmp++)

          if (ultima_zona[tmp] == i) ultima_zona[tmp] = n;

      }

      rlst->array[n].lx = rlst->array[n].x2 - rlst->array[n].x1 + 1;

      rlst->array[n].ly = rlst->array[n].y2 - rlst->array[n].y1 + 1;

      rlst->array[n].xm = (rlst->array[n].x2 + rlst->array[n].x1) / 2;

      rlst->array[n].ym = (rlst->array[n].y2 + rlst->array[n].y1) / 2;

      n++;

    } else

      rimuovi_tutti(i, rlst);

  /* mostra_vicini(rlst); */

  rlst->n = n;

  free(row[0]);

  free(row[1]);

  free(ultima_zona);

}

/*- end of scan_fabri_regions --------------------------------------------*/

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/*  Rinomina tutti i vicini regione1 in regione2                             */

/*...........................................................................*/

static void rinomina(int regione1, int regione2, int num_regioni,

                     struct s_fabri_region_list *rlst)

/*---------------------------------------------------------------------------*/

{

  struct vicine *appo, *old, appo1;

  int i;

  int trovato = FALSE;

  PRINTF("Rinomino %d %d Regioni: %d \n", regione1, regione2, num_regioni);

  /* mostra_vicini(rlst);  */

  for (i = 0; i < num_regioni; i++)

    if (rlst->array[i].active) {

      trovato = ((i == regione2) || (i == regione1));

      PRINTF(">> %d \n", i);

      old  = NULL;

      appo = rlst->array[i].vicini;

      while (appo != NULL) {

        if ((appo->region_id == regione2) || (appo->region_id == regione1)) {

          if (trovato)

            if (old != NULL) {

              PRINTF("A%d %d \n", i, appo->region_id);

              old->next = appo->next;

              free(appo);

              appo = old->next;

              /* mostra_vicini(rlst); */

            } else {

              PRINTF("B%d %d \n", i, appo->region_id);

              rlst->array[i].vicini = appo->next;

              appo1                 = *appo;

              free(appo);

              appo = appo1.next;

            }

          else /* non ho ancora trovato */

          {

            PRINTF("S%d \n", appo->region_id);

            appo->region_id = regione2;

            old             = appo;

            appo            = appo->next;

            trovato         = TRUE;

          }

        } else /* region_id non e' region2 o regione 1 */

        {

          PRINTF("D%d \n", appo->region_id);

          old  = appo;

          appo = appo->next;

        }

      }

    }

  PRINTF("Rinomino %d %d\n", regione1, regione2);

  /*   mostra_vicini(rlst);  */

}

/*- end of rinomina ---------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/* Aggiunge a regione2 il vicino regione1 e viceversa                        */

/*...........................................................................*/

static void aggiungi(int regione1, int regione2,

                     struct s_fabri_region_list *rlst)

/*---------------------------------------------------------------------------*/

{

  struct vicine *appo1, *appo2;

  /*  if((regione1==0)||(regione2==0)) */

  PRINTF("Aggiungo %d a %d\n", regione1, regione2);

  if ((regione1 != -1) && (regione2 != -1) && (regione2 != regione1)) {

    if (rlst->array[regione1].active) {

      appo1 = rlst->array[regione1].vicini;

      while ((appo1 != NULL) && (appo1->region_id != regione2))

        appo1 = appo1->next;

      if (appo1 == NULL) {

        appo1            = (struct vicine *)calloc(1, sizeof(struct vicine));

        appo1->next      = rlst->array[regione1].vicini;

        appo1->region_id = regione2;

        rlst->array[regione1].vicini = appo1;

      }

    }

    if (rlst->array[regione2].active) {

      appo2 = rlst->array[regione2].vicini;

      while ((appo2 != NULL) && (appo2->region_id != regione1))

        appo2 = appo2->next;

      if (appo2 == NULL) {

        appo2            = (struct vicine *)calloc(1, sizeof(struct vicine));

        appo2->next      = rlst->array[regione2].vicini;

        appo2->region_id = regione1;

        rlst->array[regione2].vicini = appo2;

      }

    }

  }

  PRINTF("Aggiunto %d a %d\n", regione1, regione2);

}

/*- end of aggiungi ---------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/

/*  Aggiunge i vicini di r2 a quelli di r1                                   */

/*...........................................................................*/

static void fondi(struct s_fabri_region_list *rlst, int r1, int r2)

/*---------------------------------------------------------------------------*/

{

  struct vicine *appo1, *appo2, *appo3;

  PRINTF("Fondi %d %d \n", r1, r2);

  /* mostra_vicini(rlst); */

  appo2 = rlst->array[r2].vicini;

  while (appo2 != NULL) {

    appo1 = rlst->array[r1].vicini;

    while ((appo1 != NULL) && (appo1->region_id != appo2->region_id) &&

           (appo2->region_id != r1))

      appo1 = appo1->next;

    if (appo1 == NULL) {

      appo3            = (struct vicine *)calloc(1, sizeof(struct vicine));

      appo3->next      = rlst->array[r1].vicini;

      appo3->region_id = appo2->region_id;

      rlst->array[r1].vicini = appo3;

      appo2                  = appo2->next;

    } else {

      appo2 = appo2->next;

    }

  }