igrid_obj.c

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

  int ncols;
  int nrows;
  int bits_per_pixel;
  int color_bits;


  if (glb_mype == 0)
  {
    FILE_OPEN (fp, grid_ptr->filename, "rb");
    fgets ((char *) buffer, BYTES2READ, fp);
    fclose (fp);
  }
#ifdef MPI
  MPI_Bcast (buffer, BYTES2READ, MPI_BYTE, 0, MPI_COMM_WORLD);
#endif


  strncpy (id_str, (char *) buffer, strlen (GIF_ID));
  if (strncmp (GIF_ID, id_str, strlen (GIF_ID)) != 0)
  {
    printf ("\n\n%s %d file: %s is not a %s format\n",
            __FILE__, __LINE__, grid_ptr->filename, GIF_ID);
    EXIT (1);
  }
  ncols = CONVERT2UINT (buffer[GIF_COL_OFFSET], buffer[GIF_COL_OFFSET + 1]);
  nrows = CONVERT2UINT (buffer[GIF_ROW_OFFSET], buffer[GIF_ROW_OFFSET + 1]);
  total_pixels = nrows * ncols;
  resolution = (int) buffer[GIF_RES_OFFSET];
  color_bits = (((resolution & 112) >> 4) + 1);
  bits_per_pixel = (resolution & 7) + 1;
  grid_ptr->ncols = ncols;
  grid_ptr->nrows = nrows;
  grid_ptr->color_bits = color_bits;
  grid_ptr->bits_per_pixel = bits_per_pixel;
  grid_ptr->size_bytes = BYTES_PER_PIXEL * ncols * nrows;
  grid_ptr->size_words = ROUND_BYTES_TO_WORD_BNDRY (grid_ptr->size_bytes);

}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_LogIt
** PURPOSE:       log the igrid structs to FILE * fp
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  igrid_LogIt (FILE * fp)
{
  char func[] = "igrid_LogIt";
  char buf[256];
  char asterisks[256];
  int i;

  FUNC_INIT;
  fprintf (fp, "\n\n");
  sprintf (asterisks, "%s", "************************************");
  strcat (asterisks, "************************************");
  out_center_text (fp,
                   asterisks,
                   "INPUT GIFs",
                   buf,
                   -1);
  fprintf (fp, "\n\n");
  fprintf (fp, "  Urban GIFs\n");
  fprintf (fp, "      rowXcol cb bpp path\n");
  fprintf (fp, "      rowXcol cb bpp min max path\n");

  for (i = 0; i < igrid.urban_count; i++)
  {
    sprintf (buf, "%uX%u", igrid.urban[i].nrows, igrid.urban[i].ncols);
    fprintf (fp, "    %9s  %u  %u  %3u %3u %s\n", buf,
             igrid.urban[i].color_bits,
             igrid.urban[i].bits_per_pixel,
             igrid.urban[i].min,
             igrid.urban[i].max,
             igrid.urban[i].filename);
  }
  fprintf (fp, "  Road GIFs\n");
  fprintf (fp, "      rowXcol cb bpp path\n");
  for (i = 0; i < igrid.road_count; i++)
  {
    sprintf (buf, "%uX%u", igrid.road[i].nrows, igrid.road[i].ncols);
    fprintf (fp, "    %9s  %u  %u  %3u %3u %s\n", buf,
             igrid.road[i].color_bits,
             igrid.road[i].bits_per_pixel,
             igrid.road[i].min,
             igrid.road[i].max,
             igrid.road[i].filename);
  }
  fprintf (fp, "  Landuse GIFs\n");
  fprintf (fp, "      rowXcol cb bpp path\n");
  for (i = 0; i < igrid.landuse_count; i++)
  {
    sprintf (buf, "%uX%u", igrid.landuse[i].nrows, igrid.landuse[i].ncols);
    fprintf (fp, "    %9s  %u  %u  %3u %3u %s\n", buf,
             igrid.landuse[i].color_bits,
             igrid.landuse[i].bits_per_pixel,
             igrid.landuse[i].min,
             igrid.landuse[i].max,
             igrid.landuse[i].filename);
  }
  fprintf (fp, "  Excluded GIF\n");
  fprintf (fp, "      rowXcol cb bpp path\n");
  sprintf (buf, "%uX%u", igrid.excluded.nrows, igrid.excluded.ncols);
  fprintf (fp, "    %9s  %u  %u  %3u %3u %s\n", buf,
           igrid.excluded.color_bits,
           igrid.excluded.bits_per_pixel,
           igrid.excluded.min,
           igrid.excluded.max,
           igrid.excluded.filename);

  fprintf (fp, "  Slope GIF\n");
  fprintf (fp, "      rowXcol cb bpp path\n");
  sprintf (buf, "%uX%u", igrid.slope.nrows, igrid.slope.ncols);
  fprintf (fp, "    %9s  %u  %u  %3u %3u %s\n", buf,
           igrid.slope.color_bits,
           igrid.slope.bits_per_pixel,
           igrid.slope.min,
           igrid.slope.max,
           igrid.slope.filename);

  fprintf (fp, "  Background GIF\n");
  fprintf (fp, "      rowXcol cb bpp path\n");
  sprintf (buf, "%uX%u", igrid.background.nrows, igrid.background.ncols);
  fprintf (fp, "    %9s  %u  %u  %3u %3u %s\n", buf,
           igrid.background.color_bits,
           igrid.background.bits_per_pixel,
           igrid.background.min,
           igrid.background.max,
           igrid.background.filename);

  fprintf (fp, "cb = # of color bits\n");
  fprintf (fp, "bpp = # bits per pixel\n");
  fprintf (fp, "\n\n");

  FUNC_END;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_VerifyInputs
** PURPOSE:       verify the grid sizes and some other stuff
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  igrid_VerifyInputs (FILE * fp)
{
  char func[] = "igrid_VerifyInputs";
  char buf[256];
  char *my_location;
  char *filename;
  int i;
  int rows;
  int cols;
  BOOLEAN all_sizes_the_same = TRUE;
  BOOLEAN all_locations_the_same = TRUE;

#define CHECK_LOCATION(path)                                 \
strcpy (buf, (path));                                        \
EXTRACT_FILENAME(buf);                                       \
my_location = strtok (filename, ".");                        \
if(strcmp(my_location,igrid.location) != 0)                  \
{                                                            \
  all_locations_the_same = FALSE;                            \
}

  if (fp)
  {
    fprintf (fp, "\nVerifying Data Input Files\n");
  }
  rows = igrid.slope.nrows;
  cols = igrid.slope.ncols;
  for (i = 0; i < igrid.urban_count; i++)
  {
    if ((rows != igrid.urban[i].nrows) || (cols != igrid.urban[i].ncols))
    {
      all_sizes_the_same = FALSE;
    }
    CHECK_LOCATION (igrid.urban[i].filename);
  }
  for (i = 0; i < igrid.road_count; i++)
  {
    if ((rows != igrid.road[i].nrows) || (cols != igrid.road[i].ncols))
    {
      all_sizes_the_same = FALSE;
    }
    CHECK_LOCATION (igrid.road[i].filename);
  }
  for (i = 0; i < igrid.landuse_count; i++)
  {
    if ((rows != igrid.landuse[i].nrows) || (cols != igrid.landuse[i].ncols))
    {
      all_sizes_the_same = FALSE;
    }
    CHECK_LOCATION (igrid.landuse[i].filename);
  }
  if ((rows != igrid.excluded.nrows) || (cols != igrid.excluded.ncols))
  {
    all_sizes_the_same = FALSE;
    CHECK_LOCATION (igrid.excluded.filename);
  }

  if ((rows != igrid.background.nrows) || (cols != igrid.background.ncols))
  {
    all_sizes_the_same = FALSE;
    CHECK_LOCATION (igrid.background.filename);
  }
  if (!all_sizes_the_same)
  {
    sprintf (msg_buf, "GIFs are not all the same size.");
    LOG_ERROR (msg_buf);
    sprintf (msg_buf, "Please check your input image sizes");
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  if (!all_locations_the_same)
  {
    sprintf (msg_buf, "GIFs do not all have the same location.");
    LOG_ERROR (msg_buf);
    sprintf (msg_buf, "Please check your scenario file");
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  if (scen_GetDoingLanduseFlag ())
  {
    if (igrid.landuse[1].year.digit !=
        igrid.urban[igrid.urban_count - 1].year.digit)
    {
      sprintf (msg_buf, "Last landuse year does not match last urban year.");
      LOG_ERROR (msg_buf);
      sprintf (msg_buf, "last landuse year = %u last urban year = %u",
               igrid.landuse[1].year.digit,
               igrid.urban[igrid.urban_count - 1].year.digit);
      LOG_ERROR (msg_buf);
      EXIT (1);
    }
  }
  if (fp)
  {
    fprintf (fp, "%s %u Data Input Files: OK\n", __FILE__, __LINE__);
  }
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_CountRoadPixels
** PURPOSE:       count the number of road pixels
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  igrid_CountRoadPixels ()
{
  char func[] = "igrid_CountRoadPixel";
  GRID_P roads;
  int i;

  assert (total_pixels > 0);

  for (i = 0; i < igrid.road_count; i++)
  {
#ifdef PACKING
    roads = mem_GetWGridPtr (__FILE__, func, __LINE__);
    _unpack ((char *) igrid.road[i].ptr,
             roads,
             total_pixels,
             -1);
#else
    roads = igrid.road[i].ptr;
#endif
    road_pixel_count[i] = util_count_pixels (total_pixels,
                                             roads,
                                             GT,
                                             0);
#ifdef PACKING
    mem_GetWGridFree (__FILE__, func, __LINE__, roads);
#endif
  }
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_CalculatePercentRoads
** PURPOSE:       calculate road percentage
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  igrid_CalculatePercentRoads ()
{
  char func[] = "igrid_CalculatePercentRoads";
  GRID_P excld;
  int i;


  assert (total_pixels > 0);
#ifdef PACKING
  excld = mem_GetWGridPtr (__FILE__, func, __LINE__);
  _unpack ((char *) igrid.excluded.ptr,
           excld,
           total_pixels,
           -1);
#else
  excld = igrid.excluded.ptr;
#endif
  excld_count = util_count_pixels (total_pixels,
                                   excld,
                                   GE,
                                   100);
  if (total_pixels - excld_count <= 0)
  {
    sprintf (msg_buf, "mem_GetTotalPixels()=%d excld_count = %d\n",
             mem_GetTotalPixels (), excld_count);
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  for (i = 0; i < igrid.road_count; i++)
  {
    percent_road[i] =
      (100.0 * road_pixel_count[i]) / (total_pixels - excld_count);
  }
#ifdef PACKING
  mem_GetWGridFree (__FILE__, func, __LINE__, excld);
#endif
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_TestForUrbanYear
** PURPOSE:       test if year matches an urban year
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
BOOLEAN
  igrid_TestForUrbanYear (int year)
{
  int i;

  for (i = 0; i < igrid.urban_count; i++)
  {
    if (igrid.urban[i].year.digit == year)
      return TRUE;
  }
  return FALSE;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_UrbanYear2Index
** PURPOSE:       convert an urban year into an urban index
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
int
  igrid_UrbanYear2Index (int year)
{
  BOOLEAN flag = FALSE;
  int i;

  for (i = 0; i < igrid.urban_count; i++)
  {
    if (igrid.urban[i].year.digit == year)
    {
      flag = TRUE;
      break;
    }
  }
  if (flag)
  {
    return i;
  }
  else
  {
    printf ("%s %u ERROR year=%u is not an urban year\n",
            __FILE__, __LINE__, year);
    EXIT (1);
  }
  return -1;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_TestForRoadYear
** PURPOSE:       test if year is a road year
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
BOOLEAN
  igrid_TestForRoadYear (int year)
{
  int i;

  for (i = 0; i < igrid.road_count; i++)
  {
    if (igrid.road[i].year.digit == year)
      return TRUE;
  }
  return FALSE;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: igrid_echo_input
** PURPOSE:       routine to echo input grids
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  igrid_echo_input (GRID_P ptr, char *filename)
{
  char path[MAX_FILENAME_LEN];
  char date_str[] = "";

  sprintf (path, "%secho_of_%s", scen_GetOutputDir (), filename);
  gdif_WriteGIF (ptr,
                 color_GetColortable (GRAYSCALE_COLORTABLE),
                 path,
                 date_str,
                 255);
}