Added examples from Chapter 4

Author: adrian-kaehler

CMakeLists.txt

@@ -18,6 +18,10 @@ add_executable( example_02-08 example_02-08.cpp )
 add_executable( example_02-09 example_02-09.cpp )
 add_executable( example_02-10 example_02-10.cpp )
 add_executable( example_02-11 example_02-11.cpp )
+add_executable( example_04-01 example_04-01.cpp )
+add_executable( example_04-02 example_04-02.cpp )
+add_executable( example_04-03 example_04-03.cpp )
+add_executable( example_04-04 example_04-04.cpp )
 add_executable( example_16-01 example_16-01.cpp )
 
 target_link_libraries( example_02-01 ${OpenCV_LIBS} )
@@ -31,6 +35,10 @@ target_link_libraries( example_02-08 ${OpenCV_LIBS} )
 target_link_libraries( example_02-09 ${OpenCV_LIBS} )
 target_link_libraries( example_02-10 ${OpenCV_LIBS} )
 target_link_libraries( example_02-11 ${OpenCV_LIBS} )
+target_link_libraries( example_04-01 ${OpenCV_LIBS} )
+target_link_libraries( example_04-02 ${OpenCV_LIBS} )
+target_link_libraries( example_04-03 ${OpenCV_LIBS} )
+target_link_libraries( example_04-04 ${OpenCV_LIBS} )
 target_link_libraries( example_16-01 ${OpenCV_LIBS} )
 
 

example_04-01.cpp

@@ -0,0 +1,33 @@
+#include <opencv2/opencv.hpp>
+#include <iostream>
+
+using namespace std;
+
+// Summation of a multidimensional array, done plane by plane
+//
+int main( int argc, char** argv ) {
+
+  const int n_mat_size = 5;
+  const int n_mat_sz[] = { n_mat_size, n_mat_size, n_mat_size };
+  cv::Mat n_mat( 3, n_mat_sz, CV_32FC1 );
+
+  cv::RNG rng;
+  rng.fill( n_mat, cv::RNG::UNIFORM, 0.f, 1.f );
+
+  const cv::Mat* arrays[] = { &n_mat, 0 };
+  cv::Mat my_planes[1];
+  cv::NAryMatIterator it( arrays, my_planes );
+
+  // On each iteration, it.planes[i] will be the current plane of the
+  // i-th array from 'arrays'.
+  //
+  float s = 0.f; // Total sum over all planes
+  int   n = 0;   // Total number of planes
+  for (int p = 0; p < it.nplanes; p++, ++it) {
+    s += cv::sum(it.planes[0])[0];
+    n++;
+  }
+
+  cout <<"Total across entire volume: " <<s <<endl;
+
+}

example_04-02.cpp

@@ -0,0 +1,34 @@
+#include <opencv2/opencv.hpp>
+#include <iostream>
+
+using namespace std;
+
+// Summation of a multidimensional array, done plane by plane
+//
+int main( int argc, char** argv ) {
+
+  const int n_mat_size = 5;
+  const int n_mat_sz[] = { n_mat_size, n_mat_size, n_mat_size };
+
+  cv::Mat n_mat0( 3, n_mat_sz, CV_32FC1 );
+  cv::Mat n_mat1( 3, n_mat_sz, CV_32FC1 );
+
+  cv::RNG rng;
+  rng.fill( n_mat0, cv::RNG::UNIFORM, 0.f, 1.f );
+  rng.fill( n_mat1, cv::RNG::UNIFORM, 0.f, 1.f );
+
+  const cv::Mat* arrays[] = { &n_mat0, &n_mat1, 0 };
+
+  cv::Mat my_planes[2];
+  cv::NAryMatIterator it( arrays, my_planes );
+
+  float s = 0.f; // Total sum over all planes in both arrays
+  int   n = 0;   // Total number of planes
+  for( int p = 0; p < it.nplanes; p++, ++it ) {
+    s += cv::sum(it.planes[0])[0];
+    s += cv::sum(it.planes[1])[0];
+    n++;
+  }
+
+  cout <<"Total across both volumes: " <<s <<endl;
+}

example_04-03.cpp

@@ -0,0 +1,33 @@
+#include <opencv2/opencv.hpp>
+#include <iostream>
+
+// Printing all of the nonzero elements of a sparse array
+//
+using namespace std;
+
+// Summation of a multidimensional array, done plane by plane
+//
+int main( int argc, char** argv ) {
+
+  // Create a 10x10 sparse matrix with a few nonzero elements
+  //
+  int size[] = {10,10};
+  cv::SparseMat sm( 2, size, CV_32F );
+  for( int i=0; i<10; i++ ) { // Fill the array
+    int idx[2];
+    idx[0] = size[0] * rand();
+    idx[1] = size[1] * rand();
+    sm.ref<float>( idx ) += 1.0f;
+  }
+
+  // Print out the nonzero elements
+  //
+  cv::SparseMatConstIterator_<float> it = sm.begin<float>();
+  cv::SparseMatConstIterator_<float> it_end = sm.end<float>();
+
+  for(; it != it_end; ++it) {
+    const cv::SparseMat::Node* node = it.node();
+    printf(" (%3d,%3d) %f\n", node->idx[0], node->idx[1], *it );
+  }
+
+}

example_04-04.cpp

@@ -0,0 +1,69 @@
+#include <opencv2/opencv.hpp>
+#include <iostream>
+
+using namespace std;
+
+// A better way to print a sparse matrix
+//
+template <class T> void print_matrix( const cv::SparseMat_<T>* sm ) {
+  cv::SparseMatConstIterator_<T> it = sm->begin();
+  cv::SparseMatConstIterator_<T> it_end = sm->end();
+
+  for(; it != it_end; ++it) {
+    const typename cv::SparseMat_<T>::Node* node = it.node();
+    cout <<"( " <<node->idx[0] <<", " <<node->idx[1]
+         <<" ) = " <<*it <<endl;
+  }
+}
+
+void calling_function1( void ) {
+
+  int ndim = 2;
+  int size[] = {4,4};
+
+  cv::SparseMat_<float> sm( ndim, size );
+
+  // Create a sparse matrix with a few nonzero elements
+  //
+  for( int i=0; i<4; i++ ) { // Fill the array
+    int idx[2];
+    idx[0] = size[0] * rand();
+    idx[1] = size[1] * rand();
+    sm.ref( idx ) += 1.0f;
+  }
+
+  print_matrix<float>( &sm );
+}
+
+void calling_function2( void ) {
+
+  int ndim = 2;
+  int size[] = {4,4};
+
+  cv::SparseMat sm( ndim, size, CV_32F );
+
+  // Create a sparse matrix with a few nonzero elements
+  //
+  for( int i=0; i<4; i++ ) { // Fill the array
+    int idx[2];
+    idx[0] = size[0] * rand();
+    idx[1] = size[1] * rand();
+    sm.ref<float>( idx ) += 1.0f;
+  }
+
+  print_matrix<float>( (cv::SparseMat_<float>*) &sm );
+
+}
+
+int main( int argc, char** argv ) {
+
+  cout <<"Case 1:" <<endl;
+  calling_function1();
+  cout <<endl;
+
+  cout <<"Case 2:" <<endl;
+  calling_function2();
+  cout <<endl;
+
+}
+