ifstream stream(data_file.c_str());

string filename;

int label;

int char_idx = data_file.size() - 1;

for (; char_idx >= 0; --char_idx)

if (data_file[char_idx] == '/' || data_file[char_idx] == '\\')

break;

string data_path = data_file.substr(0,char_idx+1);

while(!stream.eof() && !stream.fail()) {

stream >> filename >> label;

if (filename.size())

file_list->push_back(make_pair(data_path + filename, label));

}

stream.close();

for (size_t img_idx = 0; img_idx < file_list.size(); ++img_idx) {

// Create image

BMP* image = new BMP();

// Read image from file

image->ReadFromFile(file_list[img_idx].first.c_str());

// Add image and it's label to dataset

data_set->push_back(make_pair(image, file_list[img_idx].second));

}

const TLabels& labels,

const string& prediction_file) {

// Check that list of files and list of labels has equal size

assert(file_list.size() == labels.size());

// Open 'prediction_file' for writing

ofstream stream(prediction_file.c_str());

// Write file names and labels to stream

for (size_t image_idx = 0; image_idx < file_list.size(); ++image_idx)

stream << file_list[image_idx].first << " " << labels[image_idx] << endl;

stream.close();

{

Image res(in->TellHeight(), in->TellWidth());

for (uint i = 0; i < res.n_rows; ++i) {

for (uint j = 0; j < res.n_cols; ++j) {

RGBApixel *p = (*in)(j, i);

res(i, j) = make_tuple(p->Red, p->Green, p->Blue);

}

}

return res;

HOG hog(im);

vector <float> v(hog.ComputeHog(DIVIDESIZE));

uint sizex = im.n_rows / PYRAMIDSIZE;

uint sizey = im.n_cols / PYRAMIDSIZE;

for (int i = 0; i < PYRAMIDSIZE; i++){

for (int j = 0; j < PYRAMIDSIZE; j++){

auto tmp = im.submatrix(i * sizex, j * sizey, sizex, sizey);

HOG halfhog(tmp);

vector<float> appending(halfhog.ComputeHog(DIVIDESIZE));

v.insert(v.end(), appending.begin(), appending.end() );

}

}

return v;

for (size_t image_idx = 0; image_idx < data_set.size(); ++image_idx) {

// PLACE YOUR CODE HERE

// Remove this sample code and place your feature extraction code here

int index;

BMP *bmp;

tie(bmp, index) = data_set[image_idx];

Image im = load_image(bmp);

vector<float> v = pyramid(im);

vector <float> nv (0,0);

ModifyFeature(v, nv);

features->push_back(make_pair(v, index));

}

// Delete all images from dataset

for (size_t image_idx = 0; image_idx < data_set->size(); ++image_idx)

delete (*data_set)[image_idx].first;

// Clear dataset

data_set->clear();

// List of image file names and its labels

TFileList file_list;

// Structure of images and its labels

TDataSet data_set;

// Structure of features of images and its labels

TFeatures features;

// Model which would be trained

TModel model;

// Parameters of classifier

TClassifierParams params;

// Load list of image file names and its labels

LoadFileList(data_file, &file_list);

// Load images

LoadImages(file_list, &data_set);

// Extract features from images

ExtractFeatures(data_set, &features);

// PLACE YOUR CODE HERE

// You can change parameters of classifier here

//params.C = 0.01;

TClassifier classifier(params);

// Train classifier

classifier.Train(features, &model);

// Save model to file

model.Save(model_file);

// Clear dataset structure

ClearDataset(&data_set);

const string& model_file,

const string& prediction_file) {

// List of image file names and its labels

TFileList file_list;

// Structure of images and its labels

TDataSet data_set;

// Structure of features of images and its labels

TFeatures features;

// List of image labels

TLabels labels;

// Load list of image file names and its labels

LoadFileList(data_file, &file_list);

// Load images

LoadImages(file_list, &data_set);

// Extract features from images

ExtractFeatures(data_set, &features);

// Classifier

TClassifier classifier = TClassifier(TClassifierParams());

// Trained model

TModel model;

// Load model from file

model.Load(model_file);

// Predict images by its features using 'model' and store predictions

// to 'labels'

classifier.Predict(features, model, &labels);

// Save predictions

SavePredictions(file_list, labels, prediction_file);

// Clear dataset structure

ClearDataset(&data_set);

// Command line options parser

ArgvParser cmd;

// Description of program

cmd.setIntroductoryDescription("Machine graphics course, task 2. CMC MSU, 2014.");

// Add help option

cmd.setHelpOption("h", "help", "Print this help message");

// Add other options

cmd.defineOption("data_set", "File with dataset",

ArgvParser::OptionRequiresValue | ArgvParser::OptionRequired);

cmd.defineOption("model", "Path to file to save or load model",

ArgvParser::OptionRequiresValue | ArgvParser::OptionRequired);

cmd.defineOption("predicted_labels", "Path to file to save prediction results",

ArgvParser::OptionRequiresValue);

cmd.defineOption("train", "Train classifier");

cmd.defineOption("predict", "Predict dataset");

// Add options aliases

cmd.defineOptionAlternative("data_set", "d");

cmd.defineOptionAlternative("model", "m");

cmd.defineOptionAlternative("predicted_labels", "l");

cmd.defineOptionAlternative("train", "t");

cmd.defineOptionAlternative("predict", "p");

// Parse options

int result = cmd.parse(argc, argv);

// Check for errors or help option

if (result) {

cout << cmd.parseErrorDescription(result) << endl;

return result;

}

// Get values

string data_file = cmd.optionValue("data_set");

string model_file = cmd.optionValue("model");

bool train = cmd.foundOption("train");

bool predict = cmd.foundOption("predict");

// If we need to train classifier

if (train)

TrainClassifier(data_file, model_file);

// If we need to predict data

if (predict) {

// You must declare file to save images

if (!cmd.foundOption("predicted_labels")) {

cerr << "Error! Option --predicted_labels not found!" << endl;

return 1;

}

// File to save predictions

string prediction_file = cmd.optionValue("predicted_labels");

// Predict data

PredictData(data_file, model_file, prediction_file);

}

}