Merge branch 4.x

samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp

@@ -27,12 +27,12 @@ Mat dst;
  * @function on_trackbar
  * @brief Callback for trackbar
  */
-static void on_trackbar( int, void* )
-{
-   alpha = (double) alpha_slider/alpha_slider_max ;
-   beta = ( 1.0 - alpha );
-   addWeighted( src1, alpha, src2, beta, 0.0, dst);
-   imshow( "Linear Blend", dst );
+static void on_trackbar(int pos, void* userdata) {
+    (void) userdata;
+    alpha = (double)pos / alpha_slider_max;
+    beta = (1.0 - alpha);
+    addWeighted(src1, alpha, src2, beta, 0.0, dst);
+    imshow("Linear Blend", dst);
 }
 //![on_trackbar]
 
@@ -40,34 +40,35 @@ static void on_trackbar( int, void* )
  * @function main
  * @brief Main function
  */
-int main( void )
+int main(void)
 {
-   //![load]
-   /// Read images ( both have to be of the same size and type )
-   src1 = imread( samples::findFile("LinuxLogo.jpg") );
-   src2 = imread( samples::findFile("WindowsLogo.jpg") );
-   //![load]
+    //![load]
+    /// Read images (both must be of the same size and type)
+    src1 = imread(samples::findFile("LinuxLogo.jpg"));
+    src2 = imread(samples::findFile("WindowsLogo.jpg"));
+    //![load]
 
-   if( src1.empty() ) { cout << "Error loading src1 \n"; return -1; }
-   if( src2.empty() ) { cout << "Error loading src2 \n"; return -1; }
+    if (src1.empty()) { cout << "Error loading src1 \n"; return -1; }
+    if (src2.empty()) { cout << "Error loading src2 \n"; return -1; }
 
-   /// Initialize values
-   alpha_slider = 0;
+    // Initialize trackbar value
+    alpha_slider = 0;
 
-   //![window]
-   namedWindow("Linear Blend", WINDOW_AUTOSIZE); // Create Window
-   //![window]
+    //![window]
+    namedWindow("Linear Blend", WINDOW_AUTOSIZE); //Create Window
+    //![window]
 
-   //![create_trackbar]
-   char TrackbarName[50];
-   snprintf( TrackbarName, sizeof(TrackbarName), "Alpha x %d", alpha_slider_max );
-   createTrackbar( TrackbarName, "Linear Blend", &alpha_slider, alpha_slider_max, on_trackbar );
-   //![create_trackbar]
+    //![create_trackbar]
+    char TrackbarName[50];
+    snprintf(TrackbarName, sizeof(TrackbarName), "Alpha x %d", alpha_slider_max);
+    // Example userdata: Pass a pointer to an integer as userdata
+    createTrackbar(TrackbarName, "Linear Blend", &alpha_slider, alpha_slider_max, on_trackbar);
+    //![create_trackbar]
 
-   /// Show some stuff
-   on_trackbar( alpha_slider, 0 );
+    /// Show initial result
+    on_trackbar(alpha_slider, nullptr);
 
-   /// Wait until user press some key
-   waitKey(0);
-   return 0;
+    /// Wait for user input
+    waitKey(0);
+    return 0;
 }

samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp

@@ -15,22 +15,27 @@ using namespace std;
 /// Global variables
 
 /** General variables */
-Mat src, edges;
+Mat src, canny_edge, sobel_edge;
 Mat src_gray;
-Mat standard_hough, probabilistic_hough;
+Mat standard_hough, probabilistic_hough, weighted_hough;
 int min_threshold = 50;
 int max_trackbar = 150;
+int weightedhough_max_trackbar = 100000;
 
 const char* standard_name = "Standard Hough Lines Demo";
 const char* probabilistic_name = "Probabilistic Hough Lines Demo";
+const char* weighted_name = "Weighted Hough Lines Demo";
 
 int s_trackbar = max_trackbar;
 int p_trackbar = max_trackbar;
+int e_trackbar = 60;
+int w_trackbar = 60000;
 
 /// Function Headers
 void help();
 void Standard_Hough( int, void* );
 void Probabilistic_Hough( int, void* );
+void Weighted_Hough( int, void* );
 
 /**
  * @function main
@@ -53,22 +58,29 @@ int main( int argc, char** argv )
    /// Pass the image to gray
    cvtColor( src, src_gray, COLOR_RGB2GRAY );
 
-   /// Apply Canny edge detector
-   Canny( src_gray, edges, 50, 200, 3 );
+   /// Apply Canny/Sobel edge detector
+   Canny( src_gray, canny_edge, 50, 200, 3 );
+   Sobel( src_gray, sobel_edge, CV_16S, 1, 0 ); // dx(order of the derivative x)=1,dy=0
 
    /// Create Trackbars for Thresholds
    char thresh_label[50];
    snprintf( thresh_label, sizeof(thresh_label), "Thres: %d + input", min_threshold );
-
    namedWindow( standard_name, WINDOW_AUTOSIZE );
-   createTrackbar( thresh_label, standard_name, &s_trackbar, max_trackbar, Standard_Hough);
+   createTrackbar( thresh_label, standard_name, &s_trackbar, max_trackbar, Standard_Hough );
 
    namedWindow( probabilistic_name, WINDOW_AUTOSIZE );
-   createTrackbar( thresh_label, probabilistic_name, &p_trackbar, max_trackbar, Probabilistic_Hough);
+   createTrackbar( thresh_label, probabilistic_name, &p_trackbar, max_trackbar, Probabilistic_Hough );
+
+   char edge_thresh_label[50];
+   sprintf( edge_thresh_label, "Edge Thres: input" );
+   namedWindow( weighted_name, WINDOW_AUTOSIZE);
+   createTrackbar( edge_thresh_label, weighted_name, &e_trackbar, max_trackbar, Weighted_Hough);
+   createTrackbar( thresh_label, weighted_name, &w_trackbar, weightedhough_max_trackbar, Weighted_Hough);
 
    /// Initialize
    Standard_Hough(0, 0);
    Probabilistic_Hough(0, 0);
+   Weighted_Hough(0, 0);
    waitKey(0);
    return 0;
 }
@@ -90,10 +102,10 @@ void help()
 void Standard_Hough( int, void* )
 {
   vector<Vec2f> s_lines;
-  cvtColor( edges, standard_hough, COLOR_GRAY2BGR );
+  cvtColor( canny_edge, standard_hough, COLOR_GRAY2BGR );
 
   /// 1. Use Standard Hough Transform
-  HoughLines( edges, s_lines, 1, CV_PI/180, min_threshold + s_trackbar, 0, 0 );
+  HoughLines( canny_edge, s_lines, 1, CV_PI/180, min_threshold + s_trackbar, 0, 0 );
 
   /// Show the result
   for( size_t i = 0; i < s_lines.size(); i++ )
@@ -117,10 +129,10 @@ void Standard_Hough( int, void* )
 void Probabilistic_Hough( int, void* )
 {
   vector<Vec4i> p_lines;
-  cvtColor( edges, probabilistic_hough, COLOR_GRAY2BGR );
+  cvtColor( canny_edge, probabilistic_hough, COLOR_GRAY2BGR );
 
   /// 2. Use Probabilistic Hough Transform
-  HoughLinesP( edges, p_lines, 1, CV_PI/180, min_threshold + p_trackbar, 30, 10 );
+  HoughLinesP( canny_edge, p_lines, 1, CV_PI/180, min_threshold + p_trackbar, 30, 10 );
 
   /// Show the result
   for( size_t i = 0; i < p_lines.size(); i++ )
@@ -131,3 +143,38 @@ void Probabilistic_Hough( int, void* )
 
    imshow( probabilistic_name, probabilistic_hough );
 }
+
+/**
+ * @function Weighted_Hough
+ * This can detect lines based on the edge intensities.
+ */
+void Weighted_Hough( int, void* )
+{
+  vector<Vec2f> s_lines;
+
+  /// prepare
+  Mat edge_img;
+  convertScaleAbs(sobel_edge, edge_img );
+  // use same threshold for edge with Hough.
+  threshold( edge_img, edge_img, e_trackbar, 255, cv::THRESH_TOZERO);
+  cvtColor( edge_img, weighted_hough, COLOR_GRAY2BGR );
+
+  /// 3. Use Weighted Hough Transform
+  const bool use_edgeval{true};
+  HoughLines( edge_img, s_lines, 1, CV_PI/180, min_threshold + w_trackbar, 0, 0, 0, CV_PI, use_edgeval);
+
+  /// Show the result
+  for( size_t i = 0; i < s_lines.size(); i++ )
+     {
+      float r = s_lines[i][0], t = s_lines[i][1];
+      double cos_t = cos(t), sin_t = sin(t);
+      double x0 = r*cos_t, y0 = r*sin_t;
+      double alpha = 1000;
+
+       Point pt1( cvRound(x0 + alpha*(-sin_t)), cvRound(y0 + alpha*cos_t) );
+       Point pt2( cvRound(x0 - alpha*(-sin_t)), cvRound(y0 - alpha*cos_t) );
+       line( weighted_hough, pt1, pt2, Scalar(255,0,0), 3, LINE_AA );
+     }
+
+   imshow( weighted_name, weighted_hough );
+}

samples/cpp/tutorial_code/imgcodecs/animations.cpp

@@ -0,0 +1,51 @@
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+#include <iostream>
+
+using namespace cv;
+
+int main( int argc, const char** argv )
+{
+    std::string filename = argc > 1 ? argv[1] : "animated_image.webp";
+
+    //! [write_animation]
+    if (argc == 1)
+    {
+        Animation animation_to_save;
+        Mat image(128, 256, CV_8UC4, Scalar(150, 150, 150, 255));
+        int duration = 200;
+
+        for (int i = 0; i < 10; ++i) {
+            animation_to_save.frames.push_back(image.clone());
+            putText(animation_to_save.frames[i], format("Frame %d", i), Point(30, 80), FONT_HERSHEY_SIMPLEX, 1.5, Scalar(255, 100, 0, 255), 2);
+            animation_to_save.durations.push_back(duration);
+        }
+        imwriteanimation("animated_image.webp", animation_to_save, { IMWRITE_WEBP_QUALITY, 100 });
+    }
+    //! [write_animation]
+
+    //! [init_animation]
+    Animation animation;
+    //! [init_animation]
+
+    //! [read_animation]
+    bool success = imreadanimation(filename, animation);
+    if (!success) {
+        std::cerr << "Failed to load animation frames\n";
+        return -1;
+    }
+    //! [read_animation]
+
+    //! [show_animation]
+    while (true)
+    for (size_t i = 0; i < animation.frames.size(); ++i) {
+        imshow("Animation", animation.frames[i]);
+        int key_code = waitKey(animation.durations[i]); // Delay between frames
+        if (key_code == 27)
+            exit(0);
+    }
+    //! [show_animation]
+
+    return 0;
+}