mumble module clean up

modules/motion_sense/SCsub

@@ -0,0 +1,36 @@
+# SCsub
+Import('env')
+
+
+motion_sense_env = env.Clone()
+#http://dlib.net/compile.html
+thirdparty_dlib_dir = "#thirdparty/dlib/"
+thirdparty_dlib_srcs = [
+    "dlib/all/source.cpp"
+]
+thirdparty_dlib_sources = [ thirdparty_dlib_dir + dir for dir in thirdparty_dlib_srcs ]
+
+thirdparty_system_path = [
+    "/usr/lib/x86_64-linux-gnu/",
+    "/usr/lib/",
+    "/lib/",
+    "/lib64/"
+]
+
+sources = [
+    "data_models.cpp",
+    "utils.cpp",
+    "facial_landmark_loader.cpp",
+    "facial_landmark.cpp",
+    "register_types.cpp"
+]
+
+motion_sense_env.Append(CCFLAGS=["-DLIB_NO_GUI_SUPPORT=1", "-DUSE_AVX_INSTRUCTIONS=1" ])
+motion_sense_env.Append(CPPPATH=[thirdparty_dlib_dir])   
+#motion_sense_env.Append(LINKFLAGS=["-lopencv_core", "-lopencv" ] )
+
+motion_sense_env.add_source_files(env.modules_sources,sources+thirdparty_dlib_sources)
+motion_sense_env.Append(LIBS=["pthread"]) 
+motion_sense_env.Append(LIBPATH=thirdparty_system_path) 
+
+motion_sense_env.Append(CXXFLAGS=['-O3', '-mavx', '-std=c++11'])

modules/motion_sense/config.py

@@ -0,0 +1,12 @@
+# config.py
+
+def can_build(platform):
+    return True
+
+#TODO: needs to be tested on windows
+def configure(env):
+    env.Append(LIBS=["opencv_core", "opencv_highgui"]) 
+    env.Append(CXXFLAGS=['-mavx'])
+
+    #env.Append(CCFLAGS=["-DLIB_NO_GUI_SUPPORT=1", "-DUSE_AVX_INSTRUCTIONS=1" ])
+    #env.ParseConfig('pkg-config opencv --cflags --libs')

modules/motion_sense/data_models.cpp

@@ -0,0 +1,48 @@
+#include "data_models.h"
+#include <istream>
+#include <streambuf>
+#include <cstdio>
+#include "vector.h"
+#include "os/file_access.h"
+
+class GodotFileInStreamBuf : public std::streambuf{
+public:
+    GodotFileInStreamBuf(FileAccess * fa) {
+        _file = fa;
+    }
+    int underflow(){
+        if (_file->eof_reached()){
+            return EOF;
+        }else{
+            size_t pos = _file->get_position();
+            uint8_t ret = _file->get_8();
+            _file->seek(pos);
+            return ret;
+        }
+    }
+    int uflow(){
+        return _file->eof_reached() ?  EOF : _file -> get_8();
+    }
+private:
+    FileAccess * _file;
+};
+
+Error FacialLandmarkModel::set_file(const String &p_file) {
+    file = p_file;
+	Error err;
+	FileAccess *f = FileAccess::open(file, FileAccess::READ, &err);
+	if (err) {
+		ERR_FAIL_COND_V(err, err);
+	}
+	int _err;
+    GodotFileInStreamBuf sBuf(f);
+    std::istream is(&sBuf);
+   //http://dlib.net/dlib/serialize.h.html
+
+    dlib::deserialize(_pose_model, is);
+    memdelete(f);
+}
+
+FacialLandmarkModel::FacialLandmarkModel() {
+
+}

modules/motion_sense/data_models.h

@@ -0,0 +1,21 @@
+#include "resource.h"
+#include "reference.h"
+
+#ifndef FACIAL_LANDMARK_MODEL_H
+#define FACIAL_LANDMARK_MODEL_H
+
+#include <dlib/image_processing.h>
+
+class FacialLandmarkModel : public Resource{
+    GDCLASS(FacialLandmarkModel, Resource);
+
+public:
+    FacialLandmarkModel();
+    Error set_file(const String &p_file);
+    dlib::shape_predictor &get_data() { return _pose_model; }
+private:
+    dlib::shape_predictor _pose_model;
+    String file;
+
+};
+#endif

modules/motion_sense/facial_landmark.cpp

@@ -0,0 +1,76 @@
+/* facial_landmark.cpp */
+
+#include <dlib/image_processing/frontal_face_detector.h>
+#include <dlib/image_processing/render_face_detections.h>
+#include <dlib/image_processing.h>
+#include <dlib/opencv.h>
+#include <vector>
+#include "facial_landmark.h"
+#include "utils.h"
+#include "variant.h"
+#include "math/math_2d.h"
+#include "print_string.h"
+#include "dvector.h"
+#include "os/os.h"
+
+void FacialLandmark::_bind_methods() {
+    ClassDB::bind_method(D_METHOD("start"), &FacialLandmark::startStreaming);
+    ClassDB::bind_method(D_METHOD("stop"), &FacialLandmark::stopStreaming);
+    ClassDB::bind_method(D_METHOD("set_data", "trained_model"), &FacialLandmark::set_data);
+
+
+    ADD_SIGNAL(MethodInfo("facial_detect", PropertyInfo(Variant::RECT2, "bounding_box"), PropertyInfo(Variant::POOL_VECTOR2_ARRAY, "points")));
+
+    BIND_ENUM_CONSTANT(STATUS_ERROR);
+    BIND_ENUM_CONSTANT(STATUS_NONE);
+    BIND_ENUM_CONSTANT(STATUS_STOPPED);
+    BIND_ENUM_CONSTANT(STATUS_RUNNING);
+
+}
+
+FacialLandmark::FacialLandmark() : _vc(0), _state(STATUS_NONE)  {
+
+}
+
+void FacialLandmark::set_data(Ref<FacialLandmarkModel> m){
+    _model = m;
+}
+
+void FacialLandmark::startStreaming(){
+    if(!_vc.isOpened()){
+        ERR_PRINT("FacialLandmark: unable to connect to camera\n");
+        _state = STATUS_ERROR;
+    }
+    //OS *os = OS::get_singleton();
+    _state = STATUS_RUNNING;
+    dlib::frontal_face_detector detector = dlib::get_frontal_face_detector();
+    while( _state == STATUS_RUNNING ){
+        cv::Mat temp;
+
+      //  int startTime = os ->get_ticks_msec();
+        if (!_vc.read(temp)){
+            ERR_PRINT("FacialLandmark: unable to read to camera\n");
+            break;
+        }
+        dlib::cv_image<dlib::bgr_pixel> cimg(temp);
+        std::vector<dlib::rectangle> faces = detector(cimg);
+        print_line("delected x faces: " + itos(faces.size()));
+
+        if(faces.size()>0) {
+            dlib::full_object_detection dobj = (_model->get_data())(cimg, faces[0]);
+            dlib::rectangle r = dobj.get_rect();
+            PoolVector<Vector2> pts = utils::to_3dVec2(dobj);
+
+            emit_signal("facial_detect", Variant(utils::to_gRect(r)), Variant(pts));
+        }
+        //print_line("took X ms time processing: " + itos(os-> get_ticks_msec() -startTime));
+    }
+
+}
+void FacialLandmark::stopStreaming(){
+    if( _state == STATUS_RUNNING ){
+        _state = STATUS_STOPPED;
+    }
+}
+
+

modules/motion_sense/facial_landmark.h

@@ -0,0 +1,38 @@
+/* facial_landmark.h */
+#ifndef FACIAL_LANDMARK_H
+#define FACIAL_LANDMARK_H
+
+#include "reference.h"
+#include "resource.h"
+#include "data_models.h"
+#include <opencv2/opencv.hpp>
+
+
+class FacialLandmark : public Reference {
+    GDCLASS(FacialLandmark,Reference);
+public:
+    enum Status{
+        STATUS_NONE,
+        STATUS_STOPPED,
+        STATUS_RUNNING,
+        STATUS_ERROR
+    };
+private:
+    cv::VideoCapture _vc;
+    Ref<FacialLandmarkModel> _model;
+    Status _state;
+
+protected:
+    static void _bind_methods();
+
+public:
+
+    FacialLandmark();
+    void startStreaming();
+    void stopStreaming();
+    void set_data(Ref<FacialLandmarkModel> m);
+};
+
+VARIANT_ENUM_CAST(FacialLandmark::Status);
+#endif
+

modules/motion_sense/facial_landmark_loader.cpp

@@ -0,0 +1,28 @@
+#include "facial_landmark_loader.h"
+#include "data_models.h"
+
+ResourceFormatFacialLandmark::ResourceFormatFacialLandmark() {
+}
+RES ResourceFormatFacialLandmark::load(const String &p_path, const String &p_original_path, Error *r_error) {
+	if (r_error)
+		*r_error = OK;
+
+	FacialLandmarkModel *facial_landmark = memnew(FacialLandmarkModel);
+	facial_landmark->set_file(p_path);
+	return Ref<FacialLandmarkModel>(facial_landmark);
+}
+
+void ResourceFormatFacialLandmark::get_recognized_extensions(List<String> *p_extensions) const {
+
+	p_extensions->push_back("f68");
+}
+String ResourceFormatFacialLandmark::get_resource_type(const String &p_path) const {
+
+	if (p_path.get_extension().to_lower() == "f68")
+		return "FacialLandmarkModel";
+	return "";
+}
+
+bool ResourceFormatFacialLandmark::handles_type(const String &p_type) const {
+	return (p_type == "FacialLandmarkModel");
+}

modules/motion_sense/facial_landmark_loader.h

@@ -0,0 +1,19 @@
+#ifndef FACIAL_LANDMARK_LOADER_H
+#define FACIAL_LANDMARK_LOADER_H
+
+#include "io/resource_loader.h"
+
+
+class ResourceFormatFacialLandmark : public ResourceFormatLoader {
+public:
+	virtual RES load(const String &p_path, const String &p_original_path, Error *r_error = NULL);
+	virtual void get_recognized_extensions(List<String> *p_extensions) const;
+	virtual bool handles_type(const String &p_type) const;
+	virtual String get_resource_type(const String &p_path) const;
+
+	ResourceFormatFacialLandmark();
+	virtual ~ResourceFormatFacialLandmark() {}
+};
+
+
+#endif // FACIAL_LANDMARK_LOADER_H

modules/motion_sense/register_types.cpp

@@ -0,0 +1,19 @@
+#include "register_types.h"
+#include "class_db.h"
+#include "facial_landmark.h"
+#include "facial_landmark_loader.h"
+#include "data_models.h"
+
+static ResourceFormatFacialLandmark *facial_landmark_loader = NULL;
+
+void register_motion_sense_types(){
+    ClassDB::register_class<FacialLandmark>();
+    ClassDB::register_class<FacialLandmarkModel>();
+
+    facial_landmark_loader = memnew(ResourceFormatFacialLandmark);
+    ResourceLoader::add_resource_format_loader(facial_landmark_loader);
+
+}
+void unregister_motion_sense_types(){
+}
+

modules/motion_sense/register_types.h

@@ -0,0 +1,3 @@
+void register_motion_sense_types();
+void unregister_motion_sense_types();
+

modules/motion_sense/utils.cpp

@@ -0,0 +1,26 @@
+#include "utils.h"
+
+#define ABS(x) x > 0 ? x : -x
+
+Rect2 utils::to_gRect( dlib::rectangle &r ){
+        long height = r.top() - r.bottom();
+        long width = r.right() - r.left();
+        return Rect2( 0, 0, ABS(width), ABS(height) );
+}
+
+PoolVector<Vector2> utils::to_3dVec2( dlib::full_object_detection &dobj ){
+    PoolVector<Vector2> pts;
+    dlib::rectangle r = dobj.get_rect();
+    long height = ABS(r.top() - r.bottom());
+    long width = ABS(r.right() - r.left());
+    pts.resize(dobj.num_parts());
+    for( unsigned long i = 0; i < dobj.num_parts(); i++){
+        //shift it left cannot seem to find the faces in godot
+        long x = (dobj.part(i).x()-r.left());
+        //long y = height - (dobj.part(i).y() - r.top());
+        long y = (dobj.part(i).y()-r.top());
+        pts.set(i, Vector2(x, y));
+
+    }
+    return pts;
+}

modules/motion_sense/utils.h

@@ -0,0 +1,27 @@
+#include <dlib/geometry/rectangle.h>
+#include <dlib/image_processing/full_object_detection.h>
+
+#include "math/math_2d.h"
+#include "dvector.h"
+
+/*images seem to be lefthanded such as
+ * 0123
+ * 1
+ * 2
+ * 3
+ * 
+ * godot3d should be right handed
+ * 
+ * 
+ * need to translate between the two
+ */ 
+namespace utils{
+    //http://introcomputing.org/image-introduction.html
+    //2d and 3d coordate system are seperate in godot
+    //https://github.com/GodotNativeTools/godot-cpp/blob/master/include/core/Transform2D.hpp#L22
+    //http://docs.godotengine.org/en/latest/classes/class_rect2.html
+    //http://dlib.net/dlib/geometry/rectangle.h.html
+    Rect2 to_gRect( dlib::rectangle &r );
+    PoolVector<Vector2> to_3dVec2( dlib::full_object_detection &obj);
+
+}

modules/mumble/.gitignore

@@ -0,0 +1,4 @@
+*.backup
+*.back
+*.pyc
+*.o