//============================================================================
void AAM_CAM::DoPCA(const CvMat* AllAppearances, double percentage)
{
printf("Doing PCA of appearance datas...");
int nSamples = AllAppearances->rows;
int nfeatures = AllAppearances->cols;
int nEigenAtMost = MIN(nSamples, nfeatures);
CvMat* tmpEigenValues = cvCreateMat(1, nEigenAtMost, CV_64FC1);
CvMat* tmpEigenVectors = cvCreateMat(nEigenAtMost, nfeatures, CV_64FC1);
__MeanAppearance = cvCreateMat(1, nfeatures, CV_64FC1 );
cvCalcPCA(AllAppearances, __MeanAppearance,
tmpEigenValues, tmpEigenVectors, CV_PCA_DATA_AS_ROW);
double allSum = cvSum(tmpEigenValues).val[0];
double partSum = 0.0;
int nTruncated = 0;
double largesteigval = cvmGet(tmpEigenValues, 0, 0);
for(int i = 0; i < nEigenAtMost; i++)
{
double thiseigval = cvmGet(tmpEigenValues, 0, i);
if(thiseigval / largesteigval < 0.0001) break; // firstly check
partSum += thiseigval;
++ nTruncated;
if(partSum/allSum >= percentage) break; //secondly check
}
__AppearanceEigenValues = cvCreateMat(1, nTruncated, CV_64FC1);
__AppearanceEigenVectors = cvCreateMat(nTruncated, nfeatures, CV_64FC1);
CvMat G;
cvGetCols(tmpEigenValues, &G, 0, nTruncated);
cvCopy(&G, __AppearanceEigenValues);
cvGetRows(tmpEigenVectors, &G, 0, nTruncated);
cvCopy(&G, __AppearanceEigenVectors);
cvReleaseMat(&tmpEigenVectors);
cvReleaseMat(&tmpEigenValues);
printf("Done (%d/%d)\n", nTruncated, nEigenAtMost);
}
static int build_nbayes_classifier( char* data_filename, CvNormalBayesClassifier **nbayes){
const int var_count = 51;
CvMat* data = 0;
CvMat train_data;
CvMat* responses;
int ok = read_num_class_data( data_filename, 51, &data, &responses );
int nsamples_all = 0;
int i, j;
double train_hr = 0, test_hr = 0;
CvANN_MLP mlp;
if( !ok ){
printf( "No se pudo leer la información de entrenamiento %s\n", data_filename );
return -1;
}
printf( "La base de datos %s está siendo cargada...\n", data_filename );
nsamples_all = data->rows;
printf( "Entrenando el clasificador...\n");
// 1. unroll the responses
cvGetRows( data, &train_data, 0, nsamples_all);
// 2. train classifier
CvMat* train_resp = cvCreateMat( nsamples_all, 1, CV_32FC1);
for (int i = 0; i < nsamples_all; i++)
train_resp->data.fl[i] = responses->data.fl[i];
*nbayes = new CvNormalBayesClassifier(&train_data, train_resp);
if(DEBUG){
std::cout << "Train_data = "<< std::endl << std::endl;
PrintMat(&train_data);
std::cout << "Train_resp = "<< std::endl << " " << train_resp << std::endl << std::endl;
PrintMat(train_resp);
}
cvReleaseMat( &train_resp );
cvReleaseMat( &data );
cvReleaseMat( &responses );
return 0;
}
static
int build_mlp_classifier( char* data_filename,
char* filename_to_save, char* filename_to_load )
{
const int class_count = 26;
CvMat* data = 0;
CvMat train_data;
CvMat* responses = 0;
CvMat* mlp_response = 0;
int ok = read_num_class_data( data_filename, 16, &data, &responses );
int nsamples_all = 0, ntrain_samples = 0;
int i, j;
double train_hr = 0, test_hr = 0;
CvANN_MLP mlp;
if( !ok )
{
printf( "Could not read the database %s\n", data_filename );
return -1;
}
printf( "The database %s is loaded.\n", data_filename );
nsamples_all = data->rows;
ntrain_samples = (int)(nsamples_all*0.8);
// Create or load MLP classifier
if( filename_to_load )
{
// load classifier from the specified file
mlp.load( filename_to_load );
ntrain_samples = 0;
if( !mlp.get_layer_count() )
{
printf( "Could not read the classifier %s\n", filename_to_load );
return -1;
}
printf( "The classifier %s is loaded.\n", data_filename );
}
else
{
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//
// MLP does not support categorical variables by explicitly.
// So, instead of the output class label, we will use
// a binary vector of <class_count> components for training and,
// therefore, MLP will give us a vector of "probabilities" at the
// prediction stage
//
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
CvMat* new_responses = cvCreateMat( ntrain_samples, class_count, CV_32F );
// 1. unroll the responses
printf( "Unrolling the responses...\n");
for( i = 0; i < ntrain_samples; i++ )
{
int cls_label = cvRound(responses->data.fl[i]) - 'A';
float* bit_vec = (float*)(new_responses->data.ptr + i*new_responses->step);
for( j = 0; j < class_count; j++ )
bit_vec[j] = 0.f;
bit_vec[cls_label] = 1.f;
}
cvGetRows( data, &train_data, 0, ntrain_samples );
// 2. train classifier
int layer_sz[] = { data->cols, 100, 100, class_count };
CvMat layer_sizes =
cvMat( 1, (int)(sizeof(layer_sz)/sizeof(layer_sz[0])), CV_32S, layer_sz );
mlp.create( &layer_sizes );
printf( "Training the classifier (may take a few minutes)...\n");
mlp.train( &train_data, new_responses, 0, 0,
CvANN_MLP_TrainParams(cvTermCriteria(CV_TERMCRIT_ITER,300,0.01),
#if 1
CvANN_MLP_TrainParams::BACKPROP,0.001));
#else
CvANN_MLP_TrainParams::RPROP,0.05));
#endif
cvReleaseMat( &new_responses );
printf("\n");
}
mlp_response = cvCreateMat( 1, class_count, CV_32F );
// compute prediction error on train and test data
for( i = 0; i < nsamples_all; i++ )
{
int best_class;
CvMat sample;
cvGetRow( data, &sample, i );
CvPoint max_loc = {0,0};
mlp.predict( &sample, mlp_response );
cvMinMaxLoc( mlp_response, 0, 0, 0, &max_loc, 0 );
best_class = max_loc.x + 'A';
int r = fabs((double)best_class - responses->data.fl[i]) < FLT_EPSILON ? 1 : 0;
if( i < ntrain_samples )
train_hr += r;
else
test_hr += r;
}
test_hr /= (double)(nsamples_all-ntrain_samples);
train_hr /= (double)ntrain_samples;
printf( "Recognition rate: train = %.1f%%, test = %.1f%%\n",
train_hr*100., test_hr*100. );
// Save classifier to file if needed
if( filename_to_save )
mlp.save( filename_to_save );
cvReleaseMat( &mlp_response );
cvReleaseMat( &data );
cvReleaseMat( &responses );
return 0;
}
//---------------------------------------------------------
bool COpenCV_NNet::On_Execute(void)
{
//-------------------------------------------------
bool b_updateWeights, b_noInputScale, b_noOutputScale, b_NoData;
int i_matType, i_layers, i_maxIter, i_neurons, i_areasClassId, i_trainFeatTotalCount, *i_outputFeatureIdxs, i_outputFeatureCount, i_Grid, x, y, i_evalOut, i_winner;
double d_alpha, d_beta, d_eps;
DATA_TYPE e_dataType;
TRAINING_METHOD e_trainMet;
ACTIVATION_FUNCTION e_actFunc;
CSG_Table *t_Weights, *t_Indices, *t_TrainInput, *t_EvalInput, *t_EvalOutput;
CSG_Parameter_Grid_List *gl_TrainInputs;
CSG_Grid *g_EvalOutput, *g_EvalOutputCert;
CSG_Shapes *s_TrainInputAreas;
CSG_Parameters *p_TrainFeatures;
TSG_Point p;
CvMat *mat_Weights, *mat_Indices, **mat_data, *mat_neuralLayers, mat_layerSizesSub, *mat_EvalInput, *mat_EvalOutput; // todo: mat_indices to respect input indices, mat_weights for initialization
CvANN_MLP_TrainParams tp_trainParams;
CvANN_MLP model;
b_updateWeights = Parameters("UPDATE_WEIGHTS" )->asBool();
b_noInputScale = Parameters("NO_INPUT_SCALE" )->asBool();
b_noOutputScale = Parameters("NO_OUTPUT_SCALE" )->asBool();
i_layers = Parameters("NNET_LAYER" )->asInt();
i_neurons = Parameters("NNET_NEURONS" )->asInt();
i_maxIter = Parameters("MAX_ITER" )->asInt();
i_areasClassId = Parameters("TRAIN_INPUT_AREAS_CLASS_FIELD" )->asInt();
e_dataType = (DATA_TYPE)Parameters("DATA_TYPE" )->asInt();
e_trainMet = (TRAINING_METHOD)Parameters("TRAINING_METHOD" )->asInt();
e_actFunc = (ACTIVATION_FUNCTION)Parameters("ACTIVATION_FUNCTION" )->asInt();
d_alpha = Parameters("ALPHA" )->asDouble();
d_beta = Parameters("BETA" )->asDouble();
d_eps = Parameters("EPSILON" )->asDouble();
t_Weights = Parameters("WEIGHTS" )->asTable();
t_Indices = Parameters("INDICES" )->asTable();
t_TrainInput = Parameters("TRAIN_INPUT_TABLE" )->asTable();
t_EvalInput = Parameters("EVAL_INPUT_TABLE" )->asTable();
t_EvalOutput = Parameters("EVAL_OUTPUT_TABLE" )->asTable();
p_TrainFeatures = Parameters("TRAIN_FEATURES_TABLE" )->asParameters();
gl_TrainInputs = Parameters("TRAIN_INPUT_GRIDS" )->asGridList();
g_EvalOutput = Parameters("EVAL_OUTPUT_GRID_CLASSES" )->asGrid();
g_EvalOutputCert = Parameters("EVAL_OUTPUT_GRID_CERTAINTY" )->asGrid();
s_TrainInputAreas = Parameters("TRAIN_INPUT_AREAS" )->asShapes();
// Fixed matrix type (TODO: Analyze what to do for other types of data (i.e. images))
i_matType = CV_32FC1;
//-------------------------------------------------
if (e_dataType == TABLE)
{
// We are working with TABLE data
if( t_TrainInput->Get_Count() == 0 || p_TrainFeatures->Get_Count() == 0 )
{
Error_Set(_TL("Select an input table and at least one output feature!"));
return( false );
}
// Count the total number of available features
i_trainFeatTotalCount = t_TrainInput->Get_Field_Count();
// Count the number of selected output features
i_outputFeatureIdxs = (int *)SG_Calloc(i_trainFeatTotalCount, sizeof(int));
i_outputFeatureCount = 0;
for(int i=0; i<p_TrainFeatures->Get_Count(); i++)
{
if( p_TrainFeatures->Get_Parameter(i)->asBool() )
{
i_outputFeatureIdxs[i_outputFeatureCount++] = CSG_String(p_TrainFeatures->Get_Parameter(i)->Get_Identifier()).asInt();
}
}
// Update the number of training features
i_trainFeatTotalCount = i_trainFeatTotalCount-i_outputFeatureCount;
if( i_outputFeatureCount <= 0 )
{
Error_Set(_TL("Select at least one output feature!"));
return( false );
}
// Now convert the input and output training data into a OpenCV matrix objects
mat_data = GetTrainAndOutputMatrix(t_TrainInput, i_matType, i_outputFeatureIdxs, i_outputFeatureCount);
}
else
{
// TODO: Add some grid validation logic
i_trainFeatTotalCount = gl_TrainInputs->Get_Count();
i_outputFeatureCount = s_TrainInputAreas->Get_Count();
// Convert the data from the grid into the matrix from
mat_data = GetTrainAndOutputMatrix(gl_TrainInputs, i_matType, s_TrainInputAreas, i_areasClassId, g_EvalOutput, g_EvalOutputCert);
}
//-------------------------------------------------
// Add two additional layer to the network topology (0-th layer for input and the last as the output)
i_layers = i_layers + 2;
mat_neuralLayers = cvCreateMat(i_layers, 1, CV_32SC1);
cvGetRows(mat_neuralLayers, &mat_layerSizesSub, 0, i_layers);
//Setting the number of neurons on each layer
for (int i = 0; i < i_layers; i++)
{
if (i == 0)
{
// The first layer needs the same size (number of nerons) as the number of columns in the training data
cvSet1D(&mat_layerSizesSub, i, cvScalar(i_trainFeatTotalCount));
}
else if (i == i_layers-1)
{
// The last layer needs the same size (number of neurons) as the number of output columns
cvSet1D(&mat_layerSizesSub, i, cvScalar(i_outputFeatureCount));
}
else
{
// On every other layer set the layer size selected by the user
cvSet1D(&mat_layerSizesSub, i, cvScalar(i_neurons));
}
}
//-------------------------------------------------
// Create the training params object
tp_trainParams = CvANN_MLP_TrainParams();
tp_trainParams.term_crit = cvTermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, i_maxIter, d_eps);
// Check which training method was selected and set corresponding params
if(e_trainMet == RPROP)
{
// Set all RPROP specific params
tp_trainParams.train_method = CvANN_MLP_TrainParams::RPROP;
tp_trainParams.rp_dw0 = Parameters("RP_DW0" )->asDouble();
tp_trainParams.rp_dw_plus = Parameters("RP_DW_PLUS" )->asDouble();
tp_trainParams.rp_dw_minus = Parameters("RP_DW_MINUS" )->asDouble();
tp_trainParams.rp_dw_min = Parameters("RP_DW_MIN" )->asDouble();
tp_trainParams.rp_dw_max = Parameters("RP_DW_MAX" )->asDouble();
}
else
{
// Set all BPROP specific params
tp_trainParams.train_method = CvANN_MLP_TrainParams::BACKPROP;
tp_trainParams.bp_dw_scale = Parameters("BP_DW_SCALE" )->asDouble();
tp_trainParams.bp_moment_scale = Parameters("BP_MOMENT_SCALE" )->asInt();
}
//-------------------------------------------------
// Create the model (depending on the activation function)
if(e_actFunc == SIGMOID)
{
model.create(mat_neuralLayers);
}
else
{
model.create(mat_neuralLayers, CvANN_MLP::GAUSSIAN, d_alpha, d_beta);
}
//-------------------------------------------------
// Now train the network
// TODO: Integrate init weights and indicies for record selection
// mat_Weights = GetMatrix(t_Weights, i_matType);
// mat_Indices = GetMatrix(t_Indices, i_matType);
//model.train(mat_TrainInput, mat_TrainOutput, NULL, NULL, tp_trainParams);
model.train(mat_data[0], mat_data[1], NULL, NULL, tp_trainParams);
//-------------------------------------------------
// Predict data
if (e_dataType == TABLE)
{
// Get the eavaluation/test matrix from the eval table
mat_EvalInput = GetEvalMatrix(t_EvalInput, i_matType);
}
else
{
// Train and eval data overlap in grid mode
mat_EvalInput = GetEvalMatrix(gl_TrainInputs, i_matType);
}
// Prepare output matrix
mat_EvalOutput = cvCreateMat(mat_EvalInput->rows, i_outputFeatureCount, i_matType);
// Start prediction
model.predict(mat_EvalInput, mat_EvalOutput);
Message_Add(_TL("Successfully trained the network and predicted the values. Here comes the output."));
//-------------------------------------------------
// Save and print results
if (e_dataType == TABLE)
{
// DEBUG -> Save results to output table and print results
for (int i = 0; i < i_outputFeatureCount; i++)
{
t_EvalOutput->Add_Field(CSG_String(t_TrainInput->Get_Field_Name(i_outputFeatureIdxs[i])), SG_DATATYPE_Float);
}
for (int i = 0; i < mat_EvalOutput->rows; i++)
{
CSG_Table_Record* tr_record = t_EvalOutput->Add_Record();
for (int j = 0; j < i_outputFeatureCount; j++)
{
float f_targetValue = mat_EvalOutput->data.fl[i*i_outputFeatureCount+j];
tr_record->Set_Value(j, f_targetValue);
}
}
}
else
{
// Fill the output table output
for (int i = 0; i < i_outputFeatureCount; i++)
{
// TODO: Get the class name
t_EvalOutput->Add_Field(CSG_String::Format(SG_T("CLASS_%d"), i), SG_DATATYPE_Float);
}
for (int i = 0; i < mat_EvalOutput->rows; i++)
{
CSG_Table_Record* tr_record = t_EvalOutput->Add_Record();
for (int j = 0; j < i_outputFeatureCount; j++)
{
float f_targetValue = mat_EvalOutput->data.fl[i*i_outputFeatureCount+j];
tr_record->Set_Value(j, f_targetValue);
}
}
i_evalOut = 0;
// Fill the output grid
for(y=0, p.y=Get_YMin(); y<Get_NY() && Set_Progress(y); y++, p.y+=Get_Cellsize())
{
for(x=0, p.x=Get_XMin(); x<Get_NX(); x++, p.x+=Get_Cellsize())
{
for(i_Grid=0, b_NoData=false; i_Grid<gl_TrainInputs->Get_Count() && !b_NoData; i_Grid++)
{
// If there is one grid that has no data in this point p, then set the no data flag
if( gl_TrainInputs->asGrid(i_Grid)->is_NoData(x, y) )
{
b_NoData = true;
}
}
if (!b_NoData)
{
// We have data in all grids, so this is a point that was predicted
// Get the winner class for this point and set it to the output grid
float f_targetValue = 0;
for (int j = 0; j < i_outputFeatureCount; j++)
{
if (mat_EvalOutput->data.fl[i_evalOut*i_outputFeatureCount+j] > f_targetValue)
{
// The current value is higher than the last one, so lets memorize the current class
f_targetValue = mat_EvalOutput->data.fl[i_evalOut*i_outputFeatureCount+j];
i_winner = j;
}
}
// Now finally set the values to the grids
g_EvalOutput->Set_Value(x, y, i_winner);
g_EvalOutputCert->Set_Value(x, y, f_targetValue);
i_evalOut++;
}
}
}
}
return( true );
}
int
main (int argc, char *argv[])
{
int i, j, k;
int corner_count, found;
int p_count[IMAGE_NUM];
IplImage *src_img[IMAGE_NUM];
CvSize pattern_size = cvSize (PAT_COL, PAT_ROW);
CvPoint3D32f objects[ALL_POINTS];
CvPoint2D32f *corners = (CvPoint2D32f *) cvAlloc (sizeof (CvPoint2D32f) * ALL_POINTS);
CvMat object_points;
CvMat image_points;
CvMat point_counts;
CvMat *intrinsic = cvCreateMat (3, 3, CV_32FC1);
CvMat *rotation = cvCreateMat (1, 3, CV_32FC1);
CvMat *translation = cvCreateMat (1, 3, CV_32FC1);
CvMat *distortion = cvCreateMat (1, 4, CV_32FC1);
// (1)キャリブレーション画像の読み込み
for (i = 0; i < IMAGE_NUM; i++) {
char buf[32];
sprintf (buf, "calib_img/%02d.png", i);
if ((src_img[i] = cvLoadImage (buf, CV_LOAD_IMAGE_COLOR)) == NULL) {
fprintf (stderr, "cannot load image file : %s\n", buf);
}
}
// (2)3次元空間座標の設定
for (i = 0; i < IMAGE_NUM; i++) {
for (j = 0; j < PAT_ROW; j++) {
for (k = 0; k < PAT_COL; k++) {
objects[i * PAT_SIZE + j * PAT_COL + k].x = j * CHESS_SIZE;
objects[i * PAT_SIZE + j * PAT_COL + k].y = k * CHESS_SIZE;
objects[i * PAT_SIZE + j * PAT_COL + k].z = 0.0;
}
}
}
cvInitMatHeader (&object_points, ALL_POINTS, 3, CV_32FC1, objects);
// (3)チェスボード（キャリブレーションパターン）のコーナー検出
int found_num = 0;
cvNamedWindow ("Calibration", CV_WINDOW_AUTOSIZE);
for (i = 0; i < IMAGE_NUM; i++) {
found = cvFindChessboardCorners (src_img[i], pattern_size, &corners[i * PAT_SIZE], &corner_count);
fprintf (stderr, "%02d...", i);
if (found) {
fprintf (stderr, "ok\n");
found_num++;
}
else {
fprintf (stderr, "fail\n");
}
// (4)コーナー位置をサブピクセル精度に修正，描画
IplImage *src_gray = cvCreateImage (cvGetSize (src_img[i]), IPL_DEPTH_8U, 1);
cvCvtColor (src_img[i], src_gray, CV_BGR2GRAY);
cvFindCornerSubPix (src_gray, &corners[i * PAT_SIZE], corner_count,
cvSize (3, 3), cvSize (-1, -1), cvTermCriteria (CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03));
cvDrawChessboardCorners (src_img[i], pattern_size, &corners[i * PAT_SIZE], corner_count, found);
p_count[i] = corner_count;
cvShowImage ("Calibration", src_img[i]);
cvWaitKey (0);
}
cvDestroyWindow ("Calibration");
if (found_num != IMAGE_NUM)
return -1;
cvInitMatHeader (&image_points, ALL_POINTS, 1, CV_32FC2, corners);
cvInitMatHeader (&point_counts, IMAGE_NUM, 1, CV_32SC1, p_count);
// (5)内部パラメータ，歪み係数の推定
cvCalibrateCamera2 (&object_points, &image_points, &point_counts, cvSize (640, 480), intrinsic, distortion);
// (6)外部パラメータの推定
CvMat sub_image_points, sub_object_points;
int base = 0;
cvGetRows (&image_points, &sub_image_points, base * PAT_SIZE, (base + 1) * PAT_SIZE);
cvGetRows (&object_points, &sub_object_points, base * PAT_SIZE, (base + 1) * PAT_SIZE);
cvFindExtrinsicCameraParams2 (&sub_object_points, &sub_image_points, intrinsic, distortion, rotation, translation);
// (7)XMLファイルへの書き出し
CvFileStorage *fs;
fs = cvOpenFileStorage ("camera.xml", 0, CV_STORAGE_WRITE);
cvWrite (fs, "intrinsic", intrinsic);
cvWrite (fs, "rotation", rotation);
cvWrite (fs, "translation", translation);
cvWrite (fs, "distortion", distortion);
cvReleaseFileStorage (&fs);
for (i = 0; i < IMAGE_NUM; i++) {
cvReleaseImage (&src_img[i]);
}
return 0;
}
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[])
{
// IMAGE_NUM, PAT_ROW, PAT_COL,PAT_SIZE, ALL_POINTS, CHESS_SIZE
/*
if (argc < 6)
{
std::cout<< "ERROR : augment is incorrect" << std::endl;
return -1;
}
*/
//int PAT_ROW = atoi(argv[3]);
//int PAT_COL = atoi(argv[4]);
//int CHESS_SIZE = atoi(argv[5]);
//int PAT_SIZE = PAT_ROW*PAT_COL;
char* NAME_IMG_IN = argv[1];
//char* NAME_XML_OUT = argv[2];
int i,j;
int corner_count, found;
IplImage *src_img;
CvSize pattern_size = cvSize(PAT_COL, PAT_ROW);
CvMat image_points;
CvMat object_points;
CvMat *intrinsic, *distortion;
CvMat *rotation = cvCreateMat(1, 3, CV_32FC1);
CvMat *rotationConv = cvCreateMat(3, 3, CV_32FC1);
CvMat *translation = cvCreateMat(1, 3, CV_32FC1);
CvPoint3D32f objects[PAT_SIZE];
CvFileStorage *fs;
CvFileNode *param;
CvPoint2D32f *corners = (CvPoint2D32f *) cvAlloc (sizeof (CvPoint2D32f) * PAT_SIZE);
// (1)�����оݤȤʤ������ɤ߹���
if ( ( src_img = cvLoadImage(NAME_IMG_IN, CV_LOAD_IMAGE_COLOR) ) == 0)
//if (argc < 2 || (src_img = cvLoadImage (argv[1], CV_LOAD_IMAGE_COLOR)) == 0)
{
std::cout<< "ERROR : input image is not exist or augment is incorrect" << std::endl;
return -1;
}
// 3�������ֺ�ɸ������
for (i = 0; i < PAT_ROW; i++) {
for (j = 0; j < PAT_COL; j++) {
objects[i * PAT_COL + j].x = i * CHESS_SIZE;
objects[i * PAT_COL + j].y = j * CHESS_SIZE;
objects[i * PAT_COL + j].z = 0.0;
}
}
cvInitMatHeader(&object_points, PAT_SIZE, 3, CV_32FC1, objects);
// �������ܡ��ɡʥ����֥졼�����ѥ�����ˤΥ����ʡ�����
int found_num = 0;
// cvNamedWindow("Calibration", CV_WINDOW_AUTOSIZE);
found = cvFindChessboardCorners(src_img, pattern_size, &corners[0], &corner_count);
fprintf(stderr, "corner:%02d...\n", corner_count);
if (found) {
fprintf(stderr, "ok\n");
} else {
fprintf(stderr, "fail\n");
}
// (4)�����ʡ����֤֥ԥ��������٤˽���������
IplImage *src_gray = cvCreateImage (cvGetSize (src_img), IPL_DEPTH_8U, 1);
cvCvtColor (src_img, src_gray, CV_BGR2GRAY);
cvFindCornerSubPix (src_gray, &corners[0], corner_count,
cvSize (3, 3), cvSize (-1, -1), cvTermCriteria (CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03));
cvDrawChessboardCorners (src_img, pattern_size, &corners[0], corner_count, found);
// cvShowImage ("Calibration", src_img);
// cvWaitKey (0);
// cvDestroyWindow("Calibration");
cvShowImage ("Calibration", src_img);
cvInitMatHeader(&image_points, PAT_SIZE, 1, CV_32FC2, corners);
// (2)�ѥ����ե�������ɤ߹���
fs = cvOpenFileStorage ("xml/rgb.xml", 0, CV_STORAGE_READ);
param = cvGetFileNodeByName (fs, NULL, "intrinsic");
intrinsic = (CvMat *) cvRead (fs, param);
param = cvGetFileNodeByName (fs, NULL, "distortion");
distortion = (CvMat *) cvRead (fs, param);
cvReleaseFileStorage (&fs);
// (3) �����ѥ����ο���
CvMat sub_image_points, sub_object_points;
int base = 0;
cvGetRows(&image_points, &sub_image_points, base * PAT_SIZE, (base + 1) * PAT_SIZE);
cvGetRows(&object_points, &sub_object_points, base * PAT_SIZE, (base + 1)* PAT_SIZE);
cvFindExtrinsicCameraParams2(&sub_object_points, &sub_image_points, intrinsic, distortion, rotation, translation);
int ret = cvRodrigues2(rotation, rotationConv);
// int cols = sub_object_points.rows;
// printf("cols = %d\n", cols);
// printf("%f\n",sub_object_points.data.fl[0]);
// mm -> m
for (i = 0; i < translation->cols; i++) { translation->data.fl[i] = translation->data.fl[i] / 1000;}
// (4)XML�ե�����ؤνФ�
//fs = cvOpenFileStorage(argv[2], 0, CV_STORAGE_WRITE);
fs = cvOpenFileStorage(NAME_XML_OUT, 0, CV_STORAGE_WRITE);
cvWrite(fs, "rotation", rotationConv);
cvWrite(fs, "translation", translation);
cvReleaseFileStorage(&fs);
/////////////////////////////////////////////////
// write out py
if(1)
{
cv::Mat ttt(translation);
cv::Mat rrr(rotationConv);
char data2Write[1024];
char textFileName[256];
sprintf( textFileName , "cbCoord/cbOneShot.py");
std::ofstream outPy(textFileName);
outPy << "import sys" <<std::endl;
outPy << "sys.path.append('../')" <<std::endl;
outPy << "from numpy import *" <<std::endl;
outPy << "from numpy.linalg import svd" <<std::endl;
outPy << "from numpy.linalg import inv" <<std::endl;
outPy << "from chessboard_points import *"<<std::endl;
outPy << "sys.path.append('../geo')" <<std::endl;
outPy << "from geo import *" <<std::endl;
/*
///////////////////////////////////////////////////////////////////////////////////
// out translation and rotation as xyzabc list
outPy << "xyzabc = []" <<std::endl;
sprintf( data2Write, "xyzabc.append(%f)", ttt.at<float>(0) );
outPy << data2Write << std::endl;
std::cout << data2Write << std::endl;
sprintf( data2Write, "xyzabc.append(%f)", ttt.at<float>(1) );
outPy << data2Write << std::endl;
std::cout << data2Write << std::endl;
sprintf( data2Write, "xyzabc.append(%f)", ttt.at<float>(2) );
outPy << data2Write << std::endl;
std::cout << data2Write << std::endl;
sprintf( data2Write, "xyzabc.append(%f)", rrr.at<float>(0) );
outPy << data2Write << std::endl;
std::cout << data2Write << std::endl;
sprintf( data2Write, "xyzabc.append(%f)", rrr.at<float>(1) );
outPy << data2Write << std::endl;
std::cout << data2Write << std::endl;
sprintf( data2Write, "xyzabc.append(%f)", rrr.at<float>(2) );
outPy << data2Write << std::endl;
std::cout << data2Write << std::endl;
// out translation and rotation as xyzabc list
///////////////////////////////////////////////////////////////////////////////////
*/
///////////////////////////////////////////////////////////////////////////////////
// out translation
outPy << "ttt = []" <<std::endl;
sprintf( data2Write, "ttt.append(%f)", ttt.at<float>(0) );
outPy << data2Write << std::endl;
std::cout << data2Write << std::endl;
sprintf( data2Write, "ttt.append(%f)", ttt.at<float>(1) );
outPy << data2Write << std::endl;
std::cout << data2Write << std::endl;
sprintf( data2Write, "ttt.append(%f)", ttt.at<float>(2) );
outPy << data2Write << std::endl;
std::cout << data2Write << std::endl;
// out translation
//////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
// out rotation
outPy << "rrr = []" <<std::endl;
sprintf( data2Write, "rrr.append([%f,%f,%f])", rrr.at<float>(0), rrr.at<float>(1), rrr.at<float>(2) );
outPy << data2Write << std::endl;
std::cout << data2Write << std::endl;
sprintf( data2Write, "rrr.append([%f,%f,%f])", rrr.at<float>(3), rrr.at<float>(4), rrr.at<float>(5) );
outPy << data2Write << std::endl;
std::cout << data2Write << std::endl;
sprintf( data2Write, "rrr.append([%f,%f,%f])", rrr.at<float>(6), rrr.at<float>(7), rrr.at<float>(8) );
outPy << data2Write << std::endl;
std::cout << data2Write << std::endl;
// out rotation
//////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
outPy<< "_T = FRAME( vec=ttt, mat=rrr )" << std::endl;
/////////////////////////////////////////////////////////////////
}
// write out py
/////////////////////////////////////////////////
std::cout<< "press any key..."<< std::endl;
cvWaitKey (0);
cvDestroyWindow("Calibration");
cvReleaseImage(&src_img);
cvReleaseMat(&intrinsic);
cvReleaseMat(&distortion);
return 0;
}
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;
}
}
/**
* Transforms points from the image frame (uv-coordinates)
* into the real world frame on the ground plane (z=-height)
*
* \param inPoints input points in the image frame
* \param outPoints output points in the world frame on the ground
* (z=-height)
* \param cemaraInfo the input camera parameters
*
*/
void mcvTransformImage2Ground(const CvMat *inPoints,
CvMat *outPoints, const CameraInfo *cameraInfo)
{
//add two rows to the input points
CvMat *inPoints4 = cvCreateMat(inPoints->rows+2, inPoints->cols,
cvGetElemType(inPoints));
//copy inPoints to first two rows
CvMat inPoints2, inPoints3, inPointsr4, inPointsr3;
cvGetRows(inPoints4, &inPoints2, 0, 2);
cvGetRows(inPoints4, &inPoints3, 0, 3);
cvGetRow(inPoints4, &inPointsr3, 2);
cvGetRow(inPoints4, &inPointsr4, 3);
cvSet(&inPointsr3, cvRealScalar(1));
cvCopy(inPoints, &inPoints2);
//create the transformation matrix
float c1 = cos(cameraInfo->pitch);
float s1 = sin(cameraInfo->pitch);
float c2 = cos(cameraInfo->yaw);
float s2 = sin(cameraInfo->yaw);
float matp[] = {
-cameraInfo->cameraHeight*c2/cameraInfo->focalLength.x,
cameraInfo->cameraHeight*s1*s2/cameraInfo->focalLength.y,
(cameraInfo->cameraHeight*c2*cameraInfo->opticalCenter.x/
cameraInfo->focalLength.x)-
(cameraInfo->cameraHeight *s1*s2* cameraInfo->opticalCenter.y/
cameraInfo->focalLength.y) - cameraInfo->cameraHeight *c1*s2,
cameraInfo->cameraHeight *s2 /cameraInfo->focalLength.x,
cameraInfo->cameraHeight *s1*c2 /cameraInfo->focalLength.y,
(-cameraInfo->cameraHeight *s2* cameraInfo->opticalCenter.x
/cameraInfo->focalLength.x)-(cameraInfo->cameraHeight *s1*c2*
cameraInfo->opticalCenter.y /cameraInfo->focalLength.y) -
cameraInfo->cameraHeight *c1*c2,
0,
cameraInfo->cameraHeight *c1 /cameraInfo->focalLength.y,
(-cameraInfo->cameraHeight *c1* cameraInfo->opticalCenter.y /
cameraInfo->focalLength.y) + cameraInfo->cameraHeight *s1,
0,
-c1 /cameraInfo->focalLength.y,
(c1* cameraInfo->opticalCenter.y /cameraInfo->focalLength.y) - s1,
};
CvMat mat = cvMat(4, 3, CV_32FC1, matp);
//multiply
cvMatMul(&mat, &inPoints3, inPoints4);
//divide by last row of inPoints4
for (int i=0; i<inPoints->cols; i++)
{
float div = CV_MAT_ELEM(inPointsr4, float, 0, i);
CV_MAT_ELEM(*inPoints4, float, 0, i) =
CV_MAT_ELEM(*inPoints4, float, 0, i) / div ;
CV_MAT_ELEM(*inPoints4, float, 1, i) =
CV_MAT_ELEM(*inPoints4, float, 1, i) / div;
}
//put back the result into outPoints
cout << "cameraInfo->cameraHeight " << cameraInfo->cameraHeight << endl;
cvCopy(&inPoints2, outPoints);
//clear
cvReleaseMat(&inPoints4);
}
CvMat* cveGetRows(CvArr* arr, CvMat* submat, int startRow, int endRow, int deltaRow)
{
return cvGetRows(arr, submat, startRow, endRow, deltaRow);
}
// Read the training data and train the network.
void trainMachine()
{ int i; //The number of training samples.
int train_sample_count;
//The training data matrix.
//Note that we are limiting the number of training data samples to 1000 here.
//The data sample consists of two inputs and an output. That's why 3.
float td[10000][3];
//Read the training file
/*
A sample file contents(say we are training the network for generating
the mean given two numbers) would be:
5
12 16 14
10 5 7.5
8 10 9
5 4 4.5
12 6 9
*/
FILE *fin;
fin = fopen("train.txt", "r");
//Get the number of samples.
fscanf(fin, "%d", &train_sample_count);
printf("Found training file with %d samples...\n", train_sample_count);
//Create the matrices
//Input data samples. Matrix of order (train_sample_count x 2)
CvMat* trainData = cvCreateMat(train_sample_count, 2, CV_32FC1);
//Output data samples. Matrix of order (train_sample_count x 1)
CvMat* trainClasses = cvCreateMat(train_sample_count, 1, CV_32FC1);
//The weight of each training data sample. We'll later set all to equal weights.
CvMat* sampleWts = cvCreateMat(train_sample_count, 1, CV_32FC1);
//The matrix representation of our ANN. We'll have four layers.
CvMat* neuralLayers = cvCreateMat(4, 1, CV_32SC1);
CvMat trainData1, trainClasses1, neuralLayers1, sampleWts1;
cvGetRows(trainData, &trainData1, 0, train_sample_count);
cvGetRows(trainClasses, &trainClasses1, 0, train_sample_count);
cvGetRows(trainClasses, &trainClasses1, 0, train_sample_count);
cvGetRows(sampleWts, &sampleWts1, 0, train_sample_count);
cvGetRows(neuralLayers, &neuralLayers1, 0, 4);
//Setting the number of neurons on each layer of the ANN
/*
We have in Layer 1: 2 neurons (2 inputs)
Layer 2: 3 neurons (hidden layer)
Layer 3: 3 neurons (hidden layer)
Layer 4: 1 neurons (1 output)
*/
cvSet1D(&neuralLayers1, 0, cvScalar(2));
cvSet1D(&neuralLayers1, 1, cvScalar(3));
cvSet1D(&neuralLayers1, 2, cvScalar(3));
cvSet1D(&neuralLayers1, 3, cvScalar(1));
//Read and populate the samples.
for (i=0;i<train_sample_count;i++)
fscanf(fin,"%f %f %f",&td[i][0],&td[i][1],&td[i][2]);
fclose(fin);
//Assemble the ML training data.
for (i=0; i<train_sample_count; i++)
{
//Input 1
cvSetReal2D(&trainData1, i, 0, td[i][0]);
//Input 2
cvSetReal2D(&trainData1, i, 1, td[i][1]);
//Output
cvSet1D(&trainClasses1, i, cvScalar(td[i][2]));
//Weight (setting everything to 1)
cvSet1D(&sampleWts1, i, cvScalar(1));
}
//Create our ANN.
machineBrain.create(neuralLayers);//sigmoid 0 0(激活函数的两个参数)
//Train it with our data.
machineBrain.train(
trainData,//输入
trainClasses,//输出
sampleWts,//输入项的权值
0,
CvANN_MLP_TrainParams(
cvTermCriteria(
CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,///类型 CV_TERMCRIT_ITER 和CV_TERMCRIT_EPS二值之一，或者二者的组合
10000000,//最大迭代次数
0.00000001//结果的精确性 两次迭代间权值变化量
),
CvANN_MLP_TrainParams::BACKPROP,//BP算法
0.01,//几个可显式调整的参数 学习速率 阿尔法
0.05 //惯性参数
)
);
}
float CvANN_MLP::predict( const CvMat* _inputs, CvMat* _outputs ) const
{
CV_FUNCNAME( "CvANN_MLP::predict" );
__BEGIN__;
double* buf;
int i, j, n, dn = 0, l_count, dn0, buf_sz, min_buf_sz;
if( !layer_sizes )
CV_ERROR( CV_StsError, "The network has not been initialized" );
if( !CV_IS_MAT(_inputs) || !CV_IS_MAT(_outputs) ||
!CV_ARE_TYPES_EQ(_inputs,_outputs) ||
CV_MAT_TYPE(_inputs->type) != CV_32FC1 &&
CV_MAT_TYPE(_inputs->type) != CV_64FC1 ||
_inputs->rows != _outputs->rows )
CV_ERROR( CV_StsBadArg, "Both input and output must be floating-point matrices "
"of the same type and have the same number of rows" );
if( _inputs->cols != layer_sizes->data.i[0] )
CV_ERROR( CV_StsBadSize, "input matrix must have the same number of columns as "
"the number of neurons in the input layer" );
if( _outputs->cols != layer_sizes->data.i[layer_sizes->cols - 1] )
CV_ERROR( CV_StsBadSize, "output matrix must have the same number of columns as "
"the number of neurons in the output layer" );
n = dn0 = _inputs->rows;
min_buf_sz = 2*max_count;
buf_sz = n*min_buf_sz;
if( buf_sz > max_buf_sz )
{
dn0 = max_buf_sz/min_buf_sz;
dn0 = MAX( dn0, 1 );
buf_sz = dn0*min_buf_sz;
}
buf = (double*)cvStackAlloc( buf_sz*sizeof(buf[0]) );
l_count = layer_sizes->cols;
for( i = 0; i < n; i += dn )
{
CvMat hdr[2], _w, *layer_in = &hdr[0], *layer_out = &hdr[1], *temp;
dn = MIN( dn0, n - i );
cvGetRows( _inputs, layer_in, i, i + dn );
cvInitMatHeader( layer_out, dn, layer_in->cols, CV_64F, buf );
scale_input( layer_in, layer_out );
CV_SWAP( layer_in, layer_out, temp );
for( j = 1; j < l_count; j++ )
{
double* data = buf + (j&1 ? max_count*dn0 : 0);
int cols = layer_sizes->data.i[j];
cvInitMatHeader( layer_out, dn, cols, CV_64F, data );
cvInitMatHeader( &_w, layer_in->cols, layer_out->cols, CV_64F, weights[j] );
cvGEMM( layer_in, &_w, 1, 0, 0, layer_out );
calc_activ_func( layer_out, _w.data.db + _w.rows*_w.cols );
CV_SWAP( layer_in, layer_out, temp );
}
cvGetRows( _outputs, layer_out, i, i + dn );
scale_output( layer_in, layer_out );
}
__END__;
return 0.f;
}
CvMat* vgg_X_from_xP_nonlin(CvMat* u1, CvMat** P1, CvMat* imsize1, int K)
{
CvMat* u;
CvMat** P=new CvMat* [K];
CvMat* imsize;
u=cvCreateMat(u1->rows,u1->cols,u1->type);
cvCopy(u1,u);
int kp;
for(kp=0;kp<K;kp++)
{
P[kp]=cvCreateMat(P1[kp]->rows,P1[kp]->cols,P1[kp]->type);
cvCopy(P1[kp],P[kp]);
}
imsize=cvCreateMat(imsize1->rows,imsize1->cols,imsize1->type);
cvCopy(imsize1,imsize);
CvMat* X;
CvMat* H;
CvMat* u_2_rows;
CvMat* W;
CvMat* U;
CvMat* T;
CvMat* Y;
CvMat** Q=new CvMat*[K];//Q is a variable not well defined
CvMat* J;
CvMat* e;
CvMat* J_tr;
CvMat* eprev;
CvMat* JtJ;
CvMat* Je;
CvMat* Y_new;
CvMat* T_2_cols;
CvMat* T_rest_cols;
CvMat* X_T;
CvScalar f, inf;
int i, mat_id;
int u_rows = u->rows;
int u_cols = u->cols;
double lambda_min, lambda_max;
CvMat* imsize_col = cvCreateMat(2, 1, CV_64FC1);
/* K is the number of images */
if(K < 2)
{
printf("\n Cannot reconstruct 3D from 1 image");
return 0;
}
/* Create temporary matrix for the linear function */
u_2_rows = cvCreateMat(2, u_cols, CV_64FC1);
/* Initialize the temporary matrix by extracting the first two rows */
u_2_rows = cvGetRows(u, u_2_rows, 0, 2, 1);
/* Call the linear function */
X = vgg_X_from_xP_lin(u_2_rows, P, K, imsize);
imsize_col = cvGetCol(imsize, imsize_col, 0);
f = cvSum(imsize_col);
f.val[0] = 4 / f.val[0];
/* Create and initialize H matrix */
H = cvCreateMat(3, 3, CV_64FC1);
H->data.db[0] = f.val[0];
H->data.db[1] = 0;
H->data.db[2] = ((-1) * f.val[0] * cvmGet(imsize, 0, 0)) / 2;
H->data.db[3] = 0;
H->data.db[4] = f.val[0];
H->data.db[5] = ((-1) * f.val[0] * cvmGet(imsize, 1, 0)) / 2;
H->data.db[6] = 0;
H->data.db[7] = 0;
H->data.db[8] = 1;
for(mat_id = 0; mat_id < K ; mat_id++)
{
cvMatMul(H, P[mat_id], P[mat_id]);
}
/* u = H * u; */
cvMatMul(H, u, u);
/*
//debug
printf("....H\n");
CvMat_printdb(stdout,"%7.3f ",H);
//debug
printf("....u\n");
CvMat_printdb(stdout,"%7.3f ",u);
*/
/* Parametrize X such that X = T*[Y;1]; thus x = P*T*[Y;1] = Q*[Y;1] */
/* Create the SVD matrices X = U*W*V'*/
X_T = cvCreateMat(X->cols, X->rows, CV_64FC1); /* M * N */
W = cvCreateMat(X_T->rows, X_T->cols, CV_64FC1); /* M * N */
U = cvCreateMat(X_T->rows, X_T->rows, CV_64FC1); /* M * M */
T = cvCreateMat(X_T->cols, X_T->cols, CV_64FC1); /* N * N */
cvTranspose(X, X_T);
cvSVD(X_T, W, U, T);
cvReleaseMat(&W);
/* T = T(:,[2:end 1]); */
/* Initialize the temporary matrix by extracting the first two columns */
/* Create temporary matrix for the linear function */
T_2_cols = cvCreateMat(T->rows, 2, CV_64FC1);
T_rest_cols = cvCreateMat(T->rows, (T->cols - 2), CV_64FC1);
/* Initialize the temporary matrix by extracting the first two columns */
T_2_cols= sfmGetCols(T,0,0);
T_rest_cols=sfmGetCols(T,1,T->cols-1);
T=sfmAlignMatH(T_rest_cols,T_2_cols);
for(mat_id = 0; mat_id < K ; mat_id++)
{
/* Create temporary matrix for the linear function */
Q[mat_id] = cvCreateMat(P[mat_id]->rows, T->cols, CV_64FC1);
cvMatMul(P[mat_id], T, Q[mat_id]);
}
/*
//debug
printf("....Q0\n");
CvMat_printdb(stdout,"%7.3f ",Q[0]);
//debug
printf("....Q1\n");
CvMat_printdb(stdout,"%7.3f ",Q[1]);
*/
/* Newton estimation */
/* Create the required Y matrix for the Newton process */
Y = cvCreateMat(3, 1, CV_64FC1);
cvSetZero(Y); /* Y = [0;0;0] */
/* Initialize the infinite array */
inf.val[0] = INF;
inf.val[1] = INF;
inf.val[2] = INF;
inf.val[3] = INF;
eprev = cvCreateMat(1, 1, CV_64FC1);
cvSet(eprev, inf, 0);
for(i = 0 ; i < 10 ; i++)
{
// printf("i=%d....\n",i);
int pass;
double RCondVal;
//initialize e,J before using.
e=cvCreateMat(2*K,1,CV_64FC1);
J=cvCreateMat(2*K,3,CV_64FC1);
pass = resid(Y, u, Q, K, e, J);
J_tr = cvCreateMat(J->cols, J->rows, CV_64FC1);
cvTranspose(J, J_tr);
JtJ = cvCreateMat(J->cols, J->cols, CV_64FC1);
cvMatMul(J_tr, J, JtJ);
//prevent memory leak;
cvReleaseMat(&W);
/* Create the SVD matrices JtJ = U*W*V'*/
W = cvCreateMat(J->cols, J->cols, CV_64FC1);
cvSVD(JtJ, W);
/*
//debug
printf("....W\n");
CvMat_printdb(stdout,"%7.3f ",W);
*/
lambda_max = W->data.db[0];
lambda_min = W->data.db[((W->rows * W->cols) - 1)];
RCondVal = lambda_min / lambda_max;
if(1 - (cvNorm(e, 0, CV_L2, 0) / cvNorm(eprev, 0, CV_L2, 0)) < 1000 * EPS)
{
cvReleaseMat(&J);
cvReleaseMat(&e);
cvReleaseMat(&J_tr);
cvReleaseMat(&JtJ);
cvReleaseMat(&W);
break;
}
if(RCondVal < 10 * EPS)
{
cvReleaseMat(&J);
cvReleaseMat(&e);
cvReleaseMat(&J_tr);
cvReleaseMat(&JtJ);
cvReleaseMat(&W);
break;
}
cvReleaseMat(&eprev);
eprev = cvCreateMat(e->rows, e->cols, CV_64FC1);
cvCopy(e, eprev);
Je = cvCreateMat(J->cols, e->cols, CV_64FC1);
cvMatMul(J_tr, e, Je); /* (J'*e) */
/*
//debug
printf("....J_tr\n");
CvMat_printdb(stdout,"%7.3f ",J_tr);
//debug
printf("....e\n");
CvMat_printdb(stdout,"%7.3f ",e);
//debug
printf("....JtJ\n");
CvMat_printdb(stdout,"%7.3f ",JtJ);
//debug
printf("....Je\n");
CvMat_printdb(stdout,"%7.3f ",Je);
//debug
printf("....JtJ\n");
CvMat_printdb(stdout,"%7.3f ",JtJ);
*/
cvInvert(JtJ,JtJ);
/* (J'*J)\(J'*e) */
Je=sfmMatMul(JtJ, Je);
/*
//debug
printf("....Je\n");
CvMat_printdb(stdout,"%7.3f ",Je);
*/
/* Y = Y - (J'*J)\(J'*e) */
cvSub(Y, Je, Y, 0);
/*
//debug
printf("....Y\n");
CvMat_printdb(stdout,"%7.3f ",Y);
*/
cvReleaseMat(&J);
cvReleaseMat(&e);
cvReleaseMat(&J_tr);
cvReleaseMat(&JtJ);
cvReleaseMat(&Je);
cvReleaseMat(&W);
}
Y_new = cvCreateMat(4, 1, CV_64FC1);
PutMatV(Y,Y_new,0);
Y_new->data.db[3]=1;
/*
//debug
printf("....Y_new\n");
CvMat_printdb(stdout,"%7.3f ",Y_new);
printf("....T\n");
CvMat_printdb(stdout,"%7.3f ",T);
*/
/* Obtain the new X */
cvMatMul(T, Y_new, X);
cvReleaseMat(&H);
cvReleaseMat(&u_2_rows);
cvReleaseMat(&U);
cvReleaseMat(&T);
cvReleaseMat(&Y);
cvReleaseMat(&Y_new);
cvReleaseMat(&T_2_cols);
cvReleaseMat(&T_rest_cols);
for(kp=0;kp<K;kp++)
{
cvReleaseMat(&P[kp]);
}
cvReleaseMat(&u);
cvReleaseMat(&imsize);
cvReleaseMatGrp(Q,K);
return X;
}
CvSVM* HoGProcessor::trainSVM(CvMat* pos_mat, CvMat* neg_mat, char *savexml, char *pos_file, char *neg_file)
{
/* Read the feature vectors for positive samples */
if (pos_file != NULL)
{
printf("positive loading...\n");
pos_mat = (CvMat*) cvLoad(pos_file);
printf("positive loaded\n");
}
/* Read the feature vectors for negative samples */
if (neg_file != NULL)
{
neg_mat = (CvMat*) cvLoad(neg_file);
printf("negative loaded\n");
}
int n_positive, n_negative;
n_positive = pos_mat->rows;
n_negative = neg_mat->rows;
int feature_vector_length = pos_mat->cols;
int total_samples;
total_samples = n_positive + n_negative;
CvMat* trainData = cvCreateMat(total_samples, feature_vector_length, CV_32FC1);
CvMat* trainClasses = cvCreateMat(total_samples, 1, CV_32FC1 );
CvMat trainData1, trainData2, trainClasses1, trainClasses2;
printf("Number of positive Samples : %d\n",
pos_mat->rows);
/*Copy the positive feature vectors to training
data*/
cvGetRows(trainData, &trainData1, 0, n_positive);
cvCopy(pos_mat, &trainData1);
cvReleaseMat(&pos_mat);
/*Copy the negative feature vectors to training
data*/
cvGetRows(trainData, &trainData2, n_positive,total_samples);
cvCopy(neg_mat, &trainData2);
cvReleaseMat(&neg_mat);
printf("Number of negative Samples : %d\n", trainData2.rows);
/*Form the training classes for positive and
negative samples. Positive samples belong to class
1 and negative samples belong to class 2 */
cvGetRows(trainClasses, &trainClasses1, 0, n_positive);
cvSet(&trainClasses1, cvScalar(1));
cvGetRows(trainClasses, &trainClasses2, n_positive, total_samples);
cvSet(&trainClasses2, cvScalar(2));
/* Train a linear support vector machine to learn from
the training data. The parameters may played and
experimented with to see their effects*/
/*
CvMat* class_weight = cvCreateMat(1, 1, CV_32FC1);
(*(float*)CV_MAT_ELEM_PTR(*class_weight, 0, 0)) = 0;
//(*(float*)CV_MAT_ELEM_PTR(*class_weight, 0, 1)) = 10;
//(*(float*)CV_MAT_ELEM_PTR(*class_weight, 1, 0)) = 100;
//(*(float*)CV_MAT_ELEM_PTR(*class_weight, 1, 1)) = 0;
*/
CvSVM* svm = new CvSVM(trainData, trainClasses, 0, 0,
CvSVMParams(CvSVM::C_SVC, CvSVM::LINEAR, 0, 0, 0, 2,
0, 0, 0, cvTermCriteria(CV_TERMCRIT_EPS,0, 0.01)));
printf("SVM Training Complete!!\n");
/*Save the learnt model*/
if (savexml != NULL)
{
svm->save(savexml);
}
cvReleaseMat(&trainClasses);
cvReleaseMat(&trainData);
return svm;
}
static
int build_nbayes_classifier( char* data_filename )
{
const int var_count = 16;
CvMat* data = 0;
CvMat train_data;
CvMat* responses;
int ok = read_num_class_data( data_filename, 16, &data, &responses );
int nsamples_all = 0, ntrain_samples = 0;
//int i, j;
//double /*train_hr = 0, */test_hr = 0;
CvANN_MLP mlp;
if( !ok )
{
printf( "Could not read the database %s\n", data_filename );
return -1;
}
printf( "The database %s is loaded.\n", data_filename );
nsamples_all = data->rows;
ntrain_samples = (int)(nsamples_all*0.5);
// 1. unroll the responses
printf( "Unrolling the responses...\n");
cvGetRows( data, &train_data, 0, ntrain_samples );
// 2. train classifier
CvMat* train_resp = cvCreateMat( ntrain_samples, 1, CV_32FC1);
for (int i = 0; i < ntrain_samples; i++)
train_resp->data.fl[i] = responses->data.fl[i];
CvNormalBayesClassifier nbayes(&train_data, train_resp);
float* _sample = new float[var_count * (nsamples_all - ntrain_samples)];
CvMat sample = cvMat( nsamples_all - ntrain_samples, 16, CV_32FC1, _sample );
float* true_results = new float[nsamples_all - ntrain_samples];
for (int j = ntrain_samples; j < nsamples_all; j++)
{
float *s = data->data.fl + j * var_count;
for (int i = 0; i < var_count; i++)
{
sample.data.fl[(j - ntrain_samples) * var_count + i] = s[i];
}
true_results[j - ntrain_samples] = responses->data.fl[j];
}
CvMat *result = cvCreateMat(1, nsamples_all - ntrain_samples, CV_32FC1);
nbayes.predict(&sample, result);
int true_resp = 0;
//int accuracy = 0;
for (int i = 0; i < nsamples_all - ntrain_samples; i++)
{
if (result->data.fl[i] == true_results[i])
true_resp++;
}
printf("true_resp = %f%%\n", (float)true_resp / (nsamples_all - ntrain_samples) * 100);
delete[] true_results;
delete[] _sample;
cvReleaseMat( &train_resp );
cvReleaseMat( &result );
cvReleaseMat( &data );
cvReleaseMat( &responses );
return 0;
}
/**
* Transforms points from the ground plane (z=-h) in the world frame
* into points on the image in image frame (uv-coordinates)
*
* \param inPoints 2xN array of input points on the ground in world coordinates
* \param outPoints 2xN output points in on the image in image coordinates
* \param cameraInfo the camera parameters
*
*/
void mcvTransformGround2Image(const CvMat *inPoints,
CvMat *outPoints, const CameraInfo *cameraInfo)
{
//add two rows to the input points
CvMat *inPoints3 = cvCreateMat(inPoints->rows+1, inPoints->cols,
cvGetElemType(inPoints));
cvSet(inPoints3, cvScalar(0));
//copy inPoints to first two rows
CvMat inPoints2, inPointsr3;
cvGetRows(inPoints3, &inPoints2, 0, 2);
cvGetRow(inPoints3, &inPointsr3, 2);
cvSet(&inPointsr3, cvRealScalar(-cameraInfo->cameraHeight));
cvCopy(inPoints, &inPoints2);
//create the transformation matrix
float c1 = cos(cameraInfo->pitch);
float s1 = sin(cameraInfo->pitch);
float c2 = cos(cameraInfo->yaw);
float s2 = sin(cameraInfo->yaw);
float matp[] = {
cameraInfo->focalLength.x * c2 + c1*s2* cameraInfo->opticalCenter.x,
-cameraInfo->focalLength.x * s2 + c1*c2* cameraInfo->opticalCenter.x,
- s1 * cameraInfo->opticalCenter.x,
s2 * (-cameraInfo->focalLength.y * s1 + c1* cameraInfo->opticalCenter.y),
c2 * (-cameraInfo->focalLength.y * s1 + c1* cameraInfo->opticalCenter.y),
-cameraInfo->focalLength.y * c1 - s1* cameraInfo->opticalCenter.y,
c1*s2,
c1*c2,
-s1
};
CvMat mat = cvMat(3, 3, FLOAT_MAT_TYPE, matp);
//multiply
//std::cout << " inPoints3.rows " << inPoints3->rows << " inPoints3.cols "<< inPoints3->cols << "\n ";
cvMatMul(&mat, inPoints3, inPoints3);
//divide by last row of inPoints4
for (int i=0; i<inPoints->cols; i++)
{
float div = CV_MAT_ELEM(inPointsr3, float, 0, i);
CV_MAT_ELEM(*inPoints3, float, 0, i) =
CV_MAT_ELEM(*inPoints3, float, 0, i) / div ;
CV_MAT_ELEM(*inPoints3, float, 1, i) =
CV_MAT_ELEM(*inPoints3, float, 1, i) / div;
if(isnan(CV_MAT_ELEM(*inPoints3, float, 0, i) ) || isnan(CV_MAT_ELEM(*inPoints3, float, 1, i) ))
{
cout << "cameraInfo->pitch " << cameraInfo->pitch << endl;
cout << "cameraInfo->yaw " << cameraInfo->yaw << endl;
cout << "opticalCenter.x " << cameraInfo->opticalCenter.x << endl;
cout << "opticalCenter.y " << cameraInfo->opticalCenter.y << endl;
cout << "focalLength.x " << cameraInfo->focalLength.x << endl;
cout << "focalLength.y " << cameraInfo->focalLength.y << endl;
}
//if(isnan(CV_MAT_ELEM(*inPoints3, float, 1, i) )) cout << "JAP!!!2 div " << div <<endl;
}
//put back the result into outPoints
//std::cout << " inPoints2.rows " << inPoints2.rows << " inPoints2.cols "<< inPoints2.cols << "\n ";
// std::cout << " outPoints.rows " << outPoints->rows << " outPoints.cols "<< outPoints->cols << "\n ";
cvCopy(&inPoints2, outPoints);
// std::cout << " outPoints.rows " << outPoints->rows << " outPoints.cols "<< outPoints->cols << "\n ";
//clear
cvReleaseMat(&inPoints3);
}
static
int build_svm_classifier( char* data_filename )
{
CvMat* data = 0;
CvMat* responses = 0;
CvMat train_data;
int nsamples_all = 0, ntrain_samples = 0;
int var_count;
CvSVM svm;
int ok = read_num_class_data( data_filename, 16, &data, &responses );
if( !ok )
{
printf( "Could not read the database %s\n", data_filename );
return -1;
}
////////// SVM parameters ///////////////////////////////
CvSVMParams param;
param.kernel_type=CvSVM::LINEAR;
param.svm_type=CvSVM::C_SVC;
param.C=1;
///////////////////////////////////////////////////////////
printf( "The database %s is loaded.\n", data_filename );
nsamples_all = data->rows;
ntrain_samples = (int)(nsamples_all*0.1);
var_count = data->cols;
// train classifier
printf( "Training the classifier (may take a few minutes)...\n");
cvGetRows( data, &train_data, 0, ntrain_samples );
CvMat* train_resp = cvCreateMat( ntrain_samples, 1, CV_32FC1);
for (int i = 0; i < ntrain_samples; i++)
train_resp->data.fl[i] = responses->data.fl[i];
svm.train(&train_data, train_resp, 0, 0, param);
// classification
std::vector<float> _sample(var_count * (nsamples_all - ntrain_samples));
CvMat sample = cvMat( nsamples_all - ntrain_samples, 16, CV_32FC1, &_sample[0] );
std::vector<float> true_results(nsamples_all - ntrain_samples);
for (int j = ntrain_samples; j < nsamples_all; j++)
{
float *s = data->data.fl + j * var_count;
for (int i = 0; i < var_count; i++)
{
sample.data.fl[(j - ntrain_samples) * var_count + i] = s[i];
}
true_results[j - ntrain_samples] = responses->data.fl[j];
}
CvMat *result = cvCreateMat(1, nsamples_all - ntrain_samples, CV_32FC1);
printf("Classification (may take a few minutes)...\n");
svm.predict(&sample, result);
int true_resp = 0;
for (int i = 0; i < nsamples_all - ntrain_samples; i++)
{
if (result->data.fl[i] == true_results[i])
true_resp++;
}
printf("true_resp = %f%%\n", (float)true_resp / (nsamples_all - ntrain_samples) * 100);
cvReleaseMat( &train_resp );
cvReleaseMat( &result );
cvReleaseMat( &data );
cvReleaseMat( &responses );
return 0;
}
// Read the training data and train the network.
void trainMachine()
{
int i;
//The number of training samples.
int train_sample_count;
//The training data matrix.
//Note that we are limiting the number of training data samples to 1000 here.
//The data sample consists of two inputs and an output. That's why 3.
//td es la matriz dinde se cargan las muestras
float td[3000][7];
//Read the training file
/*
A sample file contents(say we are training the network for generating
the mean given two numbers) would be:
5
12 16 14
10 5 7.5
8 10 9
5 4 4.5
12 6 9
*/
FILE *fin;
fin = fopen("train.txt", "r");
//Get the number of samples.
fscanf(fin, "%d", &train_sample_count);
printf("Found training file with %d samples...\n", train_sample_count);
//Create the matrices
//Input data samples. Matrix of order (train_sample_count x 2)
CvMat* trainData = cvCreateMat(train_sample_count, 6, CV_32FC1);
//Output data samples. Matrix of order (train_sample_count x 1)
CvMat* trainClasses = cvCreateMat(train_sample_count, 1, CV_32FC1);
//The weight of each training data sample. We'll later set all to equal weights.
CvMat* sampleWts = cvCreateMat(train_sample_count, 1, CV_32FC1);
//The matrix representation of our ANN. We'll have four layers.
CvMat* neuralLayers = cvCreateMat(2, 1, CV_32SC1);
CvMat trainData1, trainClasses1, neuralLayers1, sampleWts1;
cvGetRows(trainData, &trainData1, 0, train_sample_count);
cvGetRows(trainClasses, &trainClasses1, 0, train_sample_count);
cvGetRows(trainClasses, &trainClasses1, 0, train_sample_count);
cvGetRows(sampleWts, &sampleWts1, 0, train_sample_count);
cvGetRows(neuralLayers, &neuralLayers1, 0, 2);
//Setting the number of neurons on each layer of the ANN
/*
We have in Layer 1: 2 neurons (6 inputs)
Layer 2: 3 neurons (hidden layer)
Layer 3: 3 neurons (hidden layer)
Layer 4: 1 neurons (1 output)
*/
cvSet1D(&neuralLayers1, 0, cvScalar(6));
//cvSet1D(&neuralLayers1, 1, cvScalar(3));
//cvSet1D(&neuralLayers1, 2, cvScalar(3));
cvSet1D(&neuralLayers1, 1, cvScalar(1));
//Read and populate the samples.
for (i=0; i<train_sample_count; i++)
fscanf(fin,"%f %f %f %f",&td[i][0],&td[i][1],&td[i][2],&td[i][3]);
fclose(fin);
//Assemble the ML training data.
for (i=0; i<train_sample_count; i++)
{
//Input 1
cvSetReal2D(&trainData1, i, 0, td[i][0]);
//Input 2
cvSetReal2D(&trainData1, i, 1, td[i][1]);
cvSetReal2D(&trainData1, i, 2, td[i][2]);
cvSetReal2D(&trainData1, i, 3, td[i][3]);
cvSetReal2D(&trainData1, i, 4, td[i][4]);
cvSetReal2D(&trainData1, i, 5, td[i][5]);
//Output
cvSet1D(&trainClasses1, i, cvScalar(td[i][6]));
//Weight (setting everything to 1)
cvSet1D(&sampleWts1, i, cvScalar(1));
}
//Create our ANN.
machineBrain.create(neuralLayers);
//Train it with our data.
//See the Machine learning reference at http://www.seas.upenn.edu/~bensapp/opencvdocs/ref/opencvref_ml.htm#ch_ann
machineBrain.train(
trainData,
trainClasses,
sampleWts,
0,
CvANN_MLP_TrainParams(
cvTermCriteria(
CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,
100000,
1.0
),
CvANN_MLP_TrainParams::BACKPROP,
0.01,
0.05
)
);
}
