/* ---------------------------------------------------------------------- */
void
setFlowAccuColorTable(char* cellname) {
struct Colors colors;
const char *mapset;
struct Range r;
mapset = G_find_raster(cellname, "");
if (mapset == NULL) {
G_fatal_error (_("Raster map <%s> not found"), cellname);
}
if (Rast_read_range(cellname, mapset, &r) == -1) {
G_fatal_error(_("cannot read range"));
}
/*fprintf(stderr, "%s range is: min=%d, max=%d\n", cellname, r.min, r.max);*/
int v[6];
v[0] = r.min;
v[1] = 5;
v[2] = 30;
v[3] = 100;
v[4] = 1000;
v[5] = r.max;
Rast_init_colors(&colors);
Rast_add_c_color_rule(&v[0], 255,255,255, &v[1], 255,255,0, &colors);
Rast_add_c_color_rule(&v[1], 255,255,0, &v[2], 0,255,255, &colors);
Rast_add_c_color_rule(&v[2], 0,255,255, &v[3], 0,127,255, &colors);
Rast_add_c_color_rule(&v[3], 0,127,255, &v[4], 0,0,255, &colors);
Rast_add_c_color_rule(&v[4], 0,0,255, &v[5], 0,0,0, &colors);
Rast_write_colors(cellname, mapset, &colors);
Rast_free_colors(&colors);
}
void color_rules_to_cats(dbCatValArray *cvarr, int is_fp,
struct Colors *vcolors, struct Colors *colors)
{
int i, cat;
dbCatVal *cv;
int red, grn, blu;
/* color table for categories */
G_message(_("Converting color rules into categories..."));
for (i = 0; i < cvarr->n_values; i++) {
cv = &(cvarr->value[i]);
cat = cv->cat;
if (is_fp) {
if (Rast_get_d_color((const DCELL *) &(cv->val.d), &red, &grn, &blu,
vcolors) == 0) {
/* G_warning(_("No color rule defined for value %f"), cv->val.d); */
G_debug(3, "scan_attr(): cat=%d, val=%f -> no color rule", cat, cv->val.d);
continue;
}
}
else {
if (Rast_get_c_color((const CELL *) &(cv->val.i), &red, &grn, &blu,
vcolors) == 0) {
/* G_warning(_("No color rule defined for value %d"), cv->val.i); */
G_debug(3, "scan_attr(): cat=%d, val=%d -> no color rule", cat, cv->val.i);
continue;
}
}
G_debug(3, "scan_attr(): cat=%d, val=%f, r=%d, g=%d, b=%d",
cat, is_fp ? cv->val.d : cv->val.i, red, grn, blu);
Rast_add_c_color_rule((const CELL*) &cat, red, grn, blu,
(const CELL*) &cat, red, grn, blu, colors);
}
}
static void make_color_cube(struct Colors *colors)
{
int nr = B[0].levels;
int ng = B[1].levels;
int nb = B[2].levels;
int mr = B[0].maxlev;
int mg = B[1].maxlev;
int mb = B[2].maxlev;
int g, b;
int i = 0;
Rast_init_colors(colors);
G_message(_("Creating color table for output raster map..."));
for (b = 0; b < nb; b++) {
G_percent(b, nb, 5);
for (g = 0; g < ng; g++) {
int blu = b * 255 / mb;
int grn = g * 255 / mg;
CELL i0 = i;
CELL i1 = i + mr;
Rast_add_c_color_rule(&i0, 0, grn, blu,
&i1, 255, grn, blu, colors);
i += nr;
}
}
G_percent(nb, nb, 1);
}
void write_cols(void)
{
struct Colors colours;
CELL val1, val2;
Rast_init_colors(&colours);
val1 = FLAT;
val2 = PIT;
Rast_add_c_color_rule(&val1, 180, 180, 180, /* White */
&val2, 0, 0, 0, &colours); /* Black */
val1 = CHANNEL;
val2 = PASS;
Rast_add_c_color_rule(&val1, 0, 0, 255, /* Blue */
&val2, 0, 255, 0, &colours); /* Green */
val1 = RIDGE;
val2 = PEAK;
Rast_add_c_color_rule(&val1, 255, 255, 0, /* Yellow */
&val2, 255, 0, 0, &colours); /* Red */
Rast_write_colors(rast_out_name, G_mapset(), &colours);
Rast_free_colors(&colours);
}
static void write_colors_int(int c)
{
channel *ch = &channels[c];
CELL i0 = 0;
CELL i1 = ch->maxval;
struct Colors colors;
int i;
Rast_init_colors(&colors);
if (color_type == PNG_COLOR_TYPE_PALETTE)
{
png_colorp palette;
int num_palette;
png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette);
for (i = 0; i < num_palette; i++)
{
png_colorp col = &palette[i];
Rast_set_c_color((CELL) i, col->red, col->green, col->blue, &colors);
}
}
else if (c == C_A || t_gamma == 1.0)
Rast_add_c_color_rule(&i0, 0, 0, 0,
&i1, 255, 255, 255,
&colors);
else
for (i = 0; i <= i1; i++)
{
int v = intensity((double) i / i1);
Rast_set_c_color((CELL) i, v, v, v, &colors);
}
Rast_write_colors(ch->name, G_mapset(), &colors);
}
void rgb2colr(const struct Map_info *Map, int layer, const char *rgb_column,
struct Colors *colors)
{
int i, ret, nskipped;
int red, grn, blu;
const char *rgb;
struct field_info *fi;
dbDriver *driver;
dbCatValArray cvarr;
dbCatVal *cv;
fi = Vect_get_field(Map, layer);
if (!fi)
G_fatal_error(_("Database connection not defined for layer %d"),
layer);
driver = db_start_driver_open_database(fi->driver, fi->database);
if (!driver)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
fi->database, fi->driver);
if (db_column_Ctype(driver, fi->table, rgb_column) != DB_C_TYPE_STRING)
G_fatal_error(_("Data type of RGB column <%s> must be char"),
rgb_column);
if (0 > db_select_CatValArray(driver, fi->table, fi->key,
rgb_column, NULL, &cvarr))
G_warning(_("No RGB values found"));
Rast_init_colors(colors);
cv = NULL;
nskipped = 0;
for (i = 0; i < cvarr.n_values; i++) {
cv = &(cvarr.value[i]);
rgb = db_get_string(cv->val.s);
G_debug(3, "cat = %d RGB = %s", cv->cat, rgb);
if (!rgb) {
nskipped++;
continue;
}
ret = G_str_to_color(rgb, &red, &grn, &blu);
if (ret != 1) {
G_debug(3, "Invalid RGB value '%s'", rgb);
nskipped++;
continue;
}
Rast_add_c_color_rule((const CELL*) &(cv->cat), red, grn, blu,
(const CELL*) &(cv->cat), red, grn, blu, colors);
}
if (nskipped > 0)
G_warning(_("%d invalid RGB color values skipped"), nskipped);
db_close_database_shutdown_driver(driver);
}
/* parse input lines with the following formats
* val1:r:g:b val2:r:g:b
* val:r:g:b (implies cat1==cat2)
*
* r:g:b can be just a single grey level
* cat1:x cat2:y
* cat:x
*
* optional lines are
* invert invert color table
* shift:n where n is the amount to shift the color table
*/
static int read_new_colors(FILE * fd, struct Colors *colors)
{
double val1, val2;
long cat1, cat2;
int r1, g1, b1;
int r2, g2, b2;
char buf[1024];
char word1[256], word2[256];
int n, fp_rule;
int null, undef;
int modular;
DCELL shift;
if (fgets(buf, sizeof buf, fd) == NULL)
return -1;
G_strip(buf);
if (sscanf(buf + 1, "%lf %lf", &val1, &val2) == 2)
Rast_set_d_color_range((DCELL) val1, (DCELL) val2, colors);
modular = 0;
while (fgets(buf, sizeof buf, fd)) {
null = undef = fp_rule = 0;
*word1 = *word2 = 0;
n = sscanf(buf, "%s %s", word1, word2);
if (n < 1)
continue;
if (sscanf(word1, "shift:%lf", &shift) == 1
|| (strcmp(word1, "shift:") == 0 &&
sscanf(word2, "%lf", &shift) == 1)) {
Rast_shift_d_colors(shift, colors);
continue;
}
if (strcmp(word1, "invert") == 0) {
Rast_invert_colors(colors);
continue;
}
if (strcmp(word1, "%%") == 0) {
modular = !modular;
continue;
}
switch (sscanf(word1, "nv:%d:%d:%d", &r1, &g1, &b1)) {
case 1:
null = 1;
b1 = g1 = r1;
break;
case 3:
null = 1;
break;
}
if (!null)
switch (sscanf(word1, "*:%d:%d:%d", &r1, &g1, &b1)) {
case 1:
undef = 1;
b1 = g1 = r1;
break;
case 3:
undef = 1;
break;
}
if (!null && !undef)
switch (sscanf(word1, "%ld:%d:%d:%d", &cat1, &r1, &g1, &b1)) {
case 2:
b1 = g1 = r1;
break;
case 4:
break;
default:
if (sscanf(word1, "%lf:%d:%d:%d", &val1, &r1, &g1, &b1) == 4)
fp_rule = 1;
else if (sscanf(word1, "%lf:%d", &val1, &r1) == 2) {
fp_rule = 1;
b1 = g1 = r1;
}
else
continue; /* other lines are ignored */
}
if (n == 2) {
switch (sscanf(word2, "%ld:%d:%d:%d", &cat2, &r2, &g2, &b2)) {
case 2:
b2 = g2 = r2;
if (fp_rule)
val2 = (DCELL) cat2;
break;
case 4:
if (fp_rule)
val2 = (DCELL) cat2;
break;
default:
if (sscanf(word2, "%lf:%d:%d:%d", &val2, &r2, &g2, &b2) == 4) {
if (!fp_rule)
val1 = (DCELL) cat1;
fp_rule = 1;
}
else if (sscanf(word2, "%lf:%d", &val2, &r2) == 2) {
if (!fp_rule)
val1 = (DCELL) cat1;
fp_rule = 1;
b2 = g2 = r2;
}
else
continue; /* other lines are ignored */
}
}
else {
if (!fp_rule)
cat2 = cat1;
else
val2 = val1;
r2 = r1;
g2 = g1;
b2 = b1;
}
if (null)
Rast_set_null_value_color(r1, g1, b1, colors);
else if (undef)
Rast_set_default_color(r1, g1, b1, colors);
else if (modular) {
if (fp_rule)
Rast_add_modular_d_color_rule((DCELL *) & val1, r1, g1,
b1, (DCELL *) & val2, r2,
g2, b2, colors);
else
Rast_add_modular_c_color_rule((CELL *) &cat1, r1, g1, b1,
(CELL *) &cat2, r2, g2, b2, colors);
}
else {
if (fp_rule)
Rast_add_d_color_rule((DCELL *) & val1, r1, g1, b1,
(DCELL *) & val2, r2, g2, b2,
colors);
else
Rast_add_c_color_rule((CELL *) &cat1, r1, g1, b1,
(CELL *) &cat2, r2, g2, b2, colors);
}
/*
fprintf (stderr, "adding rule %d=%.2lf %d %d %d %d=%.2lf %d %d %d\n", cat1,val1, r1, g1, b1, cat2, val2, r2, g2, b2);
*/
}
return 1;
}
int main(int argc, char *argv[])
{
struct Cell_head cellhd; /*region+header info */
char *mapset; /*mapset name */
int nrows, ncols;
int row, col;
struct GModule *module;
struct Option *input1, *input2, *input3, *input4, *input5;
struct Option *input6, *input7, *input8, *input9, *output1;
struct Flag *flag1;
struct History history; /*metadata */
struct Colors colors; /*Color rules */
char *name; /*input raster name */
char *result; /*output raster name */
int infd_albedo, infd_ndvi, infd_tempk, infd_time, infd_dtair;
int infd_emissivity, infd_tsw, infd_doy, infd_sunzangle;
int outfd;
char *albedo, *ndvi, *tempk, *time, *dtair, *emissivity;
char *tsw, *doy, *sunzangle;
int i = 0, j = 0;
void *inrast_albedo, *inrast_ndvi, *inrast_tempk, *inrast_rnet;
void *inrast_time, *inrast_dtair, *inrast_emissivity, *inrast_tsw;
void *inrast_doy, *inrast_sunzangle;
DCELL * outrast;
CELL val1,val2; /*For color range*/
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("imagery"));
G_add_keyword(_("energy balance"));
G_add_keyword(_("net radiation"));
G_add_keyword(_("SEBAL"));
module->description =
_("Net radiation approximation (Bastiaanssen, 1995).");
/* Define the different options */
input1 = G_define_standard_option(G_OPT_R_INPUT);
input1->key = "albedo";
input1->description = _("Name of albedo raster map [0.0;1.0]");
input2 = G_define_standard_option(G_OPT_R_INPUT);
input2->key = "ndvi";
input2->description = _("Name of NDVI raster map [-1.0;+1.0]");
input3 = G_define_standard_option(G_OPT_R_INPUT);
input3->key = "temperature";
input3->description =
_("Name of surface temperature raster map [K]");
input4 = G_define_standard_option(G_OPT_R_INPUT);
input4->key = "localutctime";
input4->description =
_("Name of time of satellite overpass raster map [local time in UTC]");
input5 = G_define_standard_option(G_OPT_R_INPUT);
input5->key = "temperaturedifference2m";
input5->description =
_("Name of the difference map of temperature from surface skin to about 2 m height [K]");
input6 = G_define_standard_option(G_OPT_R_INPUT);
input6->key = "emissivity";
input6->description = _("Name of the emissivity map [-]");
input7 = G_define_standard_option(G_OPT_R_INPUT);
input7->key = "transmissivity_singleway";
input7->description =
_("Name of the single-way atmospheric transmissivitymap [-]");
input8 = G_define_standard_option(G_OPT_R_INPUT);
input8->key = "dayofyear";
input8->description = _("Name of the Day Of Year (DOY) map [-]");
input9 = G_define_standard_option(G_OPT_R_INPUT);
input9->key = "sunzenithangle";
input9->description = _("Name of the sun zenith angle map [degrees]");
output1 = G_define_standard_option(G_OPT_R_OUTPUT);
output1->description = _("Name of the output net radiation layer");
/********************/
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
albedo = input1->answer;
ndvi = input2->answer;
tempk = input3->answer;
time = input4->answer;
dtair = input5->answer;
emissivity = input6->answer;
tsw = input7->answer;
doy = input8->answer;
sunzangle = input9->answer;
result = output1->answer;
/* Open access to image files and allocate row access memory */
infd_albedo = Rast_open_old(albedo, "");
inrast_albedo = Rast_allocate_d_buf();
infd_ndvi = Rast_open_old(ndvi, "");
inrast_ndvi = Rast_allocate_d_buf();
infd_tempk = Rast_open_old(tempk, "");
inrast_tempk = Rast_allocate_d_buf();
infd_dtair = Rast_open_old(dtair, "");
inrast_dtair = Rast_allocate_d_buf();
infd_time = Rast_open_old(time, "");
inrast_time = Rast_allocate_d_buf();
infd_emissivity = Rast_open_old(emissivity, "");
inrast_emissivity = Rast_allocate_d_buf();
infd_tsw = Rast_open_old(tsw, "");
inrast_tsw = Rast_allocate_d_buf();
infd_doy = Rast_open_old(doy, "");
inrast_doy = Rast_allocate_d_buf();
infd_sunzangle = Rast_open_old(sunzangle, "");
inrast_sunzangle = Rast_allocate_d_buf();
nrows = Rast_window_rows();
ncols = Rast_window_cols();
outfd = Rast_open_new(result, DCELL_TYPE);
outrast = Rast_allocate_d_buf();
/* Process pixels */
for (row = 0; row < nrows; row++)
{
DCELL d;
DCELL d_albedo;
DCELL d_ndvi;
DCELL d_tempk;
DCELL d_dtair;
DCELL d_time;
DCELL d_emissivity;
DCELL d_tsw;
DCELL d_doy;
DCELL d_sunzangle;
/* Display row process percentage */
G_percent(row, nrows, 2);
/* Load rows for each input image */
Rast_get_d_row(infd_albedo, inrast_albedo, row);
Rast_get_d_row(infd_ndvi, inrast_ndvi, row);
Rast_get_d_row(infd_tempk, inrast_tempk, row);
Rast_get_d_row(infd_dtair, inrast_dtair, row);
Rast_get_d_row(infd_time, inrast_time, row);
Rast_get_d_row(infd_emissivity, inrast_emissivity, row);
Rast_get_d_row(infd_tsw, inrast_tsw, row);
Rast_get_d_row(infd_doy, inrast_doy, row);
Rast_get_d_row(infd_sunzangle, inrast_sunzangle, row);
/*process the data */
for (col = 0; col < ncols; col++)
{
d_albedo = (double)((DCELL *) inrast_albedo)[col];
d_ndvi = (double)((DCELL *) inrast_ndvi)[col];
d_tempk = (double)((DCELL *) inrast_tempk)[col];
d_dtair = (double)((DCELL *) inrast_dtair)[col];
d_time = (double)((DCELL *) inrast_time)[col];
d_emissivity = (double)((DCELL *) inrast_emissivity)[col];
d_tsw = (double)((DCELL *) inrast_tsw)[col];
d_doy = (double)((DCELL *) inrast_doy)[col];
d_sunzangle = (double)((DCELL *) inrast_sunzangle)[col];
/* process NULL Values */
if (Rast_is_d_null_value(&d_albedo) ||
Rast_is_d_null_value(&d_ndvi) ||
Rast_is_d_null_value(&d_tempk) ||
Rast_is_d_null_value(&d_dtair) ||
Rast_is_d_null_value(&d_time) ||
Rast_is_d_null_value(&d_emissivity) ||
Rast_is_d_null_value(&d_tsw) ||
Rast_is_d_null_value(&d_doy) ||
Rast_is_d_null_value(&d_sunzangle)) {
Rast_set_d_null_value(&outrast[col], 1);
}
else {
/************************************/
/* calculate the net radiation */
d = r_net(d_albedo, d_ndvi, d_tempk, d_dtair, d_emissivity, d_tsw, d_doy, d_time, d_sunzangle);
outrast[col] = d;
}
}
Rast_put_d_row(outfd, outrast);
}
G_free(inrast_albedo);
G_free(inrast_ndvi);
G_free(inrast_tempk);
G_free(inrast_dtair);
G_free(inrast_time);
G_free(inrast_emissivity);
G_free(inrast_tsw);
G_free(inrast_doy);
G_free(inrast_sunzangle);
Rast_close(infd_albedo);
Rast_close(infd_ndvi);
Rast_close(infd_tempk);
Rast_close(infd_dtair);
Rast_close(infd_time);
Rast_close(infd_emissivity);
Rast_close(infd_tsw);
Rast_close(infd_doy);
Rast_close(infd_sunzangle);
G_free(outrast);
Rast_close(outfd);
/* Colors in grey shade */
Rast_init_colors(&colors);
val1=0;
val2=900;
Rast_add_c_color_rule(&val1, 0, 0, 0, &val2, 255, 255, 255, &colors);
/* Metadata */
Rast_short_history(result, "raster", &history);
Rast_command_history(&history);
Rast_write_history(result, &history);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Cell_head cellhd; /*region+header info */
char *mapset; /*mapset name */
int nrows, ncols;
int row, col;
struct GModule *module;
struct Option *input, *input1, *input2, *input3, *input4, *input5, *output;
struct History history; /*metadata */
struct Colors colors; /*Color rules */
/************************************/
char *name, *name1, *name2; /*input raster name */
char *result; /*output raster name */
/*File Descriptors */
int nfiles, nfiles1, nfiles2;
int infd[MAXFILES], infd1[MAXFILES], infd2[MAXFILES];
int outfd;
/****************************************/
/* Pointers for file names */
char **names;
char **ptr;
char **names1;
char **ptr1;
char **names2;
char **ptr2;
/****************************************/
int DOYbeforeETa[MAXFILES], DOYafterETa[MAXFILES];
int bfr, aft;
/****************************************/
int ok;
int i = 0, j = 0;
double etodoy; /*minimum ETo DOY */
double startperiod, endperiod; /*first and last days (DOYs) of the period studied */
void *inrast[MAXFILES], *inrast1[MAXFILES], *inrast2[MAXFILES];
DCELL *outrast;
CELL val1, val2;
RASTER_MAP_TYPE in_data_type[MAXFILES]; /* ETa */
RASTER_MAP_TYPE in_data_type1[MAXFILES]; /* DOY of ETa */
RASTER_MAP_TYPE in_data_type2[MAXFILES]; /* ETo */
RASTER_MAP_TYPE out_data_type = DCELL_TYPE;
/************************************/
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("imagery"));
G_add_keyword(_("evapotranspiration"));
module->description =_("Computes temporal integration of satellite "
"ET actual (ETa) following the daily ET reference "
"(ETo) from meteorological station(s).");
/* Define the different options */
input = G_define_standard_option(G_OPT_R_INPUTS);
input->key = "eta";
input->description = _("Names of satellite ETa raster maps [mm/d or cm/d]");
input1 = G_define_standard_option(G_OPT_R_INPUTS);
input1->key = "eta_doy";
input1->description =
_("Names of satellite ETa Day of Year (DOY) raster maps [0-400] [-]");
input2 = G_define_standard_option(G_OPT_R_INPUTS);
input2->key = "eto";
input2->description =
_("Names of meteorological station ETo raster maps [0-400] [mm/d or cm/d]");
input3 = G_define_option();
input3->key = "eto_doy_min";
input3->type = TYPE_DOUBLE;
input3->required = YES;
input3->description = _("Value of DOY for ETo first day");
input4 = G_define_option();
input4->key = "start_period";
input4->type = TYPE_DOUBLE;
input4->required = YES;
input4->description = _("Value of DOY for the first day of the period studied");
input5 = G_define_option();
input5->key = "end_period";
input5->type = TYPE_DOUBLE;
input5->required = YES;
input5->description = _("Value of DOY for the last day of the period studied");
output = G_define_standard_option(G_OPT_R_OUTPUT);
/* init nfiles */
nfiles = 1;
nfiles1 = 1;
nfiles2 = 1;
/********************/
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
ok = 1;
names = input->answers;
ptr = input->answers;
names1 = input1->answers;
ptr1 = input1->answers;
names2 = input2->answers;
ptr2 = input2->answers;
etodoy = atof(input3->answer);
startperiod = atof(input4->answer);
endperiod = atof(input5->answer);
result = output->answer;
/****************************************/
if (endperiod<startperiod) {
G_fatal_error(_("The DOY for end_period can not be smaller than start_period"));
ok = 0;
}
if (etodoy>startperiod) {
G_fatal_error(_("The DOY for start_period can not be smaller than eto_doy_min"));
ok = 0;
}
for (; *ptr != NULL; ptr++) {
if (nfiles > MAXFILES)
G_fatal_error(_("Too many ETa files. Only %d allowed."),
MAXFILES);
name = *ptr;
/* Allocate input buffer */
infd[nfiles] = Rast_open_old(name, "");
Rast_get_cellhd(name, "", &cellhd);
inrast[nfiles] = Rast_allocate_d_buf();
nfiles++;
}
nfiles--;
if (nfiles <= 1)
G_fatal_error(_("The min specified input map is two"));
/****************************************/
for (; *ptr1 != NULL; ptr1++) {
if (nfiles1 > MAXFILES)
G_fatal_error(_("Too many ETa_doy files. Only %d allowed."),
MAXFILES);
name1 = *ptr1;
/* Allocate input buffer */
infd1[nfiles1] = Rast_open_old(name1, "");
Rast_get_cellhd(name1, "", &cellhd);
inrast1[nfiles1] = Rast_allocate_d_buf();
nfiles1++;
}
nfiles1--;
if (nfiles1 <= 1)
G_fatal_error(_("The min specified input map is two"));
/****************************************/
if (nfiles != nfiles1)
G_fatal_error(_("ETa and ETa_DOY file numbers are not equal!"));
/****************************************/
for (; *ptr2 != NULL; ptr2++) {
if (nfiles > MAXFILES)
G_fatal_error(_("Too many ETo files. Only %d allowed."),
MAXFILES);
name2 = *ptr2;
/* Allocate input buffer */
infd2[nfiles2] = Rast_open_old(name2, "");
Rast_get_cellhd(name2, "", &cellhd);
inrast2[nfiles2] = Rast_allocate_d_buf();
nfiles2++;
}
nfiles2--;
if (nfiles2 <= 1)
G_fatal_error(_("The min specified input map is two"));
/* Allocate output buffer, use input map data_type */
nrows = Rast_window_rows();
ncols = Rast_window_cols();
outrast = Rast_allocate_d_buf();
/* Create New raster files */
outfd = Rast_open_new(result, 1);
/*******************/
/* Process pixels */
double doy[MAXFILES];
double sum[MAXFILES];
for (row = 0; row < nrows; row++)
{
DCELL d_out;
DCELL d_ETrF[MAXFILES];
DCELL d[MAXFILES];
DCELL d1[MAXFILES];
DCELL d2[MAXFILES];
G_percent(row, nrows, 2);
/* read input map */
for (i = 1; i <= nfiles; i++)
Rast_get_d_row(infd[i], inrast[i], row);
for (i = 1; i <= nfiles1; i++)
Rast_get_d_row(infd1[i], inrast1[i], row);
for (i = 1; i <= nfiles2; i++)
Rast_get_d_row (infd2[i], inrast2[i], row);
/*process the data */
for (col = 0; col < ncols; col++)
{
int d1_null=0;
int d_null=0;
for (i = 1; i <= nfiles; i++)
{
if (Rast_is_d_null_value(&((DCELL *) inrast[i])[col]))
d_null=1;
else
d[i] = ((DCELL *) inrast[i])[col];
}
for (i = 1; i <= nfiles1; i++)
{
if (Rast_is_d_null_value(&((DCELL *) inrast1[i])[col]))
d1_null=1;
else
d1[i] = ((DCELL *) inrast1[i])[col];
}
for (i = 1; i <= nfiles2; i++)
d2[i] = ((DCELL *) inrast2[i])[col];
/* Find out the DOY of the eto image */
for (i = 1; i <= nfiles1; i++)
{
if ( d_null==1 || d1_null==1 )
Rast_set_d_null_value(&outrast[col],1);
else
{
doy[i] = d1[i] - etodoy+1;
if (Rast_is_d_null_value(&d2[(int)doy[i]]) || d2[(int)doy[i]]==0 )
Rast_set_d_null_value(&outrast[col],1);
else
d_ETrF[i] = d[i] / d2[(int)doy[i]];
}
}
for (i = 1; i <= nfiles1; i++)
{
/* do nothing */
if ( d_null==1 || d1_null==1)
{
/*G_message(" null value ");*/
}
else
{
DOYbeforeETa[i]=0; DOYafterETa[i]=0;
if (i == 1)
DOYbeforeETa[i] = startperiod;
else
{
int k=i-1;
while (d1[k]>=startperiod )
{
if (d1[k]<0) // case were d1[k] is null
k=k-1;
else
{
DOYbeforeETa[i] = 1+((d1[i] + d1[k])/2.0);
break;
}
}
}
if (i == nfiles1)
DOYafterETa[i] = endperiod;
else
{
int k=i+1;
while (d1[k]<=endperiod)
{
if (d1[k]<0) // case were d1[k] is null
k=k+1;
else
{
DOYafterETa[i] = (d1[i] + d1[k]) / 2.0;
break;
}
}
}
}
}
sum[MAXFILES] = 0.0;
for (i = 1; i <= nfiles1; i++)
{
if(d_null==1 || d1_null==1)
{
/* do nothing */
}
else
{
if (DOYbeforeETa[i]==0 || DOYbeforeETa[i]==0 )
Rast_set_d_null_value(&outrast[col],1);
else
{
bfr = (int)DOYbeforeETa[i];
aft = (int)DOYafterETa[i];
sum[i]=0.0;
for (j = bfr; j < aft; j++)
sum[i] += d2[(int)(j-etodoy+1)];
}
}
}
d_out = 0.0;
for (i = 1; i <= nfiles1; i++)
{
if(d_null==1 || d_null==1)
Rast_set_d_null_value(&outrast[col],1);
else
{
d_out += d_ETrF[i] * sum[i];
outrast[col] = d_out;
}
}
}
Rast_put_row(outfd, outrast, out_data_type);
}
for (i = 1; i <= nfiles; i++) {
G_free(inrast[i]);
Rast_close(infd[i]);
}
for (i = 1; i <= nfiles1; i++) {
G_free(inrast1[i]);
Rast_close(infd1[i]);
}
for (i = 1; i <= nfiles2; i++) {
G_free(inrast2[i]);
Rast_close(infd2[i]);
}
G_free(outrast);
Rast_close(outfd);
/* Color table from 0.0 to 10.0 */
Rast_init_colors(&colors);
val1 = 0;
val2 = 10;
Rast_add_c_color_rule(&val1, 0, 0, 0, &val2, 255, 255, 255, &colors);
/* Metadata */
Rast_short_history(result, "raster", &history);
Rast_command_history(&history);
Rast_write_history(result, &history);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int nrows, ncols;
int row, col;
char *viflag; /*Switch for particular index */
char *desc;
struct GModule *module;
struct {
struct Option *viname, *red, *nir, *green, *blue, *chan5,
*chan7, *sl_slope, *sl_int, *sl_red, *bits, *output;
} opt;
struct History history; /*metadata */
struct Colors colors; /*Color rules */
char *result; /*output raster name */
int infd_redchan, infd_nirchan, infd_greenchan;
int infd_bluechan, infd_chan5chan, infd_chan7chan;
int outfd;
char *bluechan, *greenchan, *redchan, *nirchan, *chan5chan, *chan7chan;
DCELL *inrast_redchan, *inrast_nirchan, *inrast_greenchan;
DCELL *inrast_bluechan, *inrast_chan5chan, *inrast_chan7chan;
DCELL *outrast;
RASTER_MAP_TYPE data_type_redchan;
RASTER_MAP_TYPE data_type_nirchan, data_type_greenchan;
RASTER_MAP_TYPE data_type_bluechan;
RASTER_MAP_TYPE data_type_chan5chan, data_type_chan7chan;
DCELL msavip1, msavip2, msavip3, dnbits;
CELL val1, val2;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("imagery"));
G_add_keyword(_("vegetation index"));
G_add_keyword(_("biophysical parameters"));
module->label =
_("Calculates different types of vegetation indices.");
module->description = _("Uses red and nir bands mostly, "
"and some indices require additional bands.");
/* Define the different options */
opt.red = G_define_standard_option(G_OPT_R_INPUT);
opt.red->key = "red";
opt.red->label =
_("Name of input red channel surface reflectance map");
opt.red->description = _("Range: [0.0;1.0]");
opt.output = G_define_standard_option(G_OPT_R_OUTPUT);
opt.viname = G_define_option();
opt.viname->key = "viname";
opt.viname->type = TYPE_STRING;
opt.viname->required = YES;
opt.viname->description = _("Type of vegetation index");
desc = NULL;
G_asprintf(&desc,
"arvi;%s;dvi;%s;evi;%s;evi2;%s;gvi;%s;gari;%s;gemi;%s;ipvi;%s;msavi;%s;"
"msavi2;%s;ndvi;%s;pvi;%s;savi;%s;sr;%s;vari;%s;wdvi;%s",
_("Atmospherically Resistant Vegetation Index"),
_("Difference Vegetation Index"),
_("Enhanced Vegetation Index"),
_("Enhanced Vegetation Index 2"),
_("Green Vegetation Index"),
_("Green Atmospherically Resistant Vegetation Index"),
_("Global Environmental Monitoring Index"),
_("Infrared Percentage Vegetation Index"),
_("Modified Soil Adjusted Vegetation Index"),
_("second Modified Soil Adjusted Vegetation Index"),
_("Normalized Difference Vegetation Index"),
_("Perpendicular Vegetation Index"),
_("Soil Adjusted Vegetation Index"),
_("Simple Ratio"),
_("Visible Atmospherically Resistant Index"),
_("Weighted Difference Vegetation Index"));
opt.viname->descriptions = desc;
opt.viname->options = "arvi,dvi,evi,evi2,gvi,gari,gemi,ipvi,msavi,msavi2,ndvi,pvi,savi,sr,vari,wdvi";
opt.viname->answer = "ndvi";
opt.viname->key_desc = _("type");
opt.nir = G_define_standard_option(G_OPT_R_INPUT);
opt.nir->key = "nir";
opt.nir->required = NO;
opt.nir->label =
_("Name of input nir channel surface reflectance map");
opt.nir->description = _("Range: [0.0;1.0]");
opt.nir->guisection = _("Optional inputs");
opt.green = G_define_standard_option(G_OPT_R_INPUT);
opt.green->key = "green";
opt.green->required = NO;
opt.green->label =
_("Name of input green channel surface reflectance map");
opt.green->description = _("Range: [0.0;1.0]");
opt.green->guisection = _("Optional inputs");
opt.blue = G_define_standard_option(G_OPT_R_INPUT);
opt.blue->key = "blue";
opt.blue->required = NO;
opt.blue->label =
_("Name of input blue channel surface reflectance map");
opt.blue->description = _("Range: [0.0;1.0]");
opt.blue->guisection = _("Optional inputs");
opt.chan5 = G_define_standard_option(G_OPT_R_INPUT);
opt.chan5->key = "band5";
opt.chan5->required = NO;
opt.chan5->label =
_("Name of input 5th channel surface reflectance map");
opt.chan5->description = _("Range: [0.0;1.0]");
opt.chan5->guisection = _("Optional inputs");
opt.chan7 = G_define_standard_option(G_OPT_R_INPUT);
opt.chan7->key = "band7";
opt.chan7->required = NO;
opt.chan7->label =
_("Name of input 7th channel surface reflectance map");
opt.chan7->description = _("Range: [0.0;1.0]");
opt.chan7->guisection = _("Optional inputs");
opt.sl_slope = G_define_option();
opt.sl_slope->key = "soil_line_slope";
opt.sl_slope->type = TYPE_DOUBLE;
opt.sl_slope->required = NO;
opt.sl_slope->description = _("Value of the slope of the soil line (MSAVI only)");
opt.sl_slope->guisection = _("MSAVI settings");
opt.sl_int = G_define_option();
opt.sl_int->key = "soil_line_intercept";
opt.sl_int->type = TYPE_DOUBLE;
opt.sl_int->required = NO;
opt.sl_int->description = _("Value of the intercept of the soil line (MSAVI only)");
opt.sl_int->guisection = _("MSAVI settings");
opt.sl_red = G_define_option();
opt.sl_red->key = "soil_noise_reduction";
opt.sl_red->type = TYPE_DOUBLE;
opt.sl_red->required = NO;
opt.sl_red->description = _("Value of the factor of reduction of soil noise (MSAVI only)");
opt.sl_red->guisection = _("MSAVI settings");
opt.bits = G_define_option();
opt.bits->key = "storage_bit";
opt.bits->type = TYPE_INTEGER;
opt.bits->required = NO;
opt.bits->label = _("Maximum bits for digital numbers");
opt.bits->description = _("If data is in Digital Numbers (i.e. integer type), give the max bits (i.e. 8 for Landsat -> [0-255])");
opt.bits->options = "7,8,10,16";
opt.bits->answer = "8";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
viflag = opt.viname->answer;
redchan = opt.red->answer;
nirchan = opt.nir->answer;
greenchan = opt.green->answer;
bluechan = opt.blue->answer;
chan5chan = opt.chan5->answer;
chan7chan = opt.chan7->answer;
if(opt.sl_slope->answer)
msavip1 = atof(opt.sl_slope->answer);
if(opt.sl_int->answer)
msavip2 = atof(opt.sl_int->answer);
if(opt.sl_red->answer)
msavip3 = atof(opt.sl_red->answer);
if(opt.bits->answer)
dnbits = atof(opt.bits->answer);
result = opt.output->answer;
G_verbose_message(_("Calculating %s..."), viflag);
if (!strcasecmp(viflag, "sr") && (!(opt.red->answer) || !(opt.nir->answer)) )
G_fatal_error(_("sr index requires red and nir maps"));
if (!strcasecmp(viflag, "ndvi") && (!(opt.red->answer) || !(opt.nir->answer)) )
G_fatal_error(_("ndvi index requires red and nir maps"));
if (!strcasecmp(viflag, "ipvi") && (!(opt.red->answer) || !(opt.nir->answer)) )
G_fatal_error(_("ipvi index requires red and nir maps"));
if (!strcasecmp(viflag, "dvi") && (!(opt.red->answer) || !(opt.nir->answer)) )
G_fatal_error(_("dvi index requires red and nir maps"));
if (!strcasecmp(viflag, "pvi") && (!(opt.red->answer) || !(opt.nir->answer)) )
G_fatal_error(_("pvi index requires red and nir maps"));
if (!strcasecmp(viflag, "wdvi") && (!(opt.red->answer) || !(opt.nir->answer)) )
G_fatal_error(_("wdvi index requires red and nir maps"));
if (!strcasecmp(viflag, "savi") && (!(opt.red->answer) || !(opt.nir->answer)) )
G_fatal_error(_("savi index requires red and nir maps"));
if (!strcasecmp(viflag, "msavi") && (!(opt.red->answer) || !(opt.nir->answer) ||
!(opt.sl_slope->answer) || !(opt.sl_int->answer) ||
!(opt.sl_red->answer)) )
G_fatal_error(_("msavi index requires red and nir maps, and 3 parameters related to soil line"));
if (!strcasecmp(viflag, "msavi2") && (!(opt.red->answer) || !(opt.nir->answer)) )
G_fatal_error(_("msavi2 index requires red and nir maps"));
if (!strcasecmp(viflag, "gemi") && (!(opt.red->answer) || !(opt.nir->answer)) )
G_fatal_error(_("gemi index requires red and nir maps"));
if (!strcasecmp(viflag, "arvi") && (!(opt.red->answer) || !(opt.nir->answer)
|| !(opt.blue->answer)) )
G_fatal_error(_("arvi index requires blue, red and nir maps"));
if (!strcasecmp(viflag, "evi") && (!(opt.red->answer) || !(opt.nir->answer)
|| !(opt.blue->answer)) )
G_fatal_error(_("evi index requires blue, red and nir maps"));
if (!strcasecmp(viflag, "evi2") && (!(opt.red->answer) || !(opt.nir->answer) ) )
G_fatal_error(_("evi2 index requires red and nir maps"));
if (!strcasecmp(viflag, "vari") && (!(opt.red->answer) || !(opt.green->answer)
|| !(opt.blue->answer)) )
G_fatal_error(_("vari index requires blue, green and red maps"));
if (!strcasecmp(viflag, "gari") && (!(opt.red->answer) || !(opt.nir->answer)
|| !(opt.green->answer) || !(opt.blue->answer)) )
G_fatal_error(_("gari index requires blue, green, red and nir maps"));
if (!strcasecmp(viflag, "gvi") && (!(opt.red->answer) || !(opt.nir->answer)
|| !(opt.green->answer) || !(opt.blue->answer)
|| !(opt.chan5->answer) || !(opt.chan7->answer)) )
G_fatal_error(_("gvi index requires blue, green, red, nir, chan5 and chan7 maps"));
infd_redchan = Rast_open_old(redchan, "");
data_type_redchan = Rast_map_type(redchan, "");
inrast_redchan = Rast_allocate_buf(data_type_redchan);
if (nirchan) {
infd_nirchan = Rast_open_old(nirchan, "");
data_type_nirchan = Rast_map_type(nirchan, "");
inrast_nirchan = Rast_allocate_buf(data_type_nirchan);
}
if (greenchan) {
infd_greenchan = Rast_open_old(greenchan, "");
data_type_greenchan = Rast_map_type(greenchan, "");
inrast_greenchan = Rast_allocate_buf(data_type_greenchan);
}
if (bluechan) {
infd_bluechan = Rast_open_old(bluechan, "");
data_type_bluechan = Rast_map_type(bluechan, "");
inrast_bluechan = Rast_allocate_buf(data_type_bluechan);
}
if (chan5chan) {
infd_chan5chan = Rast_open_old(chan5chan, "");
data_type_chan5chan = Rast_map_type(chan5chan, "");
inrast_chan5chan = Rast_allocate_buf(data_type_chan5chan);
}
if (chan7chan) {
infd_chan7chan = Rast_open_old(chan7chan, "");
data_type_chan7chan = Rast_map_type(chan7chan, "");
inrast_chan7chan = Rast_allocate_buf(data_type_chan7chan);
}
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* Create New raster files */
outfd = Rast_open_new(result, DCELL_TYPE);
outrast = Rast_allocate_d_buf();
/* Process pixels */
for (row = 0; row < nrows; row++)
{
DCELL d_bluechan;
DCELL d_greenchan;
DCELL d_redchan;
DCELL d_nirchan;
DCELL d_chan5chan;
DCELL d_chan7chan;
G_percent(row, nrows, 2);
/* read input maps */
Rast_get_row(infd_redchan,inrast_redchan,row,data_type_redchan);
if (nirchan) {
Rast_get_row(infd_nirchan,inrast_nirchan,row,data_type_nirchan);
}
if (bluechan) {
Rast_get_row(infd_bluechan,inrast_bluechan,row,data_type_bluechan);
}
if (greenchan) {
Rast_get_row(infd_greenchan,inrast_greenchan,row,data_type_greenchan);
}
if (chan5chan) {
Rast_get_row(infd_chan5chan,inrast_chan5chan,row,data_type_chan5chan);
}
if (chan7chan) {
Rast_get_row(infd_chan7chan,inrast_chan7chan,row,data_type_chan7chan);
}
/* process the data */
for (col = 0; col < ncols; col++)
{
switch(data_type_redchan){
case CELL_TYPE:
d_redchan = (double) ((CELL *) inrast_redchan)[col];
if(opt.bits->answer)
d_redchan *= 1.0/(pow(2,dnbits)-1);
break;
case FCELL_TYPE:
d_redchan = (double) ((FCELL *) inrast_redchan)[col];
break;
case DCELL_TYPE:
d_redchan = ((DCELL *) inrast_redchan)[col];
break;
}
if (nirchan) {
switch(data_type_nirchan){
case CELL_TYPE:
d_nirchan = (double) ((CELL *) inrast_nirchan)[col];
if(opt.bits->answer)
d_nirchan *= 1.0/(pow(2,dnbits)-1);
break;
case FCELL_TYPE:
d_nirchan = (double) ((FCELL *) inrast_nirchan)[col];
break;
case DCELL_TYPE:
d_nirchan = ((DCELL *) inrast_nirchan)[col];
break;
}
}
if (greenchan) {
switch(data_type_greenchan){
case CELL_TYPE:
d_greenchan = (double) ((CELL *) inrast_greenchan)[col];
if(opt.bits->answer)
d_greenchan *= 1.0/(pow(2,dnbits)-1);
break;
case FCELL_TYPE:
d_greenchan = (double) ((FCELL *) inrast_greenchan)[col];
break;
case DCELL_TYPE:
d_greenchan = ((DCELL *) inrast_greenchan)[col];
break;
}
}
if (bluechan) {
switch(data_type_bluechan){
case CELL_TYPE:
d_bluechan = (double) ((CELL *) inrast_bluechan)[col];
if(opt.bits->answer)
d_bluechan *= 1.0/(pow(2,dnbits)-1);
break;
case FCELL_TYPE:
d_bluechan = (double) ((FCELL *) inrast_bluechan)[col];
break;
case DCELL_TYPE:
d_bluechan = ((DCELL *) inrast_bluechan)[col];
break;
}
}
if (chan5chan) {
switch(data_type_chan5chan){
case CELL_TYPE:
d_chan5chan = (double) ((CELL *) inrast_chan5chan)[col];
if(opt.bits->answer)
d_chan5chan *= 1.0/(pow(2,dnbits)-1);
break;
case FCELL_TYPE:
d_chan5chan = (double) ((FCELL *) inrast_chan5chan)[col];
break;
case DCELL_TYPE:
d_chan5chan = ((DCELL *) inrast_chan5chan)[col];
break;
}
}
if (chan7chan) {
switch(data_type_chan7chan){
case CELL_TYPE:
d_chan7chan = (double) ((CELL *) inrast_chan7chan)[col];
if(opt.bits->answer)
d_chan7chan *= 1.0/(pow(2,dnbits)-1);
break;
case FCELL_TYPE:
d_chan7chan = (double) ((FCELL *) inrast_chan7chan)[col];
break;
case DCELL_TYPE:
d_chan7chan = ((DCELL *) inrast_chan7chan)[col];
break;
}
}
if (Rast_is_d_null_value(&d_redchan) ||
((nirchan) && Rast_is_d_null_value(&d_nirchan)) ||
((greenchan) && Rast_is_d_null_value(&d_greenchan)) ||
((bluechan) && Rast_is_d_null_value(&d_bluechan)) ||
((chan5chan) && Rast_is_d_null_value(&d_chan5chan)) ||
((chan7chan) && Rast_is_d_null_value(&d_chan7chan))) {
Rast_set_d_null_value(&outrast[col], 1);
}
else {
/* calculate simple_ratio */
if (!strcasecmp(viflag, "sr"))
outrast[col] = s_r(d_redchan, d_nirchan);
/* calculate ndvi */
if (!strcasecmp(viflag, "ndvi")) {
if (d_redchan + d_nirchan < 0.001)
Rast_set_d_null_value(&outrast[col], 1);
else
outrast[col] = nd_vi(d_redchan, d_nirchan);
}
if (!strcasecmp(viflag, "ipvi"))
outrast[col] = ip_vi(d_redchan, d_nirchan);
if (!strcasecmp(viflag, "dvi"))
outrast[col] = d_vi(d_redchan, d_nirchan);
if (!strcasecmp(viflag, "evi"))
outrast[col] = e_vi(d_bluechan, d_redchan, d_nirchan);
if (!strcasecmp(viflag, "evi2"))
outrast[col] = e_vi2(d_redchan, d_nirchan);
if (!strcasecmp(viflag, "pvi"))
outrast[col] = p_vi(d_redchan, d_nirchan);
if (!strcasecmp(viflag, "wdvi"))
outrast[col] = wd_vi(d_redchan, d_nirchan);
if (!strcasecmp(viflag, "savi"))
outrast[col] = sa_vi(d_redchan, d_nirchan);
if (!strcasecmp(viflag, "msavi"))
outrast[col] = msa_vi(d_redchan, d_nirchan, msavip1, msavip2, msavip3);
if (!strcasecmp(viflag, "msavi2"))
outrast[col] = msa_vi2(d_redchan, d_nirchan);
if (!strcasecmp(viflag, "gemi"))
outrast[col] = ge_mi(d_redchan, d_nirchan);
if (!strcasecmp(viflag, "arvi"))
outrast[col] = ar_vi(d_redchan, d_nirchan, d_bluechan);
if (!strcasecmp(viflag, "gvi"))
outrast[col] = g_vi(d_bluechan, d_greenchan, d_redchan, d_nirchan, d_chan5chan, d_chan7chan);
if (!strcasecmp(viflag, "gari"))
outrast[col] = ga_ri(d_redchan, d_nirchan, d_bluechan, d_greenchan);
if (!strcasecmp(viflag, "vari"))
outrast[col] = va_ri(d_redchan, d_greenchan, d_bluechan);
}
}
Rast_put_d_row(outfd, outrast);
}
G_percent(1, 1, 1);
G_free(inrast_redchan);
Rast_close(infd_redchan);
if (nirchan) {
G_free(inrast_nirchan);
Rast_close(infd_nirchan);
}
if (greenchan) {
G_free(inrast_greenchan);
Rast_close(infd_greenchan);
}
if (bluechan) {
G_free(inrast_bluechan);
Rast_close(infd_bluechan);
}
if (chan5chan) {
G_free(inrast_chan5chan);
Rast_close(infd_chan5chan);
}
if (chan7chan) {
G_free(inrast_chan7chan);
Rast_close(infd_chan7chan);
}
G_free(outrast);
Rast_close(outfd);
if (!strcasecmp(viflag, "ndvi")) {
/* apply predefined NDVI color table */
const char *style = "ndvi";
if (G_find_color_rule("ndvi")) {
Rast_make_fp_colors(&colors, style, -1.0, 1.0);
} else
G_fatal_error(_("Unknown color request '%s'"), style);
} else {
/* Color from -1.0 to +1.0 in grey */
Rast_init_colors(&colors);
val1 = -1;
val2 = 1;
Rast_add_c_color_rule(&val1, 0, 0, 0, &val2, 255, 255, 255, &colors);
}
Rast_write_colors(result, G_mapset(), &colors);
Rast_short_history(result, "raster", &history);
Rast_command_history(&history);
Rast_write_history(result, &history);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int nrows, ncols;
int row, col;
struct GModule *module;
struct Option *input1, *input2, *input3, *input4, *input5, *input6;
struct Option *output1;
struct History history; /*metadata */
struct Colors colors;
char *result1; /*output raster name */
int infd_fpar, infd_luf, infd_lat;
int infd_doy, infd_tsw, infd_wa;
int outfd1;
char *fpar, *luf, *lat, *doy, *tsw, *wa;
void *inrast_fpar, *inrast_luf, *inrast_lat;
void *inrast_doy, *inrast_tsw, *inrast_wa;
DCELL * outrast1;
CELL val1, val2;
/************************************/
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("imagery"));
G_add_keyword(_("biomass"));
G_add_keyword(_("fpar"));
G_add_keyword(_("yield"));
module->description =
_("Computes biomass growth, precursor of crop yield calculation.");
/* Define the different options */
input1 = G_define_standard_option(G_OPT_R_INPUT);
input1->key = "fpar";
input1->description = _("Name of fPAR raster map");
input2 = G_define_standard_option(G_OPT_R_INPUT);
input2->key = "lightuseefficiency";
input2->description =
_("Name of light use efficiency raster map (UZB:cotton=1.9)");
input3 = G_define_standard_option(G_OPT_R_INPUT);
input3->key = "latitude";
input3->description = _("Name of degree latitude raster map [dd.ddd]");
input4 = G_define_standard_option(G_OPT_R_INPUT);
input4->key = "dayofyear";
input4->description = _("Name of Day of Year raster map [1-366]");
input5 = G_define_standard_option(G_OPT_R_INPUT);
input5->key = "transmissivitysingleway";
input5->description =
_("Name of single-way transmissivity raster map [0.0-1.0]");
input6 = G_define_standard_option(G_OPT_R_INPUT);
input6->key = "wateravailability";
input6->description =
_("Value of water availability raster map [0.0-1.0]");
output1 = G_define_standard_option(G_OPT_R_OUTPUT);
output1->description =
_("Name for output daily biomass growth raster map [kg/ha/d]");
/********************/
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
fpar = input1->answer;
luf = input2->answer;
lat = input3->answer;
doy = input4->answer;
tsw = input5->answer;
wa = input6->answer;
result1 = output1->answer;
/***************************************************/
infd_fpar = Rast_open_old(fpar, "");
inrast_fpar = Rast_allocate_d_buf();
infd_luf = Rast_open_old(luf, "");
inrast_luf = Rast_allocate_d_buf();
infd_lat = Rast_open_old(lat, "");
inrast_lat = Rast_allocate_d_buf();
infd_doy = Rast_open_old(doy, "");
inrast_doy = Rast_allocate_d_buf();
infd_tsw = Rast_open_old(tsw, "");
inrast_tsw = Rast_allocate_d_buf();
infd_wa = Rast_open_old(wa, "");
inrast_wa = Rast_allocate_d_buf();
nrows = Rast_window_rows();
ncols = Rast_window_cols();
outrast1 = Rast_allocate_d_buf();
/* Create New raster files */
outfd1 = Rast_open_new(result1, DCELL_TYPE);
/* Process pixels */
for (row = 0; row < nrows; row++)
{
DCELL d;
DCELL d_fpar;
DCELL d_luf;
DCELL d_lat;
DCELL d_doy;
DCELL d_tsw;
DCELL d_solar;
DCELL d_wa;
G_percent(row, nrows, 2);
/* read input maps */
Rast_get_d_row(infd_fpar, inrast_fpar, row);
Rast_get_d_row(infd_luf,inrast_luf,row);
Rast_get_d_row(infd_lat, inrast_lat, row);
Rast_get_d_row(infd_doy, inrast_doy, row);
Rast_get_d_row(infd_tsw, inrast_tsw, row);
Rast_get_d_row(infd_wa,inrast_wa,row);
/*process the data */
for (col = 0; col < ncols; col++)
{
d_fpar = ((DCELL *) inrast_fpar)[col];
d_luf = ((DCELL *) inrast_luf)[col];
d_lat = ((DCELL *) inrast_lat)[col];
d_doy = ((DCELL *) inrast_doy)[col];
d_tsw = ((DCELL *) inrast_tsw)[col];
d_wa = ((DCELL *) inrast_wa)[col];
if (Rast_is_d_null_value(&d_fpar) ||
Rast_is_d_null_value(&d_luf) ||
Rast_is_d_null_value(&d_lat) ||
Rast_is_d_null_value(&d_doy) ||
Rast_is_d_null_value(&d_tsw) ||
Rast_is_d_null_value(&d_wa))
Rast_set_d_null_value(&outrast1[col], 1);
else {
d_solar = solar_day(d_lat, d_doy, d_tsw);
d = biomass(d_fpar,d_solar,d_wa,d_luf);
outrast1[col] = d;
}
}
Rast_put_d_row(outfd1, outrast1);
}
/* Color table for biomass */
Rast_init_colors(&colors);
val1 = 0;
val2 = 1;
Rast_add_c_color_rule(&val1, 0, 0, 0, &val2, 255, 255, 255, &colors);
G_free(inrast_fpar);
G_free(inrast_luf);
G_free(inrast_lat);
G_free(inrast_doy);
G_free(inrast_tsw);
G_free(inrast_wa);
G_free(outrast1);
Rast_close(infd_fpar);
Rast_close(infd_luf);
Rast_close(infd_lat);
Rast_close(infd_doy);
Rast_close(infd_tsw);
Rast_close(infd_wa);
Rast_close(outfd1);
Rast_short_history(result1, "raster", &history);
Rast_command_history(&history);
Rast_write_history(result1, &history);
exit(EXIT_SUCCESS);
}
