fmll_svm_net * fmll_svm_net_init(const unsigned num, const unsigned dim, double (** K)(const double *, const double *, const unsigned))
{
unsigned u;
fmll_svm ** svm;
fmll_svm_net * svm_net = NULL;
fmll_try;
fmll_throw_null(svm_net = fmll_alloc(sizeof(fmll_svm_net), 1, 1));
fmll_throw_null(svm = svm_net->svm = (fmll_svm **) fmll_alloc(sizeof(fmll_svm *), 1, num));
svm_net->num = num;
for(u = 0; u < num; u++)
svm[u] = NULL;
for(u = 0; u < num; u++)
fmll_throw_null(svm[u] = fmll_svm_init(dim, K[u]));
fmll_catch;
fmll_svm_net_destroy(svm_net);
svm_net = NULL;
fmll_finally;
return svm_net;
}
fmll_pca * fmll_pca_init(const unsigned dim, const unsigned num)
{
double ** w;
unsigned u, v;
fmll_pca * pca = NULL;
fmll_try;
fmll_throw_if(! dim || ! num || dim < num);
fmll_throw_null(pca = fmll_alloc(sizeof(fmll_pca), 1, 1));
pca->w = NULL;
pca->y = NULL;
pca->dim = dim;
pca->num = num;
fmll_throw_null(w = pca->w = (double **) fmll_alloc(sizeof(double), 2, num, dim));
fmll_throw_null(pca->y = (double *) fmll_alloc(sizeof(double), 1, num));
fmll_throw_if(fmll_math_matrix_init_fill(w, 0, num, dim));
fmll_catch;
fmll_pca_destroy(pca);
pca = NULL;
fmll_finally;
return pca;
}
fmll_som * fmll_som_init(const unsigned * N, const unsigned map_dim, const unsigned dim,
double (* distance_w)(const double *, const double *, const unsigned), double (* distance)(const double *, const double *, const unsigned))
{
int v;
unsigned u, num, * tN;
double ** w, ** coord;
fmll_som * som = NULL;
fmll_try;
fmll_throw_null(som = fmll_alloc(sizeof(fmll_som), 1, 1));
som->w = som->coord = NULL;
som->N = NULL;
for(u = 0, num = 1; u < map_dim; u++)
num *= N[u];
fmll_throw_if(! num);
fmll_throw_null(w = som->w = (double **) fmll_alloc(sizeof(double), 2, num, dim));
fmll_throw_null(coord = som->coord = (double **) fmll_alloc(sizeof(double), 2, num, map_dim));
fmll_throw_null(tN = som->N = fmll_alloc(sizeof(unsigned), 1, map_dim));
som->num = num;
som->map_dim = map_dim;
som->dim = dim;
som->distance_w = distance_w;
som->distance = distance;
memset(tN, 0, map_dim * sizeof(unsigned));
fmll_throw_if(fmll_math_matrix_init_fill(w, 0, num, dim));
for(u = 0; u < num; u++)
{
for(v = 0; v < map_dim; v++)
coord[u][v] = tN[v];
for(v = map_dim - 1; v >= 0; v--)
{
if(++ tN[v] < N[v])
break;
tN[v] = 0;
}
}
memcpy(tN, N, map_dim * sizeof(unsigned));
fmll_catch;
fmll_som_destroy(som);
som = NULL;
fmll_finally;
return som;
}
int fmll_centering(double ** vec, const unsigned vec_num, const unsigned dim)
{
int ret = 0;
unsigned u, v;
double * mean = NULL;
fmll_try;
fmll_throw_null(mean = fmll_alloc(sizeof(double), 1, dim));
for(v = 0; v < dim; v++)
mean[v] = 0;
for(u = 0; u < vec_num; u++)
for(v = 0; v < dim; v++)
mean[v] += vec[u][v] / vec_num;
for(u = 0; u < vec_num; u++)
for(v = 0; v < dim; v++)
vec[u][v] -= mean[v];
fmll_catch;
ret = -1;
fmll_finally;
fmll_free(mean);
return ret;
}
fmll_som * fmll_som_load(const char * fname_prefix,
double (* distance_w)(const double *, const double *, const unsigned), double (* distance)(const double *, const double *, const unsigned))
{
char node_name[4096];
int map_dim, dim;
unsigned u, v, num, * N = NULL;
double ** w;
fmll_som * som = NULL;
mxml_node_t * sub_sub_node, * sub_node, * node, * content_node, * main_node = NULL;
fmll_try;
fmll_throw_if(xml_load(fname_prefix, TYPE_SOM, & main_node, & content_node));
fmll_throw_if(xml_get_int(content_node, "map_dim", & map_dim));
fmll_throw_if(xml_get_int(content_node, "dim", & dim));
fmll_throw_null(N = fmll_alloc(sizeof(unsigned), 1, map_dim));
fmll_throw_null(node = mxmlFindElement(content_node, content_node, "N", NULL, NULL, MXML_DESCEND_FIRST));
for(u = 0, sub_node = mxmlFindElement(node, node, NULL, NULL, NULL, MXML_DESCEND_FIRST); u < map_dim; u++)
{
fmll_throw_null(sub_node);
N[u] = sub_node->child->value.integer;
sub_node = mxmlFindElement(sub_node, node, NULL, NULL, NULL, MXML_DESCEND);
}
fmll_throw_null(som = fmll_som_init(N, map_dim, dim, distance_w, distance));
fmll_throw_null(node = mxmlFindElement(content_node, content_node, "W", NULL, NULL, MXML_DESCEND_FIRST));
w = som->w;
num = som->num;
for(u = 0; u < num; u++)
{
sprintf(node_name, "w_%u", u);
fmll_throw_null(sub_node = mxmlFindElement(node, node, node_name, NULL, NULL, MXML_DESCEND_FIRST));
for(v = 0, sub_sub_node = mxmlFindElement(sub_node, sub_node, NULL, NULL, NULL, MXML_DESCEND_FIRST); v < dim; v++)
{
w[u][v] = sub_sub_node->child->value.real;
sub_sub_node = mxmlFindElement(sub_sub_node, sub_node, NULL, NULL, NULL, MXML_DESCEND);
}
}
fmll_catch;
fmll_som_destroy(som);
som = NULL;
fmll_finally;
fmll_free(N);
xml_destroy(main_node);
return som;
}
fmll_svm_net * fmll_svm_net_load(const char * fname_prefix, double (** K)(const double *, const double *, const unsigned))
{
int num;
unsigned u;
char node_name[4096];
fmll_svm ** svm = NULL;
fmll_svm_net * svm_net = NULL;
mxml_node_t * sub_node, * node, * content_node, * main_node = NULL;
fmll_try;
fmll_throw_null(svm_net = fmll_alloc(sizeof(fmll_svm_net), 1, 1));
fmll_throw_if(xml_load(fname_prefix, TYPE_SVM_NET, & main_node, & content_node));
fmll_throw_if(xml_get_int(content_node, "num", & num));
svm_net->num = num;
fmll_throw_null(svm = svm_net->svm = (fmll_svm **) fmll_alloc(sizeof(fmll_svm *), 1, num));
fmll_throw_null(node = mxmlFindElement(content_node, content_node, "SVM", NULL, NULL, MXML_DESCEND_FIRST));
for(u = 0; u < num; u++)
svm[u] = NULL;
for(u = 0; u < num; u++)
{
sprintf(node_name, "svm_%u", u);
fmll_throw_null(sub_node = mxmlFindElement(node, node, node_name, NULL, NULL, MXML_DESCEND_FIRST));
fmll_throw_null(svm[u] = fmll_svm_load_main(sub_node, K[u]));
}
fmll_catch;
fmll_svm_net_destroy(svm_net);
svm_net = NULL;
fmll_finally;
xml_destroy(main_node);
return svm_net;
}
int fmll_svm_net_teach_smo(fmll_svm_net * svm_net, const double ** vec, const unsigned * d, const unsigned vec_num, const double * C, const double * tau,
int (** selector)(const fmll_svm *, const double **, const char *, const unsigned, int *, int *, const double, const double, const double, const double *, const double *, const double **),
const unsigned * max_iter, const double * epsilon)
{
int ret = 0;
const unsigned num = svm_net->num, t_num = omp_get_max_threads();
unsigned u, v, t_ind;
char * t_rd, ** rd;
fmll_svm ** svm = svm_net->svm;
fmll_try;
fmll_throw_null(rd = (char **) fmll_alloc(sizeof(char), 2, t_num, vec_num));
#pragma omp parallel private(u, v, t_ind, t_rd) default(shared)
{
t_ind = omp_get_thread_num();
t_rd = rd[t_ind];
for(u = t_ind; u < num; u += t_num)
{
for(v = 0; v < vec_num; v++)
{
if(d[v] == u)
t_rd[v] = 1;
else
t_rd[v] = -1;
}
fmll_print("\nSupport vector machine: %u from %u (%.5f %%)\n", u + 1, num, (100 * (u + 1.0)) / num);
fmll_svm_teach_smo(svm[u], (const double **) vec, t_rd, vec_num, C[u], tau[u], selector[u], max_iter[u], epsilon[u]);
}
}
fmll_catch;
ret = -1;
fmll_finally;
fmll_free(rd);
return ret;
}
int image_analysis(const int argc, const char * argv[])
{
#define NUM 5
char fname[4096];
unsigned u, v, q, vec_per_class, vec_num, cl_ind, yes, res, vec_class[5], max_iter[NUM], * d, * test_d;
double C[NUM], tau[NUM], epsilon[NUM], ** x, ** test_x;
double (* K[NUM])(const double *, const double *, unsigned);
int (* selector[NUM])(const fmll_svm *, const double **, const char *, const unsigned, int *, int *, const double, const double, const double, const double *, const double *, const double **);
IplImage * src_teach, * src_test, * dst;
CvSize size_teach, size_test;
CvScalar pixel, pixel_white, pixel_red, pixel_green, pixel_blue, pixel_violet, pixel_black, pixel_yellow;
fmll_svm_net * svm_net;
/* ############################################################################ */
if(argc != 3)
{
/* У C90 "проблемы" с максимальной длиной строки кода */
printf("\nДемонстрация нейронной сети, состоящей из нескольких машин опорных векторов.\n\n");
printf("Запуск программы:\n\n");
printf("ex_svm_net DIR IMAGE_1\n\n");
printf("Где:\n\n");
printf("\tDIR - путь и имя каталога, в котором должны содержаться следующие файлы:\n\n");
printf("\t\tteach.png - файл с изображением, на основании которого будет составлена обучающая выборка;\n");
printf("\t\ttest.png - файл с изображением, классификация пикселей которого будет выполнена;\n\n");
printf("\tIMAGE_1 - путь и имя файла, в который будет сохранено результирующее изображение ");
printf("(белый, красный, зеленый, синий, фиолетовый - правильно классифицированные пиксели; черный - неправильно классифицированные пиксели; ");
printf("желтый - неклассифицированные пиксели).\n\n");
return -1;
}
/* ############################################################################ */
memset(vec_class, 0, sizeof(unsigned) * 5);
sprintf(fname, "%s/teach.png", argv[1]);
src_teach = cvLoadImage(fname, CV_LOAD_IMAGE_COLOR);
size_teach = cvGetSize(src_teach);
sprintf(fname, "%s/test.png", argv[1]);
src_test = cvLoadImage(fname, CV_LOAD_IMAGE_COLOR);
size_test = cvGetSize(src_test);
dst = cvCreateImage(size_test, IPL_DEPTH_8U, 3);
pixel_white.val[0] = 255;
pixel_white.val[1] = 255;
pixel_white.val[2] = 255;
pixel_white.val[3] = 0;
pixel_red.val[0] = 0;
pixel_red.val[1] = 0;
pixel_red.val[2] = 255;
pixel_red.val[3] = 0;
pixel_green.val[0] = 0;
pixel_green.val[1] = 255;
pixel_green.val[2] = 0;
pixel_green.val[3] = 0;
pixel_black.val[0] = 0;
pixel_black.val[1] = 0;
pixel_black.val[2] = 0;
pixel_black.val[3] = 0;
pixel_blue.val[0] = 255;
pixel_blue.val[1] = 0;
pixel_blue.val[2] = 0;
pixel_blue.val[3] = 0;
pixel_violet.val[0] = 255;
pixel_violet.val[1] = 0;
pixel_violet.val[2] = 255;
pixel_violet.val[3] = 0;
pixel_yellow.val[0] = 0;
pixel_yellow.val[1] = 255;
pixel_yellow.val[2] = 255;
pixel_yellow.val[3] = 0;
vec_per_class = size_teach.height * size_teach.width / 2000;
vec_num = vec_per_class * 5;
x = (double **) fmll_alloc(sizeof(double), 2, vec_num, 3);
d = fmll_alloc(sizeof(unsigned), 1, vec_num);
test_x = (double **) fmll_alloc(sizeof(double), 2, size_test.height * size_test.width, 3);
test_d = fmll_alloc(sizeof(unsigned), 1, size_test.height * size_test.width);
for(v = 0, q = 0; v < size_teach.height; v++)
for(u = 0; u < size_teach.width; u++)
{
pixel = cvGet2D(src_teach, v, u);
if(pixel.val[0] == 0 && pixel.val[1] == 237 && pixel.val[2] == 95)
cl_ind = 0;
else if(pixel.val[0] == 10 && pixel.val[1] == 169 && pixel.val[2] == 203)
cl_ind = 1;
else if(pixel.val[0] == 0 && pixel.val[1] == 255 && pixel.val[2] == 255)
cl_ind = 2;
else if(pixel.val[0] == 255 && pixel.val[1] == 0 && pixel.val[2] == 12)
cl_ind = 3;
else
cl_ind = 4;
if(vec_class[cl_ind] < vec_per_class)
{
x[q][0] = pixel.val[0];
x[q][1] = pixel.val[1];
x[q][2] = pixel.val[2];
d[q] = cl_ind;
vec_class[cl_ind]++;
q++;
}
}
for(v = 0, q = 0; v < size_test.height; v++)
for(u = 0; u < size_test.width; u++, q++)
{
pixel = cvGet2D(src_test, v, u);
if(pixel.val[0] == 0 && pixel.val[1] == 237 && pixel.val[2] == 95)
test_d[q] = 0;
else if(pixel.val[0] == 10 && pixel.val[1] == 169 && pixel.val[2] == 203)
test_d[q] = 1;
else if(pixel.val[0] == 0 && pixel.val[1] == 255 && pixel.val[2] == 255)
test_d[q] = 2;
else if(pixel.val[0] == 255 && pixel.val[1] == 0 && pixel.val[2] == 12)
test_d[q] = 3;
else
test_d[q] = 4;
test_x[q][0] = pixel.val[0];
test_x[q][1] = pixel.val[1];
test_x[q][2] = pixel.val[2];
}
cvReleaseImage(& src_teach);
cvReleaseImage(& src_test);
/* ############################################################################ */
for(u = 0; u < NUM; u++)
K[u] = & fmll_kernel_radial;
svm_net = fmll_svm_net_init(NUM, 3, K);
/* ############################################################################ */
for(u = 0; u < NUM; u++)
{
C[u] = 1;
tau[u] = 1E-12;
selector[u] = & fmll_svm_teach_smo_selector_fan_chen_lin;
max_iter[u] = 10000;
epsilon[u] = 1E-3;
}
fmll_svm_net_teach_smo(svm_net, (const double **) x, d, vec_num, C, tau, selector, max_iter, epsilon);
/* ############################################################################ */
yes = fmll_svm_net_test(svm_net, (const double **) test_x, test_d, size_test.width * size_test.height, NULL, NULL);
printf("\nВерно классифицированных пикселей: %u из %u (%.7f %%)\n",
yes, (size_test.width * size_test.height), (100.0 * yes) / (size_test.width * size_test.height));
/* ############################################################################ */
fmll_svm_net_save(svm_net, "svm_net");
fmll_svm_net_destroy(svm_net);
svm_net = fmll_svm_net_load("svm_net", K);
for(v = 0, q = 0, yes = 0; v < size_test.height; v++)
for(u = 0; u < size_test.width; u++, q++)
{
res = fmll_svm_net_run(svm_net, test_x[q], NULL);
if(res >= 0)
{
if(res == test_d[q])
{
yes++;
switch(res)
{
case 0:
{
cvSet2D(dst, v, u, pixel_white);
break;
}
case 1:
{
cvSet2D(dst, v, u, pixel_red);
break;
}
case 2:
{
cvSet2D(dst, v, u, pixel_green);
break;
}
case 3:
{
cvSet2D(dst, v, u, pixel_blue);
break;
}
case 4:
{
cvSet2D(dst, v, u, pixel_violet);
break;
}
}
}
else
cvSet2D(dst, v, u, pixel_black);
}
else if(res == -1)
cvSet2D(dst, v, u, pixel_yellow);
else
cvSet2D(dst, v, u, pixel_black);
}
printf("Верно классифицированных пикселей: %u из %u (%.7f %%)\n",
yes, (size_test.width * size_test.height), (100.0 * yes) / (size_test.width * size_test.height));
/* ############################################################################ */
fmll_free(x);
fmll_free(d);
fmll_free(test_x);
fmll_free(test_d);
fmll_svm_net_destroy(svm_net);
cvSaveImage(argv[2], dst, NULL);
cvReleaseImage(& dst);
return 0;
}
int main(const int argc, const char * argv[])
{
const unsigned base = 256 * 256 * 256;
unsigned u, v, q, cur, index_winner, N[4];
double param[2], ** vec;
IplImage * src, * dst_1, * dst_2, * dst_3, * dst_4;
CvSize size;
CvScalar pixel;
fmll_random * rnd;
fmll_som * som;
/* ############################################################################ */
if(argc != 6)
{
/* У C90 "проблемы" с максимальной длиной строки кода */
printf("\nДемонстрация самоорганизующейся карты.\n\n");
printf("Запуск программы:\n\n");
printf("ex_som IMAGE_SRC IMAGE_1 IMAGE_2 IMAGE_3 IMAGE_4\n\n");
printf("Где:\n\n");
printf("\tIMAGE_SRC - путь и имя файла с исходным изображением;\n");
printf("\tIMAGE_1 - путь и имя файла, в который будет сохранено первое результирующее изображение;\n");
printf("\tIMAGE_2 - путь и имя файла, в который будет сохранено второе результирующее изображение;\n");
printf("\tIMAGE_3 - путь и имя файла, в который будет сохранено третье результирующее изображение;\n");
printf("\tIMAGE_4 - путь и имя файла, в который будет сохранено четвертое результирующее изображение.\n\n");
return -1;
}
/* ############################################################################ */
src = cvLoadImage(argv[1], CV_LOAD_IMAGE_COLOR);
size = cvGetSize(src);
dst_1 = cvCreateImage(size, IPL_DEPTH_8U, 3);
dst_2 = cvCreateImage(size, IPL_DEPTH_8U, 3);
dst_3 = cvCreateImage(size, IPL_DEPTH_8U, 3);
dst_4 = cvCreateImage(size, IPL_DEPTH_8U, 3);
/*
N[0] = 5;
N[1] = 5;
N[2] = 5;
N[3] = 5;
*/
N[0] = 4;
N[1] = 3;
N[2] = 3;
N[3] = 3;
vec = (double **) fmll_alloc(sizeof(double), 2, size.height * size.width, 3);
for(v = 0, q = 0; v < size.height; v++)
for(u = 0; u < size.width; u++, q++)
{
pixel = cvGet2D(src, v, u);
vec[q][0] = pixel.val[0];
vec[q][1] = pixel.val[1];
vec[q][2] = pixel.val[2];
}
param[0] = 0;
param[1] = 256;
rnd = fmll_random_init(FMLL_RANDOM_ALGORITHM_LCG, FMLL_RANDOM_DISTRIBUTION_UNIFORM, param, time(NULL));
som = fmll_som_init(N, 4, 3, & fmll_distance_euclid, & fmll_distance_square_euclid);
fmll_som_weight_init_random(som, rnd);
fmll_som_so_kohonen(som, (const double **) vec, size.height * size.width, 0, & fmll_timing_next_beta_step_plus_0_1, 0.8, 0.002, & fmll_som_neighbor_wta);
for(v = 0; v < som->num; v++)
printf("%u = [%f, %f, %f]\n", v, som->w[v][0], som->w[v][1], som->w[v][2]);
for(v = 0, q = 0; v < size.height; v++)
for(u = 0; u < size.width; u++, q++)
{
index_winner = fmll_som_run(som, vec[q]);
pixel.val[0] = som->w[index_winner][0];
pixel.val[1] = som->w[index_winner][1];
pixel.val[2] = som->w[index_winner][2];
cvSet2D(dst_1, v, u, pixel);
cur = (base / ((double) som->num + 7)) * index_winner;
pixel.val[0] = (cur & 0xFF0000) >> 16;
pixel.val[1] = (cur & 0xFF00) >> 8;
pixel.val[2] = cur & 0xFF;
cvSet2D(dst_2, v, u, pixel);
}
fmll_som_save(som, "som");
fmll_som_destroy(som);
som = NULL;
if(
(som = fmll_som_load("som", & fmll_distance_euclid, & fmll_distance_euclid)) != NULL
)
{
fmll_som_save(som, "som_2");
for(v = 0, q = 0; v < size.height; v++)
for(u = 0; u < size.width; u++, q++)
{
index_winner = fmll_som_run(som, vec[q]);
pixel.val[0] = som->w[index_winner][0];
pixel.val[1] = som->w[index_winner][1];
pixel.val[2] = som->w[index_winner][2];
cvSet2D(dst_3, v, u, pixel);
cur = (base / (double) som->num) * index_winner;
pixel.val[0] = (cur & 0xFF0000) >> 16;
pixel.val[1] = (cur & 0xFF00) >> 8;
pixel.val[2] = cur & 0xFF;
cvSet2D(dst_4, v, u, pixel);
}
}
int fmll_som_so_kohonen_penalty(fmll_som * som, const double ** vec, const unsigned vec_num, const double beta_0, double (* next_beta)(const double),
const double gamma_mult, const double gamma_add, double (* neighbor)(const fmll_som *, const double, const double, const unsigned, const unsigned), const unsigned max_win, const unsigned penalty)
{
int ret = 0,* wn = NULL;
const unsigned num = som->num, dim = som->dim;
unsigned u, v, q, index_winner;
double min, d, beta_gamma, beta = beta_0, ** w = som->w;
double (* distance)(const double *, const double *, unsigned) = som->distance;
fmll_try;
fmll_throw_if(beta_0 < 0 || beta_0 > 1);
fmll_throw_if(neighbor == & fmll_som_neighbor_radial && (gamma_mult < 0 || gamma_mult > 1));
fmll_throw_if(neighbor == & fmll_som_neighbor_radial && (gamma_add < 0));
fmll_throw_null(wn = fmll_alloc(sizeof(int), 1, num));
memset(wn, 0, num * sizeof(int));
while(beta < 1.0000001)
{
fmll_print("Self - organization: beta == %.7lf\n", beta);
for(u = 0, min = DBL_MAX; u < vec_num; u++)
{
for(v = 0; v < num; v++)
{
d = (* distance)(w[v], vec[u], dim);
if(wn[v] < 0)
wn[v]++;
else if(d < min)
{
min = d;
index_winner = v;
}
}
if(++ wn[index_winner] == max_win)
wn[index_winner] = - ((int) penalty);
if(neighbor == & fmll_som_neighbor_wta)
for(q = 0; q < dim; q++)
w[index_winner][q] += beta * (vec[u][q] - w[index_winner][q]);
else
for(v = 0; v < num; v++)
{
beta_gamma = beta * neighbor(som, gamma_mult, gamma_add, index_winner, v);
for(q = 0; q < dim; q++)
w[v][q] += beta_gamma * (vec[u][q] - w[v][q]);
}
}
beta = (* next_beta)(beta);
}
fmll_catch;
ret = -1;
fmll_finally;
fmll_free(wn);
return ret;
}
Mat Kohonen::getFrame(Mat parFrame)
{
int map_dim=2;//размерность карты
unsigned N[map_dim];
unsigned u, v, q, index_winner;
N[0] = 7;//количество нейронов в каждом слое
N[1] = 7;
//определение константы для вывода каждого класса определенным цветом
uint32_t A=1;
for (int i=0;i<map_dim; i++)
{
A*=N[i];//подсчет общего числа нейрнов
}
A=0xFFFFFF/A;
fmll_som * som;
Mat resultFrame;
resultFrame.create(parFrame.rows, parFrame.cols,CV_8UC3);
Mat frameFromUnsigned;
frameFromUnsigned.create(parFrame.rows, parFrame.cols,CV_32S);
Vec3b pixel;
double ** vec;
//инициализация векторного пространства значениями яркости изображения
vec = (double **) fmll_alloc(sizeof(double), 2, parFrame.rows * parFrame.cols, 3);
som = fmll_som_load(somFilename.c_str(),& fmll_distance_euclid, & fmll_distance_euclid);
for(v = 0, q = 0; v < parFrame.rows; v++)
for(u = 0; u < parFrame.cols; u++, q++)
{
pixel=parFrame.at<Vec3b>(v,u);
vec[q][0] = pixel[0] / 255.;
vec[q][1] = pixel[1] / 255.;
vec[q][2] = pixel[2] / 255.;
}
//загрузка карты из xml
if(som == NULL)
{
fmll_random * rnd;
double param[2];
param[0] = 0;
param[1] = 0.01;
//инициализация датчика случайных чисел
rnd = fmll_random_init(FMLL_RANDOM_ALGORITHM_LCG, FMLL_RANDOM_DISTRIBUTION_UNIFORM, param, time(NULL));
//иницилизация нейронной карты
som = fmll_som_init(N, map_dim, 3, & fmll_distance_euclid, & fmll_distance_euclid);//(1)расстояние между векторами, 2)расстояние между нейронами.(2)не исп.,т.к. алгоритм WTA)
//иницилизация весов синапсов нейронов карты случайными числами
fmll_som_weight_init_random(som, rnd);
cout<<"don't load"<<endl;
//обучение нейронной карты
fmll_som_so_kohonen(som, (const double **) vec, parFrame.rows * parFrame.cols,
0.3, & fmll_timing_next_beta_step_plus_0_1, 0.8, 0.002, & fmll_som_neighbor_wta);
if (fmll_som_save(som,somFilename.c_str())!=0)
{
cout<<"Ошибка сохранения Som в Xml"<<endl;
}
fmll_random_destroy(rnd);
}
for(v = 0, q = 0; v < parFrame.rows; v++)
{
for(u = 0; u < parFrame.cols; u++, q++)
{
index_winner = fmll_som_run(som, vec[q]);
uint32_t color=A*index_winner;
pixel[0]=0x0000FF&color;
pixel[1]=(0x00FF00&color)>>8;
pixel[2]=(0xFF0000&color)>>16;
//pixel[0] = som->w[index_winner][0];
//pixel[1] = som->w[index_winner][1];
//pixel[2] = som->w[index_winner][2];
resultFrame.at<Vec3b>(v,u)=pixel;
frameFromUnsigned.at<uint32_t>(v,u)=color;
//cout<<color<<" ";
}
//cout<<endl;
}
fmll_free(vec);
imshow( "kohonen", resultFrame );
fmll_som_destroy(som);
return frameFromUnsigned;
}
int fmll_pca_so(fmll_pca * pca, const double ** vec, const unsigned vec_num, const double beta_0, double (* next_beta)(const double), const double max_d, double * eigen)
{
int ret = 0;
const unsigned dim = pca->dim, num = pca->num;
unsigned t, u, v, q, iter = 0;
double d, sum, beta, max = 0, * y = pca->y, ** fcrow = NULL, ** w = pca->w, * pw = NULL, * yy = NULL, * yy_w = NULL;
fmll_try;
fmll_throw_if(beta_0 < 0 || beta_0 > 1);
fmll_throw_null(pw = (double *) fmll_alloc(sizeof(double), 1, dim));
fmll_throw_null(yy = (double *) fmll_alloc(sizeof(double), 1, num));
fmll_throw_null(yy_w = (double *) fmll_alloc(sizeof(double), 1, dim));
for(u = 0; u < num; u++)
{
beta = beta_0;
do
{
fmll_print("Iteration = %u, component = %u, beta = %.7lf, max = %.7lf\n", iter, u + 1, beta, max);
beta = (* next_beta)(beta);
memcpy((void *) pw, (void *) w[u], dim * sizeof(double));
for(t = 0; t < vec_num; t ++)
{
fmll_pca_run(pca, vec[t]);
for(v = 0; v < dim; v ++)
{
for(q = 0, sum = 0; q <= u; q ++)
sum += y[q] * w[q][v];
yy_w[v] = sum;
}
for(v = 0; v < dim; v ++)
w[u][v] += beta * y[u] * (vec[t][v] - yy_w[v]);
}
for(v = 0, max = 0; v < dim; v ++)
if(max < (d = fabs(w[u][v] - pw[v])))
max = d;
iter ++;
}
while(max > max_d && beta > 0);
}
if(eigen != NULL)
{
fmll_throw_null(fcrow = (double **) fmll_alloc(sizeof(double), 2, dim, dim));
for(v = 0; v < dim; v++)
for(u = 0; u < dim; u++)
fcrow[v][u] = 0;
for(v = 0; v < vec_num; v++)
for(t = 0; t < dim; t++)
{
fcrow[t][t] += vec[v][t] * vec[v][t];
for(q = t + 1; q < dim; q++)
{
d = vec[v][t] * vec[v][q];
fcrow[t][q] += d;
fcrow[q][t] += d;
}
}
for(v = 0; v < dim; v++)
for(u = 0; u < dim; u++)
fcrow[v][u] /= vec_num;
for(t = 0; t < num; t++)
{
eigen[t] = 0;
for(u = 0; u < dim; u++)
{
for(v = 0, sum = 0; v < dim; v++)
sum += w[t][v] * fcrow[u][v];
eigen[t] += sum * sum;
}
eigen[t] = sqrt(eigen[t]);
}
}
fmll_catch;
ret = -1;
fmll_finally;
fmll_free(fcrow);
fmll_free(pw);
fmll_free(yy);
fmll_free(yy_w);
return ret;
}
