~speedprog/mtg/mtg_card_detector.git

			@@ -7,7 +7,7 @@
			//
			// socket related abstractions:
			//
			#ifdef _WIN32
			#ifdef _WIN32
			#pragma comment(lib, "ws2_32.lib")
			#include <winsock.h>
			#include <windows.h>
			@@ -16,8 +16,8 @@
			#define ADDRPOINTER int*
			struct _INIT_W32DATA
			{
			WSADATA w;
			_INIT_W32DATA() { WSAStartup(MAKEWORD(2, 1), &w); }
			WSADATA w;
			_INIT_W32DATA() { WSAStartup(MAKEWORD(2, 1), &w); }
			} _init_once;
			#else /* ! win32 */
			#include <unistd.h>
			@@ -44,187 +44,288 @@
			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
			{
			SOCKET sock;
			SOCKET maxfd;
			fd_set master;
			int timeout; // master sock timeout, shutdown after timeout millis.
			int quality; // jpeg compression [1..100]
			SOCKET sock;
			SOCKET maxfd;
			fd_set master;
			int timeout; // master sock timeout, shutdown after timeout millis.
			int quality; // jpeg compression [1..100]

			int _write(int sock, char const*const s, int len)
			{
			if (len < 1) { len = strlen(s); }
			return ::send(sock, s, len, 0);
			}
			int _write(int sock, char const*const s, int len)
			{
			if (len < 1) { len = strlen(s); }
			return ::send(sock, s, len, 0);
			}

			public:

			MJPGWriter(int port = 0, int _timeout = 200000, int _quality = 30)
			: sock(INVALID_SOCKET)
			, timeout(_timeout)
			, quality(_quality)
			{
			FD_ZERO(&master);
			if (port)
			open(port);
			}
			MJPGWriter(int port = 0, int _timeout = 200000, int _quality = 30)
			: sock(INVALID_SOCKET)
			, timeout(_timeout)
			, quality(_quality)
			{
			FD_ZERO(&master);
			if (port)
			open(port);
			}

			~MJPGWriter()
			{
			release();
			}
			~MJPGWriter()
			{
			release();
			}

			bool release()
			{
			if (sock != INVALID_SOCKET)
			::shutdown(sock, 2);
			sock = (INVALID_SOCKET);
			return false;
			}
			bool release()
			{
			if (sock != INVALID_SOCKET)
			::shutdown(sock, 2);
			sock = (INVALID_SOCKET);
			return false;
			}

			bool open(int port)
			{
			sock = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
			bool open(int port)
			{
			sock = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

			SOCKADDR_IN address;
			address.sin_addr.s_addr = INADDR_ANY;
			address.sin_family = AF_INET;
			address.sin_port = htons(port); // ::htons(port);
			if (::bind(sock, (SOCKADDR*)&address, sizeof(SOCKADDR_IN)) == SOCKET_ERROR)
			{
			cerr << "error : couldn't bind sock " << sock << " to port " << port << "!" << endl;
			return release();
			}
			if (::listen(sock, 10) == SOCKET_ERROR)
			{
			cerr << "error : couldn't listen on sock " << sock << " on port " << port << " !" << endl;
			return release();
			}
			FD_ZERO(&master);
			FD_SET(sock, &master);
			maxfd = sock;
			return true;
			}
			SOCKADDR_IN address;
			address.sin_addr.s_addr = INADDR_ANY;
			address.sin_family = AF_INET;
			address.sin_port = htons(port); // ::htons(port);
			if (::bind(sock, (SOCKADDR*)&address, sizeof(SOCKADDR_IN)) == SOCKET_ERROR)
			{
			cerr << "error : couldn't bind sock " << sock << " to port " << port << "!" << endl;
			return release();
			}
			if (::listen(sock, 10) == SOCKET_ERROR)
			{
			cerr << "error : couldn't listen on sock " << sock << " on port " << port << " !" << endl;
			return release();
			}
			FD_ZERO(&master);
			FD_SET(sock, &master);
			maxfd = sock;
			return true;
			}

			bool isOpened()
			{
			return sock != INVALID_SOCKET;
			}
			bool isOpened()
			{
			return sock != INVALID_SOCKET;
			}

			bool write(const Mat & frame)
			{
			fd_set rread = master;
			struct timeval to = { 0,timeout };
			if (::select(maxfd+1, &rread, NULL, NULL, &to) <= 0)
			return true; // nothing broken, there's just noone listening
			bool write(const Mat & frame)
			{
			fd_set rread = master;
			struct timeval to = { 0,timeout };
			if (::select(maxfd+1, &rread, NULL, NULL, &to) <= 0)
			return true; // nothing broken, there's just noone listening

			std::vector<uchar> outbuf;
			std::vector<int> params;
			params.push_back(IMWRITE_JPEG_QUALITY);
			params.push_back(quality);
			cv::imencode(".jpg", frame, outbuf, params);
			size_t outlen = outbuf.size();
			std::vector<uchar> outbuf;
			std::vector<int> params;
			params.push_back(IMWRITE_JPEG_QUALITY);
			params.push_back(quality);
			cv::imencode(".jpg", frame, outbuf, params);
			size_t outlen = outbuf.size();

			#ifdef _WIN32
			for (unsigned i = 0; i<rread.fd_count; i++)
			{
			int addrlen = sizeof(SOCKADDR);
			SOCKET s = rread.fd_array[i]; // fd_set on win is an array, while ...
			#else
			for (int s = 0; s<=maxfd; s++)
			{
			socklen_t addrlen = sizeof(SOCKADDR);
			if (!FD_ISSET(s, &rread)) // ... on linux it's a bitmask ;)
			continue;
			#endif
			if (s == sock) // request on master socket, accept and send main header.
			{
			SOCKADDR_IN address = { 0 };
			SOCKET client = ::accept(sock, (SOCKADDR*)&address, &addrlen);
			if (client == SOCKET_ERROR)
			{
			cerr << "error : couldn't accept connection on sock " << sock << " !" << endl;
			return false;
			}
			maxfd = (maxfd>client ? maxfd : client);
			FD_SET(client, &master);
			_write(client, "HTTP/1.0 200 OK\r\n", 0);
			_write(client,
			"Server: Mozarella/2.2\r\n"
			"Accept-Range: bytes\r\n"
			"Connection: close\r\n"
			"Max-Age: 0\r\n"
			"Expires: 0\r\n"
			"Cache-Control: no-cache, private\r\n"
			"Pragma: no-cache\r\n"
			"Content-Type: multipart/x-mixed-replace; boundary=mjpegstream\r\n"
			"\r\n", 0);
			cerr << "new client " << client << endl;
			}
			else // existing client, just stream pix
			{
			char head[400];
			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;
			if (n < outlen)
			{
			cerr << "kill client " << s << endl;
			::shutdown(s, 2);
			FD_CLR(s, &master);
			}
			}
			}
			return true;
			}
			#ifdef _WIN32
			for (unsigned i = 0; i<rread.fd_count; i++)
			{
			int addrlen = sizeof(SOCKADDR);
			SOCKET s = rread.fd_array[i]; // fd_set on win is an array, while ...
			#else
			for (int s = 0; s<=maxfd; s++)
			{
			socklen_t addrlen = sizeof(SOCKADDR);
			if (!FD_ISSET(s, &rread)) // ... on linux it's a bitmask ;)
			continue;
			#endif
			if (s == sock) // request on master socket, accept and send main header.
			{
			SOCKADDR_IN address = { 0 };
			SOCKET client = ::accept(sock, (SOCKADDR*)&address, &addrlen);
			if (client == SOCKET_ERROR)
			{
			cerr << "error : couldn't accept connection on sock " << sock << " !" << endl;
			return false;
			}
			maxfd = (maxfd>client ? maxfd : client);
			FD_SET(client, &master);
			_write(client, "HTTP/1.0 200 OK\r\n", 0);
			_write(client,
			"Server: Mozarella/2.2\r\n"
			"Accept-Range: bytes\r\n"
			"Connection: close\r\n"
			"Max-Age: 0\r\n"
			"Expires: 0\r\n"
			"Cache-Control: no-cache, private\r\n"
			"Pragma: no-cache\r\n"
			"Content-Type: multipart/x-mixed-replace; boundary=mjpegstream\r\n"
			"\r\n", 0);
			cerr << "new client " << client << endl;
			}
			else // existing client, just stream pix
			{
			char head[400];
			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;
			if (n < outlen)
			{
			cerr << "kill client " << s << endl;
			::shutdown(s, 2);
			FD_CLR(s, &master);
			}
			}
			}
			return true;
			}
			};


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

			void send_mjpeg(IplImage* ipl, int port, int timeout, int quality) {
			static MJPGWriter wri(port, timeout, quality);
			cv::Mat mat = cv::cvarrToMat(ipl);
			wri.write(mat);
			std::cout << " MJPEG-stream sent. \n";
			static MJPGWriter wri(port, timeout, quality);
			cv::Mat mat = cv::cvarrToMat(ipl);
			wri.write(mat);
			std::cout << " MJPEG-stream sent. \n";
			}
			// ----------------------------------------

			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;
			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;
			src = cvCreateImage(cvSize(frame.cols, frame.rows), 8, frame.channels());
			*src = frame;
			}
			}
			catch (...) {
			std::cout << " Web-camera stoped! \n";
			}
			return src;
			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
			#endif // OPENCV