DictionaryTrajectory::DictionaryTrajectory(std::string baseFolder, double az, double bz) : Trajectory() {
this->baseFolder = baseFolder;
vector<string> files = getFilesInDirectory(baseFolder);
queryFiles = sortPrefix(files, "query");
trajFiles = sortPrefix(files, "traj");
dmpFiles = sortPrefix(files, "dmp");
if(dmpFiles.size() == 0) {
// learn dmps
queryPoints = mapFiles(queryFiles, trajFiles, "query", "traj");
KUKADU_SHARED_PTR<JointDMPLearner> dmpLearner;
vector<mat> jointsVec;
double tMax = 0.0;
for(int i = 0; i < queryPoints.size(); ++i) {
mat joints = readMovements((string(baseFolder) + string(queryPoints.at(i).getFileDataPath())).c_str());
degOfFreedom = joints.n_cols - 1;
queryPoints.at(i).setQueryPoint(readQuery(string(baseFolder) + string(queryPoints.at(i).getFileQueryPath())));
jointsVec.push_back(joints);
double currentTMax = joints(joints.n_rows - 1, 0);
if(tMax < currentTMax)
tMax = currentTMax;
}
for(int i = 0; i < jointsVec.size(); ++i) {
QueryPoint currentQueryPoint = queryPoints.at(i);
mat joints = jointsVec.at(i);
joints = fillTrajectoryMatrix(joints, tMax);
dmpLearner = KUKADU_SHARED_PTR<JointDMPLearner>(new JointDMPLearner(az, bz, joints));
KUKADU_SHARED_PTR<Dmp> learnedDmps = dmpLearner->fitTrajectories();
learnedDmps->serialize(baseFolder + currentQueryPoint.getFileDmpPath());
queryPoints.at(i).setDmp(learnedDmps);
startingPos = queryPoints.at(i).getDmp()->getY0();
cout << "(DMPGeneralizer) goals for query point [" << currentQueryPoint.getQueryPoint().t() << "]" << endl << "\t [";
cout << currentQueryPoint.getDmp()->getG().t() << "]" << endl;
//delete dmpLearner;
dmpLearner = KUKADU_SHARED_PTR<JointDMPLearner>();
}
} else {
queryPoints = mapFiles(queryFiles, trajFiles, dmpFiles, "query", "traj", "dmp");
}
degOfFreedom = queryPoints.at(0).getDmp()->getDegreesOfFreedom();
}
void getFilesInDirectory( const QString &p, std::vector< QString > &files, bool recursive, const std::vector< QString > &filter )
{
QString path=p;
if (path.endsWith("/"))
{
int slash=path.indexOf('/',-1);
path.truncate(slash);
}
else if (path.endsWith("\\"))
{
int slash=path.indexOf('\\',-1);
path.truncate(slash);
}
QDir d(path);
d.setFilter( QDir::Dirs | QDir::Hidden | QDir::NoSymLinks );
std::vector< QString > subDir;
const QFileInfoList &listDirectories = d.entryInfoList();
QStringList filters;
for (unsigned int i=0; i<filter.size(); ++i)
filters << filter[i];
d.setNameFilters(filters);
for (int j = 0; j < listDirectories.size(); ++j)
{
QFileInfo fileInfo=listDirectories.at(j);
subDir.push_back(fileInfo.fileName());
}
d.setFilter( QDir::Files | QDir::Hidden | QDir::NoSymLinks );
const QFileInfoList &listFiles =
d.entryInfoList();
for (int j = 0; j < listFiles.size(); ++j)
{
QFileInfo fileInfo=listFiles.at(j);
files.push_back(path+QString("/")+fileInfo.fileName());
}
if (recursive)
{
for (unsigned int i=0; i<subDir.size(); ++i)
{
if (subDir[i].left(1) == QString(".")) continue;
if (subDir[i] == QString("OBJ")) continue;
QString nextDir=path+QString("/")+subDir[i];
getFilesInDirectory(nextDir, files, recursive, filter);
}
}
}
void cPluginManager::autoLoadPlugins()
{
cAudioVector<cAudioString>::Type fileList = getFilesInDirectory(".");
for(size_t i=0; i<fileList.size(); ++i)
{
if(fileList[i].substr(0, 4) == "cAp_")
{
#ifdef CAUDIO_PLATFORM_WIN
if(fileList[i].substr(fileList[i].length()-4, 4) == ".dll")
#elif defined(CAUDIO_PLATFORM_LINUX)
if(fileList[i].substr(fileList[i].length()-3, 3) == ".so")
#elif defined(CAUDIO_PLATFORM_MAC)
if(fileList[i].substr(fileList[i].length()-6, 6) == ".dylib")
#endif
{
//Found a plugin, load it
installPlugin(cAudioString("./" + fileList[i]).c_str(), NULL);
}
}
}
}
void pcl::face_detection::FaceDetectorDataProvider<FeatureType, DataSet, LabelType, ExampleIndex, NodeType>::initialize(std::string & data_dir)
{
std::string start;
std::string ext = std::string ("pcd");
bf::path dir = data_dir;
std::vector < std::string > files;
getFilesInDirectory (dir, start, files, ext);
//apart from loading the file names, we will do some bining regarding pitch and yaw
std::vector < std::vector<int> > yaw_pitch_bins;
std::vector < std::vector<std::vector<std::string> > > image_files_per_bin;
float res_yaw = 15.f;
float res_pitch = res_yaw;
int min_yaw = -75;
int min_pitch = -60;
int num_yaw = static_cast<int>((std::abs (min_yaw) * 2) / static_cast<int>(res_yaw + 1.f));
int num_pitch = static_cast<int>((std::abs (min_pitch) * 2) / static_cast<int>(res_pitch + 1.f));
yaw_pitch_bins.resize (num_yaw);
image_files_per_bin.resize (num_yaw);
for (int i = 0; i < num_yaw; i++)
{
yaw_pitch_bins[i].resize (num_pitch);
image_files_per_bin[i].resize (num_pitch);
for (int j = 0; j < num_pitch; j++)
{
yaw_pitch_bins[i][j] = 0;
}
}
for (size_t i = 0; i < files.size (); i++)
{
std::stringstream filestream;
filestream << data_dir << "/" << files[i];
std::string file = filestream.str ();
std::string pose_file (files[i]);
boost::replace_all (pose_file, ".pcd", "_pose.txt");
Eigen::Matrix4f pose_mat;
pose_mat.setIdentity (4, 4);
std::stringstream filestream_pose;
filestream_pose << data_dir << "/" << pose_file;
pose_file = filestream_pose.str ();
bool result = readMatrixFromFile (pose_file, pose_mat);
if (result)
{
Eigen::Vector3f ea = pose_mat.block<3, 3> (0, 0).eulerAngles (0, 1, 2);
ea *= 57.2957795f; //transform it to degrees to do the binning
int y = static_cast<int>(pcl_round ((ea[0] + static_cast<float>(std::abs (min_yaw))) / res_yaw));
int p = static_cast<int>(pcl_round ((ea[1] + static_cast<float>(std::abs (min_pitch))) / res_pitch));
if (y < 0)
y = 0;
if (p < 0)
p = 0;
if (p >= num_pitch)
p = num_pitch - 1;
if (y >= num_yaw)
y = num_yaw - 1;
assert (y >= 0 && y < num_yaw);
assert (p >= 0 && p < num_pitch);
yaw_pitch_bins[y][p]++;
image_files_per_bin[y][p].push_back (file);
}
}
pcl::face_detection::showBining (num_pitch, res_pitch, min_pitch, num_yaw, res_yaw, min_yaw, yaw_pitch_bins);
int max_elems = 0;
int total_elems = 0;
for (int i = 0; i < num_yaw; i++)
{
for (int j = 0; j < num_pitch; j++)
{
total_elems += yaw_pitch_bins[i][j];
if (yaw_pitch_bins[i][j] > max_elems)
max_elems = yaw_pitch_bins[i][j];
}
}
float average = static_cast<float> (total_elems) / (static_cast<float> (num_pitch + num_yaw));
std::cout << "The average number of image per bin is:" << average << std::endl;
std::cout << "Total number of images in the dataset:" << total_elems << std::endl;
//reduce unbalance from dataset by capping the number of images per bin, keeping at least a certain min
if (min_images_per_bin_ != -1)
{
std::cout << "Reducing unbalance of the dataset." << std::endl;
for (int i = 0; i < num_yaw; i++)
{
for (int j = 0; j < num_pitch; j++)
{
if (yaw_pitch_bins[i][j] >= min_images_per_bin_)
{
std::random_shuffle (image_files_per_bin[i][j].begin (), image_files_per_bin[i][j].end ());
image_files_per_bin[i][j].resize (min_images_per_bin_);
yaw_pitch_bins[i][j] = min_images_per_bin_;
}
for (size_t ii = 0; ii < image_files_per_bin[i][j].size (); ii++)
{
image_files_.push_back (image_files_per_bin[i][j][ii]);
}
}
}
}
pcl::face_detection::showBining (num_pitch, res_pitch, min_pitch, num_yaw, res_yaw, min_yaw, yaw_pitch_bins);
std::cout << "Total number of images in the dataset:" << image_files_.size () << std::endl;
}
int annTrain::train(std::string imagesDir, int networkInputSize, float testRatio)
{
std::cout << "Reading training set..." << std::endl;
uint64 start = ofGetElapsedTimeMillis();
std::vector<std::string> files = getFilesInDirectory(imagesDir);
std::random_shuffle(files.begin(), files.end());
cv::Mat img;
for (auto it = files.begin(); it != files.end(); ++it)
{
std::string filename = *it;
//std::cout << "Reading image " << filename << "..." << std::endl;
img = cv::imread(filename, 0);
if (img.empty())
{
std::cerr << "WARNING: Could not read image." << std::endl;
continue;
}
std::string classname = getClassName(filename);
cv::Mat descriptors = getDescriptors(img);
processClassAndDesc(classname, descriptors);
}
std::cout << " Seconds : " << (ofGetElapsedTimeMillis() - start) / 1000.0 << std::endl;
std::cout << "Creating vocabulary..." << std::endl;
start = ofGetElapsedTimeMillis();
cv::Mat labels;
cv::Mat vocabulary;
// Use k-means to find k centroids (the words of our vocabulary)
cv::kmeans(descriptorsSet, networkInputSize, labels, cv::TermCriteria(cv::TermCriteria::EPS + cv::TermCriteria::MAX_ITER, 10, 0.01), 1, cv::KMEANS_PP_CENTERS, vocabulary);
// No need to keep it on memory anymore
descriptorsSet.release();
std::cout << " Seconds : " << (ofGetElapsedTimeMillis() - start) / 1000.0 << std::endl;
// Convert a set of local features for each image in a single descriptors
// using the bag of words technique
std::cout << "Getting histograms of visual words..." << std::endl;
int* ptrLabels = (int*)(labels.data);
int size = labels.rows * labels.cols;
for (int i = 0; i < size; i++)
{
int label = *ptrLabels++;
ImageData* data = descriptorsMetadata[i];
data->bowFeatures.at<float>(label)++;
}
// Filling matrixes to be used by the neural network
std::cout << "Preparing neural network..." << std::endl;
std::set<ImageData*> uniqueMetadata(descriptorsMetadata.begin(), descriptorsMetadata.end());
for (auto it = uniqueMetadata.begin(); it != uniqueMetadata.end(); )
{
ImageData* data = *it;
cv::Mat normalizedHist;
cv::normalize(data->bowFeatures, normalizedHist, 0, data->bowFeatures.rows, cv::NORM_MINMAX, -1, cv::Mat());
trainSamples.push_back(normalizedHist);
trainResponses.push_back(getClassCode(classes, data->classname));
delete *it; // clear memory
it++;
}
descriptorsMetadata.clear();
// Training neural network
std::cout << "Training neural network..." << std::endl;
start = ofGetElapsedTimeMillis();
mlp = getTrainedNeuralNetwork(trainSamples, trainResponses);
std::cout << " Seconds : " << (ofGetElapsedTimeMillis() - start) / 1000.0 << std::endl;
// We can clear memory now
trainSamples.release();
trainResponses.release();
// Train FLANN
std::cout << "Training FLANN..." << std::endl;
start = ofGetElapsedTimeMillis();
flann = cv::Ptr<cv::FlannBasedMatcher>(new cv::FlannBasedMatcher());
flann->add(vocabulary);
flann->train();
std::cout << " Seconds : " << (ofGetElapsedTimeMillis() - start) / 1000.0 << std::endl;
// Reading test set
std::cout << "Reading test set..." << std::endl;
start = ofGetElapsedTimeMillis();
readImagesToTest(files.begin() + (size_t)(files.size() * testRatio), files.end());
std::cout << " Seconds : " << (ofGetElapsedTimeMillis() - start) / 1000.0 << std::endl;
// Get confusion matrix of the test set
std::vector<std::vector<int> > confusionMatrix = getConfusionMatrix();
// how accurate is our model
std::cout << "Confusion matrix " << std::endl;
printConfusionMatrix(confusionMatrix, classes);
std::cout << "Accuracy " << getAccuracy(confusionMatrix) << std::endl;
// now save everything
std::cout << "saving models" << std::endl;
saveModels(vocabulary, classes);
return 0;
}
