void Filter::Particle_Filter::init() {
condens = cvCreateConDensation(stateNum,measureNum,sampleNum);
lowerBound = cvCreateMat(stateNum, 1, CV_32F);
upperBound = cvCreateMat(stateNum, 1, CV_32F);
lowerBound = cvCreateMat(stateNum, 1, CV_32F);
upperBound = cvCreateMat(stateNum, 1, CV_32F);
cvmSet(lowerBound,0,0,0.0);
cvmSet(upperBound,0,0,winWidth/8);
cvmSet(lowerBound,1,0,0.0);
cvmSet(upperBound,1,0,winHeight/8);
cvmSet(lowerBound,2,0,0.0);
cvmSet(upperBound,2,0,0.0);
cvmSet(lowerBound,3,0,0.0);
cvmSet(upperBound,3,0,0.0);
float A[stateNum][stateNum] ={
1,0,1,0,
0,1,0,1,
0,0,1,0,
0,0,0,1
};
memcpy(condens->DynamMatr,A,sizeof(A));
cvConDensInitSampleSet(condens, lowerBound, upperBound);
CvRNG rng_state = cvRNG(0xffffffff);
for(int i=0; i < sampleNum; i++){
condens->flSamples[i][0] = float(cvRandInt( &rng_state ) % winWidth); //width
condens->flSamples[i][1] = float(cvRandInt( &rng_state ) % winHeight);//height
}
}
// All custom drawing goes here
void draw(CvArr* img, int width, int height) {
// Initialize our library
truchetInit( time(NULL) );
CvRNG rng = truchetGetRNG();
// White background
cvSet(img, cvScalar(255, 255, 255, 0), NULL);
truchetGenericState state1 = {
// Color
cvScalar( cvRandInt(&rng)%256, cvRandInt(&rng)%256, cvRandInt(&rng)%256, cvRandInt(&rng)%256)
};
fillTiles(img, (void *) &state1, 1, width, height, 0, 0, TILE_WIDTH, TILE_HEIGHT, &truchetPoint);
}
/*! \fn int Select()
* \brief This select un number corresponding to a gaussian index
* according to the gaussian weights
* \return an integer that is a gaussian index
*/
int GaussianMixture::Select()
{
if(curnb==1) return 0;
/* si les gaussiennes sont equiprobables alors on retourne un entier
tire aleatoirement entre 0 et le nombre de gaussiennes */
if(areEquiprob) return cvRandInt(&rng_state) % curnb;
else
{
/* Choix de l'index en fonction des poids de chaque gaussiennes */
int id;
double RandVal;
/* Tir aleatoire uniforme d'un reel entre 0 et 1 */
RandVal = cvRandReal(&rng_state);
/* Choix de l'etat en fonction des probas de transition */
id=0;
/* Choix en fonction des poids */
while((id < curnb) && (RandVal > coeffCumul[id]) )
id++;
return id;
}
}
main( int argc, char* argv[] ) {
// Choose a negative floating point number. Take its absolute value,
// round it, and then take its ceiling and floor.
double a = -1.23;
printf( "CV_IABS(a) = %d\n", CV_IABS(a) );
printf( "cvRound(a) = %d\n", cvRound(a) );
printf( "cvCeil(a) = %d\n", cvCeil(a) );
printf( "cvFloor(a) = %d\n", cvFloor(a) );
// Generate some random numbers.
CvRNG rngState = cvRNG(-1);
for (int i = 0; i < 10; i++) {
printf( "%u %f\n", cvRandInt( &rngState ),
cvRandReal( &rngState ) );
}
// Create a floating point CvPoint2D32f and convert it to an integer
// CvPoint.
CvPoint2D32f point_float1 = cvPoint2D32f(1.0, 2.0);
CvPoint point_int1 = cvPointFrom32f( point_float1 );
// Convert a CvPoint to a CvPoint2D32f.
CvPoint point_int2 = cvPoint(3, 4);
CvPoint2D32f point_float2 = cvPointTo32f( point_int2 );
}
void color_similarity_init(string comparer, CvScalar center_values[]){
const char* path ="/Users/Rango/Documents/coding/XCode/TextureSimilarity_data/";
char buff[512];
sprintf(buff, "%s%s.jpg", path, comparer.c_str());
IplImage* src1 = cvLoadImage(buff, CV_LOAD_IMAGE_COLOR);
//Kmeans
CvMat *samples = cvCreateMat(NSAMPLE, 1, CV_32FC3);
CvMat *clusters = cvCreateMat(NSAMPLE, 1, CV_32SC1);
uchar* data = (uchar*)src1->imageData;
int step = src1->widthStep/sizeof(uchar);
int channels = src1->nChannels;
CvMat *m_centers = cvCreateMat(NCLUSTER, 1, CV_32FC3);
CvRNG random = cvRNG(cvGetTickCount());
//printf("%d", cvRandInt(&random)%src1->height);
for (int k = 0; k < NSAMPLE; k++) {
int i = cvRandInt(&random)%src1->height;
int j = cvRandInt(&random)%src1->width;
CvScalar s;
s.val[0] = (double)data[i*step+j*channels+0];
s.val[1] = (double)data[i*step+j*channels+1];
s.val[2] = (double)data[i*step+j*channels+2];
cvSet2D(samples, k, 0, s);
}
//CvRNG* rng;
cout << "Kmeans..." << endl;
cvKMeans2(samples, NCLUSTER, clusters, TermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 10, 1.0)
, 1, &random ,KMEANS_PP_CENTERS, m_centers);
for (int i = 0; i < NCLUSTER; i++) {
center_values[i].val[0] = (float)cvGet2D(m_centers, i, 0).val[0];
center_values[i].val[1] = (float)cvGet2D(m_centers, i, 0).val[1];
center_values[i].val[2] = (float)cvGet2D(m_centers, i, 0).val[2];
}
for (int i = 0; i < NCLUSTER; i++) {
cout << center_values[i].val[0] << " " << center_values[i].val[1] << " " << center_values[i].val[2] << endl;
}
}
CvConDensation* initCondensation ( CvMat** indexMat, int nSample, int maxWidth, int maxHeight ){
int DP = indexMat[0]->cols; //! number of state vector dimensions */
int MP = indexMat[2]->rows; //! number of measurement vector dimensions */
CvConDensation* ConDens = cvCreateConDensation( DP, MP, nSample );
CvMat* lowerBound;
CvMat* upperBound;
lowerBound = cvCreateMat(DP, 1, CV_32F);
upperBound = cvCreateMat(DP, 1, CV_32F);
cvmSet( lowerBound, 0, 0, 0.0 );
cvmSet( upperBound, 0, 0, maxWidth );
cvmSet( lowerBound, 1, 0, 0.0 );
cvmSet( upperBound, 1, 0, maxHeight );
cvmSet( lowerBound, 2, 0, 0.0 );
cvmSet( upperBound, 2, 0, 0.0 );
cvmSet( lowerBound, 3, 0, 0.0 );
cvmSet( upperBound, 3, 0, 0.0 );
//ConDens->DynamMatr = &indexMat[0]; fa il set della matrice del sistema
for (int i=0;i<DP*DP;i++){
ConDens->DynamMatr[i]= indexMat[0]->data.fl[i];
}
cvConDensInitSampleSet(ConDens, lowerBound, upperBound);
CvRNG rng_state = cvRNG(0xffffffff);
for(int i=0; i < nSample; i++){
ConDens->flSamples[i][0] = cvRandInt( &rng_state ) % maxWidth; //0 represent the widht (x coord)
ConDens->flSamples[i][1] = cvRandInt( &rng_state ) % maxHeight; //1 represent the height (1 coord)
}
//ConDens->DynamMatr=(float*)indexMat[0];
//ConDens->State[0]=maxWidth/2;ConDens->State[1]=maxHeight/2;ConDens->State[2]=0;ConDens->State[3]=0;
return ConDens;
}
int main(void)
{
CvRNG rng;
rng = cvRNG(cvGetTickCount());
for(int i=0;i<100;i++)
{
printf("%d\n",cvRandInt(&rng));
}
printf("The Tick Frequency is %f\n",cvGetTickFrequency());
return 0;
}
void BreakingPointsScreen::doWatershedAndLayers(BreakingPointsImage* theBreakingPointsImage) {
cvZero( theBreakingPointsImage->marker_mask ); //zero out the mask to start with
int imageWidth = theBreakingPointsImage->theWatershed.width;
int imageHeight = theBreakingPointsImage->theWatershed.height;
ofxCvGrayscaleImage cvGrayWater;
cvGrayWater.allocate(imageWidth, imageHeight);
cvGrayWater.setFromPixels(theBreakingPointsImage->theWatershed.getPixels(), imageWidth, imageHeight);
cvCopy(cvGrayWater.getCvImage(), theBreakingPointsImage->marker_mask);
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* contours = 0;
CvMat* color_tab;
int i, j, comp_count = 0;
cvZero( theBreakingPointsImage->markers );
cvZero( theBreakingPointsImage->wshed );
cvFindContours( theBreakingPointsImage->marker_mask, storage, &contours, sizeof(CvContour),
CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
for( ; contours != 0; contours = contours->h_next, comp_count++ )
{
cvDrawContours( theBreakingPointsImage->markers, contours, cvScalarAll(comp_count+1),
cvScalarAll(comp_count+1), -1, -1, 8, cvPoint(0,0) );
}
if(comp_count == 0) {
cout << "Can't do watershed with no contours! " << endl;
return;
}
color_tab = cvCreateMat( 1, comp_count, CV_8UC3 );
for( i = 0; i < comp_count; i++ )
{
uchar* ptr = color_tab->data.ptr + i*3;
ptr[0] = (uchar)(cvRandInt(&theBreakingPointsImage->rng)%180 + 50);
ptr[1] = (uchar)(cvRandInt(&theBreakingPointsImage->rng)%180 + 50);
ptr[2] = (uchar)(cvRandInt(&theBreakingPointsImage->rng)%180 + 50);
}
// double t = (double)cvGetTickCount();
ofxCvColorImage cvTempImage;
cvTempImage.allocate(imageWidth, imageHeight);
cvWatershed( cvTempImage.getCvImage(), theBreakingPointsImage->markers );
// t = (double)cvGetTickCount() - t;
// printf( "exec time = %gms\n", t/(cvGetTickFrequency()*1000.) );
// paint the watershed image
for( i = 0; i < theBreakingPointsImage->markers->height; i++ ) {
for( j = 0; j < theBreakingPointsImage->markers->width; j++ ) {
int idx = CV_IMAGE_ELEM( theBreakingPointsImage->markers, int, i, j );
uchar* dst = &CV_IMAGE_ELEM( theBreakingPointsImage->wshed, uchar, i, j*3 );
if( idx == -1 )
dst[0] = dst[1] = dst[2] = (uchar)255;
else if( idx <= 0 || idx > comp_count )
dst[0] = dst[1] = dst[2] = (uchar)0; // should not get here
else
{
uchar* ptr = color_tab->data.ptr + (idx-1)*3;
dst[0] = ptr[0];
dst[1] = ptr[1];
dst[2] = ptr[2];
}
}
}
cvReleaseMemStorage( &storage );
cvReleaseMat( &color_tab );
ofxCvColorImage tempToDrawWith;
tempToDrawWith.allocate(imageWidth, imageHeight);
ofxCvGrayscaleImage tempToDrawWithGrey;
tempToDrawWithGrey.allocate(imageWidth, imageHeight);
cvCopy(theBreakingPointsImage->wshed, tempToDrawWith.getCvImage() );
tempToDrawWith.flagImageChanged();
tempToDrawWithGrey = tempToDrawWith;//converting automatically i hope
tempToDrawWithGrey.contrastStretch(); //as much contrast as we can get
tempToDrawWithGrey.dilate(); //stretch out the white borders
tempToDrawWithGrey.invert(); //make them black
tempToDrawWithGrey.threshold(1); //make all the grey white
theBreakingPointsImage->contourFinder.findContours(tempToDrawWithGrey, 20, 0.9f*(float)(imageWidth * imageHeight), 10, true, true);
int numberOfBlobsFound = theBreakingPointsImage->contourFinder.blobs.size();
//cout << contourFinder.blobs.size() << " was the number of blobs" << endl;
if(numberOfBlobsFound > 0) {
theBreakingPointsImage->layers.clear();
theBreakingPointsImage->layerMasks.clear();
theBreakingPointsImage->layerFades.clear();
theBreakingPointsImage->fadeSpeeds.clear();
theBreakingPointsImage->layers.resize(numberOfBlobsFound);
theBreakingPointsImage->layerMasks.resize(numberOfBlobsFound);
theBreakingPointsImage->layerFades.resize(numberOfBlobsFound);
theBreakingPointsImage->fadeSpeeds.resize(numberOfBlobsFound);
for(int i=0; i< numberOfBlobsFound; i++) {
theBreakingPointsImage->layers[i].allocate(imageWidth, imageHeight,OF_IMAGE_COLOR_ALPHA);
theBreakingPointsImage->layerMasks[i].allocate(imageWidth, imageHeight);
theBreakingPointsImage->layerMasks[i].drawBlobIntoMe(theBreakingPointsImage->contourFinder.blobs[i], 255);
theBreakingPointsImage->layerMasks[i].flagImageChanged();
unsigned char * pixelsSrc = theBreakingPointsImage->theImage.getPixels();
unsigned char * pixelsMask = theBreakingPointsImage->layerMasks[i].getPixels();
unsigned char * pixelsFinal = new unsigned char[imageWidth*imageHeight*4]; //RGBA so *4
memset(pixelsFinal,0,imageWidth*imageHeight*4);
for( int j = 0; j < imageWidth*imageHeight; j++)
{
if( pixelsMask[j*3] == 255 ) //i.e. if the mask is white at this point
{
pixelsFinal[j*4] = pixelsSrc[ j*3 ];
pixelsFinal[j*4+1] = pixelsSrc[ j*3+1 ];
pixelsFinal[j*4+2] = pixelsSrc[ j*3+2 ];
pixelsFinal[j*4+3] = 255;
}
}
theBreakingPointsImage->layers[i].setFromPixels(pixelsFinal, imageWidth, imageHeight, OF_IMAGE_COLOR_ALPHA);
delete[] pixelsFinal;
theBreakingPointsImage->layerFades[i] = 0; //start faded out, nahhhh random, nahh zero
theBreakingPointsImage->fadeSpeeds[i] = ofRandomuf(); //ofRandomuf(); //random 0..1 fade speed
}
}
theBreakingPointsImage->watershedDone = true;
if(ofRandomuf() > 0.5f) {
theBreakingPointsImage->isStrobe = true;
} else {
theBreakingPointsImage->isStrobe = false;
}
}
int main(int argc, char **argv)
{
float priors[] = { 1.0, 10.0 }; // Edible vs poisonos weights
CvMat *var_type;
CvMat *data; // jmh add
data = cvCreateMat(20, 30, CV_8U); // jmh add
var_type = cvCreateMat(data->cols + 1, 1, CV_8U);
cvSet(var_type, cvScalarAll(CV_VAR_CATEGORICAL)); // all these vars
// are categorical
CvDTree *dtree;
dtree = new CvDTree;
dtree->train(data, CV_ROW_SAMPLE, responses, 0, 0, var_type, missing, CvDTreeParams(8, // max depth
10, // min sample count
0, // regression accuracy: N/A here
true, // compute surrogate split,
// as we have missing data
15, // max number of categories
// (use sub-optimal algorithm for
// larger numbers)
10, // cross-validations
true, // use 1SE rule => smaller tree
true, // throw away the pruned tree branches
priors // the array of priors, the bigger
// p_weight, the more attention
// to the poisonous mushrooms
)
);
dtree->save("tree.xml", "MyTree");
dtree->clear();
dtree->load("tree.xml", "MyTree");
#define MAX_CLUSTERS 5
CvScalar color_tab[MAX_CLUSTERS];
IplImage *img = cvCreateImage(cvSize(500, 500), 8, 3);
CvRNG rng = cvRNG(0xffffffff);
color_tab[0] = CV_RGB(255, 0, 0);
color_tab[1] = CV_RGB(0, 255, 0);
color_tab[2] = CV_RGB(100, 100, 255);
color_tab[3] = CV_RGB(255, 0, 255);
color_tab[4] = CV_RGB(255, 255, 0);
cvNamedWindow("clusters", 1);
for (;;) {
int k, cluster_count = cvRandInt(&rng) % MAX_CLUSTERS + 1;
int i, sample_count = cvRandInt(&rng) % 1000 + 1;
CvMat *points = cvCreateMat(sample_count, 1, CV_32FC2);
CvMat *clusters = cvCreateMat(sample_count, 1, CV_32SC1);
/* generate random sample from multivariate
Gaussian distribution */
for (k = 0; k < cluster_count; k++) {
CvPoint center;
CvMat point_chunk;
center.x = cvRandInt(&rng) % img->width;
center.y = cvRandInt(&rng) % img->height;
cvGetRows(points, &point_chunk,
k * sample_count / cluster_count,
k == cluster_count - 1 ? sample_count :
(k + 1) * sample_count / cluster_count);
cvRandArr(&rng, &point_chunk, CV_RAND_NORMAL,
cvScalar(center.x, center.y, 0, 0),
cvScalar(img->width / 6, img->height / 6, 0, 0));
}
/* shuffle samples */
for (i = 0; i < sample_count / 2; i++) {
CvPoint2D32f *pt1 = (CvPoint2D32f *) points->data.fl +
cvRandInt(&rng) % sample_count;
CvPoint2D32f *pt2 = (CvPoint2D32f *) points->data.fl +
cvRandInt(&rng) % sample_count;
CvPoint2D32f temp;
CV_SWAP(*pt1, *pt2, temp);
}
cvKMeans2(points, cluster_count, clusters,
cvTermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 10, 1.0));
cvZero(img);
for (i = 0; i < sample_count; i++) {
CvPoint2D32f pt = ((CvPoint2D32f *) points->data.fl)[i];
int cluster_idx = clusters->data.i[i];
cvCircle(img, cvPointFrom32f(pt), 2,
color_tab[cluster_idx], CV_FILLED);
}
cvReleaseMat(&points);
cvReleaseMat(&clusters);
cvShowImage("clusters", img);
int key = cvWaitKey(0);
if (key == 27) // 'ESC'
break;
}
}
int CvArrTest::prepare_test_case( int test_case_idx )
{
int code = 1;
CvSize** sizes = (CvSize**)malloc( max_arr*sizeof(sizes[0]) );
CvSize** whole_sizes = (CvSize**)malloc( max_arr*sizeof(whole_sizes[0]) );
int** types = (int**)malloc( max_arr*sizeof(types[0]) );
int i, j, total = 0;
CvRNG* rng = ts->get_rng();
bool is_image = false;
bool is_timing_test = false;
CV_FUNCNAME( "CvArrTest::prepare_test_case" );
__BEGIN__;
is_timing_test = ts->get_testing_mode() == CvTS::TIMING_MODE;
if( is_timing_test )
{
if( !get_next_timing_param_tuple() )
{
code = -1;
EXIT;
}
}
for( i = 0; i < max_arr; i++ )
{
int count = test_array[i].size();
count = MAX(count, 1);
sizes[i] = (CvSize*)malloc( count*sizeof(sizes[i][0]) );
types[i] = (int*)malloc( count*sizeof(types[i][0]) );
whole_sizes[i] = (CvSize*)malloc( count*sizeof(whole_sizes[i][0]) );
}
if( !is_timing_test )
get_test_array_types_and_sizes( test_case_idx, sizes, types );
else
{
get_timing_test_array_types_and_sizes( test_case_idx, sizes, types,
whole_sizes, &is_image );
}
for( i = 0; i < max_arr; i++ )
{
int count = test_array[i].size();
total += count;
for( j = 0; j < count; j++ )
{
unsigned t = cvRandInt(rng);
bool create_mask = true, use_roi = false;
CvSize size = sizes[i][j], whole_size = size;
CvRect roi = {0,0,0,0};
if( !is_timing_test )
{
is_image = !cvmat_allowed ? true : iplimage_allowed ? (t & 1) != 0 : false;
create_mask = (t & 6) == 0; // ~ each of 3 tests will use mask
use_roi = (t & 8) != 0;
if( use_roi )
{
whole_size.width += cvRandInt(rng) % 10;
whole_size.height += cvRandInt(rng) % 10;
}
}
else
{
whole_size = whole_sizes[i][j];
use_roi = whole_size.width != size.width || whole_size.height != size.height;
create_mask = cvReadInt(find_timing_param( "use_mask" ),0) != 0;
}
cvRelease( &test_array[i][j] );
if( size.width > 0 && size.height > 0 &&
types[i][j] >= 0 && (i != MASK || create_mask) )
{
if( use_roi )
{
roi.width = size.width;
roi.height = size.height;
if( whole_size.width > size.width )
{
if( !is_timing_test )
roi.x = cvRandInt(rng) % (whole_size.width - size.width);
else
roi.x = 1;
}
if( whole_size.height > size.height )
{
if( !is_timing_test )
roi.y = cvRandInt(rng) % (whole_size.height - size.height);
else
roi.y = 1;
}
}
if( is_image )
{
CV_CALL( test_array[i][j] = cvCreateImage( whole_size,
icvTsTypeToDepth[CV_MAT_DEPTH(types[i][j])],
CV_MAT_CN(types[i][j]) ));
if( use_roi )
cvSetImageROI( (IplImage*)test_array[i][j], roi );
}
else
{
CV_CALL( test_array[i][j] = cvCreateMat( whole_size.height,
whole_size.width, types[i][j] ));
if( use_roi )
{
CvMat submat, *mat = (CvMat*)test_array[i][j];
cvGetSubRect( test_array[i][j], &submat, roi );
submat.refcount = mat->refcount;
*mat = submat;
}
}
}
}
}
if( total > max_hdr )
{
delete hdr;
max_hdr = total;
hdr = new CvMat[max_hdr];
}
total = 0;
for( i = 0; i < max_arr; i++ )
{
int count = test_array[i].size();
test_mat[i] = count > 0 ? hdr + total : 0;
for( j = 0; j < count; j++ )
{
CvArr* arr = test_array[i][j];
CvMat* mat = &test_mat[i][j];
if( !arr )
memset( mat, 0, sizeof(*mat) );
else if( CV_IS_MAT( arr ))
{
*mat = *(CvMat*)arr;
mat->refcount = 0;
}
else
cvGetMat( arr, mat, 0, 0 );
if( mat->data.ptr )
fill_array( test_case_idx, i, j, mat );
}
total += count;
}
__END__;
for( i = 0; i < max_arr; i++ )
{
if( sizes )
free( sizes[i] );
if( whole_sizes )
free( whole_sizes[i] );
if( types )
free( types[i] );
}
free( sizes );
free( whole_sizes );
free( types );
return code;
}
int main( int argc, char** argv )
{
char* filename = argc >= 2 ? argv[1] : (char*)"fruits.jpg";
CvRNG rng = cvRNG(-1);
if( (img0 = cvLoadImage(filename,1)) == 0 )
return 0;
printf( "Hot keys: \n"
"\tESC - quit the program\n"
"\tr - restore the original image\n"
"\tw or SPACE - run watershed algorithm\n"
"\t\t(before running it, roughly mark the areas on the image)\n"
"\t (before that, roughly outline several markers on the image)\n" );
cvNamedWindow( "image", 1 );
cvNamedWindow( "watershed transform", 1 );
img = cvCloneImage( img0 );
img_gray = cvCloneImage( img0 );
wshed = cvCloneImage( img0 );
marker_mask = cvCreateImage( cvGetSize(img), 8, 1 );
markers = cvCreateImage( cvGetSize(img), IPL_DEPTH_32S, 1 );
cvCvtColor( img, marker_mask, CV_BGR2GRAY );
cvCvtColor( marker_mask, img_gray, CV_GRAY2BGR );
cvZero( marker_mask );
cvZero( wshed );
cvShowImage( "image", img );
cvShowImage( "watershed transform", wshed );
cvSetMouseCallback( "image", on_mouse, 0 );
for(;;)
{
int c = cvWaitKey(0);
if( (char)c == 27 )
break;
if( (char)c == 'r' )
{
cvZero( marker_mask );
cvCopy( img0, img );
cvShowImage( "image", img );
}
if( (char)c == 'w' || (char)c == ' ' )
{
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* contours = 0;
CvMat* color_tab;
int i, j, comp_count = 0;
//cvSaveImage( "wshed_mask.png", marker_mask );
//marker_mask = cvLoadImage( "wshed_mask.png", 0 );
cvFindContours( marker_mask, storage, &contours, sizeof(CvContour),
CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
cvZero( markers );
for( ; contours != 0; contours = contours->h_next, comp_count++ )
{
cvDrawContours( markers, contours, cvScalarAll(comp_count+1),
cvScalarAll(comp_count+1), -1, -1, 8, cvPoint(0,0) );
}
color_tab = cvCreateMat( 1, comp_count, CV_8UC3 );
for( i = 0; i < comp_count; i++ )
{
uchar* ptr = color_tab->data.ptr + i*3;
ptr[0] = (uchar)(cvRandInt(&rng)%180 + 50);
ptr[1] = (uchar)(cvRandInt(&rng)%180 + 50);
ptr[2] = (uchar)(cvRandInt(&rng)%180 + 50);
}
{
double t = (double)cvGetTickCount();
cvWatershed( img0, markers );
t = (double)cvGetTickCount() - t;
printf( "exec time = %gms\n", t/(cvGetTickFrequency()*1000.) );
}
// paint the watershed image
for( i = 0; i < markers->height; i++ )
for( j = 0; j < markers->width; j++ )
{
int idx = CV_IMAGE_ELEM( markers, int, i, j );
uchar* dst = &CV_IMAGE_ELEM( wshed, uchar, i, j*3 );
if( idx == -1 )
dst[0] = dst[1] = dst[2] = (uchar)255;
else if( idx <= 0 || idx > comp_count )
dst[0] = dst[1] = dst[2] = (uchar)0; // should not get here
else
{
uchar* ptr = color_tab->data.ptr + (idx-1)*3;
dst[0] = ptr[0]; dst[1] = ptr[1]; dst[2] = ptr[2];
}
}
cvAddWeighted( wshed, 0.5, img_gray, 0.5, 0, wshed );
cvShowImage( "watershed transform", wshed );
cvReleaseMemStorage( &storage );
cvReleaseMat( &color_tab );
}
}
int CvANN_MLP::train_backprop( CvVectors x0, CvVectors u, const double* sw )
{
CvMat* dw = 0;
CvMat* buf = 0;
double **x = 0, **df = 0;
CvMat* _idx = 0;
int iter = -1, count = x0.count;
CV_FUNCNAME( "CvANN_MLP::train_backprop" );
__BEGIN__;
int i, j, k, ivcount, ovcount, l_count, total = 0, max_iter;
double *buf_ptr;
double prev_E = DBL_MAX*0.5, E = 0, epsilon;
max_iter = params.term_crit.max_iter*count;
epsilon = params.term_crit.epsilon*count;
l_count = layer_sizes->cols;
ivcount = layer_sizes->data.i[0];
ovcount = layer_sizes->data.i[l_count-1];
// allocate buffers
for( i = 0; i < l_count; i++ )
total += layer_sizes->data.i[i] + 1;
CV_CALL( dw = cvCreateMat( wbuf->rows, wbuf->cols, wbuf->type ));
cvZero( dw );
CV_CALL( buf = cvCreateMat( 1, (total + max_count)*2, CV_64F ));
CV_CALL( _idx = cvCreateMat( 1, count, CV_32SC1 ));
for( i = 0; i < count; i++ )
_idx->data.i[i] = i;
CV_CALL( x = (double**)cvAlloc( total*2*sizeof(x[0]) ));
df = x + total;
buf_ptr = buf->data.db;
for( j = 0; j < l_count; j++ )
{
x[j] = buf_ptr;
df[j] = x[j] + layer_sizes->data.i[j];
buf_ptr += (df[j] - x[j])*2;
}
// run back-propagation loop
/*
y_i = w_i*x_{i-1}
x_i = f(y_i)
E = 1/2*||u - x_N||^2
grad_N = (x_N - u)*f'(y_i)
dw_i(t) = momentum*dw_i(t-1) + dw_scale*x_{i-1}*grad_i
w_i(t+1) = w_i(t) + dw_i(t)
grad_{i-1} = w_i^t*grad_i
*/
for( iter = 0; iter < max_iter; iter++ )
{
int idx = iter % count;
double* w = weights[0];
double sweight = sw ? count*sw[idx] : 1.;
CvMat _w, _dw, hdr1, hdr2, ghdr1, ghdr2, _df;
CvMat *x1 = &hdr1, *x2 = &hdr2, *grad1 = &ghdr1, *grad2 = &ghdr2, *temp;
if( idx == 0 )
{
if( fabs(prev_E - E) < epsilon )
break;
prev_E = E;
E = 0;
// shuffle indices
for( i = 0; i < count; i++ )
{
int tt;
j = (unsigned)cvRandInt(&rng) % count;
k = (unsigned)cvRandInt(&rng) % count;
CV_SWAP( _idx->data.i[j], _idx->data.i[k], tt );
}
}
idx = _idx->data.i[idx];
if( x0.type == CV_32F )
{
const float* x0data = x0.data.fl[idx];
for( j = 0; j < ivcount; j++ )
x[0][j] = x0data[j]*w[j*2] + w[j*2 + 1];
}
else
{
const double* x0data = x0.data.db[idx];
for( j = 0; j < ivcount; j++ )
x[0][j] = x0data[j]*w[j*2] + w[j*2 + 1];
}
cvInitMatHeader( x1, 1, ivcount, CV_64F, x[0] );
// forward pass, compute y[i]=w*x[i-1], x[i]=f(y[i]), df[i]=f'(y[i])
for( i = 1; i < l_count; i++ )
{
cvInitMatHeader( x2, 1, layer_sizes->data.i[i], CV_64F, x[i] );
cvInitMatHeader( &_w, x1->cols, x2->cols, CV_64F, weights[i] );
cvGEMM( x1, &_w, 1, 0, 0, x2 );
_df = *x2;
_df.data.db = df[i];
calc_activ_func_deriv( x2, &_df, _w.data.db + _w.rows*_w.cols );
CV_SWAP( x1, x2, temp );
}
cvInitMatHeader( grad1, 1, ovcount, CV_64F, buf_ptr );
*grad2 = *grad1;
grad2->data.db = buf_ptr + max_count;
w = weights[l_count+1];
// calculate error
if( u.type == CV_32F )
{
const float* udata = u.data.fl[idx];
for( k = 0; k < ovcount; k++ )
{
double t = udata[k]*w[k*2] + w[k*2+1] - x[l_count-1][k];
grad1->data.db[k] = t*sweight;
E += t*t;
}
}
else
{
const double* udata = u.data.db[idx];
for( k = 0; k < ovcount; k++ )
{
double t = udata[k]*w[k*2] + w[k*2+1] - x[l_count-1][k];
grad1->data.db[k] = t*sweight;
E += t*t;
}
}
E *= sweight;
// backward pass, update weights
for( i = l_count-1; i > 0; i-- )
{
int n1 = layer_sizes->data.i[i-1], n2 = layer_sizes->data.i[i];
cvInitMatHeader( &_df, 1, n2, CV_64F, df[i] );
cvMul( grad1, &_df, grad1 );
cvInitMatHeader( &_w, n1+1, n2, CV_64F, weights[i] );
cvInitMatHeader( &_dw, n1+1, n2, CV_64F, dw->data.db + (weights[i] - weights[0]) );
cvInitMatHeader( x1, n1+1, 1, CV_64F, x[i-1] );
x[i-1][n1] = 1.;
cvGEMM( x1, grad1, params.bp_dw_scale, &_dw, params.bp_moment_scale, &_dw );
cvAdd( &_w, &_dw, &_w );
if( i > 1 )
{
grad2->cols = n1;
_w.rows = n1;
cvGEMM( grad1, &_w, 1, 0, 0, grad2, CV_GEMM_B_T );
}
CV_SWAP( grad1, grad2, temp );
}
}
iter /= count;
__END__;
cvReleaseMat( &dw );
cvReleaseMat( &buf );
cvReleaseMat( &_idx );
cvFree( &x );
return iter;
}
static CvStatus
icvFitLine3D( CvPoint3D32f * points, int count, int dist,
float _param, float reps, float aeps, float *line )
{
double EPS = count*FLT_EPSILON;
void (*calc_weights) (float *, int, float *) = 0;
void (*calc_weights_param) (float *, int, float *, float) = 0;
float *w; /* weights */
float *r; /* square distances */
int i, j, k;
float _line[6], _lineprev[6];
float rdelta = reps != 0 ? reps : 1.0f;
float adelta = aeps != 0 ? aeps : 0.01f;
double min_err = DBL_MAX, err = 0;
CvRNG rng = cvRNG(-1);
memset( line, 0, 6*sizeof(line[0]) );
switch (dist)
{
case CV_DIST_L2:
return icvFitLine3D_wods( points, count, 0, line );
case CV_DIST_L1:
calc_weights = icvWeightL1;
break;
case CV_DIST_L12:
calc_weights = icvWeightL12;
break;
case CV_DIST_FAIR:
calc_weights_param = icvWeightFair;
break;
case CV_DIST_WELSCH:
calc_weights_param = icvWeightWelsch;
break;
case CV_DIST_HUBER:
calc_weights_param = icvWeightHuber;
break;
/*case CV_DIST_USER:
_PFP.p = param;
calc_weights = (void ( * )(float *, int, float *)) _PFP.fp;
break;*/
default:
return CV_BADFACTOR_ERR;
}
w = (float *) cvAlloc( count * sizeof( float ));
r = (float *) cvAlloc( count * sizeof( float ));
for( k = 0; k < 20; k++ )
{
int first = 1;
for( i = 0; i < count; i++ )
w[i] = 0.f;
for( i = 0; i < MIN(count,10); )
{
j = cvRandInt(&rng) % count;
if( w[j] < FLT_EPSILON )
{
w[j] = 1.f;
i++;
}
}
icvFitLine3D_wods( points, count, w, _line );
for( i = 0; i < 30; i++ )
{
double sum_w = 0;
if( first )
{
first = 0;
}
else
{
double t = _line[0] * _lineprev[0] + _line[1] * _lineprev[1] + _line[2] * _lineprev[2];
t = MAX(t,-1.);
t = MIN(t,1.);
if( fabs(acos(t)) < adelta )
{
float x, y, z, ax, ay, az, dx, dy, dz, d;
x = _line[3] - _lineprev[3];
y = _line[4] - _lineprev[4];
z = _line[5] - _lineprev[5];
ax = _line[0] - _lineprev[0];
ay = _line[1] - _lineprev[1];
az = _line[2] - _lineprev[2];
dx = (float) fabs( y * az - z * ay );
dy = (float) fabs( z * ax - x * az );
dz = (float) fabs( x * ay - y * ax );
d = dx > dy ? (dx > dz ? dx : dz) : (dy > dz ? dy : dz);
if( d < rdelta )
break;
}
}
/* calculate distances */
if( icvCalcDist3D( points, count, _line, r ) < FLT_EPSILON*count )
break;
/* calculate weights */
if( calc_weights )
calc_weights( r, count, w );
else
calc_weights_param( r, count, w, _param );
for( j = 0; j < count; j++ )
sum_w += w[j];
if( fabs(sum_w) > FLT_EPSILON )
{
sum_w = 1./sum_w;
for( j = 0; j < count; j++ )
w[j] = (float)(w[j]*sum_w);
}
else
{
for( j = 0; j < count; j++ )
w[j] = 1.f;
}
/* save the line parameters */
memcpy( _lineprev, _line, 6 * sizeof( float ));
/* Run again... */
icvFitLine3D_wods( points, count, w, _line );
}
if( err < min_err )
{
min_err = err;
memcpy( line, _line, 6 * sizeof(line[0]));
if( err < EPS )
break;
}
}
// Return...
cvFree( &w );
cvFree( &r );
return CV_OK;
}
static void
icvDFSInitSpillTreeNode( const CvSpillTree* tr,
const int d,
CvSpillTreeNode* node )
{
if ( node->cc <= tr->naive )
{
// already get to a leaf, terminate the recursion.
node->leaf = true;
node->spill = false;
return;
}
// random select a node, then find a farthest node from this one, then find a farthest from that one...
// to approximate the farthest node-pair
static CvRNG rng_state = cvRNG(0xdeadbeef);
int rn = cvRandInt( &rng_state ) % node->cc;
CvSpillTreeNode* lnode = NULL;
CvSpillTreeNode* rnode = node->lc;
for ( int i = 0; i < rn; i++ )
rnode = rnode->rc;
lnode = icvFarthestNode( rnode, node->lc, node->cc );
rnode = icvFarthestNode( lnode, node->lc, node->cc );
// u is the projection vector
node->u = cvCreateMat( 1, d, tr->type );
cvSub( lnode->center, rnode->center, node->u );
cvNormalize( node->u, node->u );
// find the center of node in hyperspace
node->center = cvCreateMat( 1, d, tr->type );
cvZero( node->center );
CvSpillTreeNode* it = node->lc;
for ( int i = 0; i < node->cc; i++ )
{
cvAdd( it->center, node->center, node->center );
it = it->rc;
}
cvConvertScale( node->center, node->center, 1./node->cc );
// project every node to "u", and find the mean point "mp"
it = node->lc;
node->r = -1.;
node->mp = 0;
for ( int i = 0; i < node->cc; i++ )
{
node->mp += ( it->p = cvDotProduct( it->center, node->u ) );
double norm = cvNorm( node->center, it->center );
if ( norm > node->r )
node->r = norm;
it = it->rc;
}
node->mp = node->mp / node->cc;
// overlapping buffer and upper bound, lower bound
double ob = (lnode->p-rnode->p)*tr->tau*.5;
node->ub = node->mp+ob;
node->lb = node->mp-ob;
int sl = 0, l = 0;
int sr = 0, r = 0;
it = node->lc;
for ( int i = 0; i < node->cc; i++ )
{
if ( it->p <= node->ub )
sl++;
if ( it->p >= node->lb )
sr++;
if ( it->p < node->mp )
l++;
else
r++;
it = it->rc;
}
// precision problem, return the node as it is.
if (( l == 0 )||( r == 0 ))
{
cvReleaseMat( &(node->u) );
cvReleaseMat( &(node->center) );
node->leaf = true;
node->spill = false;
return;
}
CvSpillTreeNode* lc = (CvSpillTreeNode*)cvAlloc( sizeof(CvSpillTreeNode) );
memset(lc, 0, sizeof(CvSpillTreeNode));
CvSpillTreeNode* rc = (CvSpillTreeNode*)cvAlloc( sizeof(CvSpillTreeNode) );
memset(rc, 0, sizeof(CvSpillTreeNode));
lc->lc = lc->rc = rc->lc = rc->rc = NULL;
lc->cc = rc->cc = 0;
int undo = cvRound(node->cc*tr->rho);
if (( sl >= undo )||( sr >= undo ))
{
// it is not a spill point (defeatist search disabled)
it = node->lc;
for ( int i = 0; i < node->cc; i++ )
{
CvSpillTreeNode* next = it->rc;
if ( it->p < node->mp )
icvAppendSpillTreeNode( lc, it );
else
icvAppendSpillTreeNode( rc, it );
it = next;
}
node->spill = false;
} else {
// a spill point
it = node->lc;
for ( int i = 0; i < node->cc; i++ )
{
CvSpillTreeNode* next = it->rc;
if ( it->p < node->lb )
icvAppendSpillTreeNode( lc, it );
else if ( it->p > node->ub )
icvAppendSpillTreeNode( rc, it );
else {
CvSpillTreeNode* cit = icvCloneSpillTreeNode( it );
icvAppendSpillTreeNode( lc, it );
icvAppendSpillTreeNode( rc, cit );
}
it = next;
}
node->spill = true;
}
node->lc = lc;
node->rc = rc;
// recursion process
icvDFSInitSpillTreeNode( tr, d, node->lc );
icvDFSInitSpillTreeNode( tr, d, node->rc );
}
int main(int argc, char* argv[])
{
int i, j;
CvMemStorage* storage = cvCreateMemStorage(0);
IplImage* img = cvCreateImage( cvSize(w,w), 8, 1 );
IplImage* img32f = cvCreateImage( cvSize(w,w), IPL_DEPTH_32F, 1 );
IplImage* img32s = cvCreateImage( cvSize(w,w), IPL_DEPTH_32S, 1 );
IplImage* img3 = cvCreateImage( cvSize(w,w), 8, 3 );
(void)argc; (void)argv;
help();
cvZero( img );
for( i=0; i < 6; i++ )
{
int dx = (i%2)*250 - 30;
int dy = (i/2)*150;
CvScalar white = cvRealScalar(255);
CvScalar black = cvRealScalar(0);
if( i == 0 )
{
for( j = 0; j <= 10; j++ )
{
double angle = (j+5)*CV_PI/21;
cvLine(img, cvPoint(cvRound(dx+100+j*10-80*cos(angle)),
cvRound(dy+100-90*sin(angle))),
cvPoint(cvRound(dx+100+j*10-30*cos(angle)),
cvRound(dy+100-30*sin(angle))), white, 3, 8, 0);
}
}
cvEllipse( img, cvPoint(dx+150, dy+100), cvSize(100,70), 0, 0, 360, white, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+115, dy+70), cvSize(30,20), 0, 0, 360, black, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+185, dy+70), cvSize(30,20), 0, 0, 360, black, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+115, dy+70), cvSize(15,15), 0, 0, 360, white, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+185, dy+70), cvSize(15,15), 0, 0, 360, white, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+115, dy+70), cvSize(5,5), 0, 0, 360, black, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+185, dy+70), cvSize(5,5), 0, 0, 360, black, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+150, dy+100), cvSize(10,5), 0, 0, 360, black, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+150, dy+150), cvSize(40,10), 0, 0, 360, black, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+27, dy+100), cvSize(20,35), 0, 0, 360, white, -1, 8, 0 );
cvEllipse( img, cvPoint(dx+273, dy+100), cvSize(20,35), 0, 0, 360, white, -1, 8, 0 );
}
cvNamedWindow( "image", 1 );
cvShowImage( "image", img );
cvConvert( img, img32f );
findCComp( img32f );
cvConvert( img32f, img32s );
cvFindContours( img32s, storage, &contours, sizeof(CvContour),
CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0) );
//cvFindContours( img, storage, &contours, sizeof(CvContour),
// CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0) );
{
const char* attrs[] = {"recursive", "1", 0};
cvSave("contours.xml", contours, 0, 0, cvAttrList(attrs, 0));
contours = (CvSeq*)cvLoad("contours.xml", storage, 0, 0);
}
// comment this out if you do not want approximation
contours = cvApproxPoly( contours, sizeof(CvContour), storage, CV_POLY_APPROX_DP, 3, 1 );
cvNamedWindow( "contours", 1 );
cvCreateTrackbar( "levels+3", "contours", &levels, 7, on_trackbar );
{
CvRNG rng = cvRNG(-1);
CvSeq* tcontours = contours;
cvCvtColor( img, img3, CV_GRAY2BGR );
while( tcontours->h_next )
tcontours = tcontours->h_next;
for( ; tcontours != 0; tcontours = tcontours->h_prev )
{
CvScalar color;
color.val[0] = cvRandInt(&rng) % 256;
color.val[1] = cvRandInt(&rng) % 256;
color.val[2] = cvRandInt(&rng) % 256;
color.val[3] = cvRandInt(&rng) % 256;
cvDrawContours(img3, tcontours, color, color, 0, -1, 8, cvPoint(0,0));
if( tcontours->v_next )
{
color.val[0] = cvRandInt(&rng) % 256;
color.val[1] = cvRandInt(&rng) % 256;
color.val[2] = cvRandInt(&rng) % 256;
color.val[3] = cvRandInt(&rng) % 256;
cvDrawContours(img3, tcontours->v_next, color, color, 1, -1, 8, cvPoint(0,0));
}
}
}
cvShowImage( "colored", img3 );
on_trackbar(0);
cvWaitKey(0);
cvReleaseMemStorage( &storage );
cvReleaseImage( &img );
cvReleaseImage( &img32f );
cvReleaseImage( &img32s );
cvReleaseImage( &img3 );
return 0;
}
int randint( const int min, const int max ){
return cvRandInt( &rng_state )%(max-min+1) + min;
}
void CV_SolvePolyTest::run( int )
{
CvRNG rng = cvRNG();
int fig = 100;
double range = 50;
double err_eps = 1e-4;
for (int idx = 0, max_idx = 1000, progress = 0; idx < max_idx; ++idx)
{
progress = update_progress(progress, idx-1, max_idx, 0);
int n = cvRandInt(&rng) % 13 + 1;
std::vector<complex_type> r(n), ar(n), c(n + 1, 0);
std::vector<double> a(n + 1), u(n * 2), ar1(n), ar2(n);
int rr_odds = 3; // odds that we get a real root
for (int j = 0; j < n;)
{
if (cvRandInt(&rng) % rr_odds == 0 || j == n - 1)
r[j++] = cvRandReal(&rng) * range;
else
{
r[j] = complex_type(cvRandReal(&rng) * range,
cvRandReal(&rng) * range + 1);
r[j + 1] = std::conj(r[j]);
j += 2;
}
}
for (int j = 0, k = 1 << n, jj, kk; j < k; ++j)
{
int p = 0;
complex_type v(1);
for (jj = 0, kk = 1; jj < n && !(j & kk); ++jj, ++p, kk <<= 1)
;
for (; jj < n; ++jj, kk <<= 1)
{
if (j & kk)
v *= -r[jj];
else
++p;
}
c[p] += v;
}
bool pass = false;
double div = 0, s = 0;
int cubic_case = idx & 1;
for (int maxiter = 100; !pass && maxiter < 10000; maxiter *= 2, cubic_case = (cubic_case + 1) % 2)
{
for (int j = 0; j < n + 1; ++j)
a[j] = c[j].real();
CvMat amat, umat;
cvInitMatHeader(&amat, n + 1, 1, CV_64FC1, &a[0]);
cvInitMatHeader(&umat, n, 1, CV_64FC2, &u[0]);
cvSolvePoly(&amat, &umat, maxiter, fig);
for (int j = 0; j < n; ++j)
ar[j] = complex_type(u[j * 2], u[j * 2 + 1]);
sort(r.begin(), r.end(), pred_complex());
sort(ar.begin(), ar.end(), pred_complex());
pass = true;
if( n == 3 )
{
ar2.resize(n);
cv::Mat _umat2(3, 1, CV_64F, &ar2[0]), umat2 = _umat2;
cvFlip(&amat, &amat, 0);
int nr2;
if( cubic_case == 0 )
nr2 = cv::solveCubic(cv::Mat(&amat),umat2);
else
nr2 = cv::solveCubic(cv::Mat_<float>(cv::Mat(&amat)), umat2);
cvFlip(&amat, &amat, 0);
if(nr2 > 0)
sort(ar2.begin(), ar2.begin()+nr2, pred_double());
ar2.resize(nr2);
int nr1 = 0;
for(int j = 0; j < n; j++)
if( fabs(r[j].imag()) < DBL_EPSILON )
ar1[nr1++] = r[j].real();
pass = pass && nr1 == nr2;
if( nr2 > 0 )
{
div = s = 0;
for(int j = 0; j < nr1; j++)
{
s += fabs(ar1[j]);
div += fabs(ar1[j] - ar2[j]);
}
div /= s;
pass = pass && div < err_eps;
}
}
div = s = 0;
for (int j = 0; j < n; ++j)
{
s += fabs(r[j].real()) + fabs(r[j].imag());
div += sqrt(pow(r[j].real() - ar[j].real(), 2) + pow(r[j].imag() - ar[j].imag(), 2));
}
div /= s;
pass = pass && div < err_eps;
}
if (!pass)
{
ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT);
ts->printf( CvTS::LOG, "too big diff = %g\n", div );
for (size_t j=0;j<ar2.size();++j)
ts->printf( CvTS::LOG, "ar2[%d]=%g\n", j, ar2[j]);
ts->printf(CvTS::LOG, "\n");
for (size_t j=0;j<r.size();++j)
ts->printf( CvTS::LOG, "r[%d]=(%g, %g)\n", j, r[j].real(), r[j].imag());
ts->printf( CvTS::LOG, "\n" );
for (size_t j=0;j<ar.size();++j)
ts->printf( CvTS::LOG, "ar[%d]=(%g, %g)\n", j, ar[j].real(), ar[j].imag());
break;
}
}
}
int main(int argc, const char * argv[]) {
IplImage* img = cvCreateImage( cvSize( 500, 500 ), 8, 3 );
CvRNG rng = cvRNG(-1);
cvNamedWindow( "fitline", 1 );
for(;;) {
char key;
int i, count = cvRandInt(&rng) % 100 + 1, outliers = count/5;
float a = cvRandReal(&rng) * 200;
float b = cvRandReal(&rng) * 40;
float angle = cvRandReal(&rng) * CV_PI;
float cos_a = cos(angle), sin_a = sin(angle);
CvPoint pt1, pt2;
CvPoint* points = (CvPoint*)malloc( count * sizeof(points[0]));
CvMat pointMat = cvMat( 1, count, CV_32SC2, points );
float line[4];
float d, t;
b = MIN(a*0.3, b);
// generate some points that are close to the line
for( i = 0; i < count - outliers; i++ ) {
float x = (cvRandReal(&rng)*2-1)*a;
float y = (cvRandReal(&rng)*2-1)*b;
points[i].x = cvRound(x*cos_a - y*sin_a + img->width/2);
points[i].y = cvRound(x*sin_a + y*cos_a + img->height/2);
}
// generate "completely off" points
for( ; i < count; i++ ) {
points[i].x = cvRandInt(&rng) % img->width;
points[i].y = cvRandInt(&rng) % img->height;
}
// find the optimal line
cvFitLine( &pointMat, CV_DIST_L1, 1, 0.001, 0.001, line );
cvZero( img );
// draw the points
for( i = 0; i < count; i++ ) {
cvCircle( img, points[i], 2, i < count - outliers ? CV_RGB(255, 0, 0) : CV_RGB(255,255,0), CV_FILLED, CV_AA, 0 );
}
d = sqrt((double)line[0]*line[0] + (double)line[1]*line[1]);
line[0] /= d;
line[1] /= d;
t = (float)(img->width + img->height);
pt1.x = cvRound(line[2] - line[0]*t);
pt1.y = cvRound(line[3] - line[1]*t);
pt2.x = cvRound(line[2] + line[0]*t);
pt2.y = cvRound(line[3] + line[1]*t);
cvLine( img, pt1, pt2, CV_RGB(0,255,0), 3, CV_AA, 0 );
cvShowImage( "fitline", img );
key = (char) cvWaitKey(0);
if( key == 27 ) break;
free( points );
}
cvDestroyWindow( "fitline" );
return 0;
}
void MyLable::set_scaled_button()
{
int i, j, comp_count = 0;
CvMat* color_tab = 0;
CvSeq* contours = 0;
cvSave("markes.xml",marker_mask);
cvClearMemStorage(storage);
cvFindContours( marker_mask, storage, &contours, sizeof(CvContour),
CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
cvZero( markes );
for( ; contours != 0; contours = contours->h_next, comp_count++ )
{
//cvDrawContours(markers, contours, cvScalarAll(comp_count+1),
//cvScalarAll(comp_count+1), -1, -1, 8, cvPoint(0,0) );
cvDrawContours(markes, contours, cvScalarAll(comp_count+1),
cvScalarAll(comp_count+1), 1, -1, 8, cvPoint(0,0) );
}
color_tab = cvCreateMat( 1, comp_count, CV_8UC3 );//创建随机颜色列表
for( i = 0; i < comp_count; i++ ) //不同的整数标记
{
uchar* ptr = color_tab->data.ptr + i*3;
ptr[0] = (uchar)(cvRandInt(&rng)%180 + 50);
ptr[1] = (uchar)(cvRandInt(&rng)%180 + 50);
ptr[2] = (uchar)(cvRandInt(&rng)%180 + 50);
}
double t = (double)cvGetTickCount();
cvSave("img0.xml",markes);
cvWatershed( img0, markes );
cvSave("img1.xml",markes);
// cvShowImage("imgo",img0);
t = (double)cvGetTickCount() - t;
printf( "exec time = %gms\n", t/(cvGetTickFrequency()*1000.) );
/*********/
for( i = 0; i < markes->height; i++ )
for( j = 0; j < markes->width; j++ )
{
int idx = CV_IMAGE_ELEM( markes, int, i, j );//markers的数据类型为IPL_DEPTH_32S
uchar* dst = &CV_IMAGE_ELEM( wshed, uchar, i, j*3 );//BGR三个通道的数是一起的,故要j*3
uchar* t_body = &CV_IMAGE_ELEM( tongue_body, uchar, i, j*3 );
uchar* src_pic = &CV_IMAGE_ELEM( img0, uchar, i, j*3 );
if( idx == -1 ) //输出时若为-1，表示各个部分的边界
{
//dst[0] = dst[1] = dst[2] = (uchar)128;
dst[2] = (uchar)255;
}
else if( idx <= 0 || idx > comp_count ) //异常情况
{
//dst[0] = dst[1] = dst[2] = (uchar)0; // should not get here
}
else if( idx == 1 ) //异常情况
{
//green first
dst[0] = (uchar)255;
t_body[0] = src_pic[0];
t_body[1] = src_pic[1];
t_body[2] = src_pic[2];
}
else if( idx == 2 ) //异常情况
{
//blue second
dst[1] = (uchar)255;
}
else if( idx == 3 ) //异常情况
{
//red third
dst[2] = (uchar)255;
}
else //正常情况
{
uchar* ptr = color_tab->data.ptr + (idx-1)*3;
dst[0] = ptr[0]; dst[1] = ptr[1]; dst[2] = ptr[2];
}
}
cvShowImage("img_gray",img_gray);
cvShowImage("wshed",wshed);
cvAddWeighted( wshed, 0.5, img_gray, 0.5, 0, wshed );
//wshed.x.y=0.5*wshed.x.y+0.5*img_gray+0加权融合图像
//cvShowImage("swhed",wshed);
//cvShowImage("img_gray",img_gray);
//cvShowImage( "watershed transform", wshed );
//cvShowImage("img_final",img_final);
cvShowImage( "watershed transform", wshed );
img = Function::CjwIplToQImg(tongue_body);
image = *img;
cvReleaseMat( &color_tab );
update();
clear_list();
}
// This function create cross-validation EstimateModel.
ML_IMPL CvStatModel*
cvCreateCrossValidationEstimateModel(
int samples_all,
const CvStatModelParams* estimateParams,
const CvMat* sampleIdx)
{
CvStatModel* model = NULL;
CvCrossValidationModel* crVal = NULL;
CV_FUNCNAME ("cvCreateCrossValidationEstimateModel");
__BEGIN__
int k_fold = 10;
int i, j, k, s_len;
int samples_selected;
CvRNG rng;
CvRNG* prng;
int* res_s_data;
int* te_s_data;
int* folds;
rng = cvRNG(cvGetTickCount());
cvRandInt (&rng);
cvRandInt (&rng);
cvRandInt (&rng);
cvRandInt (&rng);
// Check input parameters.
if (estimateParams)
k_fold = ((CvCrossValidationParams*)estimateParams)->k_fold;
if (!k_fold)
{
CV_ERROR (CV_StsBadArg, "Error in parameters of cross-validation (k_fold == 0)!");
}
if (samples_all <= 0)
{
CV_ERROR (CV_StsBadArg, "<samples_all> should be positive!");
}
// Alloc memory and fill standart StatModel's fields.
CV_CALL (crVal = (CvCrossValidationModel*)cvCreateStatModel (
CV_STAT_MODEL_MAGIC_VAL | CV_CROSSVAL_MAGIC_VAL,
sizeof(CvCrossValidationModel),
cvReleaseCrossValidationModel,
NULL, NULL));
crVal->current_fold = -1;
crVal->folds_all = k_fold;
if (estimateParams && ((CvCrossValidationParams*)estimateParams)->is_regression)
crVal->is_regression = 1;
else
crVal->is_regression = 0;
if (estimateParams && ((CvCrossValidationParams*)estimateParams)->rng)
prng = ((CvCrossValidationParams*)estimateParams)->rng;
else
prng = &rng;
// Check and preprocess sample indices.
if (sampleIdx)
{
int s_step;
int s_type = 0;
if (!CV_IS_MAT (sampleIdx))
CV_ERROR (CV_StsBadArg, "Invalid sampleIdx array");
if (sampleIdx->rows != 1 && sampleIdx->cols != 1)
CV_ERROR (CV_StsBadSize, "sampleIdx array must be 1-dimensional");
s_len = sampleIdx->rows + sampleIdx->cols - 1;
s_step = sampleIdx->rows == 1 ?
1 : sampleIdx->step / CV_ELEM_SIZE(sampleIdx->type);
s_type = CV_MAT_TYPE (sampleIdx->type);
switch (s_type)
{
case CV_8UC1:
case CV_8SC1:
{
uchar* s_data = sampleIdx->data.ptr;
// sampleIdx is array of 1's and 0's -
// i.e. it is a mask of the selected samples
if( s_len != samples_all )
CV_ERROR (CV_StsUnmatchedSizes,
"Sample mask should contain as many elements as the total number of samples");
samples_selected = 0;
for (i = 0; i < s_len; i++)
samples_selected += s_data[i * s_step] != 0;
if (samples_selected == 0)
CV_ERROR (CV_StsOutOfRange, "No samples is selected!");
}
s_len = samples_selected;
break;
case CV_32SC1:
if (s_len > samples_all)
CV_ERROR (CV_StsOutOfRange,
"sampleIdx array may not contain more elements than the total number of samples");
samples_selected = s_len;
break;
default:
CV_ERROR (CV_StsUnsupportedFormat, "Unsupported sampleIdx array data type "
"(it should be 8uC1, 8sC1 or 32sC1)");
}
// Alloc additional memory for internal Idx and fill it.
/*!!*/ CV_CALL (res_s_data = crVal->sampleIdxAll =
(int*)cvAlloc (2 * s_len * sizeof(int)));
if (s_type < CV_32SC1)
{
uchar* s_data = sampleIdx->data.ptr;
for (i = 0; i < s_len; i++)
if (s_data[i * s_step])
{
*res_s_data++ = i;
}
res_s_data = crVal->sampleIdxAll;
}
else
{
int* s_data = sampleIdx->data.i;
int out_of_order = 0;
for (i = 0; i < s_len; i++)
{
res_s_data[i] = s_data[i * s_step];
if (i > 0 && res_s_data[i] < res_s_data[i - 1])
out_of_order = 1;
}
if (out_of_order)
qsort (res_s_data, s_len, sizeof(res_s_data[0]), icvCmpIntegers);
if (res_s_data[0] < 0 ||
res_s_data[s_len - 1] >= samples_all)
CV_ERROR (CV_StsBadArg, "There are out-of-range sample indices");
for (i = 1; i < s_len; i++)
if (res_s_data[i] <= res_s_data[i - 1])
CV_ERROR (CV_StsBadArg, "There are duplicated");
}
}
else // if (sampleIdx)
{
// Alloc additional memory for internal Idx and fill it.
s_len = samples_all;
CV_CALL (res_s_data = crVal->sampleIdxAll = (int*)cvAlloc (2 * s_len * sizeof(int)));
for (i = 0; i < s_len; i++)
{
*res_s_data++ = i;
}
res_s_data = crVal->sampleIdxAll;
} // if (sampleIdx) ... else
// Resort internal Idx.
te_s_data = res_s_data + s_len;
for (i = s_len; i > 1; i--)
{
j = cvRandInt (prng) % i;
k = *(--te_s_data);
*te_s_data = res_s_data[j];
res_s_data[j] = k;
}
// Duplicate resorted internal Idx.
// It will be used to simplify operation of getting trainIdx.
te_s_data = res_s_data + s_len;
for (i = 0; i < s_len; i++)
{
*te_s_data++ = *res_s_data++;
}
// Cut sampleIdxAll to parts.
if (k_fold > 0)
{
if (k_fold > s_len)
{
CV_ERROR (CV_StsBadArg,
"Error in parameters of cross-validation ('k_fold' > #samples)!");
}
folds = crVal->folds = (int*) cvAlloc ((k_fold + 1) * sizeof (int));
*folds++ = 0;
for (i = 1; i < k_fold; i++)
{
*folds++ = cvRound (i * s_len * 1. / k_fold);
}
*folds = s_len;
folds = crVal->folds;
crVal->max_fold_size = (s_len - 1) / k_fold + 1;
}
else
{
k = -k_fold;
crVal->max_fold_size = k;
if (k >= s_len)
{
CV_ERROR (CV_StsBadArg,
"Error in parameters of cross-validation (-'k_fold' > #samples)!");
}
crVal->folds_all = k = (s_len - 1) / k + 1;
folds = crVal->folds = (int*) cvAlloc ((k + 1) * sizeof (int));
for (i = 0; i < k; i++)
{
*folds++ = -i * k_fold;
}
*folds = s_len;
folds = crVal->folds;
}
// Prepare other internal fields to working.
CV_CALL (crVal->predict_results = cvCreateMat (1, samples_all, CV_32FC1));
CV_CALL (crVal->sampleIdxEval = cvCreateMatHeader (1, 1, CV_32SC1));
CV_CALL (crVal->sampleIdxTrain = cvCreateMatHeader (1, 1, CV_32SC1));
crVal->sampleIdxEval->cols = 0;
crVal->sampleIdxTrain->cols = 0;
crVal->samples_all = s_len;
crVal->is_checked = 1;
crVal->getTrainIdxMat = cvCrossValGetTrainIdxMatrix;
crVal->getCheckIdxMat = cvCrossValGetCheckIdxMatrix;
crVal->nextStep = cvCrossValNextStep;
crVal->check = cvCrossValCheckClassifier;
crVal->getResult = cvCrossValGetResult;
crVal->reset = cvCrossValReset;
model = (CvStatModel*)crVal;
__END__
if (!model)
{
cvReleaseCrossValidationModel ((CvStatModel**)&crVal);
}
return model;
} // End of cvCreateCrossValidationEstimateModel
void faceDbCreator(const char filePath[50],const char coordsFilename[100],
const int startFile,const int endFile,
const int noIterations,const int border){
/**Number of Feature Points used in aligning images.**/
const int noFeaturePoints = 4;
const int initialSize = 38;
int i,j,k,iteration;
/**No of files from DB added for alignment**/
int noFiles = 0;
double xr = 0;
double yr = 0;
int x,y;
char filePathCopy[100];
/**Corrds of the standards face with respect to initialSize**/
CvMat *stdCoords = cvCreateMat(noFeaturePoints*2,1,
CV_64FC1);
double stdCoordsData[] = {5+border,6+border,32+border,
6+border,18+border,15+border,
18+border,25+border};
stdCoords->data.db = stdCoordsData;
/**Average Coords of the faces aligned so far**/
double avgData[noFeaturePoints*2];
CvMat *avgMat = cvCreateMat(noFeaturePoints*2,1,
CV_64FC1);
avgMat->data.db = avgData;
/**Coords to which other coordinates are aligned to**/
double testData[noFeaturePoints*2];
CvMat *testMat = cvCreateMat(noFeaturePoints*2,1,
CV_64FC1);
testMat->data.db = testData;
cvCopy(stdCoords,testMat);
double tempCoords[noFeaturePoints*2];
/**Coords of all the image in the database**/
CvMat* coords[endFile-startFile+1];
double coordsData[endFile-startFile+1][noFeaturePoints*8];
/**Face DB image file names**/
char fileNames[endFile-startFile+1][100];
char tempFileName[100];
char tempStr[50];
IplImage *img = NULL;
IplImage *dst = NULL;
FILE* coordsFile = fopen(coordsFilename,"r+");
FILE* t = NULL;
if (coordsFile){
for (i=-startFile+1;i<=endFile-startFile;++i){
if(!feof(coordsFile)){
fscanf(coordsFile,"%s %lf %lf %lf %lf %lf %lf %lf %lf",&tempStr,
&tempCoords[0],&tempCoords[1],&tempCoords[2],
&tempCoords[3],&tempCoords[4],&tempCoords[5],
&tempCoords[6],&tempCoords[7]);
/**Skip the coords upto startImage**/
if (i>=0){
strcpy(tempFileName,filePath);
strcat(tempFileName,tempStr);
/**Check whether the file exists**/
if (t=fopen(tempFileName,"r")){
fclose(t);
strcpy(fileNames[noFiles],tempFileName);
coords[noFiles] = cvCreateMat(noFeaturePoints*2,4,
CV_64FC1);
faceDbCreatorFillData(coordsData[noFiles],tempCoords,noFeaturePoints);
coords[noFiles]->data.db = coordsData[noFiles];
++noFiles;
}
}
}
else{
noFiles = i-1;
break;
}
}
fclose(coordsFile);
if (!noFiles){
printf("Face DB Creator Error: No File To Process\n");
exit(EXIT_FAILURE);
}
}
else {
printf("Face DB Creator Error: Could Not Open Coords File\n");
exit(EXIT_FAILURE);
}
/**PsuedoInverse**/
CvMat *temp2 = cvCreateMat(4,1,CV_64FC1);
double tempData2[4];
temp2->data.db = tempData2;
for (iteration=0;iteration<noIterations;++iteration){
cvSetZero(avgMat);
for (i=0;i<noFiles;++i){
pseudoInverse(coords[i],testMat,temp2);
for (j=0;j<noFeaturePoints;++j){
xr = coordsData[i][j*8]*temp2->data.db[0]
-coordsData[i][j*8+4]*
temp2->data.db[1]+temp2->data.db[2];
yr = coordsData[i][j*8]*temp2->data.db[1]
+coordsData[i][j*8+4]*
temp2->data.db[0]+temp2->data.db[3];
coordsData[i][j*8] = xr;
coordsData[i][j*8+5] = xr;
coordsData[i][j*8+1] = -yr;
coordsData[i][j*8+4] = yr;
avgData[j*2] += xr;
avgData[j*2+1] += yr;
}
img = cvLoadImage(fileNames[i],
CV_LOAD_IMAGE_GRAYSCALE);
dst = cvCreateImage(cvSize(initialSize+
2*border,initialSize+2*border),
img->depth,img->nChannels);
cvSetZero(dst);
double a = temp2->data.db[0];
double b = temp2->data.db[1];
double det = a*a+b*b;
double tx = temp2->data.db[2];
double ty = temp2->data.db[3];
/**Transform the image**/
for (j=0;j<dst->height;++j){
for (k=0;k<dst->width;++k){
xr = ((k-tx)*a+(j-ty)*b)/det;
yr = ((k-tx)*-b+(j-ty)*a)/det;
if ((int)xr>=0 && (int)xr <img->width && (int)yr>=0
&& (int)yr<img->height){
*((unsigned char*)(dst->imageData)+j*dst->widthStep+k)=
*((unsigned char*)(img->imageData)+
(int)yr*img->widthStep+(int)xr);
}
}
}
cvSaveImage(fileNames[i],dst);
cvReleaseImage(&img);
cvReleaseImage(&dst);
}
/**Averge of the transformation performed so far**/
for (j=0;j<noFeaturePoints*2;++j){
avgData[j] /= endFile-startFile+1;
}
/**Perform transformation on the average data**/
CvMat* tempMat = cvCreateMat(noFeaturePoints*2,4,
CV_64FC1);
double tempMatData[noFeaturePoints*8];
tempMat->data.db = tempMatData;
faceDbCreatorFillData(tempMatData,avgData,noFeaturePoints);
pseudoInverse(tempMat,stdCoords,temp2);
for (j=0;j<noFeaturePoints;++j){
testData[j*2] = avgData[j*2]*temp2->data.db[0]-
avgData[j*2+1]*temp2->data.db[1]+
temp2->data.db[2];
testData[j*2+1] = avgData[j*2]*temp2->data.db[1]+
avgData[j*2+1]*temp2->data.db[0]+
temp2->data.db[3];
}
cvReleaseMat(&tempMat);
}
IplImage *img8U,*img64F;
CvRect *cropArea;
IplImage *finalImage32F = cvCreateImage(cvSize(CROPPED_WIDTH,
CROPPED_HEIGHT),IPL_DEPTH_32F,1);
IplImage *finalImage8U = cvCreateImage(cvSize(CROPPED_WIDTH,
CROPPED_HEIGHT),IPL_DEPTH_8U,1);
IplImage *transformImage64F;
IplImage *transformImage32F;
IplImage *croppedImage32F = cvCreateImage(cvSize(initialSize,
initialSize),IPL_DEPTH_32F,1);
IplImage *croppedImage64F = cvCreateImage(cvSize(initialSize,
initialSize),IPL_DEPTH_64F,1);
IplImage* mask = cvCreateImage(cvGetSize
(croppedImage64F),IPL_DEPTH_8U,1);
maskGenerator(mask);
/**Random transformations**/
double scale = 0;
double rotate = 0;
double translateX = 0;
double translateY = 0;
tempStr[0] = '_';
tempStr[4] = '.';
tempStr[5] = 'j';
tempStr[6] = 'p';
tempStr[7] = 'g';
tempStr[8] = '\0';
/**Random Number Generator**/
CvRNG rg;
for (i=0;i<noFiles;++i){
img8U = cvLoadImage(fileNames[i],
CV_LOAD_IMAGE_GRAYSCALE);
img64F = cvCreateImage(cvGetSize(img8U),
IPL_DEPTH_64F,1);
cvConvertScale(img8U,img64F);
cvReleaseImage(&img8U);
remove(fileNames[i]);
xr = coordsData[i][0]-stdCoordsData[0]+
border;
yr = coordsData[i][4]-stdCoordsData[1]+
border;
cvSetImageROI(img64F,cvRect(cvRound(xr),cvRound(yr),initialSize,
initialSize));
cvCopy(img64F,croppedImage64F);
/**Creating variations for each image**/
for (j=0;j<NO_VARIATIONS;++j){
lightingCorrection(croppedImage64F,mask);
rg = cvRNG(time(0)*1000*(i+20)*(j+30));
cvConvertScale(croppedImage64F,croppedImage32F);
cvResize(croppedImage32F,finalImage32F);
cvConvertScale(finalImage32F,finalImage8U);
tempStr[1] = (j/100)%10+48;
tempStr[2] = (j/10)%10+48;tempStr[3]=j%10+48;
strncpy(tempFileName,fileNames[i],strlen(fileNames[i])-4);
tempFileName[strlen(fileNames[i])-4]
='\0';
strcat(tempFileName,tempStr);
cvSaveImage(tempFileName,finalImage8U);
switch (cvRandInt(&rg)%3){
/**Scaling**/
case 0:
if (cvRandInt(&rg)%2)
scale = cvRandReal(&rg)*MAX_SCALE*
initialSize/CROPPED_WIDTH;
else
scale = cvRandReal(&rg)*MIN_SCALE*
initialSize/CROPPED_HEIGHT;
transformImage64F = cvCreateImage(
cvSize(cvRound(initialSize-2*scale),
cvRound(initialSize-2*scale)),
IPL_DEPTH_64F,1);
transformImage32F = cvCreateImage(
cvSize(cvRound(initialSize-2*scale),
cvRound(initialSize-2*scale)),
IPL_DEPTH_32F,1);
cvSetImageROI(img64F,cvRect(cvRound(xr+scale),cvRound(yr+scale),
cvRound(initialSize-2*scale),cvRound(initialSize-2*scale)));
cvCopy(img64F,transformImage64F);
cvConvertScale(transformImage64F,transformImage32F);
cvResize(transformImage32F,croppedImage32F);
cvConvertScale(croppedImage32F,croppedImage64F);
cvReleaseImage(&transformImage64F);
cvReleaseImage(&transformImage32F);
break;
/**Rotation**/
case 1:
if (cvRandInt(&rg)%2)
rotate = cvRandReal(&rg)*MAX_ROTATE;
else
rotate = cvRandReal(&rg)*MIN_ROTATE;
cvResetImageROI(img64F);
transformImage64F = cvCreateImage(cvGetSize(img64F),
IPL_DEPTH_64F,1);
transformRotate(img64F,transformImage64F,
&cvPoint2D64f(xr+initialSize/2,yr+initialSize/2),rotate*M_PI/180);
cvSetImageROI(transformImage64F,
cvRect(xr,yr,initialSize,initialSize));
cvCopy(transformImage64F,croppedImage64F);
cvReleaseImage(&transformImage64F);
break;
default:
/**Translation**/
if (cvRandInt(&rg)%2){
if (cvRandInt(&rg)%2){
translateX = cvRandReal(&rg)*MAX_TRANSLATE*
initialSize/CROPPED_WIDTH;
translateY = cvRandReal(&rg)*MAX_TRANSLATE*
initialSize/CROPPED_HEIGHT;
}
else{
translateX = cvRandReal(&rg)*MIN_TRANSLATE*
initialSize/CROPPED_WIDTH;
translateY = cvRandReal(&rg)*MIN_TRANSLATE*
initialSize/CROPPED_HEIGHT;
}
}
else{
if (cvRandInt(&rg)%2){
translateX = cvRandReal(&rg)*MAX_TRANSLATE*
initialSize/CROPPED_WIDTH;
translateY = cvRandReal(&rg)*MIN_TRANSLATE*
initialSize/CROPPED_HEIGHT;
}
else{
translateX = cvRandReal(&rg)*MIN_TRANSLATE*
initialSize/CROPPED_WIDTH;
translateY = cvRandReal(&rg)*MAX_TRANSLATE*
initialSize/CROPPED_HEIGHT;
}
}
cvSetImageROI(img64F,cvRect(cvRound(xr+translateX),
cvRound(yr+translateY),initialSize,initialSize));
cvCopy(img64F,croppedImage64F);
}
}
cvReleaseImage(&img64F);
cvReleaseMat(&coords[i]);
}
cvReleaseImage(&finalImage8U);
cvReleaseImage(&finalImage32F);
cvReleaseImage(&croppedImage32F);
cvReleaseImage(&croppedImage64F);
cvReleaseMat(&stdCoords);
cvReleaseMat(&testMat);
cvReleaseMat(&avgMat);
cvReleaseMat(&temp2);
}
int main()
{
#define MAX_CLUSTER 5
CvScalar color_tab[MAX_CLUSTER];
IplImage* img = cvCreateImage(cvSize(500,500) , 8 , 3);
CvRNG rng = cvRNG(0xffffffff);
color_tab[0] = CV_RGB(255 , 0 , 0);
color_tab[1] = CV_RGB( 0 , 255 , 0);
color_tab[2] = CV_RGB(100 , 100 , 255);
color_tab[3] = CV_RGB(255 , 0 , 255);
color_tab[4] = CV_RGB(255 , 255 , 0);
cvNamedWindow("clusters" , 1);
while(1)
{
int cluster_count = cvRandInt(&rng)%MAX_CLUSTER + 1;
int sample_count = cvRandInt(&rng)%1000 + 1;
CvMat* points = cvCreateMat(sample_count , 1 , CV_32FC2);
CvMat* clusters = cvCreateMat(sample_count , 1 ,CV_32SC1);
int k;
for (k = 0 ; k<cluster_count ; k++)
{
CvPoint center;
CvMat point_chunk;
center.x = cvRandInt(&rng)%(img->width);
center.y = cvRandInt(&rng)%(img->height);
cvGetRows( points , &point_chunk ,
k*sample_count/cluster_count ,
(k+1)*sample_count/cluster_count ,
1);
cvRandArr(&rng , &point_chunk , CV_RAND_NORMAL ,
cvScalar(center.x , center.y , 0 , 0),
cvScalar(img->width/6 , img->height/6 , 0 , 0) );
}
int i;
for (i = 0; i<sample_count/2 ; i++)
{//random find two and exchange
CvPoint2D32f* pt1 = (CvPoint2D32f*)points->data.fl + cvRandInt(&rng)%sample_count;
CvPoint2D32f* pt2 = (CvPoint2D32f*)points->data.fl + cvRandInt(&rng)%sample_count;
CvPoint2D32f temp;
CV_SWAP(*pt1 , *pt2 , temp);
}
cvKMeans2(points , cluster_count , clusters ,
cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,10,1.0),
1, 0, 0, 0, 0);
cvZero(img);
for (i = 0; i<sample_count/2 ; i++)
{
CvPoint2D32f pt = ((CvPoint2D32f*)points->data.fl)[i];
int cluster_idx = clusters->data.i[i];
cvCircle(img , cvPointFrom32f(pt), 2, color_tab[cluster_idx] ,
CV_FILLED, 8, 0);
}
cvReleaseMat(&points);
cvReleaseMat(&clusters);
cvShowImage("clusters" , img);
int key = cvWaitKey(0);
if(key == 27)
break;
}//while(1)
return 0;
}
int main( int argc, char** argv )
{
IplImage* img; // input image object
IplImage* grayImg = NULL; // tmp image object
IplImage* thresholdedImg = NULL; // threshold output image object
IplImage* dst; // output connected components
int windowSize = 3; // starting threshold value
int constant = 0; // starting constant value
CvCapture* capture = NULL; // capture object
const char* windowName1 = "OPENCV: adaptive image thresholding"; // window name
const char* windowName2 = "OPENCV: grayscale image"; // window name
const char* windowName3 = "OPENCV: adaptive threshold image"; // window name
bool keepProcessing = true; // loop control flag
char key; // user input
int EVENT_LOOP_DELAY = 40; // delay for GUI window
// 40 ms equates to 1000ms/25fps = 40ms per frame
// if command line arguments are provided try to read image/video_name
// otherwise default to capture from attached H/W camera
if(
( argc == 2 && (img = cvLoadImage( argv[1], 1)) != 0 ) ||
( argc == 2 && (capture = cvCreateFileCapture( argv[1] )) != 0 ) ||
( argc != 2 && (capture = cvCreateCameraCapture( CAMERA_INDEX )) != 0 )
)
{
// create window objects
cvNamedWindow(windowName1, 0 );
cvNamedWindow(windowName2, 0 );
cvNamedWindow(windowName3, 0 );
// add adjustable trackbar for threshold parameter
cvCreateTrackbar("Neighbourhood (N)", windowName3, &windowSize, 255, NULL);
cvCreateTrackbar("Constant (C)", windowName3, &constant, 50, NULL);
// if capture object in use (i.e. video/camera)
// get initial image from capture object
if (capture) {
// cvQueryFrame s just a combination of cvGrabFrame
// and cvRetrieveFrame in one call.
img = cvQueryFrame(capture);
if(!img){
if (argc == 2){
printf("End of video file reached\n");
} else {
printf("ERROR: cannot get next fram from camera\n");
}
exit(0);
}
}
// create output image
thresholdedImg = cvCreateImage(cvSize(img->width,img->height),
img->depth, 1);
thresholdedImg->origin = img->origin;
grayImg = cvCreateImage(cvSize(img->width,img->height),
img->depth, 1);
grayImg->origin = img->origin;
dst = cvCloneImage(img);
// create a set of random labels
CvRNG rng = cvRNG(-1);
CvMat* color_tab = cvCreateMat( 1, 255, CV_8UC3 );
for(int i = 0; i < 255; i++ )
{
uchar* ptr = color_tab->data.ptr + i*3;
ptr[0] = (uchar)(cvRandInt(&rng)%180 + 50);
ptr[1] = (uchar)(cvRandInt(&rng)%180 + 50);
ptr[2] = (uchar)(cvRandInt(&rng)%180 + 50);
}
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* contours = 0;
CvSeq* current_contour;
int comp_count = 0;
// start main loop
while (keepProcessing) {
// if capture object in use (i.e. video/camera)
// get image from capture object
if (capture) {
// cvQueryFrame s just a combination of cvGrabFrame
// and cvRetrieveFrame in one call.
img = cvQueryFrame(capture);
if(!img){
if (argc == 2){
printf("End of video file reached\n");
} else {
printf("ERROR: cannot get next fram from camera\n");
}
exit(0);
}
}
// if input is not already grayscale, convert to grayscale
if (img->nChannels > 1){
cvCvtColor(img, grayImg, CV_BGR2GRAY);
} else {
grayImg = img;
}
// display image in window
cvShowImage( windowName2, grayImg );
// check that the window size is always odd and > 3
if ((windowSize > 3) && (fmod((double) windowSize, 2) == 0)) {
windowSize++;
} else if (windowSize < 3) {
windowSize = 3;
}
// threshold the image and display
cvAdaptiveThreshold(grayImg, thresholdedImg, 255,
CV_ADAPTIVE_THRESH_MEAN_C, CV_THRESH_BINARY,
windowSize, constant);
cvShowImage( windowName3, thresholdedImg );
// find the contours
cvFindContours( thresholdedImg, storage,
&contours, sizeof(CvContour), CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
// if (contours) (cvSeqSort(contours, sort_contour, NULL));
// draw the contours in the output image
cvZero(dst);
current_contour = contours;
comp_count = 0;
for( ; current_contour != 0; current_contour = current_contour->h_next, comp_count++ )
{
uchar* ptr = color_tab->data.ptr + (comp_count)*3;
CvScalar color = CV_RGB( ptr[0], ptr[1], ptr[2] );
cvDrawContours( dst, current_contour, color,
color, -1, CV_FILLED, 8, cvPoint(0,0) );
}
if (contours != NULL){
cvClearSeq(contours);
}
// display images in window
cvShowImage( windowName1, dst );
// start event processing loop (very important,in fact essential for GUI)
// 40 ms roughly equates to 1000ms/25fps = 40ms per frame
key = cvWaitKey(EVENT_LOOP_DELAY);
if (key == 'x'){
// if user presses "x" then exit
printf("Keyboard exit requested : exiting now - bye!\n");
keepProcessing = false;
}
}
// destroy window objects
// (triggered by event loop *only* window is closed)
cvDestroyAllWindows();
// destroy image object (if it does not originate from a capture object)
if (!capture){
cvReleaseImage( &img );
}
// destroy image objects
cvReleaseImage( &grayImg );
cvReleaseImage( &thresholdedImg );
cvReleaseImage( &dst );
// all OK : main returns 0
return 0;
}
// not OK : main returns -1
return -1;
}
void CV_SolvePolyTest::run( int start_from ) {
CvRNG rng = cvRNG();
int fig = 100;
double range = 50;
for (int idx = 0, max_idx = 1000, progress = 0;
idx < max_idx; ++idx) {
int n = cvRandInt(&rng) % 13 + 1;
std::vector<complex_type> r(n), ar(n), c(n + 1, 0);
std::vector<double> a(n + 1), u(n * 2);
int rr_odds = 3; // odds that we get a real root
for (int j = 0; j < n;) {
if (cvRandInt(&rng) % rr_odds == 0 || j == n - 1)
r[j++] = cvRandReal(&rng) * range;
else {
r[j] = complex_type(cvRandReal(&rng) * range,
cvRandReal(&rng) * range + 1);
r[j + 1] = std::conj(r[j]);
j += 2;
}
}
for (int j = 0, k = 1 << n, jj, kk; j < k; ++j) {
int p = 0;
complex_type v(1);
for (jj = 0, kk = 1; jj < n && !(j & kk);
++jj, ++p, kk <<= 1);
for (; jj < n; ++jj, kk <<= 1)
if (j & kk)
v *= -r[jj];
else
++p;
c[p] += v;
}
bool pass = false;
double div;
for (int maxiter = 10;
!pass && maxiter < 10000;
maxiter *= 2) {
for (int j = 0; j < n + 1; ++j)
a[j] = c[j].real();
CvMat amat, umat;
cvInitMatHeader(&amat, n + 1, 1, CV_64FC1, &a[0]);
cvInitMatHeader(&umat, n, 1, CV_64FC2, &u[0]);
cvSolvePoly(&amat, &umat, maxiter, fig);
for (int j = 0; j < n; ++j)
ar[j] = complex_type(u[j * 2], u[j * 2 + 1]);
sort(r.begin(), r.end(), pred_complex());
sort(ar.begin(), ar.end(), pred_complex());
div = 0;
double s = 0;
for (int j = 0; j < n; ++j) {
s += r[j].real() + fabs(r[j].imag());
div += pow(r[j].real() - ar[j].real(), 2) +
pow(r[j].imag() - ar[j].imag(), 2);
}
div /= s;
pass = div < 1e-2;
}
if (!pass) {
ts->set_failed_test_info(CvTS::FAIL_INVALID_OUTPUT);
std::cerr<<std::endl;
for (unsigned int j=0; j<r.size(); ++j)
std::cout << "r[" << j << "] = " << r[j] << std::endl;
std::cout << std::endl;
for (unsigned int j=0; j<ar.size(); ++j)
std::cout << "ar[" << j << "] = " << ar[j] << std::endl;
}
progress = update_progress(progress, idx-1, max_idx, 0);
}
}
// 生成随机颜色
CvScalar getRandColor()
{
return cvScalar( (cvRandInt(&rng) % RAND_INT_MAX),
(cvRandInt(&rng) % RAND_INT_MAX ),
(cvRandInt(&rng) % RAND_INT_MAX ));
}
void CvEM::kmeans( const CvVectors& train_data, int nclusters, CvMat* labels,
CvTermCriteria termcrit, const CvMat* centers0 )
{
CvMat* centers = 0;
CvMat* old_centers = 0;
CvMat* counters = 0;
CV_FUNCNAME( "CvEM::kmeans" );
__BEGIN__;
CvRNG rng = cvRNG(-1);
int i, j, k, nsamples, dims;
int iter = 0;
double max_dist = DBL_MAX;
termcrit = cvCheckTermCriteria( termcrit, 1e-6, 100 );
termcrit.epsilon *= termcrit.epsilon;
nsamples = train_data.count;
dims = train_data.dims;
nclusters = MIN( nclusters, nsamples );
CV_CALL( centers = cvCreateMat( nclusters, dims, CV_64FC1 ));
CV_CALL( old_centers = cvCreateMat( nclusters, dims, CV_64FC1 ));
CV_CALL( counters = cvCreateMat( 1, nclusters, CV_32SC1 ));
cvZero( old_centers );
if( centers0 )
{
CV_CALL( cvConvert( centers0, centers ));
}
else
{
for( i = 0; i < nsamples; i++ )
labels->data.i[i] = i*nclusters/nsamples;
cvRandShuffle( labels, &rng );
}
for( ;; )
{
CvMat* temp;
if( iter > 0 || centers0 )
{
for( i = 0; i < nsamples; i++ )
{
const float* s = train_data.data.fl[i];
int k_best = 0;
double min_dist = DBL_MAX;
for( k = 0; k < nclusters; k++ )
{
const double* c = (double*)(centers->data.ptr + k*centers->step);
double dist = 0;
for( j = 0; j <= dims - 4; j += 4 )
{
double t0 = c[j] - s[j];
double t1 = c[j+1] - s[j+1];
dist += t0*t0 + t1*t1;
t0 = c[j+2] - s[j+2];
t1 = c[j+3] - s[j+3];
dist += t0*t0 + t1*t1;
}
for( ; j < dims; j++ )
{
double t = c[j] - s[j];
dist += t*t;
}
if( min_dist > dist )
{
min_dist = dist;
k_best = k;
}
}
labels->data.i[i] = k_best;
}
}
if( ++iter > termcrit.max_iter )
break;
CV_SWAP( centers, old_centers, temp );
cvZero( centers );
cvZero( counters );
// update centers
for( i = 0; i < nsamples; i++ )
{
const float* s = train_data.data.fl[i];
k = labels->data.i[i];
double* c = (double*)(centers->data.ptr + k*centers->step);
for( j = 0; j <= dims - 4; j += 4 )
{
double t0 = c[j] + s[j];
double t1 = c[j+1] + s[j+1];
c[j] = t0;
c[j+1] = t1;
t0 = c[j+2] + s[j+2];
t1 = c[j+3] + s[j+3];
c[j+2] = t0;
c[j+3] = t1;
}
for( ; j < dims; j++ )
c[j] += s[j];
counters->data.i[k]++;
}
if( iter > 1 )
max_dist = 0;
for( k = 0; k < nclusters; k++ )
{
double* c = (double*)(centers->data.ptr + k*centers->step);
if( counters->data.i[k] != 0 )
{
double scale = 1./counters->data.i[k];
for( j = 0; j < dims; j++ )
c[j] *= scale;
}
else
{
const float* s;
for( j = 0; j < 10; j++ )
{
i = cvRandInt( &rng ) % nsamples;
if( counters->data.i[labels->data.i[i]] > 1 )
break;
}
s = train_data.data.fl[i];
for( j = 0; j < dims; j++ )
c[j] = s[j];
}
if( iter > 1 )
{
double dist = 0;
const double* c_o = (double*)(old_centers->data.ptr + k*old_centers->step);
for( j = 0; j < dims; j++ )
{
double t = c[j] - c_o[j];
dist += t*t;
}
if( max_dist < dist )
max_dist = dist;
}
}
if( max_dist < termcrit.epsilon )
break;
}
cvZero( counters );
for( i = 0; i < nsamples; i++ )
counters->data.i[labels->data.i[i]]++;
// ensure that we do not have empty clusters
for( k = 0; k < nclusters; k++ )
if( counters->data.i[k] == 0 )
for(;;)
{
i = cvRandInt(&rng) % nsamples;
j = labels->data.i[i];
if( counters->data.i[j] > 1 )
{
labels->data.i[i] = k;
counters->data.i[j]--;
counters->data.i[k]++;
break;
}
}
__END__;
cvReleaseMat( ¢ers );
cvReleaseMat( &old_centers );
cvReleaseMat( &counters );
}
CvScalar KfieldGui::random_color() {
CvRNG rng(-1);
int icolor = cvRandInt(&rng);
return CV_RGB(icolor & 255, (icolor >> 8) & 255, (icolor >> 16) & 255);
}
/*
函数：contoursample
功能：轮廓抽样
参数：seq ------ 轮廓点序列
samplearry --- 用于存放抽样点
samplearry ---- 抽样点数
*/
int contoursample(CvSeq * seq , CvPoint *samplearry, int samplenum)
{
int num = 0 ;
for (CvSeq *s = seq ; s !=NULL;s=s->h_next)
num +=s->total;
if ( num < samplenum)
{
return 0;
}
CvPoint *pointarray = (CvPoint *)malloc(num * sizeof(CvPoint));
int accum = 0 ;
for (CvSeq *s =seq ; s!=NULL;s=s->h_next)
{
cvCvtSeqToArray( s, pointarray +accum);
accum +=s->total;
}
// 轮廓点随机打乱
CvRNG rng;
rng = cvRNG(cvGetTickCount());
CvPoint pointtemp;
int tagtemp = -1;
for (int i = 0 ; i < num ; ++i)
{
int index = cvRandInt(&rng)%(num-i)+i;
if(index !=i)
{
pointtemp = pointarray[index];
pointarray[index] = pointarray[i];
pointarray[i] = pointtemp;
}
}
// 如果*samplenum > num 即取样点数远远小于轮廓点数随即抽取samplenum个点节省运算时间
if (num > 3 * samplenum)
{
CvPoint *pointarray2 = (CvPoint *)malloc(3*samplenum * sizeof(CvPoint));
for (int i = 0;i < 3*samplenum;++i)
{
pointarray2[i] = pointarray[i];
}
free(pointarray);
pointarray = pointarray2;
num = 3 * samplenum;
}
// 计算轮廓点与点间距离
int beg = 0,nelement = 0;
pairDistance* pd = (pairDistance*)malloc(sizeof(pairDistance)*((num-1)*num/2));
for (int i = 0 ; i < num ; i++)
{
for (int j = i +1 ; j < num ; ++j)
{
pd[nelement].i = i;
pd[nelement].j = j;
pd[nelement++].distance = (pointarray[i].x -pointarray[j].x) * (pointarray[i].x -pointarray[j].x) +
(pointarray[i].y -pointarray[j].y) * (pointarray[i].y -pointarray[j].y);
}
}
// 排序
quick_sort(pd,0,nelement-1);
// 删除最小距离点对中的其中一个点直到满足samplenum
int nneedremove = num - samplenum;
int *mask = (int *)malloc( num * sizeof(int));
memset(mask,0,num * sizeof(int));
//list<pairDistance>::iterator iter = list_pair.begin();
//list<pairDistance>::iterator iter = list_pair.begin();
while (nneedremove > 0)
{
int index0 = pd[beg].i;
int index1 = pd[beg].j;
if (mask[index0] == 0 && mask[index1] ==0)
{
mask[index1] = 1 ;
nneedremove --;
}
beg++;
}
// 将抽样点存放到samplearry中
int nstartindex = 0 ;
for (int i = 0 ; i < num ; ++i)
{
if (mask[i] ==0)
{
samplearry[nstartindex] = pointarray[i];
nstartindex++;
}
}
free(pointarray);
free(pd);
return 1;
}
CV_IMPL void
cvKMeans2( const CvArr* samples_arr, int cluster_count,
CvArr* labels_arr, CvTermCriteria termcrit )
{
CvMat* centers = 0;
CvMat* old_centers = 0;
CvMat* counters = 0;
CV_FUNCNAME( "cvKMeans2" );
__BEGIN__;
CvMat samples_stub, labels_stub;
CvMat* samples = (CvMat*)samples_arr;
CvMat* labels = (CvMat*)labels_arr;
CvMat* temp = 0;
CvRNG rng = CvRNG(-1);
int i, j, k, sample_count, dims;
int ids_delta, iter;
double max_dist;
if( !CV_IS_MAT( samples ))
CV_CALL( samples = cvGetMat( samples, &samples_stub ));
if( !CV_IS_MAT( labels ))
CV_CALL( labels = cvGetMat( labels, &labels_stub ));
if( cluster_count < 1 )
CV_ERROR( CV_StsOutOfRange, "Number of clusters should be positive" );
if( CV_MAT_DEPTH(samples->type) != CV_32F || CV_MAT_TYPE(labels->type) != CV_32SC1 )
CV_ERROR( CV_StsUnsupportedFormat,
"samples should be floating-point matrix, cluster_idx - integer vector" );
if( labels->rows != 1 && (labels->cols != 1 || !CV_IS_MAT_CONT(labels->type)) ||
labels->rows + labels->cols - 1 != samples->rows )
CV_ERROR( CV_StsUnmatchedSizes,
"cluster_idx should be 1D vector of the same number of elements as samples' number of rows" );
CV_CALL( termcrit = cvCheckTermCriteria( termcrit, 1e-6, 100 ));
termcrit.epsilon *= termcrit.epsilon;
sample_count = samples->rows;
if( cluster_count > sample_count )
cluster_count = sample_count;
dims = samples->cols*CV_MAT_CN(samples->type);
ids_delta = labels->step ? labels->step/(int)sizeof(int) : 1;
CV_CALL( centers = cvCreateMat( cluster_count, dims, CV_64FC1 ));
CV_CALL( old_centers = cvCreateMat( cluster_count, dims, CV_64FC1 ));
CV_CALL( counters = cvCreateMat( 1, cluster_count, CV_32SC1 ));
// init centers
for( i = 0; i < sample_count; i++ )
labels->data.i[i] = cvRandInt(&rng) % cluster_count;
counters->cols = cluster_count; // cut down counters
max_dist = termcrit.epsilon*2;
for( iter = 0; iter < termcrit.max_iter; iter++ )
{
// computer centers
cvZero( centers );
cvZero( counters );
for( i = 0; i < sample_count; i++ )
{
float* s = (float*)(samples->data.ptr + i*samples->step);
k = labels->data.i[i*ids_delta];
double* c = (double*)(centers->data.ptr + k*centers->step);
for( j = 0; j <= dims - 4; j += 4 )
{
double t0 = c[j] + s[j];
double t1 = c[j+1] + s[j+1];
c[j] = t0;
c[j+1] = t1;
t0 = c[j+2] + s[j+2];
t1 = c[j+3] + s[j+3];
c[j+2] = t0;
c[j+3] = t1;
}
for( ; j < dims; j++ )
c[j] += s[j];
counters->data.i[k]++;
}
if( iter > 0 )
max_dist = 0;
for( k = 0; k < cluster_count; k++ )
{
double* c = (double*)(centers->data.ptr + k*centers->step);
if( counters->data.i[k] != 0 )
{
double scale = 1./counters->data.i[k];
for( j = 0; j < dims; j++ )
c[j] *= scale;
}
else
{
i = cvRandInt( &rng ) % sample_count;
float* s = (float*)(samples->data.ptr + i*samples->step);
for( j = 0; j < dims; j++ )
c[j] = s[j];
}
if( iter > 0 )
{
double dist = 0;
double* c_o = (double*)(old_centers->data.ptr + k*old_centers->step);
for( j = 0; j < dims; j++ )
{
double t = c[j] - c_o[j];
dist += t*t;
}
if( max_dist < dist )
max_dist = dist;
}
}
// assign labels
for( i = 0; i < sample_count; i++ )
{
float* s = (float*)(samples->data.ptr + i*samples->step);
int k_best = 0;
double min_dist = DBL_MAX;
for( k = 0; k < cluster_count; k++ )
{
double* c = (double*)(centers->data.ptr + k*centers->step);
double dist = 0;
j = 0;
for( ; j <= dims - 4; j += 4 )
{
double t0 = c[j] - s[j];
double t1 = c[j+1] - s[j+1];
dist += t0*t0 + t1*t1;
t0 = c[j+2] - s[j+2];
t1 = c[j+3] - s[j+3];
dist += t0*t0 + t1*t1;
}
for( ; j < dims; j++ )
{
double t = c[j] - s[j];
dist += t*t;
}
if( min_dist > dist )
{
min_dist = dist;
k_best = k;
}
}
labels->data.i[i*ids_delta] = k_best;
}
if( max_dist < termcrit.epsilon )
break;
CV_SWAP( centers, old_centers, temp );
}
cvZero( counters );
for( i = 0; i < sample_count; i++ )
counters->data.i[labels->data.i[i]]++;
// ensure that we do not have empty clusters
for( k = 0; k < cluster_count; k++ )
if( counters->data.i[k] == 0 )
for(;;)
{
i = cvRandInt(&rng) % sample_count;
j = labels->data.i[i];
if( counters->data.i[j] > 1 )
{
labels->data.i[i] = k;
counters->data.i[j]--;
counters->data.i[k]++;
break;
}
}
__END__;
cvReleaseMat( ¢ers );
cvReleaseMat( &old_centers );
cvReleaseMat( &counters );
}
