int do_varifilter(dataptr dz)
{
double *dls = dz->parray[FLT_DLS];
double *dbs = dz->parray[FLT_DBS];
double *dhs = dz->parray[FLT_DHS];
double *dns = dz->parray[FLT_DNS];
double *dops[2];
double coeff = 0.0;
float *buf = dz->sampbuf[0];
int n;
int k, chans = dz->infile->channels;
int is_fbrk = FALSE, is_qbrk = FALSE;
if(dz->brksize[FLT_ONEFRQ]) is_fbrk = TRUE;
if(dz->brksize[FLT_Q]) is_qbrk = TRUE;
for(n=0;n<chans;n++) {
switch(dz->mode){
case(FSW_HIGH): dops[n] = &(dz->parray[FLT_DHS][n]); break;
case(FSW_LOW): dops[n] = &(dz->parray[FLT_DLS][n]); break;
case(FSW_BAND): dops[n] = &(dz->parray[FLT_DBS][n]); break;
case(FSW_NOTCH): dops[n] = &(dz->parray[FLT_DNS][n]); break;
}
}
for (n = 0 ; n < dz->ssampsread; n += chans) {
if(is_fbrk && (--dz->iparam[FLT_FSAMS] <= 0)) {
if(!newvalue(FLT_ONEFRQ,FLT_F_INCR,FLT_FSAMS,dz)) {
sprintf(errstr,"Ran out of sweepfrq values: do_varifilter()\n");
return(PROGRAM_ERROR);
}
}
if(is_qbrk && (--dz->iparam[FLT_SAMS] <= 0)) {
if(!newvalue(FLT_Q,FLT_Q_INCR,FLT_SAMS,dz)) {
sprintf(errstr,"Ran out of Q values: do_sweep_filter()\n");
return(PROGRAM_ERROR);
}
}
if(--dz->iparam[FLT_BLOKCNT] <= 0){
coeff = (2.0 * PI * dz->param[FLT_ONEFRQ]) * dz->param[FLT_INV_SR];
if(is_fbrk) dz->param[FLT_ONEFRQ] *= dz->param[FLT_F_INCR];
if(is_qbrk) {
dz->param[FLT_QFAC] = 1.0/(1.0 + dz->param[FLT_Q]);
dz->param[FLT_Q] *= dz->param[FLT_Q_INCR];
}
dz->iparam[FLT_BLOKCNT] = dz->iparam[FLT_BLOKSIZE];
}
for(k=0;k<chans;k++)
buf[n+k] = multifilter(&(dbs[k]),&(dls[k]),&(dhs[k]),&(dns[k]),dops[k],dz->param[FLT_Q],coeff,buf[n+k],dz);
}
return(CONTINUE);
}
int do_qvary_filters(dataptr dz)
{
int n;
int fno, chans = dz->infile->channels;
float *buf = dz->sampbuf[0];
double *ampl = dz->parray[FLT_AMPL];
double *a = dz->parray[FLT_A];
double *b = dz->parray[FLT_B];
double *y = dz->parray[FLT_Y];
double *z = dz->parray[FLT_Z];
double *d = dz->parray[FLT_D];
double *e = dz->parray[FLT_E];
for (n = 0; n < dz->ssampsread; n += chans) {
if((dz->iparam[FLT_SAMS] -= chans) <= 0) {
if(!newvalue(FLT_Q,FLT_Q_INCR,FLT_SAMS,dz)) {
sprintf(errstr,"Ran out of Q values: do_qvary_filters()\n");
return(PROGRAM_ERROR);
}
dz->iparam[FLT_SAMS] *= chans;
}
if((dz->iparam[FLT_BLOKCNT] -= chans) <= 0) {
for (fno = 0; fno < dz->iparam[FLT_CNT]; fno++)
get_coeffs2(fno,dz);
dz->param[FLT_Q] *= dz->param[FLT_Q_INCR];
dz->iparam[FLT_BLOKCNT] = dz->iparam[FLT_BLOKSIZE] * chans;
}
filtering(n,chans,buf,a,b,y,z,d,e,ampl,dz);
}
return(CONTINUE);
}
int
lbind_pushnil(struct vars *v) {
struct lvar * s = newvalue(v);
if (s == NULL)
return -1;
s->type = LT_NIL;
return 0;
}
int
lbind_pushinteger(struct vars *v, int i) {
struct lvar * s = newvalue(v);
if (s == NULL)
return -1;
s->type = LT_INTEGER;
s->v.i = i;
return 0;
}
int
lbind_pushreal(struct vars *v, double f) {
struct lvar * s = newvalue(v);
if (s == NULL)
return -1;
s->type = LT_REAL;
s->v.f = f;
return 0;
}
int
lbind_pushstring(struct vars *v, const char *str) {
struct lvar * s = newvalue(v);
if (s == NULL)
return -1;
s->type = LT_STRING;
s->v.s = str;
return 0;
}
int
lbind_pushboolean(struct vars *v, int b) {
struct lvar * s = newvalue(v);
if (s == NULL)
return -1;
s->type = LT_BOOLEAN;
s->v.b = b;
return 0;
}
int
lbind_pushpointer(struct vars *v, void *p) {
struct lvar * s = newvalue(v);
if (s == NULL)
return -1;
s->type = LT_POINTER;
s->v.p = p;
return 0;
}
void ConfigParameter::testLastParam()
{
Config* config = Config::getInstance();
std::string key("key");
std::string value("i wish to replace this value");
std::string newvalue("new value");
config->setParam(key, value);
config->setParam(key, newvalue);
config->setLastParam(key);
CPPUNIT_ASSERT(config->getParam(key) == value);
}
std::string UtilsWin::convertPathTo83Path(const std::string& path)
{
std::string newvalue(path);
DWORD lenght;
lenght = GetShortPathName(path.c_str(), NULL, 0);
if (lenght > 0) {
TCHAR* buffer = new TCHAR[lenght];
lenght = GetShortPathName(path.c_str(), buffer, lenght);
if (lenght > 0) {
newvalue.assign(static_cast < char* >(buffer));
}
delete [] buffer;
}
return newvalue;
}
int do_fvary2_filters(dataptr dz)
{
int exit_status;
int n, fno, chans = dz->infile->channels;
float *buf = dz->sampbuf[0];
//double *fincr = dz->parray[FLT_FINCR];
//double *aincr = dz->parray[FLT_AINCR];
double *ampl = dz->parray[FLT_AMPL];
double *a = dz->parray[FLT_A];
double *b = dz->parray[FLT_B];
double *y = dz->parray[FLT_Y];
double *z = dz->parray[FLT_Z];
double *d = dz->parray[FLT_D];
double *e = dz->parray[FLT_E];
int fsams = dz->iparam[FLT_FSAMS];
for (n = 0; n < dz->ssampsread; n += chans) {
if(dz->brksize[FLT_Q]) {
if((dz->iparam[FLT_SAMS] -= chans) <= 0) {
if(!newvalue(FLT_Q,FLT_Q_INCR,FLT_SAMS,dz)) {
sprintf(errstr,"Ran out of Q values: do_fvary2_filters()\n");
return(PROGRAM_ERROR);
}
dz->iparam[FLT_SAMS] *= chans;
}
}
if(fsams <= 0) {
if((exit_status = newfval2(dz->parray[FLT_FBRK],dz->parray[FLT_HBRK],dz))<0)
return(exit_status);
fsams = dz->iparam[FLT_FSAMS];
for (fno = 0; fno < dz->iparam[FLT_CNT]; fno++) {
get_coeffs1(fno,dz);
get_coeffs2(fno,dz);
}
if(dz->brksize[FLT_Q])
dz->param[FLT_Q] *= dz->param[FLT_Q_INCR];
}
filtering(n,chans,buf,a,b,y,z,d,e,ampl,dz);
fsams--;
}
return(CONTINUE);
}
int varidelay_allpass(float *buf,int chans,double prescale,dataptr dz)
{
int n, thisdelbfpos1, thisdelbfpos2, sampno;
int delay, channo;
double frac, ip, op, delval1,delval2, delval;
double *delbuf1 = dz->parray[FLT_DELBUF1];
double *delbuf2 = dz->parray[FLT_DELBUF2];
int maxdelsamps = dz->iparam[FLT_MAXDELSAMPS] * chans;
int delbufpos = dz->iparam[FLT_DELBUFPOS];
switch(dz->mode) {
case(FLT_PHASESHIFT):
for(n=0;n<dz->ssampsread;n+= chans){
if(--dz->iparam[FLT_SAMS] <= 0) {
if(!newvalue(FLT_DELAY,FLT_D_INCR,FLT_SAMS,dz)) {
sprintf(errstr,"Ran out of Delay vals: varidelay_allpass()\n");
return(PROGRAM_ERROR);
}
}
delay = (int)dz->param[FLT_DELAY];
frac = dz->param[FLT_DELAY] - (double)delay;
for(channo = 0;channo < chans; channo++) {
sampno = n + channo;
thisdelbfpos1 = my_modulus((delbufpos - (delay*chans)),maxdelsamps);
thisdelbfpos2 = my_modulus((thisdelbfpos1 + chans) ,maxdelsamps);
ip = (double)buf[sampno] * prescale;
op = (-dz->param[FLT_GAIN]) * ip;
delval1 = delbuf1[thisdelbfpos1];
delval2 = delbuf1[thisdelbfpos2];
delval = delval1 + ((delval2 - delval1) * frac);
op += delval;
delval1 = delbuf2[thisdelbfpos1];
delval2 = delbuf2[thisdelbfpos2];
delval = delval1 + ((delval2 - delval1) * frac);
op += dz->param[FLT_GAIN] * delval;
delbuf1[delbufpos] = ip;
delbuf2[delbufpos] = op;
if(++delbufpos >= maxdelsamps)
// delbufpos = 0;
delbufpos -= maxdelsamps; /*RWD 9:2001 */
//TW ?????? maxdelsamps is a mutiple of channels, delbufpos is incremented by 1 each time
// so (delbufpos -= maxdelsamps) = 0
buf[sampno] = (float) (op);
}
if(dz->vflag[FLT_LINDELAY])
dz->param[FLT_DELAY] += dz->param[FLT_D_INCR];
else
dz->param[FLT_DELAY] *= dz->param[FLT_D_INCR];
}
break;
case(FLT_PHASER):
for(n=0;n<dz->ssampsread;n+= chans){
if(--dz->iparam[FLT_SAMS] <= 0) {
if(!newvalue(FLT_DELAY,FLT_D_INCR,FLT_SAMS,dz)) {
sprintf(errstr,"Ran out of Delay vals: varidelay_allpass()\n");
return(PROGRAM_ERROR);
}
}
delay = (int)dz->param[FLT_DELAY];
frac = dz->param[FLT_DELAY] - (double)delay;
for(channo = 0;channo < chans; channo++) {
sampno = n + channo;
thisdelbfpos1 = my_modulus((delbufpos - (delay*chans)),maxdelsamps);
thisdelbfpos2 = my_modulus((thisdelbfpos1 + chans) ,maxdelsamps);
ip = (double)buf[sampno] * prescale;
op = (-dz->param[FLT_GAIN]) * ip;
delval1 = delbuf1[thisdelbfpos1];
delval2 = delbuf1[thisdelbfpos2];
delval = delval1 + ((delval2 - delval1) * frac);
op += delval;
delval1 = delbuf2[thisdelbfpos1];
delval2 = delbuf2[thisdelbfpos2];
delval = delval1 + ((delval2 - delval1) * frac);
op += dz->param[FLT_GAIN] * delval;
delbuf1[delbufpos] = ip;
delbuf2[delbufpos] = op;
if(++delbufpos >= maxdelsamps)
//delbufpos = 0;
delbufpos -= maxdelsamps; /*RWD 9:2001 (see e_tmp/cdpfloat ) */
//TW ?????? maxdelsamps is a mutiple of channels, delbufpos is incremented by 1 each time
// so (delbufpos -= maxdelsamps) = 0
buf[sampno] = (float) ((op + (double)buf[sampno]) * 0.5);
}
if(dz->vflag[FLT_LINDELAY])
dz->param[FLT_DELAY] += dz->param[FLT_D_INCR];
else
dz->param[FLT_DELAY] *= dz->param[FLT_D_INCR];
}
break;
default:
sprintf(errstr,"Unknown case:varidelay_allpass()\n");
return(PROGRAM_ERROR);
}
dz->iparam[FLT_DELBUFPOS] = delbufpos;
return(FINISHED);
}
void reset( T *ptr = nullptr ) {
shared_ptr<T> newvalue(ptr);
locker.writer.lock();
internalPtr = newvalue;
locker.writer.unlock();
}
bool resetIfNull( T *ptr = nullptr ) {
shared_ptr<T> newvalue(ptr);
shared_ptr<T> oldvalue(nullptr);
return compare_exchange(oldvalue, newvalue);
}
bool clearIfEqual( const shared_ptr<T> &curvalue ) {
shared_ptr<T> newvalue(nullptr);
return compare_exchange(curvalue, newvalue);
}
int do_fvary_filters(dataptr dz)
{
int exit_status;
int n, m, fno, chans = dz->infile->channels;
float *buf = dz->sampbuf[0];
double *fincr = dz->parray[FLT_FINCR];
double *aincr = dz->parray[FLT_AINCR];
double *ampl = dz->parray[FLT_AMPL];
double *a = dz->parray[FLT_A];
double *b = dz->parray[FLT_B];
double *y = dz->parray[FLT_Y];
double *z = dz->parray[FLT_Z];
double *d = dz->parray[FLT_D];
double *e = dz->parray[FLT_E];
int fsams = dz->iparam[FLT_FSAMS];
if (dz->vflag[DROP_OUT_AT_OVFLOW]) {
for (n = 0; n < dz->ssampsread; n += chans) {
if(fsams <= 0) {
if((exit_status = newfval(&fsams,dz))<0)
return(exit_status);
}
if(dz->brksize[FLT_Q]) {
if((dz->iparam[FLT_SAMS] -= chans) <= 0) {
if(!newvalue(FLT_Q,FLT_Q_INCR,FLT_SAMS,dz)) {
sprintf(errstr,"Ran out of Q values: do_fvary_filters()\n");
return(PROGRAM_ERROR);
}
dz->iparam[FLT_SAMS] *= chans;
}
}
if((dz->iparam[FLT_BLOKCNT] -= chans) <= 0) {
for (fno = 0; fno < dz->iparam[FLT_CNT]; fno++) {
get_coeffs1(fno,dz);
get_coeffs2(fno,dz);
}
if(dz->brksize[FLT_Q])
dz->param[FLT_Q] *= dz->param[FLT_Q_INCR];
for(m=0;m<dz->iparam[FLT_CNT];m++) {
dz->parray[FLT_FRQ][m] *= fincr[m];
dz->parray[FLT_AMP][m] *= aincr[m];
}
dz->iparam[FLT_BLOKCNT] = dz->iparam[FLT_BLOKSIZE] * chans;
}
filtering(n,chans,buf,a,b,y,z,d,e,ampl,dz);
if(dz->iparam[FLT_OVFLW] > 0) {
sprintf(errstr,"Filter overflowed\n");
return(GOAL_FAILED);
}
fsams--;
}
} else {
for (n = 0; n < dz->ssampsread; n += chans) {
if(fsams <= 0) {
if((exit_status = newfval(&fsams,dz))<0)
return(exit_status);
}
if(dz->brksize[FLT_Q]) {
if((dz->iparam[FLT_SAMS] -= chans) <= 0) {
if(!newvalue(FLT_Q,FLT_Q_INCR,FLT_SAMS,dz)) {
sprintf(errstr,"Ran out of Q values: do_fvary_filters()\n");
return(PROGRAM_ERROR);
}
dz->iparam[FLT_SAMS] *= chans;
}
}
if((dz->iparam[FLT_BLOKCNT] -= chans) <= 0) {
for (fno = 0; fno < dz->iparam[FLT_CNT]; fno++) {
get_coeffs1(fno,dz);
get_coeffs2(fno,dz);
}
if(dz->brksize[FLT_Q])
dz->param[FLT_Q] *= dz->param[FLT_Q_INCR];
for(m=0;m<dz->iparam[FLT_CNT];m++) {
dz->parray[FLT_FRQ][m] *= fincr[m];
dz->parray[FLT_AMP][m] *= aincr[m];
}
dz->iparam[FLT_BLOKCNT] = dz->iparam[FLT_BLOKSIZE] * chans;
}
filtering(n,chans,buf,a,b,y,z,d,e,ampl,dz);
fsams--;
}
}
dz->iparam[FLT_FSAMS] = fsams;
return(CONTINUE);
}
int main(int argc, char *argv[])
{
char *p;
int method;
int in_fd;
int selection_fd;
int out_fd;
DCELL *result;
char *selection;
RASTER_MAP_TYPE map_type;
int row, col;
int readrow;
int nrows, ncols;
int n;
int copycolr;
int half;
stat_func *newvalue;
stat_func_w *newvalue_w;
ifunc cat_names;
double quantile;
const void *closure;
struct Colors colr;
struct Cell_head cellhd;
struct Cell_head window;
struct History history;
struct GModule *module;
struct
{
struct Option *input, *output, *selection;
struct Option *method, *size;
struct Option *title;
struct Option *weight;
struct Option *gauss;
struct Option *quantile;
} parm;
struct
{
struct Flag *align, *circle;
} flag;
DCELL *values; /* list of neighborhood values */
DCELL(*values_w)[2]; /* list of neighborhood values and weights */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("algebra"));
G_add_keyword(_("statistics"));
module->description =
_("Makes each cell category value a "
"function of the category values assigned to the cells "
"around it, and stores new cell values in an output raster "
"map layer.");
parm.input = G_define_standard_option(G_OPT_R_INPUT);
parm.selection = G_define_standard_option(G_OPT_R_INPUT);
parm.selection->key = "selection";
parm.selection->required = NO;
parm.selection->description = _("Name of an input raster map to select the cells which should be processed");
parm.output = G_define_standard_option(G_OPT_R_OUTPUT);
parm.method = G_define_option();
parm.method->key = "method";
parm.method->type = TYPE_STRING;
parm.method->required = NO;
parm.method->answer = "average";
p = G_malloc(1024);
for (n = 0; menu[n].name; n++) {
if (n)
strcat(p, ",");
else
*p = 0;
strcat(p, menu[n].name);
}
parm.method->options = p;
parm.method->description = _("Neighborhood operation");
parm.method->guisection = _("Neighborhood");
parm.size = G_define_option();
parm.size->key = "size";
parm.size->type = TYPE_INTEGER;
parm.size->required = NO;
parm.size->description = _("Neighborhood size");
parm.size->answer = "3";
parm.size->guisection = _("Neighborhood");
parm.title = G_define_option();
parm.title->key = "title";
parm.title->key_desc = "phrase";
parm.title->type = TYPE_STRING;
parm.title->required = NO;
parm.title->description = _("Title of the output raster map");
parm.weight = G_define_standard_option(G_OPT_F_INPUT);
parm.weight->key = "weight";
parm.weight->required = NO;
parm.weight->description = _("Text file containing weights");
parm.gauss = G_define_option();
parm.gauss->key = "gauss";
parm.gauss->type = TYPE_DOUBLE;
parm.gauss->required = NO;
parm.gauss->description = _("Sigma (in cells) for Gaussian filter");
parm.quantile = G_define_option();
parm.quantile->key = "quantile";
parm.quantile->type = TYPE_DOUBLE;
parm.quantile->required = NO;
parm.quantile->description = _("Quantile to calculate for method=quantile");
parm.quantile->options = "0.0-1.0";
parm.quantile->answer = "0.5";
flag.align = G_define_flag();
flag.align->key = 'a';
flag.align->description = _("Do not align output with the input");
flag.circle = G_define_flag();
flag.circle->key = 'c';
flag.circle->description = _("Use circular neighborhood");
flag.circle->guisection = _("Neighborhood");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
sscanf(parm.size->answer, "%d", &ncb.nsize);
if (ncb.nsize <= 0)
G_fatal_error(_("Neighborhood size must be positive"));
if (ncb.nsize % 2 == 0)
G_fatal_error(_("Neighborhood size must be odd"));
ncb.dist = ncb.nsize / 2;
if (parm.weight->answer && flag.circle->answer)
G_fatal_error(_("weight= and -c are mutually exclusive"));
if (parm.weight->answer && parm.gauss->answer)
G_fatal_error(_("weight= and gauss= are mutually exclusive"));
ncb.oldcell = parm.input->answer;
ncb.newcell = parm.output->answer;
if (!flag.align->answer) {
Rast_get_cellhd(ncb.oldcell, "", &cellhd);
G_get_window(&window);
Rast_align_window(&window, &cellhd);
Rast_set_window(&window);
}
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* open raster maps */
in_fd = Rast_open_old(ncb.oldcell, "");
map_type = Rast_get_map_type(in_fd);
/* get the method */
for (method = 0; (p = menu[method].name); method++)
if ((strcmp(p, parm.method->answer) == 0))
break;
if (!p) {
G_warning(_("<%s=%s> unknown %s"),
parm.method->key, parm.method->answer, parm.method->key);
G_usage();
exit(EXIT_FAILURE);
}
if (menu[method].method == c_quant) {
quantile = atoi(parm.quantile->answer);
closure = &quantile;
}
half = (map_type == CELL_TYPE) ? menu[method].half : 0;
/* establish the newvalue routine */
newvalue = menu[method].method;
newvalue_w = menu[method].method_w;
/* copy color table? */
copycolr = menu[method].copycolr;
if (copycolr) {
G_suppress_warnings(1);
copycolr =
(Rast_read_colors(ncb.oldcell, "", &colr) > 0);
G_suppress_warnings(0);
}
/* read the weights */
if (parm.weight->answer) {
read_weights(parm.weight->answer);
if (!newvalue_w)
weights_mask();
}
else if (parm.gauss->answer) {
if (!newvalue_w)
G_fatal_error(_("Method %s not compatible with Gaussian filter"), parm.method->answer);
gaussian_weights(atof(parm.gauss->answer));
}
else
newvalue_w = NULL;
/* allocate the cell buffers */
allocate_bufs();
result = Rast_allocate_d_buf();
/* get title, initialize the category and stat info */
if (parm.title->answer)
strcpy(ncb.title, parm.title->answer);
else
sprintf(ncb.title, "%dx%d neighborhood: %s of %s",
ncb.nsize, ncb.nsize, menu[method].name, ncb.oldcell);
/* initialize the cell bufs with 'dist' rows of the old cellfile */
readrow = 0;
for (row = 0; row < ncb.dist; row++)
readcell(in_fd, readrow++, nrows, ncols);
/* open the selection raster map */
if (parm.selection->answer) {
G_message(_("Opening selection map <%s>"), parm.selection->answer);
selection_fd = Rast_open_old(parm.selection->answer, "");
selection = Rast_allocate_null_buf();
} else {
selection_fd = -1;
selection = NULL;
}
/*open the new raster map */
out_fd = Rast_open_new(ncb.newcell, map_type);
if (flag.circle->answer)
circle_mask();
if (newvalue_w)
values_w =
(DCELL(*)[2]) G_malloc(ncb.nsize * ncb.nsize * 2 * sizeof(DCELL));
else
values = (DCELL *) G_malloc(ncb.nsize * ncb.nsize * sizeof(DCELL));
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
readcell(in_fd, readrow++, nrows, ncols);
if (selection)
Rast_get_null_value_row(selection_fd, selection, row);
for (col = 0; col < ncols; col++) {
DCELL *rp = &result[col];
if (selection && selection[col]) {
*rp = ncb.buf[ncb.dist][col];
continue;
}
if (newvalue_w)
n = gather_w(values_w, col);
else
n = gather(values, col);
if (n < 0)
Rast_set_d_null_value(rp, 1);
else {
if (newvalue_w)
newvalue_w(rp, values_w, n, closure);
else
newvalue(rp, values, n, closure);
if (half && !Rast_is_d_null_value(rp))
*rp += 0.5;
}
}
Rast_put_d_row(out_fd, result);
}
G_percent(row, nrows, 2);
Rast_close(out_fd);
Rast_close(in_fd);
if (selection)
Rast_close(selection_fd);
/* put out category info */
null_cats();
if ((cat_names = menu[method].cat_names))
cat_names();
Rast_write_cats(ncb.newcell, &ncb.cats);
if (copycolr)
Rast_write_colors(ncb.newcell, G_mapset(), &colr);
Rast_short_history(ncb.newcell, "raster", &history);
Rast_command_history(&history);
Rast_write_history(ncb.newcell, &history);
exit(EXIT_SUCCESS);
}
