int main() {
int numRows = 0; //Initializes variable
int numColumns = 0; //Initializes variable
printf("Please enter the number of rows: ");
scanf("%d", &numRows); //Asks the user to enter the number of rows and stores the value in variable numRows
printf("Please enter the number of columns: ");
scanf("%d", &numColumns); //Asks the user to enter the number of columns and stores the value in variable numColumns
sumAB(numRows, numColumns); //Calls function to calculate the sum of Matrix A and Matrix B
return 0;
}
template <typename PointInT, typename PointOutT, typename NormalT> void
pcl::TrajkovicKeypoint3D<PointInT, PointOutT, NormalT>::detectKeypoints (PointCloudOut &output)
{
response_.reset (new pcl::PointCloud<float> (input_->width, input_->height));
const Normals &normals = *normals_;
const PointCloudIn &input = *input_;
pcl::PointCloud<float>& response = *response_;
const int w = static_cast<int> (input_->width) - half_window_size_;
const int h = static_cast<int> (input_->height) - half_window_size_;
if (method_ == FOUR_CORNERS)
{
#ifdef _OPENMP
#pragma omp parallel for num_threads (threads_)
#endif
for(int j = half_window_size_; j < h; ++j)
{
for(int i = half_window_size_; i < w; ++i)
{
if (!isFinite (input (i,j))) continue;
const NormalT ¢er = normals (i,j);
if (!isFinite (center)) continue;
int count = 0;
const NormalT &up = getNormalOrNull (i, j-half_window_size_, count);
const NormalT &down = getNormalOrNull (i, j+half_window_size_, count);
const NormalT &left = getNormalOrNull (i-half_window_size_, j, count);
const NormalT &right = getNormalOrNull (i+half_window_size_, j, count);
// Get rid of isolated points
if (!count) continue;
float sn1 = squaredNormalsDiff (up, center);
float sn2 = squaredNormalsDiff (down, center);
float r1 = sn1 + sn2;
float r2 = squaredNormalsDiff (right, center) + squaredNormalsDiff (left, center);
float d = std::min (r1, r2);
if (d < first_threshold_) continue;
sn1 = sqrt (sn1);
sn2 = sqrt (sn2);
float b1 = normalsDiff (right, up) * sn1;
b1+= normalsDiff (left, down) * sn2;
float b2 = normalsDiff (right, down) * sn2;
b2+= normalsDiff (left, up) * sn1;
float B = std::min (b1, b2);
float A = r2 - r1 - 2*B;
response (i,j) = ((B < 0) && ((B + A) > 0)) ? r1 - ((B*B)/A) : d;
}
}
}
else
{
#ifdef _OPENMP
#pragma omp parallel for num_threads (threads_)
#endif
for(int j = half_window_size_; j < h; ++j)
{
for(int i = half_window_size_; i < w; ++i)
{
if (!isFinite (input (i,j))) continue;
const NormalT ¢er = normals (i,j);
if (!isFinite (center)) continue;
int count = 0;
const NormalT &up = getNormalOrNull (i, j-half_window_size_, count);
const NormalT &down = getNormalOrNull (i, j+half_window_size_, count);
const NormalT &left = getNormalOrNull (i-half_window_size_, j, count);
const NormalT &right = getNormalOrNull (i+half_window_size_, j, count);
const NormalT &upleft = getNormalOrNull (i-half_window_size_, j-half_window_size_, count);
const NormalT &upright = getNormalOrNull (i+half_window_size_, j-half_window_size_, count);
const NormalT &downleft = getNormalOrNull (i-half_window_size_, j+half_window_size_, count);
const NormalT &downright = getNormalOrNull (i+half_window_size_, j+half_window_size_, count);
// Get rid of isolated points
if (!count) continue;
std::vector<float> r (4,0);
r[0] = squaredNormalsDiff (up, center);
r[0]+= squaredNormalsDiff (down, center);
r[1] = squaredNormalsDiff (upright, center);
r[1]+= squaredNormalsDiff (downleft, center);
r[2] = squaredNormalsDiff (right, center);
r[2]+= squaredNormalsDiff (left, center);
r[3] = squaredNormalsDiff (downright, center);
r[3]+= squaredNormalsDiff (upleft, center);
float d = *(std::min_element (r.begin (), r.end ()));
if (d < first_threshold_) continue;
std::vector<float> B (4,0);
std::vector<float> A (4,0);
std::vector<float> sumAB (4,0);
B[0] = normalsDiff (upright, up) * normalsDiff (up, center);
B[0]+= normalsDiff (downleft, down) * normalsDiff (down, center);
B[1] = normalsDiff (right, upright) * normalsDiff (upright, center);
B[1]+= normalsDiff (left, downleft) * normalsDiff (downleft, center);
B[2] = normalsDiff (downright, right) * normalsDiff (downright, center);
B[2]+= normalsDiff (upleft, left) * normalsDiff (upleft, center);
B[3] = normalsDiff (down, downright) * normalsDiff (downright, center);
B[3]+= normalsDiff (up, upleft) * normalsDiff (upleft, center);
A[0] = r[1] - r[0] - B[0] - B[0];
A[1] = r[2] - r[1] - B[1] - B[1];
A[2] = r[3] - r[2] - B[2] - B[2];
A[3] = r[0] - r[3] - B[3] - B[3];
sumAB[0] = A[0] + B[0];
sumAB[1] = A[1] + B[1];
sumAB[2] = A[2] + B[2];
sumAB[3] = A[3] + B[3];
if ((*std::max_element (B.begin (), B.end ()) < 0) &&
(*std::min_element (sumAB.begin (), sumAB.end ()) > 0))
{
std::vector<float> D (4,0);
D[0] = B[0] * B[0] / A[0];
D[1] = B[1] * B[1] / A[1];
D[2] = B[2] * B[2] / A[2];
D[3] = B[3] * B[3] / A[3];
response (i,j) = *(std::min (D.begin (), D.end ()));
}
else
response (i,j) = d;
}
}
}
// Non maximas suppression
std::vector<int> indices = *indices_;
std::sort (indices.begin (), indices.end (),
boost::bind (&TrajkovicKeypoint3D::greaterCornernessAtIndices, this, _1, _2));
output.clear ();
output.reserve (input_->size ());
std::vector<bool> occupency_map (indices.size (), false);
const int width (input_->width);
const int height (input_->height);
const int occupency_map_size (indices.size ());
#ifdef _OPENMP
#pragma omp parallel for shared (output) num_threads (threads_)
#endif
for (int i = 0; i < indices.size (); ++i)
{
int idx = indices[i];
if ((response_->points[idx] < second_threshold_) || occupency_map[idx])
continue;
PointOutT p;
p.getVector3fMap () = input_->points[idx].getVector3fMap ();
p.intensity = response_->points [idx];
#ifdef _OPENMP
#pragma omp critical
#endif
{
output.push_back (p);
keypoints_indices_->indices.push_back (idx);
}
const int x = idx % width;
const int y = idx / width;
const int u_end = std::min (width, x + half_window_size_);
const int v_end = std::min (height, y + half_window_size_);
for(int v = std::max (0, y - half_window_size_); v < v_end; ++v)
for(int u = std::max (0, x - half_window_size_); u < u_end; ++u)
occupency_map[v*width + u] = true;
}
output.height = 1;
output.width = static_cast<uint32_t> (output.size());
// we don not change the denseness
output.is_dense = true;
}
/// R-MAT Generator. The modes is based on the recursive descent into a 2x2
/// matrix [A,B; C, 1-(A+B+C)].
/// See: R-MAT Generator: A Recursive Model for Graph Mining.
/// D. Chakrabarti, Y. Zhan and C. Faloutsos, in SIAM Data Mining 2004.
/// URL: http://www.cs.cmu.edu/~deepay/mywww/papers/siam04.pdf
PNGraph GenRMat(const int& Nodes, const int& Edges, const double& A, const double& B, const double& C, TRnd& Rnd) {
PNGraph GraphPt = TNGraph::New();
TNGraph& Graph = *GraphPt;
Graph.Reserve(Nodes, Edges);
IAssert(A+B+C < 1.0);
int rngX, rngY, offX, offY;
int Depth=0, Collisions=0, Cnt=0, PctDone=0;
const int EdgeGap = Edges / 100 + 1;
// sum of parameters (probabilities)
TVec<double> sumA(128, 0), sumAB(128, 0), sumAC(128, 0), sumABC(128, 0); // up to 2^128 vertices ~ 3.4e38
for (int i = 0; i < 128; i++) {
const double a = A * (Rnd.GetUniDev() + 0.5);
const double b = B * (Rnd.GetUniDev() + 0.5);
const double c = C * (Rnd.GetUniDev() + 0.5);
const double d = (1.0 - (A+B+C)) * (Rnd.GetUniDev() + 0.5);
const double abcd = a+b+c+d;
sumA.Add(a / abcd);
sumAB.Add((a+b) / abcd);
sumAC.Add((a+c) / abcd);
sumABC.Add((a+b+c) / abcd);
}
// nodes
for (int node = 0; node < Nodes; node++) {
IAssert(Graph.AddNode(-1) == node);
}
// edges
for (int edge = 0; edge < Edges; ) {
rngX = Nodes; rngY = Nodes; offX = 0; offY = 0;
Depth = 0;
// recurse the matrix
while (rngX > 1 || rngY > 1) {
const double RndProb = Rnd.GetUniDev();
if (rngX>1 && rngY>1) {
if (RndProb < sumA[Depth]) { rngX/=2; rngY/=2; }
else if (RndProb < sumAB[Depth]) { offX+=rngX/2; rngX-=rngX/2; rngY/=2; }
else if (RndProb < sumABC[Depth]) { offY+=rngY/2; rngX/=2; rngY-=rngY/2; }
else { offX+=rngX/2; offY+=rngY/2; rngX-=rngX/2; rngY-=rngY/2; }
} else
if (rngX>1) { // row vector
if (RndProb < sumAC[Depth]) { rngX/=2; rngY/=2; }
else { offX+=rngX/2; rngX-=rngX/2; rngY/=2; }
} else
if (rngY>1) { // column vector
if (RndProb < sumAB[Depth]) { rngX/=2; rngY/=2; }
else { offY+=rngY/2; rngX/=2; rngY-=rngY/2; }
} else { Fail; }
Depth++;
}
// add edge
const int NId1 = offX;
const int NId2 = offY;
if (NId1 != NId2 && ! Graph.IsEdge(NId1, NId2)) {
Graph.AddEdge(NId1, NId2);
if (++Cnt > EdgeGap) {
Cnt=0; printf("\r %d%% edges", ++PctDone); }
edge++;
} else {
Collisions++; }
}
printf("\r RMat: nodes:%d, edges:%d, Iterations:%d, Collisions:%d (%.1f%%).\n", Nodes, Edges,
Edges+Collisions, Collisions, 100*Collisions/double(Edges+Collisions));
Graph.Defrag();
return GraphPt;
}
