spread.c

CA仿真模型中SLEUTH模型

  {
    for (iii = 0; iii < 1 + (int) (breed_coefficient); iii++)
    {
      /*
       *
       * DETERMINE THE MAX INDEX INTO THE GLB_RD_SEARCH_INDICES ARRAY
       * for road_gravity of 1 we have  8 values
       * for road_gravity of 2 we have 16 values
       * for road_gravity of 3 we have 24 values
       *    and so on....
       *
       * if we need to cover N road_gravity values, then total number of 
       * indexed values would be
       * 8 + 16 + 24 + ... + 8*N = 8*(1+2+3+...+N) = 8*(N(1+N))/2
       *
       */
      int_road_gravity = spr_GetRoadGravValue (road_gravity);
      max_search_index = 4 * (int_road_gravity * (1 + int_road_gravity));
      max_search_index = MAX (max_search_index, nrows);
      max_search_index = MAX (max_search_index, ncols);

      /*
       *
       * RANDOMLY SELECT A GROWTH PIXEL TO START SEARCH
       * FOR ROAD
       *
       */
      growth_index = (int) ((double) growth_count * RANDOM_FLOAT);

      /*
       *
       * SEARCH FOR ROAD ABOUT THIS GROWTH POINT
       *
       */
      road_found =
        spr_road_search (growth_row[growth_index],
                         growth_col[growth_index],
                         &i_rd_start,
                         &j_rd_start,
                         max_search_index,
                         roads);

      /*
       *
       * IF THERE'S A ROAD FOUND THEN WALK ALONG IT
       *
       */
      if (road_found)
      {
        spread = spr_road_walk (i_rd_start,                  /* IN     */
                                j_rd_start,                  /* IN     */
                                &i_rd_end,                   /* OUT    */
                                &j_rd_end,                   /* OUT    */
                                roads,                       /* IN     */
                                diffusion_coefficient);    /* IN     */

        if (spread == TRUE)
        {
          urbanized =
            spr_urbanize_nghbr (i_rd_end,                    /* IN     */
                                j_rd_end,                    /* IN     */
                                &i_rd_end_nghbr,             /* OUT    */
                                &j_rd_end_nghbr,             /* OUT    */
                                z,                           /* IN     */
                                delta,                       /* IN/OUT */
                                slp,                         /* IN     */
                                excld,                       /* IN     */
                                swght,                       /* IN     */
                                PHASE5G,                     /* IN     */
                                rt);                       /* IN/OUT */
          if (urbanized)
          {
            max_tries = 3;
            for (tries = 0; tries < max_tries; tries++)
            {
              urbanized =
                spr_urbanize_nghbr (i_rd_end_nghbr,          /* IN     */
                                    j_rd_end_nghbr,          /* IN     */
                                    &i_rd_end_nghbr_nghbr,   /* OUT    */
                                    &j_rd_end_nghbr_nghbr,   /* OUT    */
                                    z,                       /* IN     */
                                    delta,                   /* IN/OUT */
                                    slp,                     /* IN     */
                                    excld,                   /* IN     */
                                    swght,                   /* IN     */
                                    PHASE5G,                 /* IN     */
                                    rt);                   /* IN/OUT */

            }
          }
        }
      }
    }
  }
  FUNC_END;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: spr_get_slp_weights
** PURPOSE:       calculate the slope weights
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  spr_get_slp_weights (int array_size,                       /* IN     */
                       SWGHT_TYPE * lut)                   /* OUT    */
{
  char func[] = "spr_get_slp_weights";
  float val;
  float exp;
  int i;

  FUNC_INIT;
  assert (lut != NULL);

  exp = coeff_GetCurrentSlopeResist () / (MAX_SLOPE_RESISTANCE_VALUE / 2.0);
  for (i = 0; i < array_size; i++)
  {
    if (i < scen_GetCriticalSlope ())
    {
      val = (scen_GetCriticalSlope () - (SWGHT_TYPE) i) / scen_GetCriticalSlope ();
      lut[i] = 1.0 - pow (val, exp);
    }
    else
    {
      lut[i] = 1.0;
    }
  }
  if (scen_GetLogFlag ())
  {
    if (scen_GetLogSlopeWeightsFlag ())
    {
      scen_Append2Log ();
      spr_LogSlopeWeights (scen_GetLogFP (), array_size, lut);
      scen_CloseLog ();
    }
  }
  FUNC_END;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: spr_LogSlopeWeights
** PURPOSE:       log slope weights to FILE * fp
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  spr_LogSlopeWeights (FILE * fp, int array_size, SWGHT_TYPE * lut)
{
  int i;

  assert (fp != NULL);
  assert (array_size > 0);
  assert (lut != NULL);

  fprintf (fp, "\n%s %5u ***** LOG OF SLOPE WEIGHTS *****\n",
           __FILE__, __LINE__);
  fprintf (fp, "%s %5u CRITICAL_SLOPE= %f\n",
           __FILE__, __LINE__, scen_GetCriticalSlope ());
  fprintf (fp, "%s %5u coeff_GetCurrentSlopeResist= %f\n",
           __FILE__, __LINE__, coeff_GetCurrentSlopeResist ());
  fprintf (fp, "%s %5u MAX_SLOPE_RESISTANCE_VALUE= %f\n",
           __FILE__, __LINE__, MAX_SLOPE_RESISTANCE_VALUE);
  for (i = 0; i < array_size; i++)
  {
    if (i < scen_GetCriticalSlope ())
    {
      fprintf (fp, "%s %5u lut[%3u]= %f\n",
               __FILE__, __LINE__, i, lut[i]);
    }
  }
  fprintf (fp, "All values other values to lut[%u] = 1.000000\n", array_size);

}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: spr_GetDiffusionValue
** PURPOSE:       calculate the diffusion value
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static COEFF_TYPE
  spr_GetDiffusionValue (COEFF_TYPE diffusion_coeff)
{

  COEFF_TYPE diffusion_value;
  double rows_sq;
  double cols_sq;

  rows_sq = igrid_GetNumRows () * igrid_GetNumRows ();
  cols_sq = igrid_GetNumCols () * igrid_GetNumCols ();

  /*
   * diffusion_value's MAXIMUM (IF diffusion_coeff == 100)
   * WILL BE 5% OF THE IMAGE DIAGONAL. 
   */

  diffusion_value = ((diffusion_coeff * 0.005) * sqrt (rows_sq + cols_sq));
  return diffusion_value;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: spr_GetRoadGravValue
** PURPOSE:       calculate the road gravity value
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static COEFF_TYPE
  spr_GetRoadGravValue (COEFF_TYPE rg_coeff)
{

  int rg_value;
  int row;
  int col;

  row = igrid_GetNumRows ();
  col = igrid_GetNumCols ();

  /*
   * rg_value's MAXIMUM (IF rg_coeff == 100)
   * WILL BE 1/16 OF THE IMAGE DIMENSIONS. 
   */

  rg_value = (rg_coeff / MAX_ROAD_VALUE) * ((row + col) / 16.0);

  return rg_value;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: spr_urbanize
** PURPOSE:       try to urbanize a pixel
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static BOOLEAN
  spr_urbanize (int row,                                     /* IN     */
                int col,                                     /* IN     */
                GRID_P z,                                    /* IN     */
                GRID_P delta,                                /* IN/OUT */
                GRID_P slp,                                  /* IN     */
                GRID_P excld,                                /* IN     */
                SWGHT_TYPE * swght,                          /* IN     */
                PIXEL pixel_value,                           /* IN     */
                int *stat)                                 /* IN/OUT */
{
  char func[] = "spr_urbanize";
  BOOLEAN val;
  int nrows;
  int ncols;

  nrows = igrid_GetNumRows ();
  ncols = igrid_GetNumCols ();
  assert (nrows > 0);
  assert (ncols > 0);

  FUNC_INIT;
  assert ((row >= 0) && (row < nrows));
  assert ((col >= 0) && (col < ncols));
  assert (z != NULL);
  assert (delta != NULL);
  assert (slp != NULL);
  assert (excld != NULL);
  assert (swght != NULL);
  assert (stat != NULL);


  val = FALSE;
  if (z[OFFSET ((row), (col))] == 0)
  {
    if (delta[OFFSET ((row), (col))] == 0)
    {
      if (RANDOM_FLOAT > swght[slp[OFFSET ((row), (col))]])
      {
        if (excld[OFFSET ((row), (col))] < RANDOM_INT (100))
        {
          val = TRUE;
          delta[OFFSET (row, col)] = pixel_value;
          (*stat)++;
          stats_IncrementUrbanSuccess ();
        }
        else
        {
          stats_IncrementEcludedFailure ();
        }
      }
      else
      {
        stats_IncrementSlopeFailure ();
      }
    }
    else
    {
      stats_IncrementDeltaFailure ();
    }
  }
  else
  {
    stats_IncrementZFailure ();
  }

  FUNC_END;


  return val;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: spr_get_neighbor
** PURPOSE:       find a neighboring pixel
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static
  void
  spr_get_neighbor (int i_in,                                /* IN     */
                    int j_in,                                /* IN     */
                    int *i_out,                              /* OUT    */
                    int *j_out)                            /* OUT    */
{
  char func[] = "spr_get_neighbor";
  int i;
  int j;
  int k;
  int nrows;
  int ncols;

  nrows = igrid_GetNumRows ();
  ncols = igrid_GetNumCols ();
  assert (nrows > 0);
  assert (ncols > 0);

  FUNC_INIT;
  assert (nrows > i_in);
  assert (ncols > j_in);
  assert (0 <= i_in);
  assert (0 <= j_in);
  assert (i_out != NULL);
  assert (j_out != NULL);

  util_get_next_neighbor (i_in, j_in, i_out, j_out, RANDOM_INT (8));
  for (k = 0; k < 8; k++)
  {
    i = (*i_out);
    j = (*j_out);
    if (IMAGE_PT (i, j))
    {
      break;
    }
    util_get_next_neighbor (i_in, j_in, i_out, j_out, -1);
  }
  FUNC_END;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: spr_urbanize_nghbr
** PURPOSE:       try to urbanize a neighbor
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static
    BOOLEAN
  spr_urbanize_nghbr (int i,                                 /* IN     */
                      int j,                                 /* IN     */
                      int *i_nghbr,                          /* OUT    */
                      int *j_nghbr,                          /* OUT    */
                      GRID_P z,                              /* IN     */
                      GRID_P delta,                          /* IN/OUT */
                      GRID_P slp,                            /* IN     */
                      GRID_P excld,                          /* IN     */
                      SWGHT_TYPE * swght,                    /* IN     */
                      PIXEL pixel_value,                     /* IN     */
                      int *stat)                           /* IN/OUT */
{
  char func[] = "spr_urbanize_nghbr";
  BOOLEAN status = FALSE;

  FUNC_INIT;
  assert (i_nghbr != NULL);
  assert (j_nghbr != NULL);
  assert (z != NULL);
  assert (delta != NULL);
  assert (slp != NULL);
  assert (excld != NULL);
  assert (swght != NULL);
  assert (stat != NULL);

  if (IMAGE_PT (i, j))
  {
    spr_get_neighbor (i,                                     /* IN    */
                      j,                                     /* IN    */
                      i_nghbr,                               /* OUT   */
                      j_nghbr);                            /* OUT   */

    status = spr_urbanize ((*i_nghbr),                       /* IN     */
                           (*j_nghbr),                       /* IN     */
                           z,                                /* IN     */
                           delta,                            /* IN/OUT */
                           slp,                              /* IN     */
                           excld,                            /* IN     */
                           swght,                            /* IN     */