int arMatrixPCA2( ARMat *input, ARMat *evec, ARVec *ev )
{
ARMat *work;
/* ARdouble srow; */
ARdouble sum;
int row, clm;
int check, rval;
int i;
row = input->row;
clm = input->clm;
check = (row < clm)? row: clm;
if( row < 2 || clm < 2 ) return(-1);
if( evec->clm != input->clm || evec->row != check ) return(-1);
if( ev->clm != check ) return(-1);
work = arMatrixAllocDup( input );
if( work == NULL ) return -1;
/*
srow = sqrt((ARdouble)row);
for(i=0; i<row*clm; i++) work->m[i] /= srow;
*/
rval = PCA( work, evec, ev );
arMatrixFree( work );
sum = 0.0;
for( i = 0; i < ev->clm; i++ ) sum += ev->v[i];
for( i = 0; i < ev->clm; i++ ) ev->v[i] /= sum;
return( rval );
}
int
Tracker::arMatrixPCA2( ARMat *input, ARMat *evec, ARVec *ev )
{
ARMat *work;
// ARFloat srow; // unreferenced
ARFloat sum;
int row, clm;
int check, rval;
int i;
row = input->row;
clm = input->clm;
check = (row < clm)? row: clm;
if( row < 2 || clm < 2 ) return(-1);
if( evec->clm != input->clm || evec->row != check ) return(-1);
if( ev->clm != check ) return(-1);
work = Matrix::allocDup( input );
if( work == NULL ) return -1;
/*
srow = sqrt((ARFloat)row);
for(i=0; i<row*clm; i++) work->m[i] /= srow;
*/
rval = PCA( work, evec, ev );
Matrix::free( work );
sum = 0.0;
for( i = 0; i < ev->clm; i++ ) sum += ev->v[i];
for( i = 0; i < ev->clm; i++ ) ev->v[i] /= sum;
return( rval );
}
void test3()
{
matrix *m; /* Data matrix */
PCAMODEL *model;
int run = SIGSCIENTIFICRUN;
NewMatrix(&m, 10, 2);
m->data[0][0] = 2.2; m->data[0][1] = 3.3;
m->data[1][0] = 2.9; m->data[1][1] = 4.5;
m->data[2][0] = 4.0; m->data[2][1] = 3.5;
m->data[3][0] = 4.500; m->data[3][1] = 4.7;
m->data[4][0] = 5.1; m->data[4][1] = 6.0;
m->data[5][0] = 5.5; m->data[5][1] = 4.5;
m->data[6][0] = 6.5000; m->data[6][1] = 6.4;
m->data[7][0] = 7.2; m->data[7][1] = 6.2;
m->data[8][0] = 8.8; m->data[8][1] = 3.9;
m->data[9][0] = 10; m->data[9][1] = 6.2;
NewPCAModel(&model);
printf("Test PCA 3\n");
PCA(m, 1, 5, model, &run);
PrintPCA(model);
DelPCAModel(&model);
DelMatrix(&m);
}
int matrixPCAnoMean( Mat input, Mat evec, Vec ev )
{
Mat work;
double srow, sum;
int row, clm;
int check, rval;
int i;
row = input.row;
clm = input.clm;
check = (row < clm)? row: clm;
if( row < 2 || clm < 2 ) return(-1);
if( evec.clm != input.clm || evec.row != check ) return(-1);
if( ev.clm != check ) return(-1);
work = matrixAllocDup( input );
if( work.row != row || work.clm != clm ) return(-1);
srow = sqrt((double)row);
for(i=0; i<row*clm; i++) work.m[i] /= srow;
rval = PCA( work, evec, ev );
matrixFree( work );
sum = 0.0;
for( i = 0; i < ev.clm; i++ ) sum += ev.v[i];
for( i = 0; i < ev.clm; i++ ) ev.v[i] /= sum;
return( rval );
}
/**
* @author JIA Pei
* @version 2010-02-07
* @brief build point model
* @param allAlignedShapes Input - input aligned points.
* @return void
*/
void VO_Point2DDistributionModel::VO_BuildPointDistributionModel( const vector<VO_Shape>& allAlignedShapes )
{
unsigned int NbOfSamples = allAlignedShapes.size();
unsigned int NbOfPoints = allAlignedShapes[0].GetNbOfPoints();
this->m_VONormalizedEllipses.resize(NbOfPoints);
Mat_<float> matAlignedPoints = Mat_<float>::zeros(NbOfSamples, 2);
Mat_<float> matAlignedMeanPoint = Mat_<float>::zeros(1, 2);
for(unsigned int i = 0; i < NbOfPoints; ++i)
{
for(unsigned int j = 0; j < NbOfSamples; ++j)
{
matAlignedPoints(j, 0) = allAlignedShapes[j].GetA2DPoint(i).x;
matAlignedPoints(j, 1) = allAlignedShapes[j].GetA2DPoint(i).y;
}
PCA pca = PCA(matAlignedPoints, matAlignedMeanPoint, CV_PCA_DATA_AS_ROW, 2);
float xx = pca.eigenvectors.at<float>(0,0);
float yy = pca.eigenvectors.at<float>(0,1);
float theta = 0.0;
if( fabs(xx) < FLT_MIN ) theta = (float)(CV_PI/2.0);
else theta = atan(yy/xx)/CV_PI*180.0;
Point2f pt = Point2f( pca.mean.at<float>(0,0),
pca.mean.at<float>(0,1));
this->m_VONormalizedEllipses[i] = VO_Ellipse( pt,
3.0*sqrt(pca.eigenvalues.at<float>(0,0)),
3.0*sqrt(pca.eigenvalues.at<float>(1,0)),
0,
360,
theta );
}
}
void AAM::makeShapeModel()
{
shapePCA=PCA(shapeSet, Mat(), CV_PCA_DATA_AS_ROW);
meanShape=shapePCA.mean;
meanShape.convertTo(meanShape, CV_32S);
this->deltaS=this->countVariationMatrix(shapeSet, meanShape);
cout<<"shape set"<<shapeSet.type()<<endl;
cout<<"mean shape: "<<meanShape<<endl;
}
int main()
{
CvMat* Vector = cvCreateMat(ROW, COL, CV_32FC1);
cvSetData(Vector , Coordinates, Vector->step);
Image = cvCreateImage(cvSize(450, 450),8,3);
cvSet(Image, cvScalarAll(255), NULL);
Image->origin = 1;
PCA(Vector);
cvNamedWindow("Image" , 0);
cvShowImage("Image" , Image);
cvWaitKey(0);
return 0;
}
int
Tracker::arMatrixPCA(ARMat *input, ARMat *evec, ARVec *ev, ARVec *mean)
{
ARMat *work;
ARFloat srow, sum;
int row, clm;
int check, rval;
int i;
row = input->row;
clm = input->clm;
check = (row < clm)? row: clm;
if( row < 2 || clm < 2 ) return(-1);
if( evec->clm != input->clm || evec->row != check ) return(-1);
if( ev->clm != check ) return(-1);
if( mean->clm != input->clm ) return(-1);
work = Matrix::allocDup( input );
if( work == NULL ) return -1;
srow = (ARFloat)sqrt((ARFloat)row);
if( EX( work, mean ) < 0 ) {
Matrix::free( work );
return(-1);
}
if( CENTER( work, mean ) < 0 ) {
Matrix::free( work );
return(-1);
}
for(i=0; i<row*clm; i++) work->m[i] /= srow;
rval = PCA( work, evec, ev );
Matrix::free( work );
sum = 0.0;
for( i = 0; i < ev->clm; i++ ) sum += ev->v[i];
for( i = 0; i < ev->clm; i++ ) ev->v[i] /= sum;
return( rval );
}
void test4()
{
matrix *m; /* Data matrix */
PCAMODEL *model;
int run = SIGSCIENTIFICRUN;
NewMatrix(&m, 3, 2);
setMatrixValue(m, 0, 0, 0.424264); setMatrixValue(m, 0, 1, 0.565685);
setMatrixValue(m, 1, 0, 0.565685); setMatrixValue(m, 1, 1, 0.424264);
setMatrixValue(m, 2, 0, 0.707101); setMatrixValue(m, 2, 1, 0.707101);
NewPCAModel(&model);
printf("Test PCA 4\n");
PCA(m, 1, 5, model, &run);
PrintPCA(model);
DelPCAModel(&model);
DelMatrix(&m);
}
void test5()
{
matrix *m; /* Data matrix */
PCAMODEL *model;
NewMatrix(&m, 3, 4);
setMatrixValue(m, 0, 0, 0.424264); setMatrixValue(m, 0, 1, 0.565685); setMatrixValue(m, 0, 2, 0.565685); setMatrixValue(m, 0, 3, 0.424264);
setMatrixValue(m, 1, 0, 0.565685); setMatrixValue(m, 1, 1, 0.424264); setMatrixValue(m, 1, 2, 0.424264); setMatrixValue(m, 1, 3, 0.565685);
setMatrixValue(m, 2, 0, 0.707101); setMatrixValue(m, 2, 1, 0.707101); setMatrixValue(m, 2, 2, 0.707101); setMatrixValue(m, 2, 3, 0.707101);
NewPCAModel(&model);
printf("Test PCA 5\n");
PCA(m, 1, 5, model, NULL);
PrintPCA(model);
DelPCAModel(&model);
DelMatrix(&m);
}
void test6()
{
matrix *m;
PCAMODEL *model;
NewMatrix(&m, 3,3);
m->data[0][0] = 7; m->data[0][1] = 4; m->data[0][2] = 4;
m->data[1][0] = 4; m->data[1][1] = 4; m->data[1][2] = 4;
m->data[2][0] = 1; m->data[2][1] = 4; m->data[2][2] = 7;
PrintMatrix(m);
NewPCAModel(&model);
PCA(m, 0, 5, model, NULL);
PrintPCA(model);
DelPCAModel(&model);
DelMatrix(&m);
}
void PcaReductor::trainPca(SuperVectors superVectors)
{
assert(superVectors.size() > 0);
int numSuperVectors = superVectors.size();
int sizeSuperVector = getSuperVectorSize(superVectors);
// REDUCE BEFORE PCA
int reducedSize = sizeSuperVector / REDUCE_SUPER_VECTOR_FACTOR;
//
Mat matrixOfSuperVectors(reducedSize, numSuperVectors, superVectors[0].type());
for (int i = 0; i < numSuperVectors; i++) {
// REDUCE BEFORE PCA
SuperVector temp = superVectors[i].clone();
temp.resize(reducedSize, 1);
//
temp.convertTo(matrixOfSuperVectors.col(i), matrixOfSuperVectors.type());
}
pca_ = PCA(matrixOfSuperVectors, Mat(), CV_PCA_DATA_AS_COL);
}
void test7()
{
matrix *m;
PCAMODEL *model;
int nobj = 200;
int nvars = 32000;
NewMatrix(&m, nobj, nvars);
srand(nobj);
for(size_t i = 0; i < nobj; i++){
for(size_t j = 0; j < nvars; j++){
m->data[i][j] = randDouble(0,20);
}
}
NewPCAModel(&model);
PCA(m, 1, 5, model, NULL);
DelPCAModel(&model);
DelMatrix(&m);
}
void test1()
{
matrix *m; /* Data matrix */
PCAMODEL *model;
int run = SIGSCIENTIFICRUN;
NewMatrix(&m, 14, 7);
m->data[0][0] = 4.0000; m->data[0][1] = 4.0000; m->data[0][2] = 1.0000; m->data[0][3] = 84.1400; m->data[0][4] = 1.0500; m->data[0][5] = 235.1500; m->data[0][6] = 357.1500;
m->data[1][0] = 5.0000; m->data[1][1] = 5.0000; m->data[1][2] = 1.0000; m->data[1][3] = 79.1000; m->data[1][4] = 0.9780; m->data[1][5] = 1.5090; m->data[1][6] = 231.0000;
m->data[2][0] = 4.0000; m->data[2][1] = 5.0000; m->data[2][2] = 1.0000; m->data[2][3] = 67.0900; m->data[2][4] = 0.9700; m->data[2][5] = 249.0000; m->data[2][6] = 403.0000;
m->data[3][0] = 4.0000; m->data[3][1] = 4.0000; m->data[3][2] = 1.0000; m->data[3][3] = 68.0700; m->data[3][4] = 0.9360; m->data[3][5] = 187.3500; m->data[3][6] = 304.5500;
m->data[4][0] = 3.0000; m->data[4][1] = 4.0000; m->data[4][2] = 2.0000; m->data[4][3] = 68.0800; m->data[4][4] = 1.0300; m->data[4][5] = 363.0000; m->data[4][6] = 529.0000;
m->data[5][0] = 9.0000; m->data[5][1] = 7.0000; m->data[5][2] = 1.0000; m->data[5][3] = 129.1600; m->data[5][4] = 1.0900; m->data[5][5] = 258.0000; m->data[5][6] = 510.0000;
m->data[6][0] = 10.0000; m->data[6][1] = 8.0000; m->data[6][2] = 0.0000; m->data[6][3] = 128.1600; m->data[6][4] = 1.1500; m->data[6][5] = 352.0000; m->data[6][6] = 491.0000;
m->data[7][0] = 6.0000; m->data[7][1] = 6.0000; m->data[7][2] = 0.0000; m->data[7][3] = 78.1118; m->data[7][4] = 0.8765; m->data[7][5] = 278.6400; m->data[7][6] = 353.3000;
m->data[8][0] = 16.0000; m->data[8][1] = 10.0000; m->data[8][2] = 0.0000; m->data[8][3] = 202.2550; m->data[8][4] = 1.2710; m->data[8][5] = 429.1500; m->data[8][6] = 666.6500;
m->data[9][0] = 6.0000; m->data[9][1] = 12.0000; m->data[9][2] = 0.0000; m->data[9][3] = 84.1600; m->data[9][4] = 0.7800; m->data[9][5] = 279.0000; m->data[9][6] = 354.0000;
m->data[10][0] = 4.0000; m->data[10][1] = 8.0000; m->data[10][2] = 1.0000; m->data[10][3] = 72.1100; m->data[10][4] = 0.8900; m->data[10][5] = 164.5000; m->data[10][6] = 339.0000;
m->data[11][0] = 4.0000; m->data[11][1] = 9.0000; m->data[11][2] = 1.0000; m->data[11][3] = 71.1100; m->data[11][4] = 0.8660; m->data[11][5] = 210.0000; m->data[11][6] = 360.0000;
m->data[12][0] = 5.0000; m->data[12][1] = 11.0000; m->data[12][2] = 1.0000; m->data[12][3] = 85.1500; m->data[12][4] = 0.8620; m->data[12][5] = 266.0000; m->data[12][6] = 379.0000;
m->data[13][0] = 5.0000; m->data[13][1] = 10.0000; m->data[13][2] = 1.0000; m->data[13][3] = 86.1300; m->data[13][4] = 0.8800; m->data[13][5] = 228.0000; m->data[13][6] = 361.0000;
NewPCAModel(&model);
printf("Test PCA 1\n");
PCA(m, 1, 5, model, &run);
PrintPCA(model);
DelPCAModel(&model);
DelMatrix(&m);
}
/* Function: mesh
*
* Description: Reads in 3D feature points, contours, and camera coefficients
* from file. Converts the 3D feature points to PCA space, creates a thin
* plate spline over a 3D grid, and converts the mesh back to the original
* space. Using the camera coefficients to project the points of the mesh
* to 2D, we then set only points that lie within the input contours as
* valid. The resulting valid mesh points are then outputed to file for each
* input contour.
*
* Parameters:
* features3DFilename: filename of the 3D features
* contoursFilename: filename of the vertices for each contour
* cameraCoefficientsFilename: filename of the camera coefficients
* meshPointsFilenames: filenames of the files to write each contour mesh
* points to
* numMeshFiles: number of mesh point files (must be same as number of contours)
* regularization: smoothing parameter for the TPS calculations
* errorMessage: string to output an error message to, on error
*
* Returns: 0 on success, 1 on error.
*/
int mesh(
_In_ char *features3DFilename,
_In_ char *contoursFilename,
_In_ char *cameraCoefficientsFilename,
_In_ char **meshPointsFilenames,
_In_ int numMeshFiles,
_In_ double regularization,
_Out_ char *errorMessage)
{
// variable to store error status returned from functions
int status;
int numContours;
CvPoint3D32f **features3D;
int *numFeaturesInContours;
// read the input triangulated 3D features from file
status = read3DFeaturesFromInputFile(&features3D, &numFeaturesInContours, &numContours, features3DFilename);
if (status == INPUT_FILE_OPEN_ERROR)
{
sprintf(errorMessage, "Could not open 3D features file.");
return 1;
}
if (status == INVALID_NUM_CONTOURS_ERROR)
{
sprintf(errorMessage, "At least 1 contour region required.");
return 1;
}
if (status == INCORRECT_INPUT_FILE_FORMAT_ERROR)
{
sprintf(errorMessage, "3D features file has incorrect format.");
return 1;
}
if (status == OUT_OF_MEMORY_ERROR)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
if (numContours != numMeshFiles)
{
sprintf(errorMessage, "Number of contours passed into function and read in from 3D features file must match.");
return 1;
}
CvSeq* contours;
CvMemStorage *contourStorage = cvCreateMemStorage(0);
if (contourStorage == NULL)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
int numContoursFromContourFile;
// read the input region of interest contours from file
status = readContourVerticesFromInputFile(&contours, contourStorage, &numContoursFromContourFile, contoursFilename);
if (status == INPUT_FILE_OPEN_ERROR)
{
sprintf(errorMessage, "Could not open contour vertices file.");
return 1;
}
if (status == INCORRECT_INPUT_FILE_FORMAT_ERROR)
{
sprintf(errorMessage, "Contour vertices file has incorrect format.");
return 1;
}
if (numContours != numContoursFromContourFile)
{
sprintf(errorMessage, "Number of contours in contour vertices file and 3D features file must match.");
return 1;
}
double **cameraCoefficients;
int numCameras;
// get the number of cameras and 11 camera coefficients for each camera from
// file
status = readCoefficientsFromInputFile(&cameraCoefficients, &numCameras, cameraCoefficientsFilename);
if (status == INPUT_FILE_OPEN_ERROR)
{
sprintf(errorMessage, "Could not open camera coefficients file.");
return 1;
}
if (status == INCORRECT_INPUT_FILE_FORMAT_ERROR)
{
sprintf(errorMessage, "Camera coefficients file has incorrect format.");
return 1;
}
if (status == INCORRECT_NUM_CAMERAS_ERROR)
{
sprintf(errorMessage, "At least 2 cameras are required for triangulation.");
return 1;
}
if (status == OUT_OF_MEMORY_ERROR)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
CvPoint3D32f **features3DGrid = (CvPoint3D32f **)malloc(numContours * sizeof(CvPoint3D32f *));
char **validFeatureIndicator = (char **)malloc(numContours * sizeof(char *));
if (features3DGrid == NULL || validFeatureIndicator == NULL)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
int *numGridPoints = (int *)malloc(numContours * sizeof(int));
int *numGridPointsInContours = (int *)malloc(numContours * sizeof(int));
if (numGridPoints == NULL || numGridPointsInContours == NULL)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
CvSeq *contour = contours;
int k = 0;
// for each contour, calculate the TPS for the feature points
while (contour)
{
CvPoint3D32f *features3DPrime = (CvPoint3D32f *)malloc(numFeaturesInContours[k] * sizeof(CvPoint3D32f));
Data PCAData;
if (createPCA(&PCAData, 3, numFeaturesInContours[k]) == OUT_OF_MEMORY_ERROR)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
// convert the input points to PCA space, and store in features3DPrime
status = PCA(features3DPrime, features3D[k], numFeaturesInContours[k], &PCAData);
if (status == OUT_OF_MEMORY_ERROR)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
double xPrimeMax, yPrimeMax, xPrimeMin, yPrimeMin;
// get the max and min x and y values of features3DPrime, so that we can create
// a grid of appropriate size that will encompass the features
getXPrimeYPrimeMaxMin(features3DPrime, numFeaturesInContours[k], &xPrimeMax, &yPrimeMax, &xPrimeMin, &yPrimeMin);
// multiply the ranges of x and y by 3 to create grid size
int gridWidth = (int) ((xPrimeMax - xPrimeMin) * 3);
int gridHeight = (int) ((yPrimeMax - yPrimeMin) * 3);
double **grid = (double **)malloc(gridWidth * sizeof(double *));
if (grid == NULL)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
for (int i = 0; i < gridWidth; i++)
{
grid[i] = (double *)malloc(gridHeight * sizeof(double));
if (grid[i] == NULL)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
}
// since the grid row and column indices start at 0 because it is an array,
// but the actual x and y start values do not necessarily start 0, we find
// the actual start values of x and y. This is the middle point between max
// and min of x or y, minus half the width or height of the grid
int gridWidthStartIndex = (int)(((xPrimeMax + xPrimeMin)/2) - (gridWidth/2));
int gridHeightStartIndex = (int)(((yPrimeMax + yPrimeMin)/2) - (gridHeight/2));
// perform thin plate spline calculations to find the smoothed z coordinates
// for every point in the grid
status = TPS(features3DPrime, numFeaturesInContours[k], grid, gridHeight, gridWidth, gridHeightStartIndex, gridWidthStartIndex, regularization);
if (status == NOT_ENOUGH_POINTS_ERROR)
{
sprintf(errorMessage, "At least 3 valid feature points are required to define a plane for thin sheet spline function.");
return 1;
}
if (status == OUT_OF_MEMORY_ERROR)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
numGridPoints[k] = gridHeight * gridWidth;
CvPoint3D32f *features3DGridPrime = (CvPoint3D32f *)malloc(numGridPoints[k] * sizeof(CvPoint3D32f));
features3DGrid[k] = (CvPoint3D32f *)malloc(numGridPoints[k] * sizeof(CvPoint3D32f));
if (features3DGridPrime == NULL || features3DGrid[k] == NULL)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
// transform the grid to CvPoint3D32f points
for (int i = 0; i < gridWidth; i++)
{
for (int j = 0; j < gridHeight; j++)
{
int curIndex = gridWidth*j + i;
features3DGridPrime[curIndex].x = (double) i+gridWidthStartIndex;
features3DGridPrime[curIndex].y = (double) j+gridHeightStartIndex;
features3DGridPrime[curIndex].z = grid[i][j];
}
}
// convert the grid points from PCA space back to original space, and store
// the points in CvPoint3D32f array features3DGrid
status = reversePCA(features3DGrid[k], features3DGridPrime, numGridPoints[k], &PCAData);
if (status == OUT_OF_MEMORY_ERROR)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
CvPoint2D32f *idealFeatures2D = (CvPoint2D32f *)malloc(numGridPoints[k] * sizeof(CvPoint2D32f));
if (idealFeatures2D == NULL)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
// project the 3d grid points to 2D space
calculateIdealFeatures(idealFeatures2D, features3DGrid[k], numGridPoints[k], cameraCoefficients[0]);
validFeatureIndicator[k] = (char *)malloc(numGridPoints[k] * sizeof(char));
if (validFeatureIndicator[k] == NULL)
{
sprintf(errorMessage, "Out of memory error.");
return 1;
}
// test each 2d grid point to see if it lies within the input contours, and
// set the correspoinding values of validFeatureIndicator accordingly
numGridPointsInContours[k] = areFeaturesInContour(idealFeatures2D, numGridPoints[k], validFeatureIndicator[k], contour);
contour = (CvSeq *)(contour->h_next);
k++;
free(features3DPrime);
destroyPCA(&PCAData);
for (int i = 0; i < gridWidth; i++)
{
free(grid[i]);
}
free(grid);
free(features3DGridPrime);
free(idealFeatures2D);
}
// print the valid 3D mesh points to files for each contour
writeGridPointsToFile(meshPointsFilenames, features3DGrid, numGridPoints, validFeatureIndicator, numGridPointsInContours, numContours);
// cleanup
for (int i = 0; i < numContours; i++)
{
free(features3D[i]);
free(features3DGrid[i]);
free(validFeatureIndicator[i]);
}
free(features3D);
free(features3DGrid);
free(validFeatureIndicator);
free(numGridPoints);
free(numGridPointsInContours);
cvReleaseMemStorage(&contourStorage);
for (int i = 0; i < numCameras; i++)
{
free(cameraCoefficients[i]);
}
free(cameraCoefficients);
return 0;
}
hsVectorStream* plPhysXCooking::IMakePolytope(const plMaxMeshExtractor::NeutralMesh& inMesh)
{
hsBool success=0;
std::vector<hsPoint3> outCloud;
hsPoint3 offset;
int numPlanes=26;
float planeMax[26];
int indexMax[26];
hsPoint3 AABBMin(FLT_MAX,FLT_MAX,FLT_MAX);
hsPoint3 AABBMax(-FLT_MAX,-FLT_MAX,-FLT_MAX);
//prep
NxVec3* vectors = new NxVec3[26];
int curvec=0;
for(int xcomp= -1;xcomp<2;xcomp++)
{
for(int ycomp= -1;ycomp<2;ycomp++)
{
for(int zcomp= -1;zcomp<2;zcomp++)
{
if(!((xcomp==0)&&(ycomp==0)&&(zcomp==0)))
{
vectors[curvec].set((float)(xcomp),(float)(ycomp),(float)(zcomp));
vectors[curvec].normalize();
planeMax[curvec]=(-FLT_MAX);
//indexMax[curvec]=0;
curvec++;
}
}
}
}
/*
for(int i=0;i<26;i++)
{//make your max and mins
planeMax[i]=(-FLT_MAX);
}
*/
hsPoint3 centroid(0.0f,0.0f,0.0f);
for(int i=0;i<inMesh.fNumVerts;i++) centroid+=inMesh.fVerts[i];
centroid=centroid/(float)inMesh.fNumVerts;
//temp
NxVec3* nxLocs=new NxVec3[inMesh.fNumVerts];
NxVec3* nxLocs2=new NxVec3[inMesh.fNumVerts];
for(int i=0;i<inMesh.fNumVerts;i++)
{
hsPoint3 temppt=inMesh.fVerts[i] - centroid;
nxLocs[i]=plPXConvert::Point(temppt);
}
NxMat33 rot;
NxVec3 eigen;
PCA(nxLocs,inMesh.fNumVerts,rot);
NxMat33 invrot;
rot.getInverse(invrot);
for(int i=0; i<inMesh.fNumVerts;i++)
{
nxLocs2[i]=invrot*nxLocs[i];
}
for(int i=0;i<inMesh.fNumVerts;i++)
{
for(int plane=0;plane<26;plane++)
{
float dist=nxLocs2[i].dot(vectors[plane]);
if(dist>=planeMax[plane])
{
planeMax[plane]=dist;
indexMax[plane]=i;
}
}
}
for(int i=0;i<inMesh.fNumVerts;i++)
{
AABBMin.fX = hsMinimum(nxLocs2[i].x, AABBMin.fX);
AABBMin.fY = hsMinimum(nxLocs2[i].y, AABBMin.fY);
AABBMin.fZ = hsMinimum(nxLocs2[i].z, AABBMin.fZ);
AABBMax.fX = hsMaximum(nxLocs2[i].x, AABBMax.fX);
AABBMax.fY = hsMaximum(nxLocs2[i].y, AABBMax.fY);
AABBMax.fZ = hsMaximum(nxLocs2[i].z, AABBMax.fZ);
}
int resultingPoints=0;
for(int i=0;i<26;i++)
{
for(int j=0;j<26;j++)
{
for(int k=0;k<26;k++)
{
NxVec3 res;
if(ThreePlaneIntersect(vectors[i],nxLocs2[indexMax[i]],vectors[j],nxLocs2[indexMax[j]], vectors[k],nxLocs2[indexMax[k]],res))
{
//check it is within all slabs
bool within=true;
int curplane=0;
do
{
float intersecdist=res.dot(vectors[curplane]);
if((intersecdist-planeMax[curplane])>0.0001)
{
within=false;
}
curplane++;
}
while((curplane<26)&&within);
if(within)
// if((res.x>=AABBMin.fX)&&(res.x<=AABBMax.fX)&&
// (res.y>=AABBMin.fY)&&(res.y<=AABBMax.fY)&&
// (res.z>=AABBMin.fZ)&&(res.z<=AABBMax.fZ))
{
NxVec3 reverted;
reverted=rot*res;
reverted.x=reverted.x +centroid.fX;
reverted.y=reverted.y +centroid.fY;
reverted.z=reverted.z +centroid.fZ;
hsPoint3 out;
out=plPXConvert::Point(reverted);
outCloud.push_back(out);
}
}
}
}
}
//planes discovered
//this is'nt right
//cleanup
offset=centroid;
delete[] vectors;
hsPoint3* pointages=new hsPoint3[outCloud.size()];
for(int x=0;x<outCloud.size();x++)pointages[x]=outCloud[x];
hsVectorStream* vectorstrm;
vectorstrm= CookHull(outCloud.size(),pointages,true);
delete[] pointages;
delete[] nxLocs;
delete[] nxLocs2;
return vectorstrm;
}
int main(int argc, const char * argv[]) {
int r_width=50,r_height=50;
IplImage *src =cvLoadImage("/Users/Tony/DIPImage/lena.png", 0);
int width=src->width, height=src->height;
RGB * srcarry=(RGB *)malloc(sizeof(RGB)*width*height);
double * srcarry_dbl=(double *)malloc(sizeof(double)*width*height);
RGB * dst1arry=(RGB *)malloc(sizeof(RGB)*width*height);
RGB * dst2arry=(RGB *)malloc(sizeof(RGB)*width*height);
double * dst3arry=(double *)malloc(sizeof(double)*width*height);
double * dst4arry=(double *)malloc(sizeof(double)*width*height);
double * dst5arry=(double *)malloc(sizeof(double)*width*height);
double * dst6arry=(double *)malloc(sizeof(double)*width*height/4);
IplImage *dst1_r =cvCreateImage(cvSize(width, height), src->depth, 1);
IplImage *dst1_g =cvCreateImage(cvSize(width, height), src->depth, 1);
IplImage *dst1_b =cvCreateImage(cvSize(width, height), src->depth, 1);
IplImage *dst1 =cvCreateImage(cvSize(width, height), src->depth, 3);
IplImage *dst2_r =cvCreateImage(cvSize(width, height), src->depth, 1);
IplImage *dst2_g =cvCreateImage(cvSize(width, height), src->depth, 1);
IplImage *dst2_b =cvCreateImage(cvSize(width, height), src->depth, 1);
IplImage *dst2 =cvCreateImage(cvSize(width, height), src->depth, 3);
IplImage *dst3 =cvCreateImage(cvSize(width, height), src->depth, 1);
IplImage *dst4 =cvCreateImage(cvSize(width, height), src->depth, 1);
IplImage *dst5 =cvCreateImage(cvSize(width, height), src->depth, 1);
IplImage *dst6 =cvCreateImage(cvSize(width/2, height/2), src->depth, 1);
if(src->nChannels==3){
for (int j=0;j<height; j++) {
for(int i=0;i<width;i++){
CvScalar s = cvGet2D(src,j,i);
srcarry[j*width+i].c1=s.val[2];
srcarry[j*width+i].c2=s.val[1];
srcarry[j*width+i].c3=s.val[0];
}
}
}else {
for (int j=0;j<height; j++) {
for(int i=0;i<width;i++){
srcarry_dbl[j*width+i]=cvGetReal2D(src,j,i);
}
}
}
//double* dst1arry_r=(double *)malloc(sizeof(double)*width*height);
//double* dst1arry_g=(double *)malloc(sizeof(double)*width*height);
//double* dst1arry_b=(double *)malloc(sizeof(double)*width*height);
//double* dst2arry_r=(double *)malloc(sizeof(double)*width*height);
//double* dst2arry_g=(double *)malloc(sizeof(double)*width*height);
//double* dst2arry_b=(double *)malloc(sizeof(double)*width*height);
//SharpenRGB(srcarry, dst1arry, width, height, 1, SHARPEN_SOBEL);
//RGB2HSI(srcarry, dst1arry, width, height);
//SharpenHSI(dst1arry, dst1arry, width, height, 1, SHARPEN_SOBEL);
//SmoothHSI(dst1arry, dst2arry, width, height, 5, 5, 0.8, 30, SMOOTH_MEAN);
//HSI2RGB(dst2arry, dst1arry, width, height);
//Zero(dst1arry_b, width, height);
//RGB2sRGB(srcarry, dst1arry, width, height);
//sRGB2RGB(dst1arry, dst2arry, width, height);
//RGB skin_rgb;
//skin_rgb.c1=185;
//skin_rgb.c2=0;
//skin_rgb.c3=0;
//Resize(srcarry_dbl, width, height, dst6arry, width/2,height/2);
//Position p;
//p.x=20;
//p.y=20;
//InteImage(srcarry_dbl, dst3arry, width, height);
//for(int j=0;j<height;j++){
// for(int i=0;i<width;i++){
// printf("%d ",(int)dst3arry[j*width+i]);
// }
// printf("\n");
//}
//matrixMultreal(dst3arry, dst3arry, 0.0000000001, width, height);
//matrixCopyLocal(srcarry_dbl, dst6arry, width, height, width/2, height/2, &p);
//printf("%d\n",isEVEN(3));
//Resize(srcarry_dbl, 256, 256,dst6arry, 512, 512);
//SIFT_Feature * sift=NULL;
//Resize(srcarry_dbl, width, height, temp_src, width*2, height*2);
//SIFT(srcarry_dbl,&sift, width, height, 5, 5);
//SIFT_Feature *temp=sift;
//while (temp!=NULL) {
// printf("x:%g\t y:%g\t scale:%g\t orientation:%g\t\n",temp->x,temp->y,temp->scale,temp->orientation);
// for(int i=0;i<128;i++)
// printf("%d \t",temp->des_vector[i]);
// printf("\n");
// temp=temp->next;
//}
//ReleaseSIFTlist(sift);
//Position_DBL p;
//p.x=5;
//p.y=5;
//matrixMulmatrix(srcarry_dbl, srcarry_dbl, dst3arry, width, height);
double *dst_pca;
double arry[12]={1,3,2,2,4,3,3,1,1,4,2,4};
PCA(arry, 3, 4, &dst_pca, 4);
//matrixCovariance(arry, dst_pca, 3, 4);
for(int j=0;j<4;j++){
for(int i=0;i<4;i++)
printf("%10g\t",dst_pca[j*4+i]);
printf("\n");
}
//matrixRotation(srcarry_dbl, dst3arry, width, height, width, height,45,&p);
//double * space[5];
//double * dog[4];
//ScaleSpace(srcarry_dbl, space, width, height, 1.6, 5);
//DOG_Scale(space, dog, width, height, 5);
//dst3arry=dog[0];
//printf("%lf\n",delta);
//dst4arry=space[1];
//matrixSub(dst4arry,dst3arry,dst5arry, width, height);
// HistogramEqualization(dst3arry, dst3arry, width, height);
//double distance=130;
//SegmentRGB(srcarry, dst1arry, width, height, &skin_rgb, distance);
//SmoothRGB(dst2arry,dst1arry, width, height, 15, 15, 2.4, 0, SMOOTH_GAUSSIAN);
//Threshold_RGB(dst1arry, dst1arry, &threshold, width, height);
//Cover_RGB(srcarry,dst2arry, dst1arry, width, height);
//RGB2YIQ(srcarry , dst1arry, width, height);
//Split(dst1arry, dst3arry, dst4arry, dst5arry, width, height);
//Zero(dst4arry, width, height);
//Gray2Color(srcarry_dbl, dst1arry, width, height,1);
//RGB2HSV(srcarry, dst2arry, width, height);
//Complementary_Color(dst2arry, dst2arry, width, height, COLOR_SPACE_HSV);
//HSV2RGB(dst2arry, dst1arry, width, height);
//HistEqualRGB(srcarry, dst2arry, width, height);
//RGB2HSI(srcarry, dst1arry, width, height);
//Split(dst1arry, dst3arry, dst4arry, dst5arry, width, height);
//HSI2RGB(dst2arry, dst1arry, width, height);
for (int j=0;j<height; j++) {
for(int i=0;i<width;i++){
cvSetReal2D(dst1_r, j, i,dst1arry[j*width+i].c3);
cvSetReal2D(dst1_g, j, i,dst1arry[j*width+i].c2);
cvSetReal2D(dst1_b, j, i,dst1arry[j*width+i].c1);
cvSetReal2D(dst2_r, j, i,dst2arry[j*width+i].c3);
cvSetReal2D(dst2_g, j, i,dst2arry[j*width+i].c2);
cvSetReal2D(dst2_b, j, i,dst2arry[j*width+i].c1);
cvSetReal2D(dst3, j, i,dst3arry[j*width+i]);
cvSetReal2D(dst4, j, i,dst4arry[j*width+i]);
cvSetReal2D(dst5, j, i,dst5arry[j*width+i]);
}
}
for (int j=0;j<height/2; j++) {
for(int i=0;i<width/2;i++){
cvSetReal2D(dst6, j, i,dst6arry[j*(width/2)+i]);
}
}
cvMerge(dst1_r, dst1_g, dst1_b, NULL, dst1);
cvMerge(dst2_r, dst2_g, dst2_b, NULL, dst2);
//cvSaveImage("/Users/Tony/DIPImage/sift_lena_90_dst.png", dst3, 0);
//cvSaveImage("/Users/Tony/DIPImage/segment_RGB_ban1_dst.png", dst2, 0);
//cvSaveImage("/Users/Tony/DIPImage/hough_edge3.jpg", dst2, 0);
//printf("%lf",M_PI_2);
//cvCanny(src, dst2, 200, 150,3);
//Thinning(dst2, dst2);
cvNamedWindow("src", 1);
cvShowImage("src", src);
cvNamedWindow("dst1", 1);
cvShowImage("dst1", dst1);
cvNamedWindow("dst2", 1);
cvShowImage("dst2", dst2);
cvNamedWindow("dst3", 1);
cvShowImage("dst3", dst3);
cvNamedWindow("dst4", 1);
cvShowImage("dst4", dst4);
cvNamedWindow("dst5", 1);
cvShowImage("dst5", dst5);
cvNamedWindow("dst6", 1);
cvShowImage("dst6", dst6);
cvWaitKey(0);
free(srcarry);
//ReleaseMatArr(space, 5);
//ReleaseMatArr(dog, 4);
return 0;
}
void IRWPCA(const Matrix<double>& data,
Vector<double>& weights,
Vector<double>& mu,
Matrix<double>& trans,
const double tol/*=1E-8*/,
const int max_iter/*=1000*/,
const bool quiet/* = true*/)
{
int d_in = data.nrows();
int d_out = trans.nrows();
int N = data.ncols();
//check on input data
if (mu.size() != d_in)
mu.reallocate(d_in);
if (trans.ncols() != d_in)
trans.reallocate(d_out,d_in);
if (weights.size() != N)
weights.reallocate(N,1.0);
else
weights.SetAllTo(1.0);
if (max_iter<1)
throw MatVecError("max_iter must be positive");
//data needed for procedure
Matrix<double,SYM> transcov(d_in,d_in);
Vector<double> V;
Vector<double> weights_old;
Vector<double> V_minus_mu;
Matrix<double> trans_old;
PCA(data,mu,trans);
//Now we iterate and find the optimal weights,
// mean, and transformation
for(int count=1;count<max_iter;count++)
{
weights_old.deep_copy(weights);
trans_old.deep_copy(trans);
transcov = trans.Transpose() * trans;
//find errors and new weights
for(int i=0;i<N;i++)
{
V.deep_copy( data.col(i) );
V -= mu;
V_minus_mu.deep_copy(V);
V -= transcov * V_minus_mu;
weights(i) = pow( blas_NRM2(V), 2 );
}
make_weights(weights);
WPCA(data,weights,mu,trans);
//check for convergence using residuals between
// new weights and old weights
weights_old -= weights;
double Wres = blas_NRM2(weights_old);
// and new trans and old trans
//trans_old -= trans;
//double Tres = blas_NRM2(trans_old);
if ( ( Wres/sqrt(N) <tol) )
{
if (!quiet)
std::cout << "IRWPCA: converged to tol = " << tol
<< " in " << count << " iterations\n";
return;
}
}//end for
//if tolerance was not reached, return an error message
throw IterException(max_iter,tol);
}
