/* Synthetic Minority Over-sampling Technique */
cv::Mat SMOTE::smote(cv::Mat minority, int amountSmote, int nearestNeighbors) {
cv::Size s = minority.size();
int samples, pos, index = 0;
int minoritySamples = s.height;
int attributes = s.width;
std::vector<int> vectorRand;
cv::Mat newMinority;
if (amountSmote == 0) return cv::Mat();
std::cout << "\n---------------------------------------------------------" << std::endl;
std::cout << "SMOTE generation of samples to rebalance classes" << std::endl;
std::cout << "---------------------------------------------------------" << std::endl;
// The first neighbor is the sample itself
nearestNeighbors = nearestNeighbors + 1 < minority.rows ? nearestNeighbors + 1 : minority.rows;
minoritySamples = amountSmote;
newMinority.create(minoritySamples, attributes, CV_32FC1);
samples = 0;
/* If amount to smote is less than 100%, randomize the minority class
samples as only a random percent of them will be SMOTEd */
if (amountSmote < s.height) {
while (samples < minoritySamples) {
/* Generate a random position for the minority class samples */
pos = rand() % (s.height);
if (!count(vectorRand.begin(), vectorRand.end(), pos)) {
vectorRand.push_back(pos);
cv::Mat tmp = newMinority.row(samples);
minority.row(pos).copyTo(tmp);
samples++;
}
}
minority = newMinority;
}
cv::Mat synthetic(amountSmote, attributes, CV_32FC1);
cv::Mat neighbors(minoritySamples, nearestNeighbors, CV_32FC1);
/* Compute all the neighbors for the minority class */
computeNeighbors(minority, nearestNeighbors, &neighbors);
/* For each sample, generate it(s) synthetic(s) sample(s) */
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, minority.rows-1);
while (amountSmote > 0) {
// Mat minority, Mat neighbors, Mat *synthetic, int *index, int amountSmote, int i, int nearestNeighbors)
populate(minority, neighbors, &synthetic, &index, 1, dis(gen), nearestNeighbors);
amountSmote--;
}
return synthetic;
}
vector<vector<int>> imageSmoother(vector<vector<int>>& M) {
vector<vector<int>> result;
if (M.empty()) return result;
int m = M.size(), n = M[0].size();
result.resize(m, vector<int>(n));
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
result[i][j] = computeNeighbors(M, i, j);
}
}
return result;
}
void StructuralRelationsLight::computeRelations()
{
printf("StructuralRelationsLight::computeRelations start!\n");
if(!have_input_cloud || !have_patches) {
printf("[StructuralRelationsLight::computeRelations] Error: No input cloud and patches available.\n");
return;
}
view->relations.clear();
cv::Mat_<cv::Vec3b> matImage;
ConvertPCLCloud2Image(pcl_cloud, matImage);
std::vector<ColorHistogram3D> hist3D;
surface::Texture texture;
relations.resize(view->surfaces.size());
#pragma omp parallel sections
{
#pragma omp section
{
computeNeighbors();
}
#pragma omp section
{
for(unsigned i=0; i<view->surfaces.size(); i++) {
int nr_hist_bins = 4;
double uvThreshold = 0.0f;
hist3D.push_back(ColorHistogram3D(nr_hist_bins, uvThreshold));
hist3D[i].setInputCloud(pcl_cloud);
hist3D[i].setIndices(view->surfaces[i]->indices);
hist3D[i].compute();
}
}
#pragma omp section
{
texture.setInputImage(matImage);
texture.setSurfaceModels(*view);
texture.compute();
}
#pragma omp section
{
boundary.setInputCloud(pcl_cloud);
boundary.setView(view);
}
// #pragma omp section
// {
// surface::Relation rel;
// rel.valid = false;
// relations.clear();
// for(unsigned i=0; i<view->surfaces.size(); i++)
// for(unsigned j=0; j<view->surfaces.size(); j++)
// relations[i].push_back(rel);
// }
} // end parallel sections
std::vector< std::vector<surface::Relation> > relations(view->surfaces.size());
for ( int i = 0; i < relations.size(); ++ i )
relations[i].resize( view->surfaces.size() );
// surface::Relation relations[view->surfaces.size()][view->surfaces.size()];
surface::Relation rel;
rel.valid = false;
for(unsigned i=0; i<view->surfaces.size(); i++)
for(unsigned j=i+1; j<view->surfaces.size(); j++)
relations[i][j] = rel;
#pragma omp parallel for
for(int i=0; i<(int)view->surfaces.size(); i++) {
for(int j=0; j<(int)view->surfaces[i]->neighbors3D.size(); j++) {
bool valid_relation = true;
int p0 = i;
int p1 = view->surfaces[i]->neighbors3D[j];
if(p0 > p1)
continue;
double colorSimilarity = hist3D[p0].compare(hist3D[p1]);
double textureRate = texture.compare(p0, p1);
double relSize = std::min((double)view->surfaces[p0]->indices.size()/(double)view->surfaces[p1]->indices.size(),
(double)view->surfaces[p1]->indices.size()/(double)view->surfaces[p0]->indices.size());
std::vector<double> boundary_relations;
if(!boundary.compare(p0, p1, boundary_relations)) {
valid_relation = false;
printf("[StructuralRelationsLight::computeRelations] Warning: Boundary relation invalid.\n");
}
if(valid_relation) {
Relation r;
r.groundTruth = -1;
r.prediction = -1;
r.type = 1; // structural level = 1
r.id_0 = p0;
r.id_1 = p1;
r.rel_value.push_back(colorSimilarity); // r_co ... color similarity (histogram) of the patch
r.rel_value.push_back(textureRate); // r_tr ... difference of texture rate
r.rel_value.push_back(relSize); // r_rs ... relative patch size difference
r.rel_value.push_back(boundary_relations[0]); // r_co3 ... color similarity on 3D border
r.rel_value.push_back(boundary_relations[4]); // r_cu3 ... mean curvature of 3D neighboring points
r.rel_value.push_back(boundary_relations[1]); // r_di2 ... depth mean value between border points (2D)
r.rel_value.push_back(boundary_relations[2]); // r_vd2 ... depth variance value
r.rel_value.push_back(boundary_relations[5]); // r_cu3 ... curvature variance of 3D neighboring points
r.rel_value.push_back(boundary_relations[6]); // r_3d2 ... relation 3D neighbors / 2D neighbors
r.valid = true;
relations[p0][p1] = r;
}
}
}
// copy relations to view
for(unsigned i=0; i<view->surfaces.size(); i++)
for(unsigned j=i+1; j<view->surfaces.size(); j++) {
if(relations[i][j].valid) {
view->relations.push_back(relations[i][j]);
#ifdef DEBUG
printf("r_st_l: [%u][%u]: ", relations[i][j].id_0, relations[i][j].id_1);
for(unsigned ridx=0; ridx<relations[i][j].rel_value.size(); ridx++)
printf("%4.3f ", relations[i][j].rel_value[ridx]);
printf("\n");
#endif
}
}
}
