int cluster(int numObjects, /* number of input objects */
int numAttributes, /* size of attribute of each object */
float **attributes, /* [numObjects][numAttributes] */
int num_nclusters,
int NUM_THREADS, /* in: number of threads */
float ***cluster_centres /* out: [best_nclusters][numAttributes] */
)
{
int nclusters;
float **tmp_cluster_centres;
nclusters=num_nclusters;
srand(7);
tmp_cluster_centres = kmeans_clustering(attributes,
numAttributes,
numObjects,
nclusters,
NUM_THREADS);
if (*cluster_centres) {
free((*cluster_centres)[0]);
free(*cluster_centres);
}
*cluster_centres = tmp_cluster_centres;
return 0;
}
/*!
* \brief Compute depth interval defined by the hand.
*
* Starting from the depth body image this function computes the depth
* interval related to the hand, these two depth values are later used
* as thresholds for the binarization procedure. This interval is
* calculated through a K-means clustering of the body image.
*
* \param[in] body depth image
* \param[out] hand depth min max values
*/
void get_hand_interval (IplImage *body, int *interval)
{
CvMat *data, *par, *means;
double var;
int min, count = cvCountNonZero(body);
data = cvCreateMat(count, 1, CV_32FC1);
par = cvCreateMat(count, 1, CV_8UC1);
means = cvCreateMat(K, 1, CV_32FC1);
fill_mat(body, data);
min = kmeans_clustering(data, means, par);
//var = get_cluster_var(data, par);
interval[0] = min;
interval[1] = (int)cvmGet(means, 0, 0); //- var;
cvReleaseMat(&data);
cvReleaseMat(&par);
cvReleaseMat(&means);
}
/*---< cluster() >-----------------------------------------------------------*/
int cluster(int numObjects, /* number of input objects */
int numAttributes, /* size of attribute of each object */
float **attributes, /* [numObjects][numAttributes] */
int num_nclusters,
float threshold, /* in: */
float ***cluster_centres /* out: [best_nclusters][numAttributes] */
)
{
int nclusters;
int *membership;
float **tmp_cluster_centres;
membership = (int*) malloc(numObjects * sizeof(int));
nclusters=num_nclusters;
srand(7);
tmp_cluster_centres = kmeans_clustering(attributes,
numAttributes,
numObjects,
nclusters,
threshold,
membership);
if (*cluster_centres) {
free((*cluster_centres)[0]);
free(*cluster_centres);
}
*cluster_centres = tmp_cluster_centres;
free(membership);
return 0;
}
/*---< cluster() >-----------------------------------------------------------*/
int cluster(int npoints, /* number of data points */
int nfeatures, /* number of attributes for each point */
float **features, /* array: [npoints][nfeatures] */
int min_nclusters, /* range of min to max number of clusters */
int max_nclusters,
float threshold, /* loop terminating factor */
int *best_nclusters, /* out: number between min and max with lowest RMSE */
float ***cluster_centres, /* out: [best_nclusters][nfeatures] */
float *min_rmse, /* out: minimum RMSE */
int isRMSE, /* calculate RMSE */
int nloops /* number of iteration for each number of clusters */
)
{
int nclusters; /* number of clusters k */
int index =0; /* number of iteration to reach the best RMSE */
int rmse; /* RMSE for each clustering */
int *membership; /* which cluster a data point belongs to */
float **tmp_cluster_centres; /* hold coordinates of cluster centers */
int i;
/* allocate memory for membership */
membership = (int*) malloc(npoints * sizeof(int));
/* sweep k from min to max_nclusters to find the best number of clusters */
for(nclusters = min_nclusters; nclusters <= max_nclusters; nclusters++)
{
if (nclusters > npoints) break; /* cannot have more clusters than points */
/* allocate device memory, invert data array (@ kmeans_cuda.cu) */
allocateMemory(npoints, nfeatures, nclusters, features);
/* iterate nloops times for each number of clusters */
for(i = 0; i < nloops; i++)
{
/* initialize initial cluster centers, CUDA calls (@ kmeans_cuda.cu) */
tmp_cluster_centres = kmeans_clustering(features,
nfeatures,
npoints,
nclusters,
threshold,
membership);
if (*cluster_centres) {
free((*cluster_centres)[0]);
free(*cluster_centres);
}
*cluster_centres = tmp_cluster_centres;
/* find the number of clusters with the best RMSE */
if(isRMSE)
{
rmse = rms_err(features,
nfeatures,
npoints,
tmp_cluster_centres,
nclusters);
if(rmse < min_rmse_ref){
min_rmse_ref = rmse; //update reference min RMSE
*min_rmse = min_rmse_ref; //update return min RMSE
*best_nclusters = nclusters; //update optimum number of clusters
index = i; //update number of iteration to reach best RMSE
}
}
}
}
deallocateMemory(); /* free device memory (@ kmeans_cuda.cu) */
free(membership);
return index;
}
