int process(char * sat_dname, char * result_fname, char * shp_aoi_fname, char * shp_forest_fname, char ** svm_fname)
{
try;
int ret = 0;
unsigned v, u, t, pixel_index, height, width;
uint8_t index, * fa_buf, ** sat_buf;
double vec[DIM];
s_sat * sat = NULL, * fa_img = NULL;
s_svm * svm[2] = { NULL, NULL };
my_printf("Begin");
// ############################################################################
// Загрузка драйверов форматов, загрузка спутникового снимка, загрузка SVM
init();
throw_null((sat = sat_load(sat_dname)));
for(v = 0; v < 2; v++)
throw_null((svm[v] = svm_load(svm_fname[v])));
// ############################################################################
// Расчет aoi
throw_null((fa_img = sat_aoi(sat, shp_aoi_fname, shp_forest_fname)));
// ############################################################################
// Обработка спутникового снимка
height = sat->height;
width = sat->width;
sat_buf = sat->pixel;
fa_buf = fa_img->pixel[0];
for(v = 0; v < height; v++)
{
my_printf("Row %u from %u ( %lf %% )", v + 1, height, (100.0 * (v + 1)) / height);
for(u = 0; u < width; u++)
{
pixel_index = v * width + u;
if(fa_buf[pixel_index] > 0)
{
for(t = 0; t < DIM; t++)
vec[t] = sat_buf[t][pixel_index];
if(svm_run(svm[0], vec) > 0)
index = 3;
else if(svm_run(svm[1], vec) > 0)
index = 2;
else
index = 1;
}
else
index = 0;
fa_buf[pixel_index] = index;
}
}
// ############################################################################
// Сохранение результирующего изображения
throw(sat_save_ch(fa_img, result_fname, 0));
my_printf("Success");
catch;
ret = -1;
my_printf("Fail");
finally;
for(v = 0; v < 2; v++)
svm_destroy(svm[v]);
sat_destroy(sat);
sat_destroy(fa_img);
destroy();
return ret;
}
int main(int argc, char **argv)
{
int seed = 1, xdim = 0, ydim = 1, csz = 0, yindex = 0, ssz = 0;
int clever = 0, regress = 0, dump = 0, best = 0, wfirst = 0, lazy = 0;
int offset = 0, xdelta = 0, tube = 0;
double trate = 2.0, tfinal = 10.0;
double C = 100, aux = 0.5, tol = 1e-3, eps = 1e-12, regeps = 0.1;
char *fname = NULL, *kname = "gauss", *dtype = "ascii";
OPTION opts[] = {
{ "-dtype", OPT_STRING, &dtype,
"data type. Value should be one of: "
"ascii, double, short (short_val / 1000.0 = dbl_val), or map "
"(memory-mapped file of doubles)" },
{ "-kernel", OPT_STRING, &kname,
"SVM kernel. Value should be one of: "
"gauss, poly, tanh, or linear" },
{ "-xdim", OPT_INT, &xdim,
"dimensionality of input points" },
{ "-ydim", OPT_INT, &ydim,
"dimensionality of target points" },
{ "-ssz", OPT_INT, &ssz,
"subset size" },
{ "-fname", OPT_STRING, &fname,
"data file name" },
{ "-seed", OPT_INT, &seed,
"random number seed for shuffled indices" },
{ "-C", OPT_DOUBLE, &C,
"maximum size for Lagrange multipliers" },
{ "-aux", OPT_DOUBLE, &aux,
"auxiliary parameter: variance for Gaussian kernels, "
"power for polynomials, and threshold for sigmoids" },
{ "-tol", OPT_DOUBLE, &tol,
"tolerance for classification errors" },
{ "-eps", OPT_DOUBLE, &eps,
"floating point epsilon" },
{ "-csz", OPT_INT, &csz,
"kernel output cache size" },
{ "-yindex", OPT_INT, &yindex,
"which y[] to classify" },
{ "-clever", OPT_SWITCH, &clever,
"use 'ultra clever' incremental outputs" },
{ "-best", OPT_SWITCH, &best,
"use best step if relatively easy to compute" },
{ "-wfirst", OPT_SWITCH, &wfirst,
"Always attempt to optimize worst KKT exemplar first" },
{ "-lazy", OPT_SWITCH, &lazy,
"only do a hard search over all multipliers when necessary" },
{ "-tube", OPT_SWITCH, &tube,
"use tube shrinking heuristic?" },
{ "-trate", OPT_DOUBLE, &trate,
"tube shrinking factor" },
{ "-tfinal", OPT_DOUBLE, &tfinal,
"final tube shrinkage" },
{ "-regress",OPT_SWITCH, ®ress,
"assume this is a regression problem (not classification)" },
{ "-regeps", OPT_DOUBLE, ®eps,
"epsilon for regression problems" },
{ "-xdelta", OPT_INT, &xdelta,
"space between x's (only for time delayed time series)" },
{ "-offset", OPT_INT, &offset,
"space between x's and y's (only for time delayed time series)" },
{ "-dump", OPT_SWITCH, &dump,
"dump SVM output to file?" },
{ NULL, OPT_NULL, NULL, NULL }
};
SERIES *ser;
DSM_FILE *dsmfile;
DATASET *data;
SVM *svm;
SMORCH smorch = SMORCH_DEFAULT;
FILE *fp;
unsigned i, sz, j;
double *x, *y;
get_options(argc, argv, opts, NULL, NULL, 0);
if(fname == NULL || xdim <= 0) {
display_options(argv[0], opts, NULL);
exit(1);
}
srandom(seed);
if (!strcmp(dtype, "ascii")) {
ser = series_read_ascii(fname);
ser->x_width = xdim;
ser->y_width = ydim;
if (xdelta > 0 && offset > 0) {
ser->x_delta = xdelta;
ser->offset = offset;
ser->step = 1;
}
else {
ser->x_delta = ser->y_delta = ser->offset = 1;
ser->step = ser->x_width + ser->y_width;
}
data = dataset_create(&dsm_series_method, ser);
}
else if (!strcmp(dtype, "map")) {
dsmfile = dsm_file(fname);
dsmfile->x_width = xdim;
dsmfile->y_width = ydim;
dsmfile->x_read_width = xdim * sizeof(double);
dsmfile->y_read_width = ydim * sizeof(double);
dsmfile->offset = dsmfile->skip = 0;
dsmfile->step = dsmfile->x_read_width + dsmfile->y_read_width;
dsmfile->type = SL_DOUBLE;
dsm_file_initiate(dsmfile);
data = dataset_create(&dsm_file_method, dsmfile);
}
else if (!strcmp(dtype, "double")) {
data = create_double_dataset(fname, xdim, ydim);
}
else if (!strcmp(dtype, "short")) {
data = create_short_dataset(fname, xdim, ydim);
}
else {
display_options(argv[0], opts, NULL);
exit(1);
}
smorch.data = data;
/* Set up the proper kernel to use. */
if(!strcmp(kname, "gauss"))
smorch.kernel = svm_kernel_gauss;
else if(!strcmp(kname, "poly"))
smorch.kernel = svm_kernel_poly;
else if(!strcmp(kname, "tanh"))
smorch.kernel = svm_kernel_tanh;
else if(!strcmp(kname, "linear"))
smorch.kernel = svm_kernel_linear;
else {
display_options(argv[0], opts, NULL);
exit(1);
}
smorch.cache_size = csz;
smorch.yindex = yindex;
smorch.aux = aux;
smorch.C = C;
smorch.tol = tol;
smorch.eps = eps;
smorch.hook = myhook;
smorch.finalhook = myfinalhook;
smorch.subset_size = ssz;
smorch.ultra_clever = clever;
smorch.best_step = best;
smorch.worst_first = wfirst;
smorch.lazy_loop = lazy;
smorch.regression = regress;
smorch.regeps = regeps;
smorch.tube = tube;
smorch.tube_rate = trate;
smorch.tube_final = tfinal;
svm = smorch_train(&smorch);
svm_write(svm, "tsvm.svm");
if (dump) {
fp = fopen("tsvm.tst", "w");
sz = dataset_size(data);
for (i = 0; i < sz; i++) {
x = dataset_x(data, i);
y = dataset_y(data, i);
for (j = 0; j < xdim; j++)
fprintf(fp, "% .4f ", x[j]);
fprintf(fp, "% .4f ", y[yindex]);
fprintf(fp, "% .4f\n", svm_output(svm, x));
}
fclose(fp);
}
svm_destroy(svm);
exit(0);
}
