gint16 vik_dem_get_xy ( VikDEM *dem, guint col, guint row )
{
if ( col < dem->n_columns )
if ( row < GET_COLUMN(dem, col)->n_points )
return GET_COLUMN(dem, col)->points[row];
return VIK_DEM_INVALID_ELEVATION;
}
static void dem_parse_block_as_cont ( gchar *buffer, VikDEM *dem, gint *cur_column, gint *cur_row )
{
gint tmp;
while ( *cur_row < GET_COLUMN(dem, *cur_column)->n_points ) {
if ( get_int_and_continue(&buffer, &tmp,FALSE) ) {
if ( dem->orig_vert_units == VIK_DEM_VERT_DECIMETERS )
GET_COLUMN(dem, *cur_column)->points[*cur_row] = (gint16) (tmp / 10);
else
GET_COLUMN(dem, *cur_column)->points[*cur_row] = (gint16) tmp;
} else
return;
(*cur_row)++;
}
*cur_row = -1; /* expecting new column */
}
BOOL insert_value(unit_box *boxes, INDEX index, UNIT val, INDEX i,INDEX j)
{
BOOL ret = TRUE;
INDEX ri = 0, ci = 0, bi = 0;
bi = index;
ri = GET_ROW(bi)*COLUMN + i;
ci = GET_COLUMN(bi)*ROW + j;
if(val > 0 && val <= TOTAL)
{
ret = (IS_FLAG(box[bi], val-1) || IS_FLAG(row[ri], val-1) || IS_FLAG(column[ci],val-1)) ? FALSE : TRUE;
}
else
ret = FALSE;
if(ret)
{
if(debug)
printf("\nPREV VAL (%d, %d, %d) : %d",index, i, j, boxes[index].value[i][j]);
boxes[index].value[i][j] = val;
SET_FLAG(box[bi], val-1);
SET_FLAG(row[ri], val-1);
SET_FLAG(column[ci], val-1);
if(debug)
printf("\nNEW VAL (%d, %d, %d) : %d",index, i, j, boxes[index].value[i][j]);
}
return ret;
}
void vik_dem_free ( VikDEM *dem )
{
guint i;
for ( i = 0; i < dem->n_columns; i++)
g_free ( GET_COLUMN(dem, i)->points );
g_ptr_array_free ( dem->columns, TRUE );
g_free ( dem );
}
void delete_value(unit_box *boxes, INDEX index, INDEX i,INDEX j)
{
INDEX ri = 0, ci = 0, bi = 0;
UNIT val = 0;
bi = index;
ri = GET_ROW(bi)*COLUMN + i;
ci = GET_COLUMN(bi)*ROW + j;
val = boxes[index].value[i][j];
if(val > 0 && val <= TOTAL)
{
boxes[index].value[i][j] = 0;
CLEAR_FLAG(box[bi], val-1);
CLEAR_FLAG(row[ri], val-1);
CLEAR_FLAG(column[ci], val-1);
}
}
void update_params(unit_box *boxes, inv_unit_box *box, inv_unit_box *row, inv_unit_box *column)
{
INDEX i=0, j=0, bi=0;
for(i = 0 ; i < TOTAL ; i++)
for(j = 0 ; j < TOTAL ; j++)
{
CLEAR_FLAG(box[i], j);
CLEAR_FLAG(row[i], j);
CLEAR_FLAG(column[i], j);
}
for( bi= 0; bi < TOTAL; bi++)
for( i= 0; i < COLUMN; i++)
{
INDEX ri = GET_ROW(bi)*COLUMN + i;
for(j= 0; j < ROW; j++)
{
INDEX ci = GET_COLUMN(bi)*ROW + j;
UNIT val = boxes[bi].value[i][j]-1;
SET_FLAG(box[bi], val);
SET_FLAG(row[ri], val);
SET_FLAG(column[ci], val);
}
}
}
VikDEM *vik_dem_new_from_file(const gchar *file)
{
FILE *f=NULL;
VikDEM *rv;
gchar buffer[DEM_BLOCK_SIZE+1];
/* use to record state for dem_parse_block */
gint cur_column = -1;
gint cur_row = -1;
const gchar *basename = a_file_basename(file);
if ( g_access ( file, R_OK ) != 0 )
return NULL;
if ( (strlen(basename)==11 || ((strlen(basename) == 15) && (basename[11] == '.' && basename[12] == 'z' && basename[13] == 'i' && basename[14] == 'p'))) &&
basename[7]=='.' && basename[8]=='h' && basename[9]=='g' && basename[10]=='t' &&
(basename[0] == 'N' || basename[0] == 'S') && (basename[3] == 'E' || basename[3] =='W')) {
gboolean is_zip_file = (strlen(basename) == 15);
rv = vik_dem_read_srtm_hgt(file, basename, is_zip_file);
return(rv);
}
/* Create Structure */
rv = g_malloc(sizeof(VikDEM));
/* Header */
f = g_fopen(file, "r");
if ( !f ) {
g_free ( rv );
return NULL;
}
buffer[fread(buffer, 1, DEM_BLOCK_SIZE, f)] = '\0';
if ( ! dem_parse_header ( buffer, rv ) ) {
g_free ( rv );
return NULL;
}
/* TODO: actually use header -- i.e. GET # OF COLUMNS EXPECTED */
rv->columns = g_ptr_array_new();
rv->n_columns = 0;
/* Column -- Data */
while (! feof(f) ) {
gchar *tmp;
/* read block */
buffer[fread(buffer, 1, DEM_BLOCK_SIZE, f)] = '\0';
/* Fix Fortran-style exponentiation */
tmp = buffer;
while (*tmp) {
if ( *tmp=='D')
*tmp='E';
tmp++;
}
dem_parse_block(buffer, rv, &cur_column, &cur_row);
}
/* TODO - class C records (right now says 'Invalid' and dies) */
fclose(f);
f = NULL;
/* 24k scale */
if ( rv->horiz_units == VIK_DEM_HORIZ_UTM_METERS && rv->n_columns >= 2 )
rv->north_scale = rv->east_scale = GET_COLUMN(rv, 1)->east_west - GET_COLUMN(rv,0)->east_west;
/* FIXME bug in 10m DEM's */
if ( rv->horiz_units == VIK_DEM_HORIZ_UTM_METERS && rv->north_scale == 10 ) {
rv->min_east -= 100;
rv->min_north += 200;
}
return rv;
}
static VikDEM *vik_dem_read_srtm_hgt(const gchar *file_name, const gchar *basename, gboolean zip)
{
gint i, j;
VikDEM *dem;
off_t file_size;
gint16 *dem_mem = NULL;
gchar *dem_file = NULL;
const gint num_rows_3sec = 1201;
const gint num_rows_1sec = 3601;
gint num_rows;
GMappedFile *mf;
gint arcsec;
GError *error = NULL;
dem = g_malloc(sizeof(VikDEM));
dem->horiz_units = VIK_DEM_HORIZ_LL_ARCSECONDS;
dem->orig_vert_units = VIK_DEM_VERT_DECIMETERS;
/* TODO */
dem->min_north = atoi(basename+1) * 3600;
dem->min_east = atoi(basename+4) * 3600;
if ( basename[0] == 'S' )
dem->min_north = - dem->min_north;
if ( basename[3] == 'W' )
dem->min_east = - dem->min_east;
dem->max_north = 3600 + dem->min_north;
dem->max_east = 3600 + dem->min_east;
dem->columns = g_ptr_array_new();
dem->n_columns = 0;
if ((mf = g_mapped_file_new(file_name, FALSE, &error)) == NULL) {
g_error(_("Couldn't map file %s: %s"), file_name, error->message);
g_error_free(error);
g_free(dem);
return NULL;
}
file_size = g_mapped_file_get_length(mf);
dem_file = g_mapped_file_get_contents(mf);
if (zip) {
void *unzip_mem = NULL;
gulong ucsize;
if ((unzip_mem = unzip_hgt_file(dem_file, &ucsize)) == NULL) {
g_mapped_file_free(mf);
g_ptr_array_free(dem->columns, TRUE);
g_free(dem);
return NULL;
}
dem_mem = unzip_mem;
file_size = ucsize;
}
if (file_size == (num_rows_3sec * num_rows_3sec * sizeof(gint16)))
arcsec = 3;
else if (file_size == (num_rows_1sec * num_rows_1sec * sizeof(gint16)))
arcsec = 1;
else {
g_warning("%s(): file %s does not have right size", __PRETTY_FUNCTION__, basename);
g_mapped_file_free(mf);
g_free(dem);
return NULL;
}
num_rows = (arcsec == 3) ? num_rows_3sec : num_rows_1sec;
dem->east_scale = dem->north_scale = arcsec;
for ( i = 0; i < num_rows; i++ ) {
dem->n_columns++;
g_ptr_array_add ( dem->columns, g_malloc(sizeof(VikDEMColumn)) );
GET_COLUMN(dem,i)->east_west = dem->min_east + arcsec*i;
GET_COLUMN(dem,i)->south = dem->min_north;
GET_COLUMN(dem,i)->n_points = num_rows;
GET_COLUMN(dem,i)->points = g_malloc(sizeof(gint16)*num_rows);
}
int ent = 0;
for ( i = (num_rows - 1); i >= 0; i-- ) {
for ( j = 0; j < num_rows; j++ ) {
GET_COLUMN(dem,j)->points[i] = GINT16_FROM_BE(dem_mem[ent]);
ent++;
}
}
if (zip)
g_free(dem_mem);
g_mapped_file_free(mf);
return dem;
}
static void dem_parse_block_as_header ( gchar *buffer, VikDEM *dem, gint *cur_column, gint *cur_row )
{
guint n_rows;
gint i;
gdouble east_west, south;
gdouble tmp;
/* 1 x n_rows 1 east_west south x x x DATA */
if ( (!get_double_and_continue(&buffer, &tmp, TRUE)) || tmp != 1 ) {
g_warning(_("Incorrect DEM Class B record: expected 1"));
return;
}
/* don't need this */
if ( !get_double_and_continue(&buffer, &tmp, TRUE ) ) return;
/* n_rows */
if ( !get_double_and_continue(&buffer, &tmp, TRUE ) )
return;
n_rows = (guint) tmp;
if ( (!get_double_and_continue(&buffer, &tmp, TRUE)) || tmp != 1 ) {
g_warning(_("Incorrect DEM Class B record: expected 1"));
return;
}
if ( !get_double_and_continue(&buffer, &east_west, TRUE) )
return;
if ( !get_double_and_continue(&buffer, &south, TRUE) )
return;
/* next three things we don't need */
if ( !get_double_and_continue(&buffer, &tmp, TRUE)) return;
if ( !get_double_and_continue(&buffer, &tmp, TRUE)) return;
if ( !get_double_and_continue(&buffer, &tmp, TRUE)) return;
dem->n_columns ++;
(*cur_column) ++;
/* empty spaces for things before that were skipped */
(*cur_row) = (south - dem->min_north) / dem->north_scale;
if ( south > dem->max_north || (*cur_row) < 0 )
(*cur_row) = 0;
n_rows += *cur_row;
g_ptr_array_add ( dem->columns, g_malloc(sizeof(VikDEMColumn)) );
GET_COLUMN(dem,*cur_column)->east_west = east_west;
GET_COLUMN(dem,*cur_column)->south = south;
GET_COLUMN(dem,*cur_column)->n_points = n_rows;
GET_COLUMN(dem,*cur_column)->points = g_malloc(sizeof(gint16)*n_rows);
/* no information for things before that */
for ( i = 0; i < (*cur_row); i++ )
GET_COLUMN(dem,*cur_column)->points[i] = VIK_DEM_INVALID_ELEVATION;
/* now just continue */
dem_parse_block_as_cont ( buffer, dem, cur_column, cur_row );
}
