add code from c9

Signed-off-by: jsxyhelu <jsxyhelu@foxmail.com>

Author: jsxyhelu

example_09-01.cpp

@@ -0,0 +1,24 @@
+#include <opencv2/opencv.hpp>
+
+using namespace std;
+
+int main( int argc, char** argv ) {
+  // Create a named window with the name of the file
+  //
+  cv::namedWindow( argv[1], 1 );
+  // Load the image from the given filename
+  //
+  cv::Mat = cv::imread( argv[1] );
+  // Show the image in the named window
+  //
+  cv::imshow( argv[1], img );
+  // Idle until the user hits the Esc key
+  //
+  while( true ) {
+    if( cv::waitKey( 100 /* milliseconds */ ) == 27 ) break;
+  }
+  // Clean up and don't be piggies
+  //
+  cv::destroyWindow( argv[1] );
+  exit(0);
+}

example_09-02.cpp

@@ -0,0 +1,94 @@
+#include <opencv2/opencv.hpp>
+// Define our callback which we will install for
+// mouse events
+//
+void my_mouse_callback(
+   int event, int x, int y, int flags, void* param
+);
+Rect box;
+bool drawing_box = false;
+// A little subroutine to draw a box onto an image
+//
+void draw_box( cv::Mat& img, cv::Rect box ) {
+  cv::rectangle(
+    img,
+    box.tl(),
+    box.br(),
+    cv::Scalar(0x00,0x00,0xff)    /* red */
+  );
+}
+void help() {
+  std::cout << "Call: ./ch4_ex4_1\n" <<
+    " shows how to use a mouse to draw regions in an image." << std::endl;
+}
+int main( int argc, char** argv ) {
+  help();
+  box = cv::Rect(-1,-1,0,0);
+  cv::Mat image(200, 200, CV_8UC3), temp;
+  image.copyTo(temp);
+  box   = cv::Rect(-1,-1,0,0);
+  image = cv::Scalar::all(0);
+  cv::namedWindow( "Box Example" );
+ // Here is the crucial moment where we actually install
+  // the callback. Note that we set the value of 'params' to
+  // be the image we are working with so that the callback
+  // will have the image to edit.
+  //
+  cv::setMouseCallback(
+    "Box Example",
+    my_mouse_callback,
+    (void*)&image
+  );
+  // The main program loop. Here we copy the working image
+  // to the temp image, and if the user is drawing, then
+  // put the currently contemplated box onto that temp image.
+  // Display the temp image, and wait 15ms for a keystroke,
+  // then repeat.
+  //
+  for(;;) {
+    image.copyTo(temp);
+    if( drawing_box ) draw_box( temp, box );
+    cv::imshow( "Box Example", temp );
+    if( cv::waitKey( 15 ) == 27 ) break;
+  }
+  return 0;
+}
+// This is our mouse callback. If the user
+// presses the left button, we start a box.
+// When the user releases that button, then we
+// add the box to the current image. When the
+// mouse is dragged (with the button down) we
+// resize the box.
+//
+void my_mouse_callback(
+   int event, int x, int y, int flags, void* param) 
+{
+  cv::Mat& image = *(cv::Mat*) param;
+  switch( event ) {
+    case cv::EVENT_MOUSEMOVE: {
+      if( drawing_box ) {
+        box.width  = x-box.x;
+        box.height = y-box.y;
+      }
+    }
+    break;
+ case cv::EVENT_LBUTTONDOWN: {
+      drawing_box = true;
+      box = cv::Rect( x, y, 0, 0 );
+    }
+    break;
+    case cv::EVENT_LBUTTONUP: {
+      drawing_box = false;
+      if( box.width < 0  ) {
+        box.x += box.width;
+        box.width *= -1;
+      }
+      if( box.height < 0 ) {
+        box.y += box.height;
+        box.height *= -1;
+      }
+      draw_box( image, box );
+    }
+    break;
+  }
+}

example_09-03.cpp

@@ -0,0 +1,59 @@
+// An example program in which the user can draw boxes on the screen.
+//
+#include <opencv2/opencv.hpp>
+#include <iostream>
+using namespace std;
+//
+// Using a trackbar to create a "switch" that the user can turn on and off.
+// We make this value global so everyone can see it.
+//
+int g_switch_value = 1;
+void switch_off_function() { cout << "Pause\n"; }; //YOU COULD DO MORE
+void switch_on_function()  { cout << "Run\n"; };
+// This will be the callback that we give to the trackbar.
+//
+void switch_callback( int position, void* ) {
+  if( position == 0 ) {
+    switch_off_function();
+  } else {
+    switch_on_function();
+  }
+}
+void help() {
+    cout << "Call: my.avi" << endl;
+    cout << "Shows putting a pause button in a video." << endl;
+}
+int main( int argc, char** argv ) {
+  cv::Mat frame; // To hold movie images
+  cv::VideoCapture g_capture;
+  help();
+  if( argc < 2 || !g_capture.open( argv[1] ) ){
+    cout << "Failed to open " << argv[1] << " video file\n" << endl;
+    return -1;
+  }
+  // Name the main window
+  //
+  cv::namedWindow( "Example", 1 );
+  // Create the trackbar. We give it a name,
+  // and tell it the name of the parent window.
+  //
+  cv::createTrackbar(
+    "Switch",
+    "Example",
+    &g_switch_value,
+    1,
+    switch_callback
+  );
+  // This will cause OpenCV to idle until
+  // someone hits the Esc key.
+  //
+  for(;;) {
+    if( g_switch_value ) {
+          g_capture >> frame;
+          if( frame.empty() ) break;
+          cv::imshow( "Example", frame);
+      }
+      if( cv::waitKey(10)==27 ) break;
+  }
+  return 0;
+}

example_09-04.cpp

@@ -0,0 +1,31 @@
+#include <opencv2/opencv.hpp>
+using namespace std;
+
+void on_opengl( void* param ) {
+  glMatrixModel( GL_MODELVIEW );
+  glLoadIdentity();
+  glTranslated( 0.0, 0.0, -1.0 );
+  glRotatef( rotx, 1, 0, 0 );
+  glRotatef( roty, 0, 1, 0 );
+  glRotatef( 0, 0, 0, 1 );
+  static const int coords[6][4][3] = {
+    { { +1, -1, -1 }, { -1, -1, -1 }, { -1, +1, -1 }, { +1, +1, -1 } },
+    { { +1, +1, -1 }, { -1, +1, -1 }, { -1, +1, +1 }, { +1, +1, +1 } },
+    { { +1, -1, +1 }, { +1, -1, -1 }, { +1, +1, -1 }, { +1, +1, +1 } },
+    { { -1, -1, -1 }, { -1, -1, +1 }, { -1, +1, +1 }, { -1, +1, -1 } },
+    { { +1, -1, +1 }, { -1, -1, +1 }, { -1, -1, -1 }, { +1, -1, -1 } },
+    { { -1, -1, +1 }, { +1, -1, +1 }, { +1, +1, +1 }, { -1, +1, +1 } }
+  };
+  for (int i = 0; i < 6; ++i) {
+    glColor3ub( i*20, 100+i*10, i*42 );
+    glBegin(GL_QUADS);
+    for (int j = 0; j < 4; ++j) {
+      glVertex3d(
+        0.2 * coords[i][j][0],
+        0.2 * coords[i][j][1],
+        0.2 * coords[i][j][2]
+      );
+    }
+    glEnd();
+  }
+}

example_09-05.cpp

@@ -0,0 +1,10 @@
+#include <QApplication>
+#include <QLabel>
+#include <QMoviePlayer.hpp>
+int main( int argc, char* argv[] ) {
+  QApplication app( argc, argv );
+  QMoviePlayer mp;
+  mp.open( argv[1] );
+  mp.show();
+  return app.exec();
+}

example_09-06.cpp

@@ -0,0 +1,21 @@
+#include "ui_QMoviePlayer.h"
+#include <opencv2/opencv.hpp>
+#include <string>
+using namespace std;
+class QMoviePlayer : public QWidget {
+  Q_OBJECT;
+  public:
+  QMoviePlayer( QWidget *parent = NULL );
+  virtual ~QMoviePlayer() {;}
+  bool open( string file );
+  private:
+  Ui::QMoviePlayer  ui;
+  cv::VideoCapture m_cap;
+  QImage  m_qt_img;
+  cv::Mat m_cv_img;
+  QTimer* m_timer;
+  void paintEvent( QPaintEvent* q );
+  void _copyImage( void );
+  public slots:
+  void nextFrame();
+};

example_09-07.cpp

@@ -0,0 +1,8 @@
+#include "QMoviePlayer.hpp"
+#include <QTimer>
+#include <QPainter>
+QMoviePlayer::QMoviePlayer( QWidget *parent )
+ : QWidget( parent )
+{
+  ui.setupUi( this );
+}

example_09-08.cpp

@@ -0,0 +1,26 @@
+#include "wx/wx.h"
+#include "WxMoviePlayer.hpp"
+// Application class, the top level object in wxWidgets
+//
+class MyApp : public wxApp {
+  public:
+    virtual bool OnInit();
+};
+// Behind the scenes stuff to create a main() function and attach MyApp
+//
+DECLARE_APP( MyApp );
+IMPLEMENT_APP( MyApp );
+// When MyApp is initialized, do these things.
+//
+bool MyApp::OnInit() {
+  wxFrame* frame = new wxFrame( NULL, wxID_ANY, wxT("ch4_wx") );
+  frame->Show( true );
+  WxMoviePlayer* mp = new WxMoviePlayer(
+    frame,
+    wxPoint( -1, -1 ),
+    wxSize( 640, 480 )
+  );
+  mp->open( wxString(argv[1]) );
+  mp->Show( true );
+  return true;
+}

example_09-09.cpp

@@ -0,0 +1,28 @@
+#include "opencv2/opencv.hpp"
+#include "wx/wx.h"
+#include <string>
+#define TIMER_ID 0
+using namespace std;
+class WxMoviePlayer : public wxWindow {
+  public:
+    WxMoviePlayer(
+      wxWindow*      parent,
+      const wxPoint& pos,
+      const wxSize&  size
+    );
+    virtual ~WxMoviePlayer() {};
+    bool open( wxString file );
+  private:
+    cv::VideoCapture m_cap;
+    cv::Mat          m_cv_img;
+    wxImage          m_wx_img;
+    wxBitmap         m_wx_bmp;
+    wxTimer*         m_timer;
+    wxWindow*        m_parent;
+    void _copyImage( void );
+ void OnPaint( wxPaintEvent& e );
+    void OnTimer( wxTimerEvent& e );
+    void OnKey(   wxKeyEvent&   e );
+  protected:
+    DECLARE_EVENT_TABLE();
+};

example_09-10.cpp

@@ -0,0 +1,16 @@
+#include "WxMoviePlayer.hpp"
+BEGIN_EVENT_TABLE( WxMoviePlayer, wxWindow )
+  EVT_PAINT( WxMoviePlayer::OnPaint )
+  EVT_TIMER( TIMER_ID, WxMoviePlayer::OnTimer )
+  EVT_CHAR( WxMoviePlayer::OnKey )
+END_EVENT_TABLE()
+The first thing we do is to set up the callbacks that will be associated with individual
+events. We do this through macros provided by the wxWidgets framework.17
+WxMoviePlayer::WxMoviePlayer(
+  wxWindow*      parent,
+  const wxPoint& pos,
+  const wxSize&  size
+) : wxWindow( parent, -1, pos, size, wxSIMPLE_BORDER ) {
+  m_timer         = NULL;
+  m_parent        = parent;
+}