deltatron.c

来自「CA仿真模型中SLEUTH模型」· C语言 代码 · 共 555 行 · 第 1/2 页

#define DELTATRON_MODULE

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "igrid_obj.h"
#include "landclass_obj.h"
#include "globals.h"
#include "random.h"
#include "utilities.h"
#include "ugm_macros.h"
#include "memory_obj.h"
#include "timer_obj.h"
#include "proc_obj.h"
#include "gdif_obj.h"
#include "color_obj.h"
#include "scenario_obj.h"
#include "pgrid_obj.h"

/*****************************************************************************\
*******************************************************************************
**                                                                           **
**                                 MACROS                                    **
**                                                                           **
*******************************************************************************
\*****************************************************************************/
#define TRANS_PROBABILITY1(arg1,arg2)                  \
    ftransition[TRANS_OFFSET(                          \
       new_indices[urban_land[OFFSET((arg1),(arg2))]], \
       new_indices[new_landuse])]

#define TRANS_PROBABILITY2(arg1,arg2,arg3,arg4)                    \
   ftransition[TRANS_OFFSET(                                       \
     new_indices[phase2_land[OFFSET((arg1),(arg2))]],              \
     new_indices[urban_land[OFFSET((arg3),(arg4))]])]*             \
     DELTA_PHASE2_SENSITIVITY


/*****************************************************************************\
*******************************************************************************
**                                                                           **
**                        STATIC FUNCTION PROTOTYPES                         **
**                                                                           **
*******************************************************************************
\*****************************************************************************/
static
  void delta_phase1 (int drive,                              /* IN     */
                     GRID_P urban_land,                      /* IN     */
                     GRID_P phase1_land,                     /* OUT    */
                     GRID_P slope,                           /* IN     */
                     GRID_P deltatron,                       /* IN/OUT */
                     Classes * landuse_classes,              /* IN     */
                     Classes * class_indices,                /* IN     */
                     int *new_indices,                       /* IN     */
                     CLASS_SLP_TYPE * class_slope,           /* IN     */
                     FTRANS_TYPE * ftransition);           /* IN     */
static
  int delta_get_new_landuse (Classes * class_indices,        /* IN     */
                             Classes * landuse_classes,      /* IN     */
                             PIXEL local_slope,              /* IN     */
                             CLASS_SLP_TYPE * class_slope); /* IN     */
static
  void delta_phase2 (GRID_P urban_land,                      /* IN     */
                     GRID_P phase1_land,                     /* IN     */
                     GRID_P deltatron,                       /* IN/OUT */
                     GRID_P phase2_land,                     /* OUT    */
                     Classes * landuse_classes,              /* IN     */
                     int *new_indices,                       /* IN     */
                     FTRANS_TYPE * ftransition);           /* IN     */

/*****************************************************************************\
*******************************************************************************
**                                                                           **
**                               SCCS ID                                     **
**                                                                           **
*******************************************************************************
\*****************************************************************************/
char deltatron_c_sccs_id[] = "@(#)deltatron.c	1.372	12/4/00";

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: delta_deltatron
** PURPOSE:       main driver which calls delta_phase1 & delta_phase2
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  delta_deltatron (int *new_indices,                         /* IN     */
                   Classes * landuse_classes,                /* IN     */
                   Classes * class_indices,                  /* IN     */
                   GRID_P workspace1,                        /* MOD    */
                   GRID_P deltatron,                         /* IN/OUT */
                   GRID_P urban_land,                        /* IN     */
                   GRID_P land_out,                          /* OUT    */
                   GRID_P slp,                               /* IN     */
                   int drive,                                /* IN     */
                   CLASS_SLP_TYPE * class_slope,             /* IN     */
                   FTRANS_TYPE * ftransition)              /* IN     */
{
  char func[] = "DeltaTron";
  GRID_P phase1_land;
  GRID_P phase2_land;


  timer_Start (DELTA_DELTATRON);
  FUNC_INIT;
  assert (new_indices != NULL);
  assert (landuse_classes != NULL);
  assert (class_indices != NULL);
  assert (workspace1 != NULL);
  assert (urban_land != NULL);
  assert (land_out != NULL);
  assert (slp != NULL);
  assert (class_slope != NULL);
  assert (ftransition != NULL);

  phase1_land = workspace1;
  phase2_land = land_out;

  delta_phase1 (drive,                                       /* IN     */
                urban_land,                                  /* IN     */
                phase1_land,                                 /* OUT    */
                slp,                                         /* IN     */
                deltatron,                                   /* IN/OUT */
                landuse_classes,                             /* IN     */
                class_indices,                               /* IN     */
                new_indices,                                 /* IN     */
                class_slope,                                 /* IN     */
                ftransition                                  /* IN     */
    );

  delta_phase2 (urban_land,                                  /* IN     */
                phase1_land,                                 /* IN     */
                deltatron,                                   /* IN/OUT */
                phase2_land,                                 /* OUT    */
                landuse_classes,                             /* IN     */
                new_indices,                                 /* IN     */
                ftransition                                  /* IN     */
    );

  timer_Stop (DELTA_DELTATRON);
  FUNC_END;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: delta_phase1
** PURPOSE:       performs deltatron phase 1 growth
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/

static
  void
  delta_phase1 (int drive,                                   /* IN     */
                GRID_P urban_land,                           /* IN     */
                GRID_P phase1_land,                          /* OUT    */
                GRID_P slope,                                /* IN     */
                GRID_P deltatron,                            /* IN/OUT */
                Classes * landuse_classes,                   /* IN     */
                Classes * class_indices,                     /* IN     */
                int *new_indices,                            /* IN     */
                CLASS_SLP_TYPE * class_slope,                /* IN     */
                FTRANS_TYPE * ftransition)                 /* IN     */
{
  char func[] = "delta_phase1";
  int index;
  int i;
  int j;
  int k;
  int l;
  int i_center;
  int j_center;
  PIXEL new_landuse;
  int random_int;

  timer_Start (DELTA_PHASE1);
  FUNC_INIT;
  assert (drive >= 0);
  assert (urban_land != NULL);
  assert (phase1_land != NULL);
  assert (slope != NULL);
  assert (deltatron != NULL);
  assert (landuse_classes != NULL);
  assert (class_indices != NULL);
  assert (new_indices != NULL);
  assert (class_slope != NULL);
  assert (ftransition != NULL);

  /*
   *
   * COPY INPUT LAND GRID INTO OUTPUT LAND GRID
   *
   */
  util_copy_grid (urban_land, phase1_land);

  /*
   *
   * TRY DRIVE TIMES TO MAKE TRANSITIONS
   *
   */
  for (k = 0; k < drive; k++)
  {
    /*
     *
     * SELECT A TRANSITION PIXEL TO BE CENTER OF SPREADING CLUSTER
     *
     */
    do
    {
      i_center = RANDOM_ROW;
      j_center = RANDOM_COL;
      index = new_indices[urban_land[OFFSET (i_center, j_center)]];
    }
    while (landuse_classes[index].trans == FALSE);
    /*
     *
     * RANDOMLY CHOOSE NEW LANDUSE NUMBER
     *
     */
    new_landuse =
      delta_get_new_landuse (class_indices,                  /* IN    */
                             landuse_classes,                /* IN    */
                             slope[OFFSET (i_center, j_center)],   /* IN    */
                             class_slope);                 /* IN    */

    /*
     *
     * TEST TRANSITION PROBABILITY FOR NEW CLUSTER
     *
     */
    if (RANDOM_FLOAT < TRANS_PROBABILITY1 (i_center, j_center))
    {
      /*
       *
       * TRANSITION THE CENTER PIXEL
       *
       */
      phase1_land[OFFSET (i_center, j_center)] = new_landuse;
      deltatron[OFFSET (i_center, j_center)] = 1;

      /*
       *
       * TRY BUILDING UP CLUSTER AROUND THIS CENTER PIXEL
       *
       */
      i = i_center;
      j = j_center;
      for (l = 0; l < REGION_SIZE; l++)
      {

        /*
         *
         * OCCASIONALLY RESET TO CENTER OF CLUSTER
         *
         */
        random_int = RANDOM_INT (8);
        if (random_int == 7)
        {
          i = i_center;
          j = j_center;
        }
        /*
         *
         * GET A NEIGHBOR
         *
         */
        util_get_neighbor (i, j, &i, &j);
        if (IMAGE_PT (i, j))