igrid_obj.c

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

  igrid_ValidateLanduseGrids (FILE * fp)
{
  char func[] = "igrid_ValidateLanduseGrids";
  BOOLEAN rv = TRUE;
  int i;
  int j;

  for (i = 0; i < igrid.landuse_count; i++)
  {
    if (fp)
    {
      fprintf (fp, "\nValidating landuse input grid: %s\n",
               igrid.landuse[i].filename);
      fprintf (fp, "\nIndex Count PercentOfImage\n");
    }
    for (j = 0; j < 256; j++)
    {
      if (igrid.landuse[i].histogram[j] > 0)
      {
        if (fp)
        {
          fprintf (fp, "%3u  %5u  %8.2f%%\n", j, igrid.landuse[i].histogram[j],
                   100.0 * igrid.landuse[i].histogram[j] / total_pixels);
        }
        if (!landclass_IsAlandclass (j))
        {
          rv = FALSE;
          sprintf (msg_buf, "landuse type %u appears in file: %s",
                   j, igrid.landuse[i].filename);
          LOG_ERROR (msg_buf);
        }
      }
    }
  }
  return rv;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_ValidateSlopeGrid
** PURPOSE:       check validity of slope grid values
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:   could not think of good validity check!!!
**
**
*/
static BOOLEAN
  igrid_ValidateSlopeGrid (FILE * fp)
{
  if (fp)
  {
    fprintf (fp, "\nValidating slope input grid: %s\n", igrid.slope.filename);
  }
  return TRUE;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_ValidateExcludedGrid
** PURPOSE:       check validity of excluded grid values
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:   could not think of good validity check!!!
**
**
*/
static BOOLEAN
  igrid_ValidateExcludedGrid (FILE * fp)
{
  if (fp)
  {
    fprintf (fp, "\nValidating excluded input grid: %s\n",
             igrid.excluded.filename);
  }
  return TRUE;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_ValidateBackgroundGrid
** PURPOSE:       check validity of background grid values
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:   could not think of good validity check!!!
**
**
*/
static BOOLEAN
  igrid_ValidateBackgroundGrid (FILE * fp)
{
  if (fp)
  {
    fprintf (fp, "\nValidating background input grid: %s\n",
             igrid.background.filename);
  }
  return TRUE;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_ReadGrid
** PURPOSE:       read input grid
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  igrid_ReadGrid (char *filepath, GRID_P scratch_pad, GRID_P grid_ptr)
{
#ifndef lint
  char func[] = "igrid_ReadGrid";
#endif
  char *filename;

  EXTRACT_FILENAME (filepath);
  if (scratch_pad != NULL)
  {
    if (glb_mype == 0)
    {
      gdif_ReadGIF (scratch_pad, filepath);
    }
#ifdef MPI
    MPI_Bcast (scratch_pad, memGetBytesPerGridRound (),
               MPI_BYTE, 0, MPI_COMM_WORLD);
#endif
    if (glb_mype == 0)
    {
      if (scen_GetEchoImageFlag ())
      {
        igrid_echo_input (scratch_pad, filename);
      }
    }
#ifdef PACKING
    _pack (scratch_pad, (char *) grid_ptr,
           mem_GetTotalPixels (), -1);
#else
    sprintf (msg_buf, "PACKING not defined");
    LOG_ERROR (msg_buf);
    exit (1);
#endif
  }
  else
  {
    if (glb_mype == 0)
    {
      gdif_ReadGIF (grid_ptr, filepath);
    }
#ifdef MPI
    MPI_Bcast (grid_ptr, memGetBytesPerGridRound (),
               MPI_BYTE, 0, MPI_COMM_WORLD);
#endif
    if (glb_mype == 0)
    {
      if (scen_GetEchoImageFlag ())
      {
        igrid_echo_input (grid_ptr, filename);
      }
    }
  }
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_ReadFiles
** PURPOSE:       read input grids
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  igrid_ReadFiles ()
{
  char func[] = "igrid_ReadFiles";
  int i;
  GRID_P scratch_pad = NULL;
#ifdef PACKING
  scratch_pad = mem_GetWGridPtr (__FILE__, func, __LINE__);
  assert (scratch_pad != NULL);
#endif


  for (i = 0; i < igrid.urban_count; i++)
  {
    igrid.urban[i].ptr = mem_GetIGridPtr (func);
    igrid_ReadGrid (igrid.urban[i].filename,
                    scratch_pad, igrid.urban[i].ptr);
    grid_SetMinMax (&igrid.urban[i]);
    grid_histogram (&igrid.urban[i]);
  }

  for (i = 0; i < igrid.road_count; i++)
  {
    igrid.road[i].ptr = mem_GetIGridPtr (func);
    igrid_ReadGrid (igrid.road[i].filename,
                    scratch_pad, igrid.road[i].ptr);
    grid_SetMinMax (&igrid.road[i]);
    grid_histogram (&igrid.road[i]);
  }

  for (i = 0; i < igrid.landuse_count; i++)
  {
    igrid.landuse[i].ptr = mem_GetIGridPtr (func);
    igrid_ReadGrid (igrid.landuse[i].filename,
                    scratch_pad, igrid.landuse[i].ptr);
    grid_SetMinMax (&igrid.landuse[i]);
    grid_histogram (&igrid.landuse[i]);
  }

  igrid.excluded.ptr = mem_GetIGridPtr (func);
  igrid_ReadGrid (igrid.excluded.filename,
                  scratch_pad, igrid.excluded.ptr);
  grid_SetMinMax (&igrid.excluded);
  grid_histogram (&igrid.excluded);

  igrid.slope.ptr = mem_GetIGridPtr (func);
  igrid_ReadGrid (igrid.slope.filename,
                  scratch_pad, igrid.slope.ptr);
  grid_SetMinMax (&igrid.slope);
  grid_histogram (&igrid.slope);

  igrid.background.ptr = mem_GetIGridPtr (func);
  igrid_ReadGrid (igrid.background.filename,
                  scratch_pad, igrid.background.ptr);
  grid_SetMinMax (&igrid.background);
  grid_histogram (&igrid.excluded);

#ifdef PACKING
  scratch_pad = mem_GetWGridFree (__FILE__, func, __LINE__, scratch_pad);
#endif

  igrid_CountRoadPixels ();
  igrid_CalculatePercentRoads ();
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_init
** PURPOSE:       initialize some variables
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  igrid_init ()
{

  igrid_count = 0;
  igrid_SetLocation ();
  igrid_SetFilenames ();

}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_SetLocation
** PURPOSE:       set the location string variable
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  igrid_SetLocation ()
{
  char buf[256];

  strcpy (buf, scen_GetSlopeDataFilename ());
  strcpy (igrid.location, strtok (buf, "."));
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_SetFilenames
** PURPOSE:       set the filenames of the input files
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  igrid_SetFilenames ()
{
  int i;
  int j;
  int start_year;
  int this_year;
  char *this_year_str;
  char buf[256];
  BOOLEAN packed;

  start_year = scen_GetPredictionStartDate ();
#ifdef PACKING
  packed = TRUE;
#else
  packed = FALSE;
#endif

  j = 0;
  for (i = 0; i < scen_GetUrbanDataFileCount (); i++)
  {
    strcpy (buf, scen_GetUrbanDataFilename (i));
    strtok (buf, ".");
    strtok (NULL, ".");
    this_year_str = strtok (NULL, ".");
    this_year = atoi (this_year_str);
    if (proc_GetProcessingType () == PREDICTING)
    {
      if (this_year >= start_year)
      {
        strcpy (igrid.urban[j].filename, scen_GetInputDir ());
        strcat (igrid.urban[j].filename, scen_GetUrbanDataFilename (i));
        igrid_SetGridSizes (&igrid.urban[j]);
        strcpy (igrid.urban[j].year.string, this_year_str);
        igrid.urban[j].year.digit = this_year;
        igrid.urban[j].packed = packed;
        j++;
      }
    }
    else
    {
      strcpy (igrid.urban[j].filename, scen_GetInputDir ());
      strcat (igrid.urban[j].filename, scen_GetUrbanDataFilename (i));
      igrid_SetGridSizes (&igrid.urban[j]);
      strcpy (igrid.urban[j].year.string, this_year_str);
      igrid.urban[j].year.digit = this_year;
      igrid.urban[j].packed = packed;
      j++;
    }
  }
  igrid.urban_count = j;

  j = 0;
  for (i = 0; i < scen_GetRoadDataFileCount (); i++)
  {
    strcpy (buf, scen_GetRoadDataFilename (i));
    strtok (buf, ".");
    strtok (NULL, ".");
    this_year_str = strtok (NULL, ".");
    this_year = atoi (this_year_str);
    if (proc_GetProcessingType () == PREDICTING)
    {
      if ((this_year >= start_year) | (i = scen_GetRoadDataFileCount () - 1))
      {
        strcpy (igrid.road[j].filename, scen_GetInputDir ());
        strcat (igrid.road[j].filename, scen_GetRoadDataFilename (i));
        igrid_SetGridSizes (&igrid.road[j]);
        strcpy (igrid.road[j].year.string, this_year_str);
        igrid.road[j].year.digit = this_year;
        igrid.road[j].packed = packed;
        j++;
      }
    }
    else
    {
      strcpy (igrid.road[j].filename, scen_GetInputDir ());
      strcat (igrid.road[j].filename, scen_GetRoadDataFilename (i));
      igrid_SetGridSizes (&igrid.road[j]);
      strcpy (igrid.road[j].year.string, this_year_str);
      igrid.road[j].year.digit = this_year;
      igrid.road[j].packed = packed;
      j++;
    }
  }
  igrid.road_count = j;

  for (i = 0; i < scen_GetLanduseDataFileCount (); i++)
  {
    strcpy (buf, scen_GetLanduseDataFilename (i));
    strtok (buf, ".");
    strtok (NULL, ".");
    this_year_str = strtok (NULL, ".");
    this_year = atoi (this_year_str);
    strcpy (igrid.landuse[i].filename, scen_GetInputDir ());
    strcat (igrid.landuse[i].filename, scen_GetLanduseDataFilename (i));
    strcpy (igrid.landuse[i].year.string, this_year_str);
    igrid.landuse[i].year.digit = this_year;
    igrid_SetGridSizes (&igrid.landuse[i]);
    igrid.landuse[i].packed = packed;
  }
  igrid.landuse_count = scen_GetLanduseDataFileCount ();

  strcpy (igrid.excluded.filename, scen_GetInputDir ());
  strcat (igrid.excluded.filename, scen_GetExcludedDataFilename ());
  igrid_SetGridSizes (&igrid.excluded);
  strcpy (igrid.excluded.year.string, "");
  igrid.excluded.year.digit = 0;
  igrid.excluded.packed = packed;
  igrid.excluded_count = 1;

  strcpy (igrid.slope.filename, scen_GetInputDir ());
  strcat (igrid.slope.filename, scen_GetSlopeDataFilename ());
  igrid_SetGridSizes (&igrid.slope);
  strcpy (igrid.slope.year.string, "");
  igrid.slope.year.digit = 0;
  igrid.slope.packed = packed;
  igrid.slope_count = 1;

  strcpy (igrid.background.filename, scen_GetInputDir ());
  strcat (igrid.background.filename, scen_GetBackgroundDataFilename ());
  igrid_SetGridSizes (&igrid.background);
  strcpy (igrid.background.year.string, "");
  igrid.background.year.digit = 0;
  igrid.background.packed = packed;
  igrid.background_count = 1;

  igrid_count = igrid.urban_count +
    igrid.road_count +
    igrid.landuse_count +
    igrid.excluded_count +
    igrid.slope_count +
    igrid.background_count;

}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_SetGridSizes
** PURPOSE:       scan the input GIFs for size and other parameters
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  igrid_SetGridSizes (grid_info * grid_ptr)
{
#define BYTES2READ 15
#define GIF_ID "GIF"
#define GIF_ROW_OFFSET 8
#define GIF_COL_OFFSET 6
#define GIF_RES_OFFSET 10
#define CONVERT2UINT(a,b) (((b)<<8)|(a))
  char func[] = "igrid_SetGridSizes";
  FILE *fp;
  unsigned char buffer[BYTES2READ + 1];
  char id_str[7];
  int resolution;