Example #1
0
Kmeans::Kmeans(const Mat& points, int k, string fileName)
{
	this->k = k;
	n = points.rows;
	m = points.cols;
	k_means(points);
	collect();
	updateMeasure();
	save(fileName.c_str());
}
Example #2
0
File: gmm.c Project: spygg/openVP
/** @function
********************************************************************************
<PRE>
函数名: InitGMM()
功能: 获得GMM初值
用法:
参数:
[IN] X: 特征向量组
返回:
调用: k_means()
主调函数: GMMs()
</PRE>
*******************************************************************************/
static GMM InitGMM(double X[GOOD_FRAME_NUM][D])
{
    int i;
    int j;
    int clusterIndex[GOOD_FRAME_NUM] = {0};  //向量所属质心索引
    int clusterSize[M] = {0};                //聚类所含向量数
    GMM gmm = {{0}, {{0}}, {{0}}};
    double sum[M][D] = {{0}};


    //初始化均值u
    gmm = k_means(X, clusterIndex, clusterSize);

    //初始化加权系数p
    for (i = 0; i < M; ++i)
    {
        gmm.p[i] = 1.0 / M;
    }

    //初始化协方差矩阵cMatrix
    for (i = 0; i < GOOD_FRAME_NUM; ++i)
    {
        for (j = 0; j < D; ++j)
        {
            sum[clusterIndex[i]][j] += pow(X[i][j], 2);
        }
    }
    for (i = 0; i < M; ++i)
    {
        if (clusterSize[i] > 0) //防止分母为0
        {
            for (j = 0; j < D; ++j)
            {
                //此处有负值和0值
                gmm.cMatrix[i][j] = sum[i][j] / clusterSize[i] - pow(gmm.u[i][j], 2);
                if (gmm.cMatrix[i][j] < 0)
                {
                    #ifdef _DEBUG
                    printf("InitGMM: initial value of GMM`cMatrix < 0\n");
                    #endif // _DEBUG
                    exit(0);
                }
                else if(gmm.cMatrix[i][j] < 1e-10) //消除相同double值相减的误差
                {
                    gmm.cMatrix[i][j] = 0;
                }
            }
        } //end if (clusterSize[i] > 0)
    }

    return gmm;
}
Example #3
0
void do_kmeans_sort(struct cluster_bed_matrix *cbm, double t, boolean sort)
/* clusters but also sorts the labels by cluster size */
{
    int i = 0;
    int *labels = k_means(cbm, t);
    /* if (sort) */
    /* 	exchange_labels(cbm->cluster_sizes, cbm->k, labels, cbm->num_na, cbm->pbm->nrow); */
    for (i = cbm->num_na; i < cbm->pbm->nrow; i++)
	cbm->pbm->array[i]->label = labels[i];
    qsort(cbm->pbm->array, cbm->pbm->nrow, sizeof(cbm->pbm->array[0]), perBaseWigLabelCmp);
    for (i = 0; i < cbm->pbm->nrow; i++)
	cbm->pbm->matrix[i] = cbm->pbm->array[i]->data;
    freeMem(labels);
}
int main(int argc, char** args) {

  if(argc!=3) {
    std::cerr << "Usage cq image.jpg centroids.txt" << std::endl;
    return -1;
  }

  unsigned int max_loops = 5;
  
  std::string img_filename = args[1];
  std::cout << "Image file = " << img_filename << std::endl;

  test(img_filename);

  // read image
  img_struct<unsigned char> rgb = read_image(img_filename);
  // read centroids
  std::string centroids_filename = args[2];
  img_struct<unsigned char> rgb_centroids = read_centroids_txt(centroids_filename);
  // convert image and centroids to YUV
  float rgb_2_yuv[] = { 0.299, 0.587, 0.114, -0.14713, -0.28886, 0.436, 0.615, -0.51499, -0.10001 };
  img_struct<float> yuv = convert_img<unsigned char, float, 3>(rgb, rgb_2_yuv);
  img_struct<float> centroids_yuv = convert_img<unsigned char, float, 3>(rgb_centroids, rgb_2_yuv);
  std::cout << "Done converting to yuv " << std::endl;
  // cluster the YUV image
  std::cout << "Start k_means " << std::endl;
  img_struct<float> clustered_yuv = k_means(yuv, centroids_yuv, max_loops);
  std::cout << "End k_means " << std::endl;  
  // YUV 2 RGB (cluster image)
  float yuv_2_rgb[] = { 1, 0, 1.13983, 1, -0.39465, -0.58060, 1, 2.03211, 0 };
  img_struct<unsigned char> clustered_rgb = convert_img<float, unsigned char, 3>(clustered_yuv, yuv_2_rgb);
  std::string img_clustered_filename = "clustered_image.jpg";
  save_file<unsigned char>(clustered_rgb, img_clustered_filename);
  
  return 0;
};
Example #5
0
File: main.c Project: 10v/cmusphinx
static float64
furthest_neighbor_kmeans(uint32 n_obs,
			 uint32 veclen,
			 vector_t *mean,
			 uint32 n_mean,
			 float32 min_ratio,
			 uint32 max_iter)
{
    uint32 **obs_of;
    uint32 *occ_cnt;
    codew_t *lbl;
    uint32 k_max=0, occ_max;
    uint32 n_mean_cur;
    vector_t *extr_mean;
    uint32 k, l;
    float64 sqerr;

    lbl = ckd_calloc(n_obs, sizeof(codew_t));
    occ_cnt = ckd_calloc(n_mean, sizeof(uint32));
    n_mean_cur = 1;

    extr_mean = (float32 **)ckd_calloc_2d(2, veclen, sizeof(float32));

    do {
	E_INFO("n_mean == %u\n", n_mean_cur);

	obs_of = cw_obs(lbl, n_mean_cur, n_obs, occ_cnt);

	occ_max = 0;

	for (k = 0; k < n_mean_cur; k++) {
	    if (occ_cnt[k] > occ_max) {
		occ_max = occ_cnt[k];
		k_max = k;
	    }
	}
	
	/* set the initial values of the new means by extreme means */

	E_INFO("d_max == %e\n",
	       find_farthest_neigh(obs_of[k_max], occ_cnt[k_max], veclen,
				   extr_mean[0], extr_mean[1]));
	
	
	sqerr = k_means_subset(extr_mean, 2,
			       obs_of[k_max], occ_cnt[k_max],
			       veclen,
			       min_ratio,
			       max_iter,
			       NULL);
	
	for (l = 0; l < veclen; l++) {
	    mean[k_max][l] = extr_mean[0][l];
	    mean[n_mean_cur][l] = extr_mean[1][l];
	}

	++n_mean_cur;

	ckd_free(lbl);

	sqerr = k_means(mean, n_mean_cur, n_obs,
			veclen,
			min_ratio,
			max_iter,
			&lbl);

	E_INFO("\tsquerr == %e\n", sqerr);
    } while (n_mean_cur < n_mean);

    return sqerr;
}
Example #6
0
File: main.c Project: 10v/cmusphinx
static float32
random_kmeans(uint32 n_trial,
	      uint32 n_obs,
	      uint32 veclen,
	      vector_t *bst_mean,
	      uint32 n_mean,
	      float32 min_ratio,
	      uint32 max_iter,
	      codew_t **out_label)
{
    uint32 t, k, kk;
    float32 rr;
    uint32 cc;
    codew_t *label = NULL, *b_label = NULL;
    vector_t *tmp_mean;
    float64 sqerr, b_sqerr = MAX_POS_FLOAT64;
    vector_t c;
    uint32 n_aborts;

    tmp_mean = (vector_t *)ckd_calloc_2d(n_mean, veclen, sizeof(float32));

    E_INFO("Initializing means using random k-means\n");

    for (t = 0; t < n_trial; t++) {
	E_INFO("Trial %u: %u means\n", t, n_mean);

	n_aborts = 100;		/* # of aborts to allow */
	do {
	    /* pick a (pseudo-)random set of initial means from the corpus */
	    for (k = 0; k < n_mean; k++) {
		rr = drand48();	/* random numbers in the interval [0, 1) */
		cc = rr * n_obs;
		assert((cc >= 0) && (cc < n_obs));
		c = get_obs(cc);
		for (kk = 0; kk < veclen; kk++) {
		    tmp_mean[k][kk] = c[kk];
		}
	    }

	    if (n_mean > 1) {
		sqerr = k_means_trineq(tmp_mean, n_mean,
				       n_obs,
				       veclen,
				       min_ratio,
				       max_iter,
				       &label);
	    }
	    else {
		sqerr = k_means(tmp_mean, n_mean,
				n_obs,
				veclen,
				min_ratio,
				max_iter,
				&label);
	    }

	    if (sqerr < 0) {
		E_INFO("\t-> Aborting k-means, bad initialization\n");
		--n_aborts;
	    }
	} while ((sqerr < 0) && (n_aborts > 0));
	    

	if (sqerr < b_sqerr) {
	    b_sqerr = sqerr;

	    E_INFO("\tbest-so-far sqerr = %e\n", b_sqerr);
	    if (b_label)
		ckd_free(b_label);
	    b_label = label;
	    for (k = 0; k < n_mean; k++) {
		for (kk = 0; kk < veclen; kk++) {
		    bst_mean[k][kk] = tmp_mean[k][kk];
		}
	    }
	}
	else {
	    if (label) {
		ckd_free(label);
		label = NULL;
	    }
	}
    }

    *out_label = b_label;

    ckd_free_2d((void **)tmp_mean);

    return b_sqerr;
}
Example #7
0
// main function in class BrightnessGroup
// analyze and classify images
void BrightnessGroup::run(){
	int i;
	
	// get the number of clusters from user to set the number of group 
	cout << "How many clusters? ";
	cin >> numcluster; cout << endl;

	// make the folder to save the result
	makebrightnessfolder( numcluster );
	// set the size of brightness array to the number of images
	brightness = (float*)malloc(sizeof(float)*num);

	// for each image,
	for( i=0; i<num; i++){
		Mat image, hsv_image;
		image = images[i]; 

		// extract color element of the image
		// if the images doesn't have 3 channels, it's classified to '-1'
		if (image.channels() == 3){

			// change the mode of image from RGB to HSV
			cvtColor(image, hsv_image, CV_BGR2HSV);

			// Separate the image in 3 places ( H, S, V )
			vector<Mat> hsv_planes;

			split( hsv_image, hsv_planes );

			// make histogram with brightness element ('v' in hsv means 'value')
			int vHistSize = 100;
			float vRange[] = {0, 100};
			const float* vHistRange = { vRange };

			Mat v_hist;
		
			calcHist( &hsv_planes[0], 1, 0, Mat(), v_hist, 1, &vHistSize, &vHistRange, true, false);

			int vHist_w = 300; int vHist_h = 400;
			int vbin_w = cvRound( (double) vHist_w/vHistSize);

			Mat vHistImage( vHist_h, vHist_w, CV_8UC3, Scalar( 0, 0, 0) );

			normalize(v_hist, v_hist, 0, vHistImage.rows, NORM_MINMAX, -1, Mat() );

			// with histogram of brightness, get the average of the brightness
			brightness[i] = avgBrightness(v_hist, vHistSize);
			cout << "The average of brightness is " << brightness[i] << endl;
		}else{
			brightness[i] = -1;
		}
		cout << "next, go to other picture..." << endl;
	}

	// with the average of brightness data, 
	// let the image get its own group by k means clustering
	k_means();

	// with the clusters array result, classify and save images in appropriate folder
	if( flag == IS_FROM_FILES ){
		
		int i=0;
		string filename;

		// open "filenames.txt" and get the name of file
		ifstream file;
		file.open("filenames.txt");
		
		// save the images in appropriate folder which is the clusters array result
		while(!file.eof() && i<num ){
			getline(file, filename);

			char newfile[FILE_NAME_MAX+20] = "./brightness_result/";
			strcat(newfile, intToString(clusters[i]).c_str());
			strcat(newfile, "/");
			strcat(newfile, filename.c_str());

			cout << "new file adress : " << newfile << endl;
			imwrite(newfile, images[i]);
			i++;
		}

	}else if( flag == IS_FROM_URLS ){
		
		int i;

		// make the file name to save. It counts from 0 in increasing order
		// and save the images in appropriate folder which is the color array 
		const char file[10] = "photo_";
		for( i=0; i<num; i++){
			char newfile[FILE_NAME_MAX+20] = "./brightness_result/";

			strcat(newfile, intToString(clusters[i]).c_str());
			strcat(newfile, "/");
			strcat(newfile, file);
			if( i < 10 ){
				strcat(newfile, "00");
				strcat(newfile, intToString(i).c_str());
			}else if ( i >= 10 && i < 100 ){
				strcat(newfile, "0");
				strcat(newfile, intToString(i).c_str());
			}else if ( i >= 100 && i < 1000 ){
				strcat(newfile, intToString(i).c_str());
			}
			cout << newfile << endl;
			strcat(newfile, ".jpg");
			imwrite(newfile, images[i]);
		}

	}

	cout << "brightness grouping finished" << endl;

}
Example #8
0
int main(int argc, const char *argv[])
{
    // build k_means() compatible memory layout
    points = calloc(npoints, sizeof(double*));
    for (int i = 0; i < npoints; ++i) {
        points[i] = &_points[i * DIM];
    }

    // determine the number of points - this is a fragile heuristic!
    nclusters = sqrt(npoints / 2);

    //
    centroids = calloc(nclusters, sizeof(double*));
    for (int i = 0; i < nclusters; ++i) {
        centroids[i] = calloc(2, sizeof(double));
    }

    // print our data
    //printf("npoints: %ld\n", npoints);
    //for (int i = 0; i < npoints; ++i) {
    //    printf("  %f %f\n", points[i][0], points[i][1]);
    //}

    // run k_means()
    clusters = k_means(points, npoints, DIM, nclusters, 0.0001, centroids);

    // print clusters
    printf("npoints: %ld\n", npoints);
    printf("nclusters: %ld\n", nclusters);
    // x, y, cluster, centroid x, centroid y
    printf("  %8s %8s %2s %8s %8s\n", "x", "y", "c", "cx", "cy");
    for (int i = 0; i < npoints; ++i) {
        int cluster = clusters[i];
        printf("  %8f %8f %2d %f %f\n", points[i][0], points[i][1], cluster,
               centroids[cluster][0],
               centroids[cluster][1]);
    }

    // print just the centroids
    printf("\ncentroids:\n");
    for (int i = 0; i < nclusters; ++i) {
        int cluster = clusters[i];
        printf("  %2d %f\n", i, centroids[i][0]);
    }
    printf("\n");
    for (int i = 0; i < nclusters; ++i) {
        printf("  %2d %f\n", i, centroids[i][1]);
    }

    // clean up
    if (points)
        free(points);
    if (centroids) {
        for (int i = 0; i < nclusters; ++i) {
            if (centroids[i]) free(centroids[i]);
        }
        free(centroids);
    }

    return 0;
}
Example #9
0
object *baseline(unsigned char *image, unsigned char *mask, int width, int height, int *n_object)
{
int i = 0, j = 0, k = 0;
int n;	/* number of objects */

int    *area;	/* area */
double *len;	/* perimeter length */
double *circ;	/* circularity index */
double *input_val;
/*Color features*/
double *clr_mn_value, *clr_std_dev, *clr_skew, *clr_kurtosis, **clr_hist;
/*Texture features*/
double ***glcmat, *ang_sec_mom, *contr, *corr, *var;
double *inv_diff_mom, *sum_av, *sum_entrp, *sum_varnc;
double *entrp, *diff_var, *diff_entrp;

object *obj;	/* for storing results */

int **obj_id = (int **)malloc(height*sizeof(int *));
if (obj_id == NULL){
	printf("Could not allocate %d bytes.\n", height*sizeof(int *));
	exit(0);
	}
else{
	for (i = 0; i < height; i++){
		obj_id[i] = (int *)malloc(width*sizeof(int));
		if (obj_id[i] == NULL){
			printf("Could not allocate %d bytes for i=%d index.\n", width*sizeof(int), i);
			exit(0);
			}
		}
	}


/* assign ID to each object and returns the number of objects */
n = assign_id(mask, width, height, obj_id);

/* allocate memories */
area = (int *)malloc(n * sizeof(int));
if (area == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(int)));
	exit(-1);
	}

len  = (double *)malloc(n * sizeof(double));
if (len == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}

circ = (double *)malloc(n * sizeof(double));
if (circ == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}

obj  = (object *)malloc(n * sizeof(object));
if (obj == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(object)));
	exit(-1);
	}
/*Colors*/
clr_mn_value = (double *)malloc(n * sizeof(double));
if (clr_mn_value == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}

input_val = (double *)malloc(n * sizeof(double));
if (input_val == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}

clr_std_dev = (double *)malloc(n * sizeof(double));
if (clr_std_dev == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}

clr_skew = (double *)malloc(n * sizeof(double));
if (clr_skew == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}

clr_kurtosis = (double *)malloc(n * sizeof(double));
if (clr_kurtosis == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}

clr_hist = (double **)malloc(n*sizeof(double *));
if (clr_hist == NULL){
	printf("Could not allocate %d bytes.\n", n*sizeof(double *));
	exit(0);
	}
else{
	for (i = 0; i < n; i++){
		clr_hist[i] = (double *)malloc(256*sizeof(double));
		if (clr_hist[i] == NULL){
			printf("Could not allocate %d bytes for i=%d index.\n", 256*sizeof(double), i);
			exit(0);
			}
		else{
			for (j = 0; j<256; j++){
				clr_hist[i][j] = 0.0;
				}
			}
		}
	}

/*Texture*/
glcmat = (double ***)malloc(n * sizeof(double**));
if (glcmat == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double**)));
	exit(-1);
	}
else{
	for (i = 0;i < n; i++){
		glcmat[i] = (double **)malloc(256 * sizeof(double *));
		if (glcmat[i] == NULL){
			printf("Cannot allocate %d bytes for memory.\n", (256 * sizeof(double *)));
			exit(-1);
			}
		else{
			for (j = 0;j < 256; j++){
				glcmat[i][j] = (double *)malloc(256 * sizeof(double));
				if (glcmat[i][j] == NULL){
					printf("Cannot allocate %d bytes for memory.\n", (256 * sizeof(double)));
					exit(-1);
					}
				else{
					for (k = 0;k < 256;k++){
						glcmat[i][j][k] = 0.0;
						}
					}
				}/*for j*/
			}
		}/*for i*/
	}

ang_sec_mom = (double *)malloc(n * sizeof(double));
if (ang_sec_mom == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}
memset(ang_sec_mom, 0, (n * sizeof(double)));

contr = (double *)malloc(n * sizeof(double));
if (contr == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}
memset(contr, 0, (n * sizeof(double)));

corr = (double *)malloc(n * sizeof(double));
if (corr == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}
memset(corr, 0, (n * sizeof(double)));

var = (double *)malloc(n * sizeof(double));
if (var == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}
memset(var, 0, (n * sizeof(double)));

inv_diff_mom = (double *)malloc(n * sizeof(double));
if (inv_diff_mom == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}
memset(inv_diff_mom, 0, (n * sizeof(double)));

sum_av = (double *)malloc(n * sizeof(double));
if (sum_av == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}
memset(sum_av, 0, (n * sizeof(double)));

sum_entrp = (double *)malloc(n * sizeof(double));
if (sum_entrp == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}
memset(sum_entrp, 0, (n * sizeof(double)));

sum_varnc = (double *)malloc(n * sizeof(double));
if (sum_varnc == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}
memset(sum_varnc, 0, (n * sizeof(double)));

entrp = (double *)malloc(n * sizeof(double));
if (entrp == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}
memset(entrp, 0, (n * sizeof(double)));

diff_var = (double *)malloc(n * sizeof(double));
if (diff_var == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}
memset(diff_var, 0, (n * sizeof(double)));

diff_entrp = (double *)malloc(n * sizeof(double));
if (diff_entrp == NULL){
	printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
	exit(-1);
	}
memset(diff_entrp, 0, (n * sizeof(double)));

/* calcuate areas */
calculate_area(obj_id, width, height, n, area);
/* calcuate perimeter length */
calculate_length(obj_id, width, height, n, len, image);


/* calcuate cirularity index */
/*
morphological_feature_circularity_index(area, len, n, circ);
morphological_feature_object_moment(1.0, 1.0, obj_id, width, height, n, image, circ);
morphological_feature_central_moments(0.0, 0.0, obj_id, width, height, n, image, circ);
morphological_feature_object_orientation(obj_id, width, height, n, image, circ);
*/
morphological_feature_object_eccentricity(obj_id, width, height, n, image, circ);
/*
morphological_feature_central_invariant_moments(1.0, 1.0, obj_id, width, height, n, image, circ);
*/

/*color features*/
/*
color_feature_mean(obj_id, width, height, n, area, image, clr_mn_value);
color_feature_standard_deviation(obj_id, width, height, n, area, image, clr_mn_value, clr_std_dev);
color_feature_skewness(obj_id, width, height, n, area, image, clr_mn_value, clr_skew);
color_feature_kurtosis(obj_id, width, height, n, area, image, clr_mn_value, clr_kurtosis);
color_feature_histogram(0, obj_id, width, height, n, area, image, clr_hist);
*/

/*texture features*/
/*
glcm(0, obj_id, width, height, n, image, glcmat);
texture_feature_angular_second_moment(glcmat, n, ang_sec_mom);
texture_feature_contrast(glcmat, n, contr);
texture_feature_correlation(glcmat, n, corr);
texture_feature_variance(glcmat, n, var);
texture_feature_inverse_diff_moment(glcmat, n, inv_diff_mom);
texture_feature_sum_average(glcmat, n, sum_av);
texture_feature_sum_entropy(glcmat, n, sum_entrp);
texture_feature_sum_variance(glcmat, n, sum_entrp, sum_varnc);
texture_feature_entropy(glcmat, n, entrp);
texture_feature_difference_variance(glcmat, n, diff_var);
texture_feature_difference_entropy(glcmat, n, diff_entrp);
*/

double weight = 0.0;
for (i = 0; i < n; i++) {
	/*Morphological feature*/
	input_val[i] = circ[i];
	/*Color features*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*clr_mn_value[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*clr_std_dev[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*clr_skew[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*clr_kurtosis[i];*/
	/*input_val[i] = weight*circ[i] + weight*clr_mn_value[i] + weight*clr_std_dev[i] + weight*clr_skew[i] + weight*clr_kurtosis[i];*/
	/*input_val[i] = weight*clr_mn_value[i] + weight*clr_std_dev[i] + weight*clr_skew[i] + weight*clr_kurtosis[i];*/

	/*Texture features*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*ang_sec_mom[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*contr[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*corr[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*var[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*inv_diff_mom[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*sum_av[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*sum_entrp[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*sum_varnc[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*entrp[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*diff_var[i];*/
	/*input_val[i] = weight*circ[i] + (1.0 - weight)*diff_entrp[i];*/
	}

/* k-means clustering */
/*k_means(circ, obj, n);*/
k_means(input_val, obj, n);

/* choose representatives (smallest number for each cluster) */
for (i = 0; i < n; i++) obj[i].rep = 0;
for (j = 0; j < NUM_CLASS; j++) {
	for (i = 0; i < n; i++) {
		if (obj[i].label == j) {
			obj[i].rep = 1;
			break;
		}
	}
}

/* find bounding box */
find_rect(obj_id, width, height, n, obj);

for (i = 0; i < height; i++) free(obj_id[i]);
free(obj_id);

free(area);
free(len);
free(circ);
free(input_val);

/*color features*/
free(clr_mn_value);
free(clr_std_dev);
free(clr_skew);
free(clr_kurtosis);
for (i = 0; i < n; i++)
	free(clr_hist[i]);
free(clr_hist);


/*texture features*/
for (i=0;i<n;i++){
	for (j=0;j<256;j++){
		free(glcmat[i][j]);
		}/*for j*/
	free(glcmat[i]);
	}/*for i*/
free(glcmat);

free(ang_sec_mom);
free(contr);
free(corr);
free(var);
free(inv_diff_mom);
free(sum_av);
free(sum_entrp);
free(sum_varnc);
free(entrp);
free(diff_var);
free(diff_entrp);

*n_object = n;

return obj;

}
Example #10
0
/* It executes the Brain Storm Optimization for function minimization according to Algorithm 1 (El-Abd, 2017)
Parameters:
s: search space
Evaluate: pointer to the function used to evaluate particles
arg: list of additional arguments */
void runBSO(SearchSpace *s, prtFun Evaluate, ...)
{
	va_list arg, argtmp;
	int i, j, z, k, t, *best = NULL, c1, c2, **ideas_per_cluster = NULL;
	double p, r;
	Agent *nidea = NULL;

	va_start(arg, Evaluate);
	va_copy(argtmp, arg);

	if (!s)
	{
		fprintf(stderr, "\nSearch space not allocated @runBSO.\n");
		exit(-1);
	}

	ideas_per_cluster = (int **)malloc(s->k * sizeof(int *));
	best = (int *)malloc(s->k * sizeof(int));
	nidea = CreateAgent(s->n, _BSO_, _NOTENSOR_);

	EvaluateSearchSpace(s, _BSO_, Evaluate, arg); /* Initial evaluation */

	for (t = 1; t <= s->iterations; t++)
	{
		fprintf(stderr, "\nRunning iteration %d/%d ... ", t, s->iterations);

		/* clustering ideas */
		k_means(s, best, &ideas_per_cluster);

		/* for each idea */
		for (i = 0; i < s->m; i++)
		{
			va_copy(arg, argtmp);

			p = GenerateUniformRandomNumber(0, 1);
			if (s->p_one_cluster > p)
			{
				c1 = (int)GenerateUniformRandomNumber(0, s->k); /* selecting a cluster probabilistically */
				p = GenerateUniformRandomNumber(0, 1);

				/* creating a new idea based on the cluster selected previously.
		We also consider if cluster c1 has a single idea, i.e., ideas_per_cluster[c1][0] == 0.
		Notice we do not consider the cluster's center into that computation @kmeans function, which means a
		unitary cluster has ideas_per_cluster[c1][0] == 0. */
				if ((s->p_one_center > p) || (ideas_per_cluster[c1][0] == 0))
				{
					for (k = 0; k < s->n; k++)
						nidea->x[k] = s->a[best[c1]]->x[k];
				}
				else
				{ /* creating a new idea based on another idea j selected randomly from cluster c1 */
					j = (int)GenerateUniformRandomNumber(1, ideas_per_cluster[c1][0]);
					j = ideas_per_cluster[c1][j];

					for (k = 0; k < s->n; k++)
						nidea->x[k] = s->a[j]->x[k];
				}
			}
			else
			{

				/* selecting two clusters' centers probabilistically */
				c1 = (int)GenerateUniformRandomNumber(0, s->k);
				c2 = (int)GenerateUniformRandomNumber(0, s->k);

				/* selecting two ideas randomly */
				if (ideas_per_cluster[c1][0] == 0)
					j = best[c1];
				else
				{
					j = (int)GenerateUniformRandomNumber(1, ideas_per_cluster[c1][0]);
					j = ideas_per_cluster[c1][j];
				}

				if (ideas_per_cluster[c2][0] == 0)
					z = best[c2];
				else
				{
					z = (int)GenerateUniformRandomNumber(1, ideas_per_cluster[c2][0]);
					z = ideas_per_cluster[c2][z];
				}

				p = GenerateUniformRandomNumber(0, 1);
				r = GenerateUniformRandomNumber(0, 1);

				/* it creates a new idea based on a random combination of two selected clusters' centers */
				if (s->p_two_centers > p)
				{
					for (k = 0; k < s->n; k++)
						nidea->x[k] = r * s->a[best[c1]]->x[k] + (1 - r) * s->a[best[c2]]->x[k];
				}
				else
				{ /* it creates a new idea based on the ideas selected at random from the clusters previously chosen */
					for (k = 0; k < s->n; k++)
						nidea->x[k] = r * s->a[j]->x[k] + (1 - r) * s->a[z]->x[k];
				}
			}

			/* adding local noise to the new created idea */
			p = (0.5 * s->iterations - t) / k;
			r = GenerateUniformRandomNumber(0, 1) * Logistic_Sigmoid(p);

			for (k = 0; k < s->n; k++)
				nidea->x[k] += r * randGaussian(0, 1);

			/* It evaluates the new created idea */
			CheckAgentLimits(s, nidea);
			p = Evaluate(nidea, arg);
			if (p < s->a[i]->fit)
			{ /* if the new idea is better than the current one */
				for (k = 0; k < s->n; k++)
					s->a[i]->x[k] = nidea->x[k];
				s->a[i]->fit = p;
			}

			if (s->a[i]->fit < s->gfit)
				s->gfit = s->a[i]->fit;
		}

		fprintf(stderr, "OK (minimum fitness value %lf)", s->gfit);

		for (i = 0; i < s->k; i++)
			free(ideas_per_cluster[i]);
	}

	free(ideas_per_cluster);
	free(best);
	DestroyAgent(&nidea, _BSO_);
	va_end(arg);
}
Example #11
0
int
quantize(Pixel *pixelData,
         uint32_t nPixels,
         uint32_t nQuantPixels,
         Pixel **palette,
         uint32_t *paletteLength,
         uint32_t **quantizedPixels,
         int kmeans)
{
   PixelList *hl[3];
   HashTable *h;
   BoxNode *root;
   uint32_t i;
   uint32_t *qp;
   uint32_t nPaletteEntries;

   uint32_t *avgDist;
   uint32_t **avgDistSortKey;
   Pixel *p;

#ifndef NO_OUTPUT
   uint32_t timer,timer2;
#endif

#ifndef NO_OUTPUT
   timer2=clock();
   printf ("create hash table..."); fflush(stdout); timer=clock();
#endif
   h=create_pixel_hash(pixelData,nPixels);
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif
   if (!h) {
      goto error_0;
   }

#ifndef NO_OUTPUT
   printf ("create lists from hash table..."); fflush(stdout); timer=clock();
#endif
   hl[0]=hl[1]=hl[2]=NULL;
   hashtable_foreach(h,hash_to_list,hl);
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif

   if (!hl[0]) {
      goto error_1;
   }

#ifndef NO_OUTPUT
   printf ("mergesort lists..."); fflush(stdout); timer=clock();
#endif
   for(i=0;i<3;i++) {
      hl[i]=mergesort_pixels(hl[i],i);
   }
#ifdef TEST_MERGESORT
   if (!test_sorted(hl)) {
      printf ("bug in mergesort\n");
      goto error_1;
   }
#endif
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif

#ifndef NO_OUTPUT
   printf ("median cut..."); fflush(stdout); timer=clock();
#endif
   root=median_cut(hl,nPixels,nQuantPixels);
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif
   if (!root) {
      goto error_1;
   }
   nPaletteEntries=0;
#ifndef NO_OUTPUT
   printf ("median cut tree to hash table..."); fflush(stdout); timer=clock();
#endif
   annotate_hash_table(root,h,&nPaletteEntries);
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif
#ifndef NO_OUTPUT
   printf ("compute palette...\n"); fflush(stdout); timer=clock();
#endif
   if (!compute_palette_from_median_cut(pixelData,nPixels,h,&p,nPaletteEntries)) {
      goto error_3;
   }
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif

   free_box_tree(root);
   root=NULL;

   /* malloc check ok, using calloc for overflow */
   qp=calloc(nPixels, sizeof(uint32_t));
   if (!qp) { goto error_4; }

   if (nPaletteEntries > UINT32_MAX / nPaletteEntries )  {
       goto error_5;
   }
   /* malloc check ok, using calloc for overflow, check of n*n above */
   avgDist=calloc(nPaletteEntries*nPaletteEntries, sizeof(uint32_t));
   if (!avgDist) { goto error_5; }

   /* malloc check ok, using calloc for overflow, check of n*n above */
   avgDistSortKey=calloc(nPaletteEntries*nPaletteEntries, sizeof(uint32_t *));
   if (!avgDistSortKey) { goto error_6; }

   if (!build_distance_tables(avgDist,avgDistSortKey,p,nPaletteEntries)) {
      goto error_7;
   }

   if (!map_image_pixels_from_median_box(pixelData,nPixels,p,nPaletteEntries,h,avgDist,avgDistSortKey,qp)) {
      goto error_7;
   }

#ifdef TEST_NEAREST_NEIGHBOUR
#include <math.h>
   {
      uint32_t bestmatch,bestdist,dist;
      HashTable *h2;
      printf ("nearest neighbour search (full search)..."); fflush(stdout); timer=clock();
      h2=hashtable_new(unshifted_pixel_hash,unshifted_pixel_cmp);
      for (i=0;i<nPixels;i++) {
         if (hashtable_lookup(h2,pixelData[i],&paletteEntry)) {
            bestmatch=paletteEntry;
         } else {
            bestmatch=0;
            bestdist=
               _SQR(pixelData[i].c.r-p[0].c.r)+
               _SQR(pixelData[i].c.g-p[0].c.g)+
               _SQR(pixelData[i].c.b-p[0].c.b);
            for (j=1;j<nPaletteEntries;j++) {
               dist=
                  _SQR(pixelData[i].c.r-p[j].c.r)+
                  _SQR(pixelData[i].c.g-p[j].c.g)+
                  _SQR(pixelData[i].c.b-p[j].c.b);
               if (dist==bestdist && j==qp[i]) {
                  bestmatch=j;
               }
               if (dist<bestdist) {
                  bestdist=dist;
                  bestmatch=j;
               }
            }
            hashtable_insert(h2,pixelData[i],bestmatch);
         }
         if (qp[i]!=bestmatch ) {
            printf ("discrepancy in matching algorithms pixel %d [%d %d] %f %f\n",
                    i,qp[i],bestmatch,
                    sqrt((double)(_SQR(pixelData[i].c.r-p[qp[i]].c.r)+
                                  _SQR(pixelData[i].c.g-p[qp[i]].c.g)+
                                  _SQR(pixelData[i].c.b-p[qp[i]].c.b))),
                    sqrt((double)(_SQR(pixelData[i].c.r-p[bestmatch].c.r)+
                                  _SQR(pixelData[i].c.g-p[bestmatch].c.g)+
                                  _SQR(pixelData[i].c.b-p[bestmatch].c.b)))
                   );
         }
      }
      hashtable_free(h2);
   }
#endif
#ifndef NO_OUTPUT
   printf ("k means...\n"); fflush(stdout); timer=clock();
#endif
   if (kmeans) k_means(pixelData,nPixels,p,nPaletteEntries,qp,kmeans-1);
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
#endif

   *quantizedPixels=qp;
   *palette=p;
   *paletteLength=nPaletteEntries;

#ifndef NO_OUTPUT
   printf ("cleanup..."); fflush(stdout); timer=clock();
#endif
   if (avgDist) free(avgDist);
   if (avgDistSortKey) free(avgDistSortKey);
   destroy_pixel_hash(h);
#ifndef NO_OUTPUT
   printf ("done (%f)\n",(clock()-timer)/(double)CLOCKS_PER_SEC);
   printf ("-----\ntotal time %f\n",(clock()-timer2)/(double)CLOCKS_PER_SEC);
#endif
   return 1;

error_7:
   if (avgDistSortKey) free(avgDistSortKey);
error_6:
   if (avgDist) free(avgDist);
error_5:
   if (qp) free(qp);
error_4:
   if (p) free(p);
error_3:
   if (root) free_box_tree(root);
error_1:
   destroy_pixel_hash(h);
error_0:
   *quantizedPixels=NULL;
   *paletteLength=0;
   *palette=NULL;
   return 0;
}