Merge branch '2.x.x'

Author: Bardo91

CMakeLists.txt

@@ -22,13 +22,12 @@
 cmake_minimum_required(VERSION 3.8 FATAL_ERROR)
 PROJECT(fastcom VERSION 1.3.0)
 
-
 #########################################
 ######			General config	   ######
 #########################################
 
 option(BUILD_EXAMPLES "Compile examples" ON)
-option(BUILD_TESTS "Prepare tests" ON)
+option(BUILD_TESTS "Prepare tests" OFF)
 
 if(UNIX)
 	add_definitions(-std=c++11 -pthread -lpthread)
@@ -42,11 +41,6 @@ endif()
 #########################################
 set(Boost_USE_MULTITHREAD ON)
 
-find_package(Boost REQUIRED COMPONENTS system thread regex)
-
-find_package(OpenCV)
-
-
 #########################################
 ######			Library	   ######
 #########################################
@@ -58,7 +52,7 @@ if(UNIX)
 elseif(WIN32)
 	add_library(${PROJECT_NAME} STATIC ${FASTCOM_SOURCES} ${FASTCOM_HEADERS})
 endif()
-target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_11)
+target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_17)
 set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE C)
 
 target_include_directories(${PROJECT_NAME} PUBLIC
@@ -72,16 +66,22 @@ elseif(WIN32)
 	target_compile_options(${PROJECT_NAME} PUBLIC "/EHsc")
 endif()
 
+find_package(Boost REQUIRED COMPONENTS system thread regex)
 target_include_directories(${PROJECT_NAME} PUBLIC ${Boost_INCLUDE_DIRS})
 target_link_libraries(${PROJECT_NAME} LINK_PUBLIC ${Boost_LIBRARIES})
 
+find_package(OpenCV)
 if(OpenCV_FOUND)
   target_include_directories(${PROJECT_NAME} PUBLIC ${OpenCV_INCLUDE_DIRS})
   target_link_libraries(${PROJECT_NAME} LINK_PUBLIC ${OpenCV_LIBRARIES})
   target_compile_definitions(${PROJECT_NAME} PUBLIC FASTCOM_HAS_OPENCV)
 endif(OpenCV_FOUND)
 
 
+find_package(websocketpp REQUIRED)
+target_link_libraries(${PROJECT_NAME} LINK_PUBLIC websocketpp::websocketpp)
+
+
 if(WIN32)
 	target_compile_definitions(${PROJECT_NAME} PUBLIC "_WIN32_WINNT=0x0601")
 endif()
@@ -120,21 +120,21 @@ endif()
 ######			Test				######
 #########################################
 
-if(${BUILD_TESTS})
-if(WIN32)
-	enable_testing()
-	add_definitions("-D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING")
-	include(cmake/AddGoogleTest.cmake)
-	add_subdirectory(tests)
-endif()
-if(UNIX)
-	find_package(GTest)
-	if(${GTest_FOUND})
-	  enable_testing()
-	  add_subdirectory(tests)
-	endif()
-endif()
-endif()
+# if(${BUILD_TESTS})
+# if(WIN32)
+# 	enable_testing()
+# 	add_definitions("-D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING")
+# 	include(cmake/AddGoogleTest.cmake)
+# 	add_subdirectory(tests)
+# endif()
+# if(UNIX)
+# 	find_package(GTest)
+# 	if(${GTest_FOUND})
+# 	  enable_testing()
+# 	  add_subdirectory(tests)
+# 	endif()
+# endif()
+# endif()
 
 
 #########################################

README.md

@@ -4,3 +4,30 @@
 
 [![Build Status](https://travis-ci.org/Bardo91/fastcom.svg?branch=master)](https://travis-ci.org/Bardo91/fastcom)
 
+
+
+# Installation
+
+Clone the repository into any folder, and create a build folder for the compilation
+
+```
+git clone https://github.com/Bardo91/fastcom
+cd fastcom && mkdir build && cd build
+```
+
+Configure with cmake and compile the project
+
+```
+cmake .. && make
+```
+
+Install fastcom to use it at any project you want.
+```
+sudo make install
+```
+
+Create fastcom mole IP environment variable. If you are using fastcom in the same computer, this step is not necessary. If you are using multiple computers, this variable should have the IP of where the first fastcom app is instantiated.
+```
+echo "export FASTCOM_MOLE_IP=\"127.0.0.1\"" >> ~/.bashrc
+```
+

doc/fastcom_logo.png

@@ -20,31 +20,18 @@
 ##---------------------------------------------------------------------------------------------------------------------
 
 add_executable(example_sender "sender.cpp")
-target_include_directories(example_sender PRIVATE "../include")
 target_link_libraries(example_sender LINK_PUBLIC fastcom)
 
 add_executable(example_receiver "receiver.cpp")
-target_include_directories(example_receiver PRIVATE "../include")
 target_link_libraries(example_receiver LINK_PUBLIC fastcom)
 
-
 add_executable(example_sender_image "sender_image.cpp")
-target_include_directories(example_sender_image PRIVATE "../include")
 target_link_libraries(example_sender_image LINK_PUBLIC fastcom)
 
 add_executable(example_receiver_image "receiver_image.cpp")
-target_include_directories(example_receiver_image PRIVATE "../include")
 target_link_libraries(example_receiver_image LINK_PUBLIC fastcom)
 
-add_executable(example_destruction "destruction.cpp")
-target_include_directories(example_destruction PRIVATE "../include")
-target_link_libraries(example_destruction LINK_PUBLIC fastcom)
-
 
-add_executable(example_service_client "service_client.cpp")
-target_include_directories(example_service_client PRIVATE "../include")
-target_link_libraries(example_service_client LINK_PUBLIC fastcom)
 
-add_executable(example_service_server "service_server.cpp")
-target_include_directories(example_service_server PRIVATE "../include")
-target_link_libraries(example_service_server LINK_PUBLIC fastcom)
+add_executable(sample "sample.cpp")
+target_link_libraries(sample LINK_PUBLIC fastcom)

examples/CMakeLists.txt

@@ -0,0 +1,51 @@
+
+#ifndef SERIALIZABLEMAT_H_
+#define SERIALIZABLEMAT_H_
+
+#include <vector>
+#include <string_view>
+#include <opencv2/opencv.hpp>
+
+class SerializableMat{
+public:
+    SerializableMat(cv::Mat _img = cv::Mat(), int _jpegQuality = 50){
+        imgRef_ = _img;
+        params_.push_back(CV_IMWRITE_JPEG_QUALITY);
+        params_.push_back(_jpegQuality);
+    }
+
+    operator const cv::Mat &() const { return imgRef_; };
+    operator cv::Mat &() { return imgRef_; };
+    const cv::Mat & getCvMat() const { return imgRef_; };
+
+    friend std::ostream & operator<<(std::ostream &_out, SerializableMat &_v) {
+        std::vector<uchar> buffer;
+        cv::imencode(".jpg", _v.imgRef_, buffer, _v.params_);
+        std::string_view res((char*)buffer.data(), buffer.size());
+        _out << res;
+        std::cout << "Serialized image of size " << buffer.size() << std::endl;
+        return _out;
+    }
+    friend std::istream & operator>>(std::istream &_in, SerializableMat &_v) {
+
+        std::cout << "Deserializing image. ";
+        std::vector<uint8_t> buffer;
+        std::for_each(std::istreambuf_iterator<char>(_in),
+                    std::istreambuf_iterator<char>(),
+                    [&buffer](const char c){
+                        buffer.push_back(c);
+                    });
+        
+        std::cout << "Final size: " << buffer.size() << std::endl;
+
+        _v.imgRef_=cv::imdecode(buffer,1);
+        return _in;
+    }
+    
+private:
+    std::vector<int> params_;
+    cv::Mat imgRef_;
+};
+
+
+#endif

examples/SerializableMat.h

@@ -0,0 +1,45 @@
+
+#ifndef SERIALIZABLEVECTOR_H_
+#define SERIALIZABLEVECTOR_H_
+
+
+template<typename Type_>
+class SerializableVector{
+public:
+    void push_back(Type_ _t){ v_.push_back(_t);};
+
+    typename std::vector<Type_>::iterator begin() { return v_.begin();};
+    typename std::vector<Type_>::iterator end() { return v_.end();};
+
+    typename std::vector<Type_>::const_iterator begin() const { return v_.begin();};
+    typename std::vector<Type_>::const_iterator end() const { return v_.end();};
+
+    friend std::ostream & operator<<(std::ostream &_out, SerializableVector<Type_> &_v) {
+        std::string res((char*)_v.data(), sizeof(Type_)*_v.size());
+        _out << res;
+        return _out;
+    }
+    friend std::istream & operator>>(std::istream &_in, SerializableVector<Type_> &_v) {
+        
+        char *buffer = new char[sizeof(float)];
+        while (_in) {
+            _in.read(buffer, sizeof(float));
+            _v.push_back(*((float*)buffer));
+        }
+
+        delete[] buffer;
+    }
+
+    void resize(unsigned int _s) { v_.resize(_s);};
+
+    Type_ *data() { return v_.data(); };
+
+    size_t size() { return v_.size(); };
+
+private:
+    std::vector<Type_> v_;
+
+};
+
+
+#endif

examples/SerializableVector.h

@@ -1,7 +1,10 @@
 //---------------------------------------------------------------------------------------------------------------------
 //  FASTCOM
 //---------------------------------------------------------------------------------------------------------------------
-//  Copyright 2019 - Pablo Ramon Soria (a.k.a. Bardo91) 
+//  Copyright 2020 -    Manuel Perez Jimenez (a.k.a. manuoso)
+//                      Marco A. Montes Grova (a.k.a. mgrova) 
+//                      Pablo Ramon Soria (a.k.a. Bardo91)
+//                      Ricardo Lopez Lopez (a.k.a. ric92)
 //---------------------------------------------------------------------------------------------------------------------
 //  Permission is hereby granted, free of charge, to any person obtaining a copy of this software 
 //  and associated documentation files (the "Software"), to deal in the Software without restriction, 
@@ -19,29 +22,42 @@
 //  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //---------------------------------------------------------------------------------------------------------------------
 
+
+#include <fastcom/Publisher.h>
 #include <fastcom/Subscriber.h>
 
+#include <fastcom/ConnectionManager.h>
+
+#include <string>
 #include <thread>
-#include <iostream>
 #include <chrono>
+#include <iostream>
 
+#include "SerializableVector.h"
 
-struct SimpleFloat{
-    float a;
-    float b;
-    float c;
-};
+int main(){
 
-int main(int _argc, char **_argv){
+    fastcom::Subscriber<int> s1("/integer_count");
+    fastcom::Subscriber<std::string> s2("/jojo");
+    fastcom::Subscriber<SerializableVector<float>> s3("/custom");
+    
+    s1.addCallback([&](const int &_msg){
+        std::cout << _msg << std::endl;
+    });
 
-    fastcom::Subscriber<SimpleFloat> subscriber(_argv[1], 8888);
+    s2.addCallback([&](const std::string &_msg){
+        std::cout << _msg << std::endl;
+    });
 
-    subscriber.attachCallback([&](SimpleFloat &_data){
-        std::cout << _data.a << std::endl;
+    s3.addCallback([&](const SerializableVector<float> &_msg){
+        for(auto elem: _msg)
+            std::cout << elem << ", "<< std::endl;
     });
 
-    for(;;){
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));   
+
+    while (true) {
+        std::this_thread::sleep_for(std::chrono::seconds(1));
     }
+    
 
 }

examples/receiver.cpp

@@ -1,7 +1,10 @@
 //---------------------------------------------------------------------------------------------------------------------
 //  FASTCOM
 //---------------------------------------------------------------------------------------------------------------------
-//  Copyright 2019 - Pablo Ramon Soria (a.k.a. Bardo91) 
+//  Copyright 2020 -    Manuel Perez Jimenez (a.k.a. manuoso)
+//                      Marco A. Montes Grova (a.k.a. mgrova) 
+//                      Pablo Ramon Soria (a.k.a. Bardo91)
+//                      Ricardo Lopez Lopez (a.k.a. ric92)
 //---------------------------------------------------------------------------------------------------------------------
 //  Permission is hereby granted, free of charge, to any person obtaining a copy of this software 
 //  and associated documentation files (the "Software"), to deal in the Software without restriction, 
@@ -20,35 +23,33 @@
 //---------------------------------------------------------------------------------------------------------------------
 
 
-#ifdef FASTCOM_HAS_OPENCV
+#include <fastcom/Publisher.h>
+#include <fastcom/Subscriber.h>
 
-#include <fastcom/ImageSubscriber.h>
+#include <fastcom/ConnectionManager.h>
 
+#include <string>
 #include <thread>
-#include <iostream>
 #include <chrono>
+#include <iostream>
 
-int main(int _argc, char**_argv){
+#include "SerializableMat.h"
+#include <opencv2/opencv.hpp>
 
-    fastcom::ImageSubscriber subscriber(_argv[1], 8888);
+int main(){
 
-    std::function<void(cv::Mat &)> callback = [&](cv::Mat &_data){
-        cv::imshow("display", _data);
+    fastcom::Subscriber<SerializableMat> s1("/beauty_face");
+
+    s1.addCallback([&](const SerializableMat &_msg){
+        auto mat = _msg.getCvMat();
+        cv::imshow("face", mat);
         cv::waitKey(3);
-    };
+    });
 
-    subscriber.attachCallback(callback);
 
-    for(;;){
-        std::this_thread::sleep_for(std::chrono::milliseconds(100));   
+    while (true) {
+        std::this_thread::sleep_for(std::chrono::seconds(1));
     }
+    
 
-}
-
-#else
-
-int main() {
-
-}
-
-#endif
+}