Merge pull request #1085 from tinohager/master

Alexey

2018-06-24 24c889d85705643ca4860dea88827a7f1893b731

 src/http_stream.cpp

@@ -37,15 +37,23 @@
#define SOCKET_ERROR   -1
#endif /* _WIN32 */

#include <cstdio>
#include <vector>
#include <iostream>
using std::cerr;
using std::endl;

#include "opencv2/opencv.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/highgui/highgui_c.h"
#include "opencv2/imgproc/imgproc_c.h"
#ifndef CV_VERSION_EPOCH
#include "opencv2/videoio/videoio.hpp"
#endif
using namespace cv;

#include "http_stream.h"
#include "image.h"


class MJPGWriter
@@ -56,7 +64,7 @@
   int timeout; // master sock timeout, shutdown after timeout millis.
   int quality; // jpeg compression [1..100]

   int _write(int sock, char *s, int len)
   int _write(int sock, char const*const s, int len)
   {
      if (len < 1) { len = strlen(s); }
      return ::send(sock, s, len, 0);
@@ -128,7 +136,7 @@
      params.push_back(IMWRITE_JPEG_QUALITY);
      params.push_back(quality);
      cv::imencode(".jpg", frame, outbuf, params);
      unsigned int outlen = outbuf.size();
      size_t outlen = outbuf.size();

#ifdef _WIN32 
      for (unsigned i = 0; i<rread.fd_count; i++)
@@ -169,7 +177,7 @@
         else // existing client, just stream pix
         {
            char head[400];
            sprintf(head, "--mjpegstream\r\nContent-Type: image/jpeg\r\nContent-Length: %lu\r\n\r\n", outlen);
            sprintf(head, "--mjpegstream\r\nContent-Type: image/jpeg\r\nContent-Length: %zu\r\n\r\n", outlen);
            _write(s, head, 0);
            int n = _write(s, (char*)(&outbuf[0]), outlen);
            //cerr << "known client " << s << " " << n << endl;
@@ -184,8 +192,7 @@
      return true;
   }
};


// ----------------------------------------

void send_mjpeg(IplImage* ipl, int port, int timeout, int quality) {
   static MJPGWriter wri(port, timeout, quality);
@@ -193,5 +200,132 @@
   wri.write(mat);
   std::cout << " MJPEG-stream sent. \n";
}
// ----------------------------------------

#endif   // OPENCV
CvCapture* get_capture_video_stream(char *path) {
   CvCapture* cap = NULL;
   try {
      cap = (CvCapture*)new cv::VideoCapture(path);
   }
   catch (...) {
      std::cout << " Error: video-stream " << path << " can't be opened! \n";
   }
   return cap;
}
// ----------------------------------------

CvCapture* get_capture_webcam(int index) {
   CvCapture* cap = NULL;
   try {
      cap = (CvCapture*)new cv::VideoCapture(index);
      //((cv::VideoCapture*)cap)->set(CV_CAP_PROP_FRAME_WIDTH, 1280);
      //((cv::VideoCapture*)cap)->set(CV_CAP_PROP_FRAME_HEIGHT, 960);
   }
   catch (...) {
      std::cout << " Error: Web-camera " << index << " can't be opened! \n";
   }
   return cap;
}
// ----------------------------------------

IplImage* get_webcam_frame(CvCapture *cap) {
   IplImage* src = NULL;
   try {
      cv::VideoCapture &cpp_cap = *(cv::VideoCapture *)cap;
      cv::Mat frame;
      if (cpp_cap.isOpened()) 
      {
         cpp_cap >> frame;
         IplImage tmp = frame;
         src = cvCloneImage(&tmp);
      }
      else {
         std::cout << " Video-stream stoped! \n";
      }
   }
   catch (...) {
      std::cout << " Video-stream stoped! \n";
   }
   return src;
}

int get_stream_fps_cpp(CvCapture *cap) {
   int fps = 25;
   try {
      cv::VideoCapture &cpp_cap = *(cv::VideoCapture *)cap;
#ifndef CV_VERSION_EPOCH   // OpenCV 3.x
      fps = cpp_cap.get(CAP_PROP_FPS);
#else                // OpenCV 2.x
      fps = cpp_cap.get(CV_CAP_PROP_FPS);
#endif		
   }
   catch (...) {
      std::cout << " Can't get FPS of source videofile. For output video FPS = 25 by default. \n";
   }
   return fps;
}
// ----------------------------------------
extern "C" {
   image ipl_to_image(IplImage* src);  // image.c
}

image image_data_augmentation(IplImage* ipl, int w, int h,
   int pleft, int ptop, int swidth, int sheight, int flip,
   float jitter, float dhue, float dsat, float dexp)
{
   cv::Mat img = cv::cvarrToMat(ipl);

   // crop
   cv::Rect src_rect(pleft, ptop, swidth, sheight);
   cv::Rect img_rect(cv::Point2i(0, 0), img.size());
   cv::Rect new_src_rect = src_rect & img_rect;

   cv::Rect dst_rect(cv::Point2i(std::max(0, -pleft), std::max(0, -ptop)), new_src_rect.size());

   cv::Mat cropped(cv::Size(src_rect.width, src_rect.height), img.type());
   cropped.setTo(cv::Scalar::all(0));

   img(new_src_rect).copyTo(cropped(dst_rect));

   // resize
   cv::Mat sized;
   cv::resize(cropped, sized, cv::Size(w, h), 0, 0, INTER_LINEAR);

   // flip
   if (flip) {
      cv::flip(sized, cropped, 1);  // 0 - x-axis, 1 - y-axis, -1 - both axes (x & y)
      sized = cropped.clone();
   }

   // HSV augmentation
   // CV_BGR2HSV, CV_RGB2HSV, CV_HSV2BGR, CV_HSV2RGB
   if (ipl->nChannels >= 3)
   {
      cv::Mat hsv_src;
      cvtColor(sized, hsv_src, CV_BGR2HSV);  // also BGR -> RGB
	
      std::vector<cv::Mat> hsv;
      cv::split(hsv_src, hsv);

      hsv[1] *= dsat;
      hsv[2] *= dexp;
      hsv[0] += 179 * dhue;

      cv::merge(hsv, hsv_src);

      cvtColor(hsv_src, sized, CV_HSV2RGB);  // now RGB instead of BGR
   }
   else
   {
      sized *= dexp;
   }

   // Mat -> IplImage -> image
   IplImage src = sized;
   image out = ipl_to_image(&src);

   return out;
}


#endif   // OPENCV