spread.c

CA仿真模型中SLEUTH模型

                           pixel_value,                      /* IN     */
                           stat);                          /* IN/OUT */
  }
  FUNC_END;

  return status;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: spr_road_walk
** PURPOSE:       perform road walk
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static
    BOOLEAN
  spr_road_walk (int i_road_start,                           /* IN     */
                 int j_road_start,                           /* IN     */
                 int *i_road_end,                            /* OUT    */
                 int *j_road_end,                            /* OUT    */
                 GRID_P roads,                               /* IN     */
                 double diffusion_coefficient)             /* IN     */
{
  char func[] = "spr_road_walk";
  int i;
  int j;
  int i_nghbr;
  int j_nghbr;
  int k;
  BOOLEAN end_of_road;
  BOOLEAN spread = FALSE;
  int run_value;
  int run = 0;

  FUNC_INIT;
  assert (i_road_end != NULL);
  assert (j_road_end != NULL);
  assert (roads != NULL);

  i = i_road_start;
  j = j_road_start;
  end_of_road = FALSE;
  while (!end_of_road)
  {
    end_of_road = TRUE;
    util_get_next_neighbor (i, j, &i_nghbr, &j_nghbr, RANDOM_INT (8));
    for (k = 0; k < 8; k++)
    {
      if (IMAGE_PT (i_nghbr, j_nghbr))
      {
        if (roads[OFFSET (i_nghbr, j_nghbr)])
        {
          end_of_road = FALSE;
          run++;
          i = i_nghbr;
          j = j_nghbr;
          break;
        }
      }
      util_get_next_neighbor (i, j, &i_nghbr, &j_nghbr, -1);
    }
    run_value = (int) (roads[OFFSET (i, j)] / MAX_ROAD_VALUE *
                       diffusion_coefficient);
    if (run > run_value)
    {
      end_of_road = TRUE;
      spread = TRUE;
      (*i_road_end) = i;
      (*j_road_end) = j;
    }
  }
  FUNC_END;
  return spread;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: spr_road_search
** PURPOSE:       perform road search
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static
    BOOLEAN
  spr_road_search (int i_grwth_center,                       /* IN     */
                   int j_grwth_center,                       /* IN     */
                   int *i_road,                              /* OUT    */
                   int *j_road,                              /* OUT    */
                   int max_search_index,                     /* IN     */
                   GRID_P roads)                           /* IN     */
{
  char func[] = "spr_road_search";
  int i;
  int j;
  int i_offset;
  int j_offset;
  BOOLEAN road_found = FALSE;
  int srch_index;

  FUNC_INIT;
  assert (i_road != NULL);
  assert (j_road != NULL);
  assert (max_search_index >= 0);

  for (srch_index = 0; srch_index < max_search_index; srch_index++)
  {
    spr_spiral (srch_index, &i_offset, &j_offset);
    i = i_grwth_center + i_offset;
    j = j_grwth_center + j_offset;

    if (IMAGE_PT (i, j))
    {
      if (roads[OFFSET (i, j)])
      {
        road_found = TRUE;
        (*i_road) = i;
        (*j_road) = j;
        break;
      }
    }
  }

  FUNC_END;
  return road_found;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: spr_spiral
** PURPOSE:       generate spiral search pattern
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  spr_spiral (int index,                                     /* IN     */
              int *i_out,                                    /* OUT    */
              int *j_out)                                  /* OUT    */
{
  char func[] = "spr_spiral";
  BOOLEAN bn_found;
  int i;
  int j;
  int bn;
  int bo;
  int total;
  int left_side_len;
  int right_side_len;
  int top_len;
  int bot_len;
  int range1;
  int range2;
  int range3;
  int range4;
  int region_offset;
  int nrows;
  int ncols;

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


  FUNC_INIT;
  assert (i_out != NULL);
  assert (j_out != NULL);

  bn_found = FALSE;
  for (bn = 1; bn < MAX (ncols, nrows); bn++)
  {
    total = 8 * ((1 + bn) * bn) / 2;
    if (total > index)
    {
      bn_found = TRUE;
      break;
    }
  }
  if (!bn_found)
  {
    sprintf (msg_buf, "Unable to find road search band, bn.");
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  bo = index - 8 * ((bn - 1) * bn) / 2;
  left_side_len = right_side_len = bn * 2 + 1;
  top_len = bot_len = bn * 2 - 1;
  range1 = left_side_len;
  range2 = left_side_len + bot_len;
  range3 = left_side_len + bot_len + right_side_len;
  range4 = left_side_len + bot_len + right_side_len + top_len;
  if (bo < range1)
  {
    region_offset = bo % range1;
    i = -bn + region_offset;
    j = -bn;
  }
  else if (bo < range2)
  {
    region_offset = (bo - range1) % range2;
    i = bn;
    j = -bn + 1 + region_offset;
  }
  else if (bo < range3)
  {
    region_offset = (bo - range2) % range3;
    i = bn - region_offset;
    j = bn;
  }
  else if (bo < range4)
  {
    region_offset = (bo - range3) % range4;
    i = -bn;
    j = bn - 1 - region_offset;
  }
  else
  {
    sprintf (msg_buf, "Unable to calculate (i,j) for road search");
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  *i_out = i;
  *j_out = j;
  FUNC_END;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: spr_spread
** PURPOSE:       main spread routine
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  spr_spread (
               float *average_slope,                         /* OUT    */
               int *num_growth_pix,                          /* OUT    */
               int *sng,
               int *sdc,
               int *og,
               int *rt,
               int *pop,
               GRID_P z                                      /* IN/OUT */
  )                                                        /* MOD    */
{
  char func[] = "Spread";
  GRID_P delta;
  int i;
  int total_pixels;
  int nrows;
  int ncols;
  double road_gravity;
  COEFF_TYPE diffusion_coefficient;
  COEFF_TYPE breed_coefficient;
  COEFF_TYPE spread_coefficient;
  GRID_P excld;
  GRID_P roads;
  GRID_P slp;
  GRID_P scratch_gif1;
  GRID_P scratch_gif3;
  SWGHT_TYPE swght[SLOPE_WEIGHT_ARRAY_SZ];

  road_gravity = coeff_GetCurrentRoadGravity ();
  diffusion_coefficient = coeff_GetCurrentDiffusion ();
  breed_coefficient = coeff_GetCurrentBreed ();
  spread_coefficient = coeff_GetCurrentSpread ();

  scratch_gif1 = mem_GetWGridPtr (__FILE__, func, __LINE__);
  scratch_gif3 = mem_GetWGridPtr (__FILE__, func, __LINE__);

  excld = igrid_GetExcludedGridPtr (__FILE__, func, __LINE__);
  roads = igrid_GetRoadGridPtrByYear (__FILE__, func,
                                      __LINE__, proc_GetCurrentYear ());
  slp = igrid_GetSlopeGridPtr (__FILE__, func, __LINE__);
  FUNC_INIT;
  assert (road_gravity > 0.0);
  assert (diffusion_coefficient > 0.0);
  assert (breed_coefficient > 0.0);
  assert (spread_coefficient > 0.0);
  assert (z != NULL);
  assert (excld != NULL);
  assert (roads != NULL);
  assert (slp != NULL);
  assert (scratch_gif1 != NULL);
  assert (scratch_gif3 != NULL);

  total_pixels = mem_GetTotalPixels ();
  nrows = igrid_GetNumRows ();
  ncols = igrid_GetNumCols ();

  assert (total_pixels > 0);
  assert (nrows > 0);
  assert (ncols > 0);


  /*
   *
   * SET UP WORKSPACE
   *
   */
  delta = scratch_gif1;

  /*
   *
   * ZERO THE GROWTH ARRAY FOR THIS TIME PERIOD
   *
   */
  util_init_grid (delta, 0);

  /*
   *
   * GET SLOPE RATES
   *
   */
  spr_get_slp_weights (SLOPE_WEIGHT_ARRAY_SZ,                /* IN     */
                       swght);                             /* OUT    */

  /*
   *
   * PHASE 1N3 - SPONTANEOUS NEIGHBORHOOD GROWTH AND SPREADING
   *
   */


  timer_Start (SPR_PHASE1N3);
  spr_phase1n3 (diffusion_coefficient,                       /* IN     */
                breed_coefficient,                           /* IN     */
                z,                                           /* IN     */
                delta,                                       /* IN/OUT */
                slp,                                         /* IN     */
                excld,                                       /* IN     */
                swght,                                       /* IN     */
                sng,                                         /* IN/OUT */
                sdc);                                      /* IN/OUT */
  timer_Stop (SPR_PHASE1N3);

  /*
   *
   * PHASE 4 - ORGANIC GROWTH
   *
   */
  timer_Start (SPR_PHASE4);
  spr_phase4 (spread_coefficient,                            /* IN     */
              z,                                             /* IN     */
              excld,                                         /* IN     */
              delta,                                         /* IN/OUT */
              slp,                                           /* IN     */
              swght,                                         /* IN     */
              og);                                         /* IN/OUT */
  timer_Stop (SPR_PHASE4);

  /*
   *
   * PHASE 5 - ROAD INFLUENCE GROWTH
   *
   */
  timer_Start (SPR_PHASE5);
  spr_phase5 (road_gravity,                                  /* IN     */
              diffusion_coefficient,                         /* IN     */
              breed_coefficient,                             /* IN     */
              z,                                             /* IN     */
              delta,                                         /* IN/OUT */
              slp,                                           /* IN     */
              excld,                                         /* IN     */
              roads,                                         /* IN     */
              swght,                                         /* IN     */
              rt,                                            /* IN/OUT */
              scratch_gif3);                               /* MOD    */
  timer_Stop (SPR_PHASE5);

  util_condition_gif (total_pixels,                          /* IN     */
                      delta,                                 /* IN     */
                      GT,                                    /* IN     */
                      PHASE5G,                               /* IN     */
                      delta,                                 /* IN/OUT */
                      0);                                  /* IN     */

  util_condition_gif (total_pixels,                          /* IN     */
                      excld,                                 /* IN     */
                      GE,                                    /* IN     */
                      100,                                   /* IN     */
                      delta,                                 /* IN/OUT */
                      0);                                  /* IN     */

  /* now place growth array into current array */
  (*num_growth_pix) = 0;
  (*average_slope) = 0.0;

  for (i = 0; i < total_pixels; i++)
  {
    if ((z[i] == 0) && (delta[i] > 0))
    {
      /* new growth being placed into array */
      (*average_slope) += (float) slp[i];
      z[i] = delta[i];
      (*num_growth_pix)++;
    }
  }
  *pop = util_count_pixels (total_pixels, z, GE, PHASE0G);

  if (*num_growth_pix == 0)
  {
    *average_slope = 0.0;
  }
  else
  {
    *average_slope /= (float) *num_growth_pix;
  }

  roads = igrid_GridRelease (__FILE__, func, __LINE__, roads);
  excld = igrid_GridRelease (__FILE__, func, __LINE__, excld);
  slp = igrid_GridRelease (__FILE__, func, __LINE__, slp);
  scratch_gif1 = mem_GetWGridFree (__FILE__, func, __LINE__, scratch_gif1);
  scratch_gif3 = mem_GetWGridFree (__FILE__, func, __LINE__, scratch_gif3);
  FUNC_END;
}