static int get_ellipsoid_parameters(struct Key_Value *proj_keys, double *a, double *e2)
{
const char *str, *str1;
if (!proj_keys) {
return -1;
}
if ((str = G_find_key_value("ellps", proj_keys)) != NULL) {
if (strncmp(str, "sphere", 6) == 0) {
str = G_find_key_value("a", proj_keys);
if (str != NULL) {
if (sscanf(str, "%lf", a) != 1)
G_fatal_error(_("Invalid a: field '%s' in file %s in <%s>"),
str, PROJECTION_FILE, PERMANENT);
}
else
*a = 6370997.0;
*e2 = 0.0;
return 0;
}
else {
if (G_get_ellipsoid_by_name(str, a, e2) == 0)
G_fatal_error(_("Invalid ellipsoid '%s' in file %s in <%s>"),
str, PROJECTION_FILE, PERMANENT);
else
return 1;
}
}
else {
str = G_find_key_value("a", proj_keys);
str1 = G_find_key_value("es", proj_keys);
if ((str != NULL) && (str1 != NULL)) {
if (sscanf(str, "%lf", a) != 1)
G_fatal_error(_("Invalid a: field '%s' in file %s in <%s>"),
str, PROJECTION_FILE, PERMANENT);
if (sscanf(str1, "%lf", e2) != 1)
G_fatal_error(_("Invalid es: field '%s' in file %s in <%s>"),
str, PROJECTION_FILE, PERMANENT);
return 1;
}
else {
str = G_find_key_value("proj", proj_keys);
if ((str == NULL) || (strcmp(str, "ll") == 0)) {
*a = 6378137.0;
*e2 = .006694385;
return 0;
}
else
G_fatal_error(_("No ellipsoid info given in file %s in <%s>"),
PROJECTION_FILE, PERMANENT);
}
}
return 1;
}
static void read_gdal_options(void)
{
FILE *fp;
struct Key_Value *key_val;
const char *p;
fp = G_fopen_old("", "GDAL", G_mapset());
if (!fp)
G_fatal_error(_("Unable to open GDAL file"));
key_val = G_fread_key_value(fp);
fclose(fp);
p = G_find_key_value("directory", key_val);
if (!p)
p = "gdal";
if (*p == '/') {
st->opts.dir = G_store(p);
}
else {
char path[GPATH_MAX];
G_file_name(path, p, "", G_mapset());
st->opts.dir = G_store(path);
if (access(path, 0) != 0)
G_make_mapset_element(p);
}
p = G_find_key_value("extension", key_val);
st->opts.ext = G_store(p ? p : "");
p = G_find_key_value("format", key_val);
st->opts.format = G_store(p ? p : "GTiff");
p = G_find_key_value("options", key_val);
st->opts.options = p ? G_tokenize(p, ",") : NULL;
G_free_key_value(key_val);
}
/*!
\brief Get color rules description for Option->descriptions
\return allocated buffer with descriptions
*/
char *G_color_rules_descriptions(void)
{
char path[GPATH_MAX];
struct Key_Value *kv;
int result_len, result_max;
char *result, **rules;
const char *name, *desc;
int i, len, nrules;
result_len = 0;
result_max = 2000;
result = G_malloc(result_max);
G_snprintf(path, GPATH_MAX, "%s/etc/colors.desc", G_gisbase());
kv = G_read_key_value_file(path);
if (!kv)
return NULL;
rules = scan_rules(&nrules);
for (i = 0; i < nrules; i++) {
name = rules[i];
desc = G_find_key_value(name, kv);
if (!desc)
desc = _("no description");
/* desc = _(desc); */
len = strlen(name) + strlen(desc) + 2;
if (result_len + len >= result_max) {
result_max = result_len + len + 1000;
result = G_realloc(result, result_max);
}
sprintf(result + result_len, "%s;%s;", name, desc);
result_len += len;
}
G_free_key_value(kv);
G_free(rules);
return result;
}
static char *rules_descriptions(void)
{
char path[GPATH_MAX];
struct Key_Value *kv;
int result_len = 0;
int result_max = 2000;
char *result = G_malloc(result_max);
int stat;
int i;
sprintf(path, "%s/etc/colors.desc", G_gisbase());
kv = G_read_key_value_file(path, &stat);
if (!kv || stat < 0)
return NULL;
for (i = 0; i < nrules; i++) {
const char *name = rules[i];
const char *desc = G_find_key_value(name, kv);
int len;
if (!desc)
desc = "no description";
desc = _(desc);
len = strlen(name) + strlen(desc) + 2;
if (result_len + len >= result_max) {
result_max = result_len + len + 1000;
result = G_realloc(result, result_max);
}
sprintf(result + result_len, "%s;%s;", name, desc);
result_len += len;
}
G_free_key_value(kv);
return result;
}
void print_proj4(int dontprettify)
{
struct pj_info pjinfo;
char *proj4, *proj4mod, *i;
const char *unfact;
if (check_xy(FALSE))
return;
if (pj_get_kv(&pjinfo, projinfo, projunits) == -1)
G_fatal_error(_("Unable to convert projection information to PROJ.4 format"));
proj4 = pj_get_def(pjinfo.pj, 0);
pj_free(pjinfo.pj);
/* GRASS-style PROJ.4 strings don't include a unit factor as this is
* handled separately in GRASS - must include it here though */
unfact = G_find_key_value("meters", projunits);
if (unfact != NULL && (strcmp(pjinfo.proj, "ll") != 0))
G_asprintf(&proj4mod, "%s +to_meter=%s", proj4, unfact);
else
proj4mod = G_store(proj4);
pj_dalloc(proj4);
for (i = proj4mod; *i; i++) {
/* Don't print the first space */
if (i == proj4mod && *i == ' ')
continue;
if (*i == ' ' && *(i+1) == '+' && !(dontprettify))
fputc('\n', stdout);
else
fputc(*i, stdout);
}
fputc('\n', stdout);
G_free(proj4mod);
return;
}
const char *lookup_epsg()
{
init();
return G_find_key_value("epsg", proj_epsg);
}
const char *lookup_units(const char *key)
{
init();
return G_find_key_value(key, proj_units);
}
const char *lookup_proj(const char *key)
{
init();
return G_find_key_value(key, proj_info);
}
int GPJ__get_datum_params(const struct Key_Value *projinfo,
char **datumname, char **params)
{
int returnval = -1;
if (NULL != G_find_key_value("datum", projinfo)) {
*datumname = G_store(G_find_key_value("datum", projinfo));
returnval = 1;
}
else
*datumname = NULL;
if (G_find_key_value("datumparams", projinfo) != NULL) {
*params = G_store(G_find_key_value("datumparams", projinfo));
returnval = 2;
}
else if (G_find_key_value("nadgrids", projinfo) != NULL) {
const char *gisbase = G_gisbase();
G_asprintf(params, "nadgrids=%s%s/%s", gisbase, GRIDDIR,
G_find_key_value("nadgrids", projinfo));
returnval = 2;
}
else if (G_find_key_value("towgs84", projinfo) != NULL) {
G_asprintf(params, "towgs84=%s",
G_find_key_value("towgs84", projinfo));
returnval = 2;
}
else if (G_find_key_value("dx", projinfo) != NULL
&& G_find_key_value("dy", projinfo) != NULL
&& G_find_key_value("dz", projinfo) != NULL) {
G_asprintf(params, "towgs84=%s,%s,%s",
G_find_key_value("dx", projinfo),
G_find_key_value("dy", projinfo),
G_find_key_value("dz", projinfo));
returnval = 2;
}
else
*params = NULL;
return returnval;
}
int main(int argc, char *argv[])
{
struct GModule *module;
int Out_proj;
int out_stat;
int old_zone, old_proj;
int i;
int stat;
char cmnd2[500];
char proj_out[20], proj_name[50], set_name[20];
char path[1024], buffa[1024], buffb[1024], answer[200], answer1[200];
char answer2[200], buff[1024];
char tmp_buff[20], *buf;
struct Key_Value *old_proj_keys, *out_proj_keys, *in_unit_keys;
double aa, e2;
double f;
FILE *FPROJ;
int exist = 0;
char spheroid[100];
int j, k, sph_check;
struct Cell_head cellhd;
char datum[100], dat_ellps[100], dat_params[100];
struct proj_parm *proj_parms;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("general"));
G_add_keyword(_("projection"));
module->description =
_("Interactively reset the location's projection settings.");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (strcmp(G_mapset(), "PERMANENT") != 0)
G_fatal_error(_("You must be in the PERMANENT mapset to run g.setproj"));
/***
* no longer necessary, table is a static struct
* init_unit_table();
***/
sprintf(set_name, "PERMANENT");
G_file_name(path, "", PROJECTION_FILE, set_name);
/* get the output projection parameters, if existing */
/* Check for ownership here */
stat = G__mapset_permissions(set_name);
if (stat == 0) {
G_fatal_error(_("PERMANENT: permission denied"));
}
G_get_default_window(&cellhd);
if (-1 == G_set_window(&cellhd))
G_fatal_error(_("Current region cannot be set"));
if (G_get_set_window(&cellhd) == -1)
G_fatal_error(_("Retrieving and setting region failed"));
Out_proj = cellhd.proj;
old_zone = cellhd.zone;
old_proj = cellhd.proj;
if (access(path, 0) == 0) {
exist = 1;
FPROJ = fopen(path, "r");
old_proj_keys = G_fread_key_value(FPROJ);
fclose(FPROJ);
buf = G_find_key_value("name", old_proj_keys);
fprintf(stderr,
"\nWARNING: A projection file already exists for this location\n(Filename '%s')\n",
path);
fprintf(stderr,
"\nThis file contains all the parameters for the location's projection:\n %s\n",
buf);
fprintf(stderr,
"\n Overriding this information implies that the old projection parameters\n"
" were incorrect. If you change the parameters, all existing data will\n"
" be interpreted differently by the projection software.\n%c%c%c",
7, 7, 7);
fprintf(stderr,
" GRASS will not re-project your data automatically.\n\n");
if (!G_yes
(_("Would you still like to change some of the parameters?"),
0)) {
G_message(_("The projection information will not be updated"));
leave(SP_NOCHANGE);
}
}
out_proj_keys = G_create_key_value();
if (exist) {
buf = G_find_key_value("zone", old_proj_keys);
if (buf != NULL)
sscanf(buf, "%d", &zone);
if (zone != old_zone) {
G_warning(_("Zone in default geographic region definition: %d\n"
" is different from zone in PROJ_INFO file: %d"),
old_zone, zone);
old_zone = zone;
}
}
switch (Out_proj) {
case 0: /* No projection/units */
if (!exist) {
/* leap frog over code, and just make sure we remove the file */
G_warning(_("XY-location cannot be projected"));
goto write_file;
break;
}
case PROJECTION_UTM:
if (!exist) {
sprintf(proj_name, "%s", G__projection_name(PROJECTION_UTM));
sprintf(proj_out, "utm");
break;
}
case PROJECTION_SP:
if (!exist) {
sprintf(proj_name, "%s", G__projection_name(PROJECTION_SP));
sprintf(proj_out, "stp");
break;
}
case PROJECTION_LL:
if (!exist) {
sprintf(proj_name, "%s", G__projection_name(PROJECTION_LL));
sprintf(proj_out, "ll");
break;
}
case PROJECTION_OTHER:
if (G_ask_proj_name(proj_out, proj_name) < 0)
leave(SP_NOCHANGE);
if (G_strcasecmp(proj_out, "LL") == 0)
Out_proj = PROJECTION_LL;
else if (G_strcasecmp(proj_out, "UTM") == 0)
Out_proj = PROJECTION_UTM;
else if (G_strcasecmp(proj_out, "STP") == 0)
Out_proj = PROJECTION_SP;
break;
default:
G_fatal_error(_("Unknown projection"));
}
cellhd.proj = Out_proj;
proj_parms = get_proj_parms(proj_out);
if (!proj_parms)
G_fatal_error(_("Projection %s is not specified in the file 'proj-parms.table'"),
proj_out);
G_set_key_value("name", proj_name, out_proj_keys);
sph_check = 0;
if (G_yes
(_("Do you wish to specify a geodetic datum for this location?"),
1)) {
char lbuf[100], lbufa[100];
if (exist &&
(G_get_datumparams_from_projinfo(old_proj_keys, lbuf, lbufa) ==
2)) {
G_strip(lbuf);
if ((i = G_get_datum_by_name(lbuf)) > 0) {
G_message(_("The current datum is %s (%s)"),
G_datum_name(i), G_datum_description(i));
if (G_yes
(_("Do you wish to change the datum (or datum transformation parameters)?"),
0))
sph_check = ask_datum(datum, dat_ellps, dat_params);
else {
sprintf(datum, lbuf);
sprintf(dat_params, lbufa);
sprintf(dat_ellps, G_datum_ellipsoid(i));
sph_check = 1;
G_message(_("The datum information has not been changed"));
}
}
else
sph_check = ask_datum(datum, dat_ellps, dat_params);
}
else
sph_check = ask_datum(datum, dat_ellps, dat_params);
}
if (sph_check > 0) {
char *paramkey, *paramvalue;
/* write out key/value pairs to out_proj_keys */
if (G_strcasecmp(datum, "custom") != 0)
G_set_key_value("datum", datum, out_proj_keys);
/* G_set_key_value("datumparams", dat_params, out_proj_keys); */
paramkey = strtok(dat_params, "=");
paramvalue = dat_params + strlen(paramkey) + 1;
G_set_key_value(paramkey, paramvalue, out_proj_keys);
sprintf(spheroid, "%s", dat_ellps);
}
else {
/***************** GET spheroid **************************/
if (Out_proj != PROJECTION_SP) { /* some projections have
* fixed spheroids */
if (G_strcasecmp(proj_out, "ALSK") == 0 ||
G_strcasecmp(proj_out, "GS48") == 0 ||
G_strcasecmp(proj_out, "GS50") == 0) {
sprintf(spheroid, "%s", "clark66");
G_set_key_value("ellps", spheroid, out_proj_keys);
sph_check = 1;
}
else if (G_strcasecmp(proj_out, "LABRD") == 0 ||
G_strcasecmp(proj_out, "NZMG") == 0) {
sprintf(spheroid, "%s", "international");
G_set_key_value("ellps", spheroid, out_proj_keys);
sph_check = 1;
}
else if (G_strcasecmp(proj_out, "SOMERC") == 0) {
sprintf(spheroid, "%s", "bessel");
G_set_key_value("ellps", spheroid, out_proj_keys);
sph_check = 1;
}
else if (G_strcasecmp(proj_out, "OB_TRAN") == 0) {
/* Hard coded to use "Equidistant Cylincrical"
* until g.setproj has been changed to run
* recurively, to allow input of options for
* a second projection, MHu991010 */
G_set_key_value("o_proj", "eqc", out_proj_keys);
sph_check = 2;
}
else {
if (exist &&
(buf =
G_find_key_value("ellps", old_proj_keys)) != NULL) {
strcpy(spheroid, buf);
G_strip(spheroid);
if (G_get_spheroid_by_name(spheroid, &aa, &e2, &f)) {
/* if legal ellips. exist, ask wether or not to change it */
G_message(_("The current ellipsoid is %s"), spheroid);
if (G_yes
(_("Do you want to change ellipsoid parameter?"),
0))
sph_check = G_ask_ellipse_name(spheroid);
else {
G_message(_("The ellipse information has not been changed"));
sph_check = 1;
}
} /* the val is legal */
else
sph_check = G_ask_ellipse_name(spheroid);
}
else
sph_check = G_ask_ellipse_name(spheroid);
}
}
if (sph_check > 0) {
if (sph_check == 2) { /* ask radius */
if (exist) {
buf = G_find_key_value("a", old_proj_keys);
if ((buf != NULL) && (sscanf(buf, "%lf", &radius) == 1)) {
G_message(_("The radius is currently %f"), radius);
if (G_yes(_("Do you want to change the radius?"), 0))
radius =
prompt_num_double(_("Enter radius for the sphere in meters"),
RADIUS_DEF, 1);
}
}
else
radius =
prompt_num_double(_("Enter radius for the sphere in meters"),
RADIUS_DEF, 1);
} /* end ask radius */
}
}
/*** END get spheroid ***/
/* create the PROJ_INFO & PROJ_UNITS files, if required */
if (G_strcasecmp(proj_out, "LL") == 0) ;
else if (G_strcasecmp(proj_out, "STP") == 0)
get_stp_proj(buffb);
else if (sph_check != 2) {
G_strip(spheroid);
if (G_get_spheroid_by_name(spheroid, &aa, &e2, &f) == 0)
G_fatal_error(_("Invalid input ellipsoid"));
}
write_file:
/*
** NOTE the program will (hopefully) never exit abnormally
** after this point. Thus we know the file will be completely
** written out once it is opened for write
*/
if (exist) {
sprintf(buff, "%s~", path);
G_rename_file(path, buff);
}
if (Out_proj == 0)
goto write_units;
/*
** Include MISC parameters for PROJ_INFO
*/
if (G_strcasecmp(proj_out, "STP") == 0) {
for (i = 0; i < strlen(buffb); i++)
if (buffb[i] == ' ')
buffb[i] = '\t';
sprintf(cmnd2, "%s\t\n", buffb);
for (i = 0; i < strlen(cmnd2); i++) {
j = k = 0;
if (cmnd2[i] == '+') {
while (cmnd2[++i] != '=')
buffa[j++] = cmnd2[i];
buffa[j] = 0;
while (cmnd2[++i] != '\t' && cmnd2[i] != '\n' &&
cmnd2[i] != 0)
buffb[k++] = cmnd2[i];
buffb[k] = 0;
G_set_key_value(buffa, buffb, out_proj_keys);
}
}
}
else if (G_strcasecmp(proj_out, "LL") == 0) {
G_set_key_value("proj", "ll", out_proj_keys);
G_set_key_value("ellps", spheroid, out_proj_keys);
}
else {
if (sph_check != 2) {
G_set_key_value("proj", proj_out, out_proj_keys);
G_set_key_value("ellps", spheroid, out_proj_keys);
sprintf(tmp_buff, "%.10f", aa);
G_set_key_value("a", tmp_buff, out_proj_keys);
sprintf(tmp_buff, "%.10f", e2);
G_set_key_value("es", tmp_buff, out_proj_keys);
sprintf(tmp_buff, "%.10f", f);
G_set_key_value("f", tmp_buff, out_proj_keys);
}
else {
G_set_key_value("proj", proj_out, out_proj_keys);
/* G_set_key_value ("ellps", "sphere", out_proj_keys); */
sprintf(tmp_buff, "%.10f", radius);
G_set_key_value("a", tmp_buff, out_proj_keys);
G_set_key_value("es", "0.0", out_proj_keys);
G_set_key_value("f", "0.0", out_proj_keys);
}
for (i = 0;; i++) {
struct proj_parm *parm = &proj_parms[i];
struct proj_desc *desc;
if (!parm->name)
break;
desc = get_proj_desc(parm->name);
if (!desc)
break;
if (parm->ask) {
if (G_strcasecmp(desc->type, "bool") == 0) {
if (G_yes((char *)desc->desc, 0)) {
G_set_key_value(desc->key, "defined", out_proj_keys);
if (G_strcasecmp(parm->name, "SOUTH") == 0)
cellhd.zone = -abs(cellhd.zone);
}
}
else if (G_strcasecmp(desc->type, "lat") == 0) {
double val;
while (!get_LL_stuff(parm, desc, 1, &val)) ;
sprintf(tmp_buff, "%.10f", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "lon") == 0) {
double val;
while (!get_LL_stuff(parm, desc, 0, &val)) ;
sprintf(tmp_buff, "%.10f", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "float") == 0) {
double val;
while (!get_double(parm, desc, &val)) ;
sprintf(tmp_buff, "%.10f", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "int") == 0) {
int val;
while (!get_int(parm, desc, &val)) ;
sprintf(tmp_buff, "%d", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "zone") == 0) {
if ((Out_proj == PROJECTION_UTM) && (old_zone != 0)) {
G_message(_("The UTM zone is now set to %d"),
old_zone);
if (!G_yes
(_("Do you want to change the UTM zone?"), 0)) {
G_message(_("UTM zone information has not been updated"));
zone = old_zone;
break;
}
else {
G_message(_("But if you change zone, all the existing "
"data will be interpreted by projection software. "
"GRASS will not automatically re-project or even "
"change the headers for existing maps."));
if (!G_yes
(_("Would you still like to change the UTM zone?"),
0)) {
zone = old_zone;
break;
}
}
} /* UTM */
while (!get_zone()) ;
sprintf(tmp_buff, "%d", zone);
G_set_key_value("zone", tmp_buff, out_proj_keys);
cellhd.zone = zone;
}
}
else if (parm->def_exists) {
/* don't ask, use the default */
if (G_strcasecmp(desc->type, "float") == 0 ||
G_strcasecmp(desc->type, "lat") == 0 ||
G_strcasecmp(desc->type, "lon") == 0) {
sprintf(tmp_buff, "%.10f", parm->deflt);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "int") == 0) {
sprintf(tmp_buff, "%d", (int)parm->deflt);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
}
} /* for OPTIONS */
}
/* create the PROJ_INFO & PROJ_UNITS files, if required */
G_write_key_value_file(path, out_proj_keys, &out_stat);
if (out_stat != 0) {
G_fatal_error(_("Error writing PROJ_INFO file <%s>"), path);
}
G_free_key_value(out_proj_keys);
if (exist)
G_free_key_value(old_proj_keys);
write_units:
G_file_name(path, "", UNIT_FILE, set_name);
/* if we got this far, the user
** already affirmed to write over old info
** so if units file is here, remove it.
*/
if (access(path, 0) == 0) {
sprintf(buff, "%s~", path);
G_rename_file(path, buff);
}
if (Out_proj == 0)
leave(0);
{
in_unit_keys = G_create_key_value();
switch (Out_proj) {
case PROJECTION_UTM:
G_set_key_value("unit", "meter", in_unit_keys);
G_set_key_value("units", "meters", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
break;
case PROJECTION_SP:
for (;;) {
do {
fprintf(stderr, "\nSpecify the correct units to use:\n");
fprintf(stderr, "Enter the corresponding number\n");
fprintf(stderr,
"1.\tUS Survey Foot (Default for State Plane 1927)\n");
fprintf(stderr, "2.\tInternational Foot\n");
fprintf(stderr, "3.\tMeter\n");
fprintf(stderr, ">");
} while (!G_gets(answer));
G_strip(answer);
if (strcmp(answer, "1") == 0) {
G_set_key_value("unit", "USfoot", in_unit_keys);
G_set_key_value("units", "USfeet", in_unit_keys);
G_set_key_value("meters", "0.30480060960121920243",
in_unit_keys);
break;
}
else if (strcmp(answer, "2") == 0) {
G_set_key_value("unit", "foot", in_unit_keys);
G_set_key_value("units", "feet", in_unit_keys);
G_set_key_value("meters", "0.3048", in_unit_keys);
break;
}
else if (strcmp(answer, "3") == 0) {
G_set_key_value("unit", "meter", in_unit_keys);
G_set_key_value("units", "meters", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
break;
}
else
fprintf(stderr, "\nInvalid Entry (number 1 - 3)\n");
}
break;
case PROJECTION_LL:
G_set_key_value("unit", "degree", in_unit_keys);
G_set_key_value("units", "degrees", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
break;
default:
if (G_strcasecmp(proj_out, "LL") != 0) {
fprintf(stderr, _("Enter plural form of units [meters]: "));
G_gets(answer);
if (strlen(answer) == 0) {
G_set_key_value("unit", "meter", in_unit_keys);
G_set_key_value("units", "meters", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
}
else {
const struct proj_unit *unit;
G_strip(answer);
unit = get_proj_unit(answer);
if (unit) {
#ifdef FOO
if (G_strcasecmp(proj_out, "STP") == 0 &&
!strcmp(answer, "feet")) {
fprintf(stderr,
"%cPROJECTION 99 State Plane cannot be in FEET.\n",
7);
remove(path); /* remove file */
leave(SP_FATAL);
}
#endif
G_set_key_value("unit", unit->unit, in_unit_keys);
G_set_key_value("units", unit->units, in_unit_keys);
sprintf(buffb, "%.10f", unit->fact);
G_set_key_value("meters", buffb, in_unit_keys);
}
else {
double unit_fact;
while (1) {
fprintf(stderr, _("Enter singular for unit: "));
G_gets(answer1);
G_strip(answer1);
if (strlen(answer1) > 0)
break;
}
while (1) {
fprintf(stderr,
_("Enter conversion factor from %s to meters: "),
answer);
G_gets(answer2);
G_strip(answer2);
if (!
(strlen(answer2) == 0 ||
(1 != sscanf(answer2, "%lf", &unit_fact))))
break;
}
G_set_key_value("unit", answer1, in_unit_keys);
G_set_key_value("units", answer, in_unit_keys);
sprintf(buffb, "%.10f", unit_fact);
G_set_key_value("meters", buffb, in_unit_keys);
}
}
}
else {
G_set_key_value("unit", "degree", in_unit_keys);
G_set_key_value("units", "degrees", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
}
} /* switch */
G_write_key_value_file(path, in_unit_keys, &out_stat);
if (out_stat != 0)
G_fatal_error(_("Error writing into UNITS output file <%s>"),
path);
G_free_key_value(in_unit_keys);
} /* if */
if (G__put_window(&cellhd, "", "DEFAULT_WIND") < 0)
G_fatal_error(_("Unable to write to DEFAULT_WIND region file"));
fprintf(stderr,
_("\nProjection information has been recorded for this location\n\n"));
if ((old_zone != zone) | (old_proj != cellhd.proj)) {
G_message(_("The geographic region information in WIND is now obsolete"));
G_message(_("Run g.region -d to update it"));
}
leave(0);
}
void make_link(const char *dsn_opt,
const char *format,
char *option_str, char **options)
{
int use_ogr;
char *filename, *dsn;
FILE *fp;
struct Key_Value *key_val;
key_val = G_create_key_value();
/* check for weird options */
if (G_strncasecmp(dsn_opt, "PG:", 3) == 0 &&
strcmp(format, "PostgreSQL") != 0)
G_warning(_("Data source starts with \"PG:\" prefix, expecting \"PostgreSQL\" "
"format (\"%s\" given)"), format);
/* use OGR ? */
use_ogr = is_ogr(format);
if (use_ogr) {
filename = "OGR";
G_remove("", "PG");
}
else {
filename = "PG";
G_remove("", "OGR");
}
/* be friendly, ignored 'PG:' prefix for GRASS-PostGIS data driver */
if (!use_ogr && strcmp(format, "PostgreSQL") == 0 &&
G_strncasecmp(dsn_opt, "PG:", 3) == 0) {
int i, length;
length = strlen(dsn_opt);
dsn = (char *) G_malloc(length - 3);
for (i = 3; i < length; i++)
dsn[i-3] = dsn_opt[i];
dsn[length-3] = '\0';
}
else {
dsn = G_store(dsn_opt);
}
/* parse options for PG data format */
if (options && *options && !use_ogr) {
int i;
char *key, *value;
i = 0;
while (options[i]) {
if (parse_option_pg(options[i++], &key, &value) != 0)
continue;
G_set_key_value(key, value, key_val);
}
}
/* datasource section */
if (dsn) {
if (use_ogr)
G_set_key_value("dsn", dsn, key_val);
else
G_set_key_value("conninfo", dsn, key_val);
}
if (use_ogr) { /* OGR */
if (format)
G_set_key_value("format", format, key_val);
if (option_str)
G_set_key_value("options", option_str, key_val);
}
else { /* PG */
G_set_key_value("format", "PostgreSQL", key_val);
}
/* save file - OGR or PG */
fp = G_fopen_new("", filename);
if (!fp)
G_fatal_error(_("Unable to create settings file"));
if (G_fwrite_key_value(fp, key_val) < 0)
G_fatal_error(_("Error writing settings file"));
fclose(fp);
if (use_ogr)
G_verbose_message(_("Switched to OGR format (%s)"),
G_find_key_value("format", key_val));
else
G_verbose_message(_("Switched to PostGIS format"));
G_free_key_value(key_val);
}
OGRSpatialReferenceH GPJ_grass_to_osr(struct Key_Value * proj_info,
struct Key_Value * proj_units)
{
struct pj_info pjinfo;
char *proj4, *proj4mod, *wkt, *modwkt, *startmod, *lastpart;
OGRSpatialReferenceH hSRS, hSRS2;
OGRErr errcode;
struct gpj_datum dstruct;
struct gpj_ellps estruct;
size_t len;
const char *ellpskv, *unit, *unfact;
char *ellps, *ellpslong, *datum, *params, *towgs84, *datumlongname,
*start, *end;
const char *sysname, *osrunit, *osrunfact;
double a, es, rf;
int haveparams = 0;
if ((proj_info == NULL) || (proj_units == NULL))
return NULL;
hSRS = OSRNewSpatialReference(NULL);
if (pj_get_kv(&pjinfo, proj_info, proj_units) < 0) {
G_warning(_("Unable parse GRASS PROJ_INFO file"));
return NULL;
}
if ((proj4 = pj_get_def(pjinfo.pj, 0)) == NULL) {
G_warning(_("Unable get PROJ.4-style parameter string"));
return NULL;
}
pj_free(pjinfo.pj);
unit = G_find_key_value("unit", proj_units);
unfact = G_find_key_value("meters", proj_units);
if (unfact != NULL && (strcmp(pjinfo.proj, "ll") != 0))
G_asprintf(&proj4mod, "%s +to_meter=%s", proj4, unfact);
else
proj4mod = G_store(proj4);
pj_dalloc(proj4);
if ((errcode = OSRImportFromProj4(hSRS, proj4mod)) != OGRERR_NONE) {
G_warning(_("OGR can't parse PROJ.4-style parameter string: "
"%s (OGR Error code was %d)"), proj4mod, errcode);
return NULL;
}
G_free(proj4mod);
if ((errcode = OSRExportToWkt(hSRS, &wkt)) != OGRERR_NONE) {
G_warning(_("OGR can't get WKT-style parameter string "
"(OGR Error code was %d)"), errcode);
return NULL;
}
ellpskv = G_find_key_value("ellps", proj_info);
GPJ__get_ellipsoid_params(proj_info, &a, &es, &rf);
haveparams = GPJ__get_datum_params(proj_info, &datum, ¶ms);
if(ellpskv != NULL)
ellps = G_store(ellpskv);
else
ellps = NULL;
if ((datum == NULL) || (GPJ_get_datum_by_name(datum, &dstruct) < 0)) {
datumlongname = G_store("unknown");
if (ellps == NULL)
ellps = G_store("unnamed");
}
else {
datumlongname = G_store(dstruct.longname);
if (ellps == NULL)
ellps = G_store(dstruct.ellps);
GPJ_free_datum(&dstruct);
}
G_free(datum);
if (GPJ_get_ellipsoid_by_name(ellps, &estruct) > 0) {
ellpslong = G_store(estruct.longname);
DatumNameMassage(&ellpslong);
GPJ_free_ellps(&estruct);
}
else
ellpslong = G_store(ellps);
startmod = strstr(wkt, "GEOGCS");
lastpart = strstr(wkt, "PRIMEM");
len = strlen(wkt) - strlen(startmod);
wkt[len] = '\0';
if (haveparams == 2) {
/* Only put datum params into the WKT if they were specifically
* specified in PROJ_INFO */
char *paramkey, *paramvalue;
paramkey = strtok(params, "=");
paramvalue = params + strlen(paramkey) + 1;
if (G_strcasecmp(paramkey, "towgs84") == 0)
G_asprintf(&towgs84, ",TOWGS84[%s]", paramvalue);
else
towgs84 = G_store("");
G_free(params);
}
else
towgs84 = G_store("");
sysname = OSRGetAttrValue(hSRS, "PROJCS", 0);
if (sysname == NULL) {
/* Not a projected co-ordinate system */
start = G_store("");
end = G_store("");
}
else {
if ((strcmp(sysname, "unnamed") == 0) &&
(G_find_key_value("name", proj_info) != NULL))
G_asprintf(&start, "PROJCS[\"%s\",",
G_find_key_value("name", proj_info));
else
start = G_store(wkt);
osrunit = OSRGetAttrValue(hSRS, "UNIT", 0);
osrunfact = OSRGetAttrValue(hSRS, "UNIT", 1);
if ((unfact == NULL) || (G_strcasecmp(osrunit, "unknown") != 0))
end = G_store("");
else {
char *buff;
double unfactf = atof(unfact);
G_asprintf(&buff, ",UNIT[\"%s\",", osrunit);
startmod = strstr(lastpart, buff);
len = strlen(lastpart) - strlen(startmod);
lastpart[len] = '\0';
G_free(buff);
if (unit == NULL)
unit = "unknown";
G_asprintf(&end, ",UNIT[\"%s\",%.16g]]", unit, unfactf);
}
}
OSRDestroySpatialReference(hSRS);
G_asprintf(&modwkt,
"%sGEOGCS[\"%s\",DATUM[\"%s\",SPHEROID[\"%s\",%.16g,%.16g]%s],%s%s",
start, ellps, datumlongname, ellpslong, a, rf, towgs84,
lastpart, end);
hSRS2 = OSRNewSpatialReference(modwkt);
G_free(modwkt);
CPLFree(wkt);
G_free(start);
G_free(ellps);
G_free(datumlongname);
G_free(ellpslong);
G_free(towgs84);
G_free(end);
return hSRS2;
}
/*!
\brief Get GDAL link settings for given raster map
\param name map name
\param mapset name of mapset
\return pointer to GDAL_link structure
\return NULL if link not found
*/
struct GDAL_link *Rast_get_gdal_link(const char *name, const char *mapset)
{
#ifdef GDAL_LINK
GDALDatasetH data;
GDALRasterBandH band;
GDALDataType type;
RASTER_MAP_TYPE req_type;
#endif
const char *filename;
int band_num;
struct GDAL_link *gdal;
RASTER_MAP_TYPE map_type;
FILE *fp;
struct Key_Value *key_val;
const char *p;
DCELL null_val;
int hflip, vflip;
if (!G_find_raster2(name, mapset))
return NULL;
map_type = Rast_map_type(name, mapset);
if (map_type < 0)
return NULL;
fp = G_fopen_old_misc("cell_misc", "gdal", name, mapset);
if (!fp)
return NULL;
key_val = G_fread_key_value(fp);
fclose(fp);
if (!key_val)
return NULL;
filename = G_find_key_value("file", key_val);
if (!filename)
return NULL;
p = G_find_key_value("band", key_val);
if (!p)
return NULL;
band_num = atoi(p);
if (!band_num)
return NULL;
p = G_find_key_value("null", key_val);
if (!p)
return NULL;
if (strcmp(p, "none") == 0)
Rast_set_d_null_value(&null_val, 1);
else
null_val = atof(p);
hflip = G_find_key_value("hflip", key_val) ? 1 : 0;
vflip = G_find_key_value("vflip", key_val) ? 1 : 0;
#ifdef GDAL_LINK
p = G_find_key_value("type", key_val);
if (!p)
return NULL;
type = atoi(p);
switch (type) {
case GDT_Byte:
case GDT_Int16:
case GDT_UInt16:
case GDT_Int32:
case GDT_UInt32:
req_type = CELL_TYPE;
break;
case GDT_Float32:
req_type = FCELL_TYPE;
break;
case GDT_Float64:
req_type = DCELL_TYPE;
break;
default:
return NULL;
}
if (req_type != map_type)
return NULL;
Rast_init_gdal();
data = (*pGDALOpen) (filename, GA_ReadOnly);
if (!data)
return NULL;
band = (*pGDALGetRasterBand) (data, band_num);
if (!band) {
(*pGDALClose) (data);
return NULL;
}
#endif
gdal = G_calloc(1, sizeof(struct GDAL_link));
gdal->filename = G_store(filename);
gdal->band_num = band_num;
gdal->null_val = null_val;
gdal->hflip = hflip;
gdal->vflip = vflip;
#ifdef GDAL_LINK
gdal->data = data;
gdal->band = band;
gdal->type = type;
#endif
return gdal;
}
int
G_compare_projections(const struct Key_Value *proj_info1,
const struct Key_Value *proj_units1,
const struct Key_Value *proj_info2,
const struct Key_Value *proj_units2)
{
const char *proj1, *proj2;
if (proj_info1 == NULL && proj_info2 == NULL)
return TRUE;
/* -------------------------------------------------------------------- */
/* Are they both in the same projection? */
/* -------------------------------------------------------------------- */
/* prevent seg fault in G_find_key_value */
if (proj_info1 == NULL || proj_info2 == NULL)
return -1;
proj1 = G_find_key_value("proj", proj_info1);
proj2 = G_find_key_value("proj", proj_info2);
if (proj1 == NULL || proj2 == NULL || strcmp(proj1, proj2))
return -1;
/* -------------------------------------------------------------------- */
/* Verify that the linear unit translation to meters is OK. */
/* -------------------------------------------------------------------- */
/* prevent seg fault in G_find_key_value */
if (proj_units1 == NULL && proj_units2 == NULL)
return TRUE;
if (proj_units1 == NULL || proj_units2 == NULL)
return -2;
{
double a1 = 0, a2 = 0;
if (G_find_key_value("meters", proj_units1) != NULL)
a1 = atof(G_find_key_value("meters", proj_units1));
if (G_find_key_value("meters", proj_units2) != NULL)
a2 = atof(G_find_key_value("meters", proj_units2));
if (a1 && a2 && (fabs(a2 - a1) > 0.000001))
return -2;
}
/* -------------------------------------------------------------------- */
/* Do they both have the same ellipsoid? */
/* Lets just check the semi-major axis for now to keep it simple */
/* -------------------------------------------------------------------- */
{
double a1 = 0, a2 = 0;
if (G_find_key_value("a", proj_info1) != NULL)
a1 = atof(G_find_key_value("a", proj_info1));
if (G_find_key_value("a", proj_info2) != NULL)
a2 = atof(G_find_key_value("a", proj_info2));
if (a1 && a2 && (fabs(a2 - a1) > 0.000001))
return -4;
}
/* -------------------------------------------------------------------- */
/* Zone check specially for UTM */
/* -------------------------------------------------------------------- */
if (!strcmp(proj1, "utm") && !strcmp(proj2, "utm")
&& atof(G_find_key_value("zone", proj_info1))
!= atof(G_find_key_value("zone", proj_info2)))
return -5;
/* -------------------------------------------------------------------- */
/* Do they both have the same false easting? */
/* -------------------------------------------------------------------- */
{
const char *x_0_1 = NULL, *x_0_2 = NULL;
x_0_1 = G_find_key_value("x_0", proj_info1);
x_0_2 = G_find_key_value("x_0", proj_info2);
if (x_0_1 && x_0_2 && (fabs(atof(x_0_1) - atof(x_0_2)) > 0.000001))
return -6;
}
/* -------------------------------------------------------------------- */
/* Do they both have the same false northing? */
/* -------------------------------------------------------------------- */
{
const char *y_0_1 = NULL, *y_0_2 = NULL;
y_0_1 = G_find_key_value("y_0", proj_info1);
y_0_2 = G_find_key_value("y_0", proj_info2);
if (y_0_1 && y_0_2 && (fabs(atof(y_0_1) - atof(y_0_2)) > 0.000001))
return -7;
}
/* -------------------------------------------------------------------- */
/* Add more details in later. */
/* -------------------------------------------------------------------- */
return TRUE;
}
int
GPJ__get_ellipsoid_params(const struct Key_Value *proj_keys,
double *a, double *e2, double *rf)
{
struct gpj_ellps estruct;
struct gpj_datum dstruct;
const char *str, *str3;
char *str1, *ellps;
str = G_find_key_value("datum", proj_keys);
if ((str != NULL) && (GPJ_get_datum_by_name(str, &dstruct) > 0)) {
/* If 'datum' key is present, look up correct ellipsoid
* from datum.table */
ellps = G_store(dstruct.ellps);
GPJ_free_datum(&dstruct);
}
else
/* else use ellipsoid defined in PROJ_INFO */
ellps = G_store(G_find_key_value("ellps", proj_keys));
if (ellps != NULL && *ellps) {
if (GPJ_get_ellipsoid_by_name(ellps, &estruct) < 0)
G_fatal_error(_("Invalid ellipsoid <%s> in file"), ellps);
*a = estruct.a;
*e2 = estruct.es;
*rf = estruct.rf;
GPJ_free_ellps(&estruct);
G_free(ellps);
return 1;
}
else {
if (ellps) /* *ellps = '\0' */
G_free(ellps);
str3 = G_find_key_value("a", proj_keys);
if (str3 != NULL) {
char *str4;
G_asprintf(&str4, "a=%s", str3);
if ((str3 = G_find_key_value("es", proj_keys)) != NULL)
G_asprintf(&str1, "e=%s", str3);
else if ((str3 = G_find_key_value("f", proj_keys)) != NULL)
G_asprintf(&str1, "f=1/%s", str3);
else if ((str3 = G_find_key_value("rf", proj_keys)) != NULL)
G_asprintf(&str1, "f=1/%s", str3);
else if ((str3 = G_find_key_value("b", proj_keys)) != NULL)
G_asprintf(&str1, "b=%s", str3);
else
G_fatal_error(_("No secondary ellipsoid descriptor "
"(rf, es or b) in file"));
if (get_a_e2_rf(str4, str1, a, e2, rf) == 0)
G_fatal_error(_("Invalid ellipsoid descriptors "
"(a, rf, es or b) in file"));
return 1;
}
else {
str = G_find_key_value("proj", proj_keys);
if ((str == NULL) || (strcmp(str, "ll") == 0)) {
*a = 6378137.0;
*e2 = .006694385;
*rf = 298.257223563;
return 0;
}
else {
G_fatal_error(_("No ellipsoid info given in file"));
}
}
}
return 1;
}
int G_get_datumparams_from_projinfo(const struct Key_Value *projinfo,
char *datumname, char *params)
{
int returnval = -1;
if (NULL != G_find_key_value("datum", projinfo)) {
sprintf(datumname, "%s", G_find_key_value("datum", projinfo));
returnval = 1;
}
if (G_find_key_value("datumparams", projinfo) != NULL) {
sprintf(params, "%s", G_find_key_value("datumparams", projinfo));
returnval = 2;
}
else if (G_find_key_value("nadgrids", projinfo) != NULL) {
sprintf(params, "nadgrids=%s",
G_find_key_value("nadgrids", projinfo));
returnval = 2;
}
else if (G_find_key_value("towgs84", projinfo) != NULL) {
sprintf(params, "towgs84=%s", G_find_key_value("towgs84", projinfo));
returnval = 2;
}
else if (G_find_key_value("dx", projinfo) != NULL
&& G_find_key_value("dy", projinfo) != NULL
&& G_find_key_value("dz", projinfo) != NULL) {
sprintf(params, "towgs84=%s,%s,%s",
G_find_key_value("dx", projinfo),
G_find_key_value("dy", projinfo),
G_find_key_value("dz", projinfo));
returnval = 2;
}
return returnval;
}