commit
98afb8ebf6
19 changed files with 1760 additions and 0 deletions
@ -0,0 +1,90 @@ |
|||||
|
#.gitignore is a file which makes git ignore files which should |
||||
|
# not go into version control in the first place |
||||
|
# Questions? See |
||||
|
# http://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository#Ignoring-Files |
||||
|
# http://git-scm.com/docs/gitignore |
||||
|
|
||||
|
########################### |
||||
|
# ignore generated binaries |
||||
|
# but not the data folder |
||||
|
########################### |
||||
|
|
||||
|
/bin/* |
||||
|
|
||||
|
######### |
||||
|
# general |
||||
|
######### |
||||
|
|
||||
|
[Bb]uild/ |
||||
|
[Oo]bj/ |
||||
|
*.o |
||||
|
[Dd]ebug*/ |
||||
|
[Rr]elease*/ |
||||
|
*.mode* |
||||
|
*.app/ |
||||
|
*.pyc |
||||
|
.svn/ |
||||
|
*.log |
||||
|
|
||||
|
######################## |
||||
|
# IDE files which should |
||||
|
# be ignored |
||||
|
######################## |
||||
|
|
||||
|
# XCode |
||||
|
*.pbxuser |
||||
|
*.perspective |
||||
|
*.perspectivev3 |
||||
|
*.mode1v3 |
||||
|
*.mode2v3 |
||||
|
# XCode 4 |
||||
|
*.xccheckout |
||||
|
xcuserdata/ |
||||
|
|
||||
|
# Visual Studio |
||||
|
*.sdf |
||||
|
*.opensdf |
||||
|
*.suo |
||||
|
*.pdb |
||||
|
*.ilk |
||||
|
*.aps |
||||
|
ipch/ |
||||
|
|
||||
|
# Eclipse |
||||
|
.metadata |
||||
|
local.properties |
||||
|
.externalToolBuilders |
||||
|
|
||||
|
# Android Studio |
||||
|
.gradle |
||||
|
/local.properties |
||||
|
/.idea/workspace.xml |
||||
|
/.idea/libraries |
||||
|
|
||||
|
################## |
||||
|
# operating system |
||||
|
################## |
||||
|
|
||||
|
# Linux |
||||
|
*~ |
||||
|
# KDE |
||||
|
.directory |
||||
|
.AppleDouble |
||||
|
|
||||
|
# OSX |
||||
|
.DS_Store |
||||
|
*.swp |
||||
|
*~.nib |
||||
|
# Thumbnails |
||||
|
._* |
||||
|
|
||||
|
# Windows |
||||
|
# Image file caches |
||||
|
Thumbs.db |
||||
|
# Folder config file |
||||
|
Desktop.ini |
||||
|
|
||||
|
# Android |
||||
|
.csettings |
||||
|
|
||||
|
/bin/data/ |
||||
@ -0,0 +1,181 @@ |
|||||
|
{ |
||||
|
"configurations": [ |
||||
|
{ |
||||
|
"name": "Mac", |
||||
|
"includePath": [ |
||||
|
"/usr/include", |
||||
|
"/usr/local/include", |
||||
|
"/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/", |
||||
|
"/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/c++/4.2.1", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/3d", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/app", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/communication", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/events", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/gl", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/graphics", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/math", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/sound", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/types", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/utils", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/video", |
||||
|
"${workspaceRoot}/../../../libs/boost/include", |
||||
|
"${workspaceRoot}/../../../libs/cairo/include", |
||||
|
"${workspaceRoot}/../../../libs/curl/include", |
||||
|
"${workspaceRoot}/../../../libs/fmod/include", |
||||
|
"${workspaceRoot}/../../../libs/FreeImage/include", |
||||
|
"${workspaceRoot}/../../../libs/freetype/include", |
||||
|
"${workspaceRoot}/../../../libs/glew/include", |
||||
|
"${workspaceRoot}/../../../libs/glfw/include", |
||||
|
"${workspaceRoot}/../../../libs/glm/include", |
||||
|
"${workspaceRoot}/../../../libs/json/include", |
||||
|
"${workspaceRoot}/../../../libs/pugixml/include", |
||||
|
"${workspaceRoot}/../../../libs/rtAudio/include", |
||||
|
"${workspaceRoot}/../../../libs/tess2/include", |
||||
|
"${workspaceRoot}/../../../libs/uriparser/include", |
||||
|
"${workspaceRoot}/../../../libs/utf8/include" |
||||
|
], |
||||
|
"browse": { |
||||
|
"limitSymbolsToIncludedHeaders": true, |
||||
|
"databaseFilename": "${workspaceRoot}/.vscode/browse.db", |
||||
|
"path": [ |
||||
|
"/usr/include", |
||||
|
"/usr/local/include", |
||||
|
"/System/Library/Frameworks", |
||||
|
"/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/", |
||||
|
"${workspaceRoot}/../../../libs", |
||||
|
"${workspaceRoot}/../../../addons", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks" |
||||
|
] |
||||
|
}, |
||||
|
"intelliSenseMode": "clang-x64", |
||||
|
"macFrameworkPath": [ |
||||
|
"/System/Library/Frameworks", |
||||
|
"/Library/Frameworks" |
||||
|
], |
||||
|
"compilerPath": "/usr/local/bin/gcc-8", |
||||
|
"cStandard": "c11", |
||||
|
"cppStandard": "c++17" |
||||
|
}, |
||||
|
{ |
||||
|
"name": "Linux", |
||||
|
"includePath": [ |
||||
|
"/usr/include", |
||||
|
"/usr/local/include", |
||||
|
"/usr/include/c++/5", |
||||
|
"/usr/include/c++/5/backward", |
||||
|
"/usr/lib/gcc/x86_64-linux-gnu/5/include", |
||||
|
"/usr/lib/x86_64-linux-gnu/glib-2.0/include", |
||||
|
"/usr/lib/x86_64-linux-gnu/gstreamer-1.0/include", |
||||
|
"/usr/local/include", |
||||
|
"/usr/lib/gcc/x86_64-linux-gnu/5/include-fixed", |
||||
|
"/usr/include/x86_64-linux-gnu", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/3d", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/app", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/communication", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/events", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/gl", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/graphics", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/math", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/sound", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/types", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/utils", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/video", |
||||
|
"${workspaceRoot}/../../../libs/boost/include", |
||||
|
"${workspaceRoot}/../../../libs/cairo/include", |
||||
|
"${workspaceRoot}/../../../libs/curl/include", |
||||
|
"${workspaceRoot}/../../../libs/fmod/include", |
||||
|
"${workspaceRoot}/../../../libs/FreeImage/include", |
||||
|
"${workspaceRoot}/../../../libs/freetype/include", |
||||
|
"${workspaceRoot}/../../../libs/glew/include", |
||||
|
"${workspaceRoot}/../../../libs/glfw/include", |
||||
|
"${workspaceRoot}/../../../libs/glm/include", |
||||
|
"${workspaceRoot}/../../../libs/json/include", |
||||
|
"${workspaceRoot}/../../../libs/pugixml/include", |
||||
|
"${workspaceRoot}/../../../libs/rtAudio/include", |
||||
|
"${workspaceRoot}/../../../libs/tess2/include", |
||||
|
"${workspaceRoot}/../../../libs/uriparser/include", |
||||
|
"${workspaceRoot}/../../../libs/utf8/include", |
||||
|
"${workspaceRoot}/../../../libs/poco/include", |
||||
|
"${workspaceRoot}/../../../libs/kiss/include", |
||||
|
"/usr/include/x86_64-linux-gnu/c++/5", |
||||
|
"/usr/include/pulse", |
||||
|
"/usr/include/cairo", |
||||
|
"/usr/include/gstreamer-1.0", |
||||
|
"/usr/include/glib-2.0", |
||||
|
"${workspaceRoot}", |
||||
|
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxOpenCv/src", |
||||
|
"/usr/local/onnxruntime-linux-x64-gpu-1.19.2/include", |
||||
|
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxOpenCv/libs/opencv/include/opencv4" |
||||
|
], |
||||
|
"browse": { |
||||
|
"limitSymbolsToIncludedHeaders": true, |
||||
|
"databaseFilename": "", |
||||
|
"path": [ |
||||
|
"/usr/include", |
||||
|
"/usr/local/include", |
||||
|
"${workspaceRoot}/../../../libs", |
||||
|
"${workspaceRoot}/../../../addons", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks", |
||||
|
"/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/addons/ofxOpenCv/src", |
||||
|
"/usr/local/onnxruntime-linux-x64-gpu-1.19.2/include" |
||||
|
] |
||||
|
}, |
||||
|
"intelliSenseMode": "clang-x64", |
||||
|
"compilerPath": "/usr/bin/g++", |
||||
|
"cStandard": "c17", |
||||
|
"cppStandard": "c++17" |
||||
|
}, |
||||
|
{ |
||||
|
"name": "Win32", |
||||
|
"includePath": [ |
||||
|
"C:/msys64/mingw32/include/c++/7.4.0", |
||||
|
"C:/msys64/mingw32/i686-w64-mingw32/include", |
||||
|
"${workspaceRoot}/../../../libs", |
||||
|
"${workspaceRoot}/../../../addons", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/3d", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/app", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/communication", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/events", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/gl", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/graphics", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/math", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/sound", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/types", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/utils", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks/video", |
||||
|
"${workspaceRoot}/../../../libs/boost/include", |
||||
|
"${workspaceRoot}/../../../libs/cairo/include", |
||||
|
"${workspaceRoot}/../../../libs/curl/include", |
||||
|
"${workspaceRoot}/../../../libs/fmod/include", |
||||
|
"${workspaceRoot}/../../../libs/FreeImage/include", |
||||
|
"${workspaceRoot}/../../../libs/freetype/include", |
||||
|
"${workspaceRoot}/../../../libs/glew/include", |
||||
|
"${workspaceRoot}/../../../libs/glfw/include", |
||||
|
"${workspaceRoot}/../../../libs/glm/include", |
||||
|
"${workspaceRoot}/../../../libs/json/include", |
||||
|
"${workspaceRoot}/../../../libs/pugixml/include", |
||||
|
"${workspaceRoot}/../../../libs/rtAudio/include", |
||||
|
"${workspaceRoot}/../../../libs/tess2/include", |
||||
|
"${workspaceRoot}/../../../libs/uriparser/include", |
||||
|
"${workspaceRoot}/../../../libs/utf8/include" |
||||
|
], |
||||
|
"browse": { |
||||
|
"limitSymbolsToIncludedHeaders": true, |
||||
|
"databaseFilename": "", |
||||
|
"path": [ |
||||
|
"${workspaceRoot}/../../../libs", |
||||
|
"${workspaceRoot}/../../../addons", |
||||
|
"${workspaceRoot}/../../../libs/openFrameworks" |
||||
|
] |
||||
|
}, |
||||
|
"intelliSenseMode": "clang-x64", |
||||
|
"compilerPath": "C:/msys64/mingw32/bin/g++.exe", |
||||
|
"cStandard": "c11", |
||||
|
"cppStandard": "c++17" |
||||
|
} |
||||
|
], |
||||
|
"version": 4 |
||||
|
} |
||||
@ -0,0 +1,72 @@ |
|||||
|
{ |
||||
|
"version": "0.2.0", |
||||
|
"configurations": [ |
||||
|
{ |
||||
|
"name": "C++ Launch", |
||||
|
"type": "cppdbg", |
||||
|
"request": "launch", |
||||
|
"args": [], |
||||
|
"stopAtEntry": false, |
||||
|
"cwd": "${workspaceRoot}", |
||||
|
"environment": [], |
||||
|
"externalConsole": false, |
||||
|
"linux": { |
||||
|
"MIMode": "gdb", |
||||
|
"setupCommands": [ |
||||
|
{ |
||||
|
"description": "Enable pretty-printing for gdb", |
||||
|
"text": "-enable-pretty-printing", |
||||
|
"ignoreFailures": true |
||||
|
} |
||||
|
], |
||||
|
"program": "${workspaceRoot}/bin/${workspaceFolderBasename}_debug" |
||||
|
}, |
||||
|
"osx": { |
||||
|
"MIMode": "lldb", |
||||
|
"program": "${workspaceRoot}/bin/${workspaceFolderBasename}_debug.app/Contents/MacOS/${workspaceFolderBasename}_debug" |
||||
|
}, |
||||
|
"windows": { |
||||
|
"MIMode": "gdb", |
||||
|
"miDebuggerPath": "gdb.exe", |
||||
|
"setupCommands": [ |
||||
|
{ |
||||
|
"description": "Enable pretty-printing for gdb", |
||||
|
"text": "-enable-pretty-printing", |
||||
|
"ignoreFailures": true |
||||
|
} |
||||
|
], |
||||
|
"program": "${workspaceRoot}/bin/${workspaceFolderBasename}_debug" |
||||
|
} |
||||
|
}, |
||||
|
{ |
||||
|
"name": "C++ Attach", |
||||
|
"type": "cppdbg", |
||||
|
"request": "attach", |
||||
|
"program": "enter program name, for example ${workspaceRoot}/a.out", |
||||
|
"processId": "${command:pickProcess}", |
||||
|
"linux": { |
||||
|
"MIMode": "gdb", |
||||
|
"setupCommands": [ |
||||
|
{ |
||||
|
"description": "Enable pretty-printing for gdb", |
||||
|
"text": "-enable-pretty-printing", |
||||
|
"ignoreFailures": true |
||||
|
} |
||||
|
] |
||||
|
}, |
||||
|
"osx": { |
||||
|
"MIMode": "lldb" |
||||
|
}, |
||||
|
"windows": { |
||||
|
"MIMode": "gdb", |
||||
|
"setupCommands": [ |
||||
|
{ |
||||
|
"description": "Enable pretty-printing for gdb", |
||||
|
"text": "-enable-pretty-printing", |
||||
|
"ignoreFailures": true |
||||
|
} |
||||
|
] |
||||
|
} |
||||
|
} |
||||
|
] |
||||
|
} |
||||
@ -0,0 +1,133 @@ |
|||||
|
{ |
||||
|
"version": "2.0.0", |
||||
|
"shell":{ |
||||
|
"task": true |
||||
|
}, |
||||
|
"tasks": [ |
||||
|
{ |
||||
|
"type": "shell", |
||||
|
"label": "Build RELEASE", |
||||
|
"presentation": { |
||||
|
"reveal": "always", |
||||
|
"panel": "shared" |
||||
|
}, |
||||
|
"command": "make -j -s 2>&1 && make RunRelease", |
||||
|
"group": { |
||||
|
"kind": "build", |
||||
|
"isDefault": true |
||||
|
}, |
||||
|
"problemMatcher": { |
||||
|
"owner": "cpp", |
||||
|
"fileLocation": ["relative", "${workspaceFolder}"], |
||||
|
"pattern": { |
||||
|
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$", |
||||
|
"file": 1, |
||||
|
"line": 2, |
||||
|
"column": 3, |
||||
|
"severity": 4, |
||||
|
"message": 5 |
||||
|
} |
||||
|
} |
||||
|
}, |
||||
|
{ |
||||
|
"type": "shell", |
||||
|
"label": "Build DEBUG", |
||||
|
"presentation": { |
||||
|
"reveal": "always", |
||||
|
"panel": "shared" |
||||
|
}, |
||||
|
"command": "make Debug -j -s 2>&1 || exit 1", |
||||
|
"group": { |
||||
|
"kind": "build", |
||||
|
"isDefault": true |
||||
|
}, |
||||
|
"problemMatcher": { |
||||
|
"owner": "cpp", |
||||
|
"fileLocation": ["relative", "${workspaceFolder}"], |
||||
|
"pattern": { |
||||
|
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$", |
||||
|
"file": 1, |
||||
|
"line": 2, |
||||
|
"column": 3, |
||||
|
"severity": 4, |
||||
|
"message": 5 |
||||
|
} |
||||
|
} |
||||
|
}, |
||||
|
{ |
||||
|
"type": "shell", |
||||
|
"label": "Clean DEBUG", |
||||
|
"presentation": { |
||||
|
"reveal": "always", |
||||
|
"panel": "shared" |
||||
|
}, |
||||
|
"command": "make CleanDebug", |
||||
|
"group": { |
||||
|
"kind": "build", |
||||
|
"isDefault": true |
||||
|
}, |
||||
|
"problemMatcher": { |
||||
|
"owner": "cpp", |
||||
|
"fileLocation": ["relative", "${workspaceFolder}"], |
||||
|
"pattern": { |
||||
|
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$", |
||||
|
"file": 1, |
||||
|
"line": 2, |
||||
|
"column": 3, |
||||
|
"severity": 4, |
||||
|
"message": 5 |
||||
|
} |
||||
|
} |
||||
|
}, |
||||
|
{ |
||||
|
"type": "shell", |
||||
|
"label": "Clean RELEASE", |
||||
|
"presentation": { |
||||
|
"reveal": "always", |
||||
|
"panel": "shared" |
||||
|
}, |
||||
|
"command": "make CleanRelease", |
||||
|
"group": { |
||||
|
"kind": "build", |
||||
|
"isDefault": true |
||||
|
}, |
||||
|
"problemMatcher": { |
||||
|
"owner": "cpp", |
||||
|
"fileLocation": ["relative", "${workspaceFolder}"], |
||||
|
"pattern": { |
||||
|
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$", |
||||
|
"file": 1, |
||||
|
"line": 2, |
||||
|
"column": 3, |
||||
|
"severity": 4, |
||||
|
"message": 5 |
||||
|
} |
||||
|
} |
||||
|
}, |
||||
|
{ |
||||
|
"type": "shell", |
||||
|
"label": "Clean ALL", |
||||
|
"presentation": { |
||||
|
"reveal": "always", |
||||
|
"panel": "shared" |
||||
|
}, |
||||
|
"command": "make clean", |
||||
|
"group": { |
||||
|
"kind": "build", |
||||
|
"isDefault": true |
||||
|
}, |
||||
|
"problemMatcher": { |
||||
|
"owner": "cpp", |
||||
|
"fileLocation": ["relative", "${workspaceFolder}"], |
||||
|
"pattern": { |
||||
|
"regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$", |
||||
|
"file": 1, |
||||
|
"line": 2, |
||||
|
"column": 3, |
||||
|
"severity": 4, |
||||
|
"message": 5 |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
] |
||||
|
} |
||||
@ -0,0 +1,13 @@ |
|||||
|
# Attempt to load a config.make file.
|
||||
|
# If none is found, project defaults in config.project.make will be used.
|
||||
|
ifneq ($(wildcard config.make),) |
||||
|
include config.make |
||||
|
endif |
||||
|
|
||||
|
# make sure the the OF_ROOT location is defined
|
||||
|
ifndef OF_ROOT |
||||
|
OF_ROOT=$(realpath ../../..) |
||||
|
endif |
||||
|
|
||||
|
# call the project makefile!
|
||||
|
include $(OF_ROOT)/libs/openFrameworksCompiled/project/makefileCommon/compile.project.mk |
||||
@ -0,0 +1,2 @@ |
|||||
|
ofxOpenCv |
||||
|
ofxOpenCv |
||||
@ -0,0 +1,142 @@ |
|||||
|
################################################################################ |
||||
|
# CONFIGURE PROJECT MAKEFILE (optional) |
||||
|
# This file is where we make project specific configurations. |
||||
|
################################################################################ |
||||
|
|
||||
|
################################################################################ |
||||
|
# OF ROOT |
||||
|
# The location of your root openFrameworks installation |
||||
|
# (default) OF_ROOT = ../../.. |
||||
|
################################################################################ |
||||
|
OF_ROOT = ../../.. |
||||
|
|
||||
|
################################################################################ |
||||
|
# PROJECT ROOT |
||||
|
# The location of the project - a starting place for searching for files |
||||
|
# (default) PROJECT_ROOT = . (this directory) |
||||
|
# |
||||
|
################################################################################ |
||||
|
# PROJECT_ROOT = . |
||||
|
|
||||
|
################################################################################ |
||||
|
# PROJECT SPECIFIC CHECKS |
||||
|
# This is a project defined section to create internal makefile flags to |
||||
|
# conditionally enable or disable the addition of various features within |
||||
|
# this makefile. For instance, if you want to make changes based on whether |
||||
|
# GTK is installed, one might test that here and create a variable to check. |
||||
|
################################################################################ |
||||
|
# None |
||||
|
|
||||
|
################################################################################ |
||||
|
# PROJECT EXTERNAL SOURCE PATHS |
||||
|
# These are fully qualified paths that are not within the PROJECT_ROOT folder. |
||||
|
# Like source folders in the PROJECT_ROOT, these paths are subject to |
||||
|
# exlclusion via the PROJECT_EXLCUSIONS list. |
||||
|
# |
||||
|
# (default) PROJECT_EXTERNAL_SOURCE_PATHS = (blank) |
||||
|
# |
||||
|
# Note: Leave a leading space when adding list items with the += operator |
||||
|
################################################################################ |
||||
|
# PROJECT_EXTERNAL_SOURCE_PATHS = |
||||
|
|
||||
|
################################################################################ |
||||
|
# PROJECT EXCLUSIONS |
||||
|
# These makefiles assume that all folders in your current project directory |
||||
|
# and any listed in the PROJECT_EXTERNAL_SOURCH_PATHS are are valid locations |
||||
|
# to look for source code. The any folders or files that match any of the |
||||
|
# items in the PROJECT_EXCLUSIONS list below will be ignored. |
||||
|
# |
||||
|
# Each item in the PROJECT_EXCLUSIONS list will be treated as a complete |
||||
|
# string unless teh user adds a wildcard (%) operator to match subdirectories. |
||||
|
# GNU make only allows one wildcard for matching. The second wildcard (%) is |
||||
|
# treated literally. |
||||
|
# |
||||
|
# (default) PROJECT_EXCLUSIONS = (blank) |
||||
|
# |
||||
|
# Will automatically exclude the following: |
||||
|
# |
||||
|
# $(PROJECT_ROOT)/bin% |
||||
|
# $(PROJECT_ROOT)/obj% |
||||
|
# $(PROJECT_ROOT)/%.xcodeproj |
||||
|
# |
||||
|
# Note: Leave a leading space when adding list items with the += operator |
||||
|
################################################################################ |
||||
|
# PROJECT_EXCLUSIONS = |
||||
|
|
||||
|
################################################################################ |
||||
|
# PROJECT LINKER FLAGS |
||||
|
# These flags will be sent to the linker when compiling the executable. |
||||
|
# |
||||
|
# (default) PROJECT_LDFLAGS = -Wl,-rpath=./libs |
||||
|
# |
||||
|
# Note: Leave a leading space when adding list items with the += operator |
||||
|
################################################################################ |
||||
|
|
||||
|
# Currently, shared libraries that are needed are copied to the |
||||
|
# $(PROJECT_ROOT)/bin/libs directory. The following LDFLAGS tell the linker to |
||||
|
# add a runtime path to search for those shared libraries, since they aren't |
||||
|
# incorporated directly into the final executable application binary. |
||||
|
# TODO: should this be a default setting? |
||||
|
# PROJECT_LDFLAGS=-Wl,-rpath=./libs |
||||
|
|
||||
|
################################################################################ |
||||
|
# PROJECT DEFINES |
||||
|
# Create a space-delimited list of DEFINES. The list will be converted into |
||||
|
# CFLAGS with the "-D" flag later in the makefile. |
||||
|
# |
||||
|
# (default) PROJECT_DEFINES = (blank) |
||||
|
# |
||||
|
# Note: Leave a leading space when adding list items with the += operator |
||||
|
################################################################################ |
||||
|
# PROJECT_DEFINES = |
||||
|
|
||||
|
################################################################################ |
||||
|
# PROJECT CFLAGS |
||||
|
# This is a list of fully qualified CFLAGS required when compiling for this |
||||
|
# project. These CFLAGS will be used IN ADDITION TO the PLATFORM_CFLAGS |
||||
|
# defined in your platform specific core configuration files. These flags are |
||||
|
# presented to the compiler BEFORE the PROJECT_OPTIMIZATION_CFLAGS below. |
||||
|
# |
||||
|
# (default) PROJECT_CFLAGS = (blank) |
||||
|
# |
||||
|
# Note: Before adding PROJECT_CFLAGS, note that the PLATFORM_CFLAGS defined in |
||||
|
# your platform specific configuration file will be applied by default and |
||||
|
# further flags here may not be needed. |
||||
|
# |
||||
|
# Note: Leave a leading space when adding list items with the += operator |
||||
|
################################################################################ |
||||
|
# PROJECT_CFLAGS = |
||||
|
|
||||
|
################################################################################ |
||||
|
# PROJECT OPTIMIZATION CFLAGS |
||||
|
# These are lists of CFLAGS that are target-specific. While any flags could |
||||
|
# be conditionally added, they are usually limited to optimization flags. |
||||
|
# These flags are added BEFORE the PROJECT_CFLAGS. |
||||
|
# |
||||
|
# PROJECT_OPTIMIZATION_CFLAGS_RELEASE flags are only applied to RELEASE targets. |
||||
|
# |
||||
|
# (default) PROJECT_OPTIMIZATION_CFLAGS_RELEASE = (blank) |
||||
|
# |
||||
|
# PROJECT_OPTIMIZATION_CFLAGS_DEBUG flags are only applied to DEBUG targets. |
||||
|
# |
||||
|
# (default) PROJECT_OPTIMIZATION_CFLAGS_DEBUG = (blank) |
||||
|
# |
||||
|
# Note: Before adding PROJECT_OPTIMIZATION_CFLAGS, please note that the |
||||
|
# PLATFORM_OPTIMIZATION_CFLAGS defined in your platform specific configuration |
||||
|
# file will be applied by default and further optimization flags here may not |
||||
|
# be needed. |
||||
|
# |
||||
|
# Note: Leave a leading space when adding list items with the += operator |
||||
|
################################################################################ |
||||
|
# PROJECT_OPTIMIZATION_CFLAGS_RELEASE = |
||||
|
# PROJECT_OPTIMIZATION_CFLAGS_DEBUG = |
||||
|
|
||||
|
################################################################################ |
||||
|
# PROJECT COMPILERS |
||||
|
# Custom compilers can be set for CC and CXX |
||||
|
# (default) PROJECT_CXX = (blank) |
||||
|
# (default) PROJECT_CC = (blank) |
||||
|
# Note: Leave a leading space when adding list items with the += operator |
||||
|
################################################################################ |
||||
|
# PROJECT_CXX = |
||||
|
# PROJECT_CC = |
||||
@ -0,0 +1,107 @@ |
|||||
|
{ |
||||
|
"folders": [ |
||||
|
{ |
||||
|
"path": "." |
||||
|
}, |
||||
|
{ |
||||
|
"path": "${workspaceRoot}/../../../../libs/openFrameworks" |
||||
|
}, |
||||
|
{ |
||||
|
"path": "${workspaceRoot}/../../../../addons" |
||||
|
} |
||||
|
], |
||||
|
"settings": { |
||||
|
"files.associations": { |
||||
|
"cctype": "cpp", |
||||
|
"clocale": "cpp", |
||||
|
"cmath": "cpp", |
||||
|
"csignal": "cpp", |
||||
|
"cstdarg": "cpp", |
||||
|
"cstddef": "cpp", |
||||
|
"cstdio": "cpp", |
||||
|
"cstdlib": "cpp", |
||||
|
"cstring": "cpp", |
||||
|
"ctime": "cpp", |
||||
|
"cwchar": "cpp", |
||||
|
"cwctype": "cpp", |
||||
|
"any": "cpp", |
||||
|
"array": "cpp", |
||||
|
"atomic": "cpp", |
||||
|
"strstream": "cpp", |
||||
|
"bit": "cpp", |
||||
|
"*.tcc": "cpp", |
||||
|
"bitset": "cpp", |
||||
|
"cfenv": "cpp", |
||||
|
"charconv": "cpp", |
||||
|
"chrono": "cpp", |
||||
|
"codecvt": "cpp", |
||||
|
"compare": "cpp", |
||||
|
"complex": "cpp", |
||||
|
"concepts": "cpp", |
||||
|
"condition_variable": "cpp", |
||||
|
"cstdint": "cpp", |
||||
|
"deque": "cpp", |
||||
|
"forward_list": "cpp", |
||||
|
"list": "cpp", |
||||
|
"map": "cpp", |
||||
|
"set": "cpp", |
||||
|
"string": "cpp", |
||||
|
"unordered_map": "cpp", |
||||
|
"unordered_set": "cpp", |
||||
|
"vector": "cpp", |
||||
|
"exception": "cpp", |
||||
|
"expected": "cpp", |
||||
|
"algorithm": "cpp", |
||||
|
"functional": "cpp", |
||||
|
"iterator": "cpp", |
||||
|
"memory": "cpp", |
||||
|
"memory_resource": "cpp", |
||||
|
"numeric": "cpp", |
||||
|
"optional": "cpp", |
||||
|
"random": "cpp", |
||||
|
"ratio": "cpp", |
||||
|
"regex": "cpp", |
||||
|
"source_location": "cpp", |
||||
|
"string_view": "cpp", |
||||
|
"system_error": "cpp", |
||||
|
"tuple": "cpp", |
||||
|
"type_traits": "cpp", |
||||
|
"utility": "cpp", |
||||
|
"fstream": "cpp", |
||||
|
"future": "cpp", |
||||
|
"initializer_list": "cpp", |
||||
|
"iomanip": "cpp", |
||||
|
"iosfwd": "cpp", |
||||
|
"iostream": "cpp", |
||||
|
"istream": "cpp", |
||||
|
"limits": "cpp", |
||||
|
"mutex": "cpp", |
||||
|
"new": "cpp", |
||||
|
"numbers": "cpp", |
||||
|
"ostream": "cpp", |
||||
|
"ranges": "cpp", |
||||
|
"semaphore": "cpp", |
||||
|
"shared_mutex": "cpp", |
||||
|
"span": "cpp", |
||||
|
"sstream": "cpp", |
||||
|
"stdexcept": "cpp", |
||||
|
"stop_token": "cpp", |
||||
|
"streambuf": "cpp", |
||||
|
"thread": "cpp", |
||||
|
"cinttypes": "cpp", |
||||
|
"typeindex": "cpp", |
||||
|
"typeinfo": "cpp", |
||||
|
"valarray": "cpp", |
||||
|
"variant": "cpp", |
||||
|
"format": "cpp", |
||||
|
"stdfloat": "cpp", |
||||
|
"__nullptr": "cpp", |
||||
|
"*.ipp": "cpp", |
||||
|
"__bit_reference": "cpp", |
||||
|
"__hash_table": "cpp", |
||||
|
"__split_buffer": "cpp", |
||||
|
"__tree": "cpp", |
||||
|
"filesystem": "cpp" |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,69 @@ |
|||||
|
import qbs |
||||
|
import qbs.Process |
||||
|
import qbs.File |
||||
|
import qbs.FileInfo |
||||
|
import qbs.TextFile |
||||
|
import "../../../libs/openFrameworksCompiled/project/qtcreator/ofApp.qbs" as ofApp |
||||
|
|
||||
|
Project{ |
||||
|
property string of_root: "../../.." |
||||
|
|
||||
|
ofApp { |
||||
|
name: { return FileInfo.baseName(sourceDirectory) } |
||||
|
|
||||
|
files: [ |
||||
|
'src/main.cpp', |
||||
|
'src/ofApp.cpp', |
||||
|
'src/ofApp.h', |
||||
|
] |
||||
|
|
||||
|
of.addons: [ |
||||
|
'ofxOpenCv', |
||||
|
'ofxOpenCv', |
||||
|
] |
||||
|
|
||||
|
// additional flags for the project. the of module sets some |
||||
|
// flags by default to add the core libraries, search paths... |
||||
|
// this flags can be augmented through the following properties: |
||||
|
of.pkgConfigs: [] // list of additional system pkgs to include |
||||
|
of.includePaths: [] // include search paths |
||||
|
of.cFlags: [] // flags passed to the c compiler |
||||
|
of.cxxFlags: [] // flags passed to the c++ compiler |
||||
|
of.linkerFlags: [] // flags passed to the linker |
||||
|
of.defines: [] // defines are passed as -D to the compiler |
||||
|
// and can be checked with #ifdef or #if in the code |
||||
|
of.frameworks: [] // osx only, additional frameworks to link with the project |
||||
|
of.staticLibraries: [] // static libraries |
||||
|
of.dynamicLibraries: [] // dynamic libraries |
||||
|
|
||||
|
// other flags can be set through the cpp module: http://doc.qt.io/qbs/cpp-module.html |
||||
|
// eg: this will enable ccache when compiling |
||||
|
// |
||||
|
// cpp.compilerWrapper: 'ccache' |
||||
|
|
||||
|
Depends{ |
||||
|
name: "cpp" |
||||
|
} |
||||
|
|
||||
|
// common rules that parse the include search paths, core libraries... |
||||
|
Depends{ |
||||
|
name: "of" |
||||
|
} |
||||
|
|
||||
|
// dependency with the OF library |
||||
|
Depends{ |
||||
|
name: "openFrameworks" |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
property bool makeOF: true // use makfiles to compile the OF library |
||||
|
// will compile OF only once for all your projects |
||||
|
// otherwise compiled per project with qbs |
||||
|
|
||||
|
|
||||
|
property bool precompileOfMain: false // precompile ofMain.h |
||||
|
// faster to recompile when including ofMain.h |
||||
|
// but might use a lot of space per project |
||||
|
|
||||
|
references: [FileInfo.joinPaths(of_root, "/libs/openFrameworksCompiled/project/qtcreator/openFrameworks.qbs")] |
||||
|
} |
||||
@ -0,0 +1 @@ |
|||||
|
## Affection Mapping Beta ## |
||||
@ -0,0 +1,287 @@ |
|||||
|
#include "Onnx.h" |
||||
|
|
||||
|
// Setups the model. CUDA is enabled by default
|
||||
|
void Onnx::Setup(ORTCHAR_T* modelPath, bool isLog, bool useCuda){ |
||||
|
session_options.SetIntraOpNumThreads(1); |
||||
|
session_options.SetIntraOpNumThreads(1); |
||||
|
session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL); |
||||
|
log = isLog; |
||||
|
|
||||
|
// cuda setup
|
||||
|
if(useCuda){ |
||||
|
OrtCUDAProviderOptions opts; |
||||
|
opts.device_id = 0; |
||||
|
opts.cudnn_conv_algo_search = OrtCudnnConvAlgoSearchExhaustive; |
||||
|
opts.do_copy_in_default_stream = 0; |
||||
|
opts.arena_extend_strategy = 0; |
||||
|
session_options.AppendExecutionProvider_CUDA(opts); |
||||
|
} |
||||
|
|
||||
|
ort_session = std::make_shared<Ort::Session>(ort_env, modelPath, session_options); |
||||
|
|
||||
|
Ort::AllocatorWithDefaultOptions allocator; |
||||
|
for (std::size_t i = 0; i < ort_session->GetInputCount(); i++) { |
||||
|
input_node_names.emplace_back(ort_session->GetInputNameAllocated(i, allocator).get()); |
||||
|
input_node_dims = ort_session->GetInputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape(); |
||||
|
if(log) |
||||
|
std::cout << "\t" << input_node_names.at(i) << " : " << PrintShape(input_node_dims) << std::endl; |
||||
|
} |
||||
|
|
||||
|
// some models might have negative shape values to indicate dynamic shape, e.g., for variable batch size.
|
||||
|
for (auto& s : input_node_dims) { |
||||
|
if (s < 0) { |
||||
|
s = 1; |
||||
|
if(log) |
||||
|
std::cout << "transfromed!" << std::endl; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
|
||||
|
if(log) |
||||
|
std::cout << "Output Node Name/Shape (" << output_node_names.size() << "):" << std::endl; |
||||
|
for (std::size_t i = 0; i < ort_session->GetOutputCount(); i++) { |
||||
|
output_node_names.emplace_back(ort_session->GetOutputNameAllocated(i, allocator).get()); |
||||
|
auto output_shapes = ort_session->GetOutputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape(); |
||||
|
if(log) |
||||
|
std::cout << "\t" << output_node_names.at(i) << " : " << PrintShape(output_shapes) << std::endl; |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
// Runs the model, given an image
|
||||
|
std::vector<Ort::Value> Onnx::Run(ofImage &img){ |
||||
|
|
||||
|
auto start = std::chrono::high_resolution_clock::now(); |
||||
|
|
||||
|
TransformImage(img); |
||||
|
size_t input_tensor_size = image_array.total(); |
||||
|
std::vector<Ort::Value> input_tensors; |
||||
|
Ort::MemoryInfo mem_info = Ort::MemoryInfo::CreateCpu(OrtAllocatorType::OrtArenaAllocator, OrtMemType::OrtMemTypeDefault); |
||||
|
input_tensors.emplace_back(Ort::Value::CreateTensor<float>(mem_info, (float*)image_array.data, |
||||
|
input_tensor_size, input_node_dims.data(), input_node_dims.size())); |
||||
|
|
||||
|
// double-check the dimensions of the input tensor
|
||||
|
assert(input_tensors[0].IsTensor() && input_tensors[0].GetTensorTypeAndShapeInfo().GetShape() == input_node_dims); |
||||
|
|
||||
|
//std::cout << "\ninput_tensor shape: " << PrintShape(input_tensors[0].GetTensorTypeAndShapeInfo().GetShape()) << std::endl;
|
||||
|
|
||||
|
// pass data through model
|
||||
|
std::vector<const char*> input_names_char(input_node_names.size(), nullptr); |
||||
|
std::transform(std::begin(input_node_names), std::end(input_node_names), std::begin(input_names_char), |
||||
|
[&](const std::string& str) { return str.c_str(); }); |
||||
|
|
||||
|
std::vector<const char*> output_names_char(output_node_names.size(), nullptr); |
||||
|
std::transform(std::begin(output_node_names), std::end(output_node_names), std::begin(output_names_char), |
||||
|
[&](const std::string& str) { return str.c_str(); }); |
||||
|
|
||||
|
std::cout << "Running model... "; |
||||
|
|
||||
|
try { |
||||
|
auto output_tensors = ort_session->Run(Ort::RunOptions{nullptr}, input_names_char.data(), input_tensors.data(), |
||||
|
input_names_char.size(), output_names_char.data(), output_names_char.size()); |
||||
|
|
||||
|
std::cout << "Done!" << std::endl; |
||||
|
|
||||
|
if (timeStamp) { |
||||
|
auto end = std::chrono::high_resolution_clock::now(); |
||||
|
std::chrono::duration<double, std::milli> elapsed = end - start; |
||||
|
std::cout << "Update loop took " << elapsed.count() << " ms" << std::endl; |
||||
|
} |
||||
|
|
||||
|
return output_tensors; |
||||
|
|
||||
|
} catch (const Ort::Exception& exception) { |
||||
|
std::cout << "ERROR running model inference: " << exception.what() << std::endl; |
||||
|
return input_tensors; |
||||
|
|
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
/*
|
||||
|
Runs a model, with a batch of images as input (emotion.onnx) |
||||
|
(1) Creates a 1-dim float array based on the batch * channels * width * height) |
||||
|
(2) Transforms each image into a cv::Mat, and appends it to the array |
||||
|
(3) Sends that information to the model to be processed. |
||||
|
*/ |
||||
|
std::vector<Ort::Value> Onnx::RunBatch(std::vector<ofImage>& images){ |
||||
|
|
||||
|
auto start = std::chrono::high_resolution_clock::now(); |
||||
|
|
||||
|
// Number of images in the batch
|
||||
|
size_t batchSize = images.size(); |
||||
|
|
||||
|
std::vector<int64_t> batch_node_dims = {static_cast<int64_t>(batchSize), 3, 260, 260}; |
||||
|
|
||||
|
std::vector<float> batch_image_array(static_cast<int64_t>(batchSize) * 3 * 260 * 260); |
||||
|
|
||||
|
for(size_t i = 0; i < batchSize; i++){ |
||||
|
TransformImage(images[i]); |
||||
|
// Copy the image data into the batch_image_array
|
||||
|
std::memcpy( |
||||
|
batch_image_array.data() + i * 3 * 260 * 260, // Destination: starting point for this image in the batch array
|
||||
|
image_array.data, // Source: pixel data in the cv::Mat
|
||||
|
3 * 260 * 260 * sizeof(float) // Size: number of bytes to copy (3 channels * 260 * 260 pixels)
|
||||
|
); |
||||
|
} |
||||
|
|
||||
|
size_t input_tensor_size = batch_image_array.size(); |
||||
|
std::vector<Ort::Value> input_tensors; |
||||
|
Ort::MemoryInfo mem_info = Ort::MemoryInfo::CreateCpu(OrtAllocatorType::OrtArenaAllocator, OrtMemType::OrtMemTypeDefault); |
||||
|
input_tensors.emplace_back(Ort::Value::CreateTensor<float>(mem_info, batch_image_array.data(), |
||||
|
input_tensor_size, batch_node_dims.data(), batch_node_dims.size())); |
||||
|
|
||||
|
// double-check the dimensions of the input tensor
|
||||
|
assert(input_tensors[0].IsTensor() && input_tensors[0].GetTensorTypeAndShapeInfo().GetShape() == batch_node_dims); |
||||
|
|
||||
|
std::cout << "\ninput_tensor shape: " << PrintShape(input_tensors[0].GetTensorTypeAndShapeInfo().GetShape()) << std::endl; |
||||
|
|
||||
|
// pass data through model
|
||||
|
std::vector<const char*> input_names_char(input_node_names.size(), nullptr); |
||||
|
std::transform(std::begin(input_node_names), std::end(input_node_names), std::begin(input_names_char), |
||||
|
[&](const std::string& str) { return str.c_str(); }); |
||||
|
|
||||
|
std::vector<const char*> output_names_char(output_node_names.size(), nullptr); |
||||
|
std::transform(std::begin(output_node_names), std::end(output_node_names), std::begin(output_names_char), |
||||
|
[&](const std::string& str) { return str.c_str(); }); |
||||
|
|
||||
|
std::cout << "Running model... "; |
||||
|
|
||||
|
try { |
||||
|
auto output_tensors = ort_session->Run(Ort::RunOptions{nullptr}, input_names_char.data(), input_tensors.data(), |
||||
|
input_names_char.size(), output_names_char.data(), output_names_char.size()); |
||||
|
|
||||
|
std::cout << "Done!" << std::endl; |
||||
|
|
||||
|
if (timeStamp) { |
||||
|
auto end = std::chrono::high_resolution_clock::now(); |
||||
|
std::chrono::duration<double, std::milli> elapsed = end - start; |
||||
|
std::cout << "Update loop took " << elapsed.count() << " ms" << std::endl; |
||||
|
} |
||||
|
|
||||
|
return output_tensors; |
||||
|
|
||||
|
} catch (const Ort::Exception& exception) { |
||||
|
std::cout << "ERROR running model inference: " << exception.what() << std::endl; |
||||
|
return input_tensors; |
||||
|
|
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
// Transforms an ofImage into a cv::ImageArray
|
||||
|
void Onnx::TransformImage(ofImage &img){ |
||||
|
// Convert ofImage to cv::Mat
|
||||
|
ofPixels &pixels = img.getPixels(); // Get pixels from ofImage
|
||||
|
int width = img.getWidth(); |
||||
|
int height = img.getHeight(); |
||||
|
int channels = img.getPixels().getNumChannels(); |
||||
|
|
||||
|
// Create a cv::Mat from the pixel data
|
||||
|
cv::Mat cvImg = cv::Mat(height, width, (channels == 3) ? CV_8UC3 : CV_8UC1, pixels.getData()); |
||||
|
|
||||
|
// Convert cv::Mat to cv::InputArray
|
||||
|
cv::InputArray inputArray(cvImg); |
||||
|
|
||||
|
image_array = cv::dnn::blobFromImage(inputArray, 1 / 255.0, cv::Size(input_node_dims[2] , input_node_dims[3] ), (0, 0, 0), false, false); |
||||
|
} |
||||
|
|
||||
|
/* Generates a random 1 dimensional float array, creating values between 0->255.
|
||||
|
Returns a tensor. */ |
||||
|
Ort::Value Onnx::GenerateTensor(){ |
||||
|
std::vector<float> random_input_tensor_values(CalculateProduct(input_node_dims)); |
||||
|
std::generate(random_input_tensor_values.begin(), random_input_tensor_values.end(), [&] { return rand() % 255; }); |
||||
|
return VectorToTensor(random_input_tensor_values, input_node_dims); |
||||
|
} |
||||
|
|
||||
|
// Calculates the product of the vector, how many values.
|
||||
|
int Onnx::CalculateProduct(const std::vector<std::int64_t>& v){ |
||||
|
int total = 1; |
||||
|
for (auto& i : v) total *= i; |
||||
|
return total; |
||||
|
} |
||||
|
|
||||
|
// Creates a tensor from a given vector input.
|
||||
|
Ort::Value Onnx::VectorToTensor(std::vector<float>& data, const std::vector<std::int64_t>& shape){ |
||||
|
Ort::MemoryInfo mem_info = Ort::MemoryInfo::CreateCpu(OrtAllocatorType::OrtArenaAllocator, OrtMemType::OrtMemTypeDefault); |
||||
|
auto tensor = Ort::Value::CreateTensor<float>(mem_info, data.data(), data.size(), shape.data(), shape.size()); |
||||
|
return tensor; |
||||
|
} |
||||
|
|
||||
|
// Prints the shape of the given tensor (ex. input: (1, 1, 512, 512))
|
||||
|
std::string Onnx::PrintShape(const std::vector<std::int64_t>& v){ |
||||
|
std::stringstream ss(""); |
||||
|
for (std::size_t i = 0; i < v.size() - 1; i++) ss << v[i] << "x"; |
||||
|
ss << v[v.size() - 1]; |
||||
|
return ss.str(); |
||||
|
} |
||||
|
|
||||
|
// Function to calculate the minimum value in an array
|
||||
|
float Onnx::ReduceMin(const float* data, size_t size) { |
||||
|
return *std::min_element(data, data + size); |
||||
|
} |
||||
|
|
||||
|
// Function to calculate the maximum value in an array
|
||||
|
float Onnx::ReduceMax(const float* data, size_t size) { |
||||
|
return *std::max_element(data, data + size); |
||||
|
} |
||||
|
|
||||
|
// Function to normalize an array between 0 and 1
|
||||
|
void Onnx::Normalize(float* data, size_t size, float min_value, float max_value) { |
||||
|
for (size_t i = 0; i < size; ++i) { |
||||
|
data[i] = (data[i] - min_value) / (max_value - min_value); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Coverts the output tensor data to a texture of a given ofFbo.
|
||||
|
void Onnx::DataToFbo(const float* data, size_t width, size_t height, ofFbo& fbo){ |
||||
|
// Convert data into opencv mat
|
||||
|
cv::Mat inputMat(height, width, CV_32FC1, const_cast<float*>(data)); |
||||
|
|
||||
|
// Convert to 8-bit grayscale Mat
|
||||
|
cv::Mat inputMat8U; |
||||
|
inputMat.convertTo(inputMat8U, CV_8UC1, 255.0); // Convert float to 8-bit grayscale
|
||||
|
|
||||
|
// Resize the image using OpenCV
|
||||
|
cv::Mat resizedMat; |
||||
|
cv::resize(inputMat8U, resizedMat, cv::Size(fbo.getWidth(), fbo.getHeight()), 0, 0, cv::INTER_LINEAR); |
||||
|
|
||||
|
// Convert OpenCV Mat to ofPixels
|
||||
|
ofPixels pixels; |
||||
|
pixels.allocate(fbo.getWidth(), fbo.getHeight(), OF_PIXELS_GRAY); |
||||
|
|
||||
|
// Copy data from resizedMat to ofPixels
|
||||
|
for (size_t y = 0; y < fbo.getHeight(); ++y) { |
||||
|
for (size_t x = 0; x < fbo.getWidth(); ++x) { |
||||
|
unsigned char value = resizedMat.at<uchar>(y, x); |
||||
|
pixels.setColor(x, y, ofColor(value)); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Update FBO with new pixels
|
||||
|
fbo.begin(); |
||||
|
ofTexture& texture = fbo.getTexture(); |
||||
|
texture.loadData(pixels); |
||||
|
fbo.end(); |
||||
|
|
||||
|
|
||||
|
} |
||||
|
|
||||
|
void Onnx::Softmax(float* data, size_t size) { |
||||
|
std::vector<float> logits(data, data + size); |
||||
|
std::vector<float> expValues(size); |
||||
|
float maxLogit = *std::max_element(logits.begin(), logits.end()); |
||||
|
|
||||
|
// Calculate exp(logit - maxLogit) for numerical stability
|
||||
|
std::transform(logits.begin(), logits.end(), expValues.begin(), |
||||
|
[maxLogit](float logit) { return std::exp(logit - maxLogit); }); |
||||
|
|
||||
|
float sumExp = std::accumulate(expValues.begin(), expValues.end(), 0.0f); |
||||
|
|
||||
|
// Normalize to get probabilities
|
||||
|
std::transform(expValues.begin(), expValues.end(), data, |
||||
|
[sumExp](float expValue) { return expValue / sumExp; }); |
||||
|
} |
||||
|
|
||||
|
|
||||
@ -0,0 +1,57 @@ |
|||||
|
#ifndef ONNX |
||||
|
#define ONNX |
||||
|
|
||||
|
#include <onnxruntime_cxx_api.h> |
||||
|
#include <algorithm> // std::generate |
||||
|
#include <cassert> |
||||
|
#include <cstddef> |
||||
|
#include <cstdint> |
||||
|
#include <iostream> |
||||
|
#include <sstream> |
||||
|
#include <string> |
||||
|
#include <vector> |
||||
|
#include <cstdlib> // For std::rand and std::srand |
||||
|
#include "ofMain.h" |
||||
|
#include "ofxOpenCv.h" |
||||
|
#include <numeric> |
||||
|
#include <cmath> |
||||
|
|
||||
|
class Onnx { |
||||
|
|
||||
|
public: |
||||
|
Onnx() {} |
||||
|
void Setup(ORTCHAR_T* modelPath, bool isLog, bool useCuda); |
||||
|
std::vector<Ort::Value> Run(ofImage &img); |
||||
|
std::vector<Ort::Value> RunBatch(std::vector<ofImage> &images); |
||||
|
std::string PrintShape(const std::vector<std::int64_t>& v); |
||||
|
Ort::Value VectorToTensor(std::vector<float>& data, const std::vector<std::int64_t>& shape); |
||||
|
Ort::Value GenerateTensor(); |
||||
|
int CalculateProduct(const std::vector<std::int64_t>& v); |
||||
|
void TransformImage(ofImage &img); |
||||
|
float ReduceMin(const float* data, size_t size); |
||||
|
float ReduceMax(const float* data, size_t size); |
||||
|
void Normalize(float* data, size_t size, float min_value, float max_value); |
||||
|
void DataToFbo(const float* data, size_t width, size_t height, ofFbo& fbo); |
||||
|
void Softmax(float* data, size_t size); |
||||
|
bool timeStamp = true; |
||||
|
bool log = false; |
||||
|
|
||||
|
protected: |
||||
|
Ort::Env ort_env; |
||||
|
Ort::SessionOptions session_options; |
||||
|
cv::Mat image_array; |
||||
|
std::shared_ptr<Ort::Session> ort_session; |
||||
|
std::vector<std::string> input_node_names; |
||||
|
std::vector<int64_t> input_node_dims; // 1 input only.
|
||||
|
std::size_t input_tensor_size = 1; |
||||
|
std::vector<float> input_values_handler; |
||||
|
Ort::MemoryInfo memory_info_handler = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault); |
||||
|
std::vector<std::string> output_node_names; |
||||
|
std::vector<std::vector<int64_t>> output_node_dims; // >=1 outputs
|
||||
|
std::vector<Ort::Value> output_values; |
||||
|
Ort::Value dummy_tensor{ nullptr }; |
||||
|
std::vector<ofImage> imageBatch; |
||||
|
int num_outputs = 1; |
||||
|
}; |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,55 @@ |
|||||
|
#include "Player.h" |
||||
|
|
||||
|
Player::Player(){ |
||||
|
hasVideo = false; |
||||
|
} |
||||
|
|
||||
|
/* Basic ofVideoPlayer setup */ |
||||
|
void Player::Setup(){ |
||||
|
videoPlayer.setLoopState(OF_LOOP_NONE); |
||||
|
videoPlayer.setVolume(0); |
||||
|
} |
||||
|
|
||||
|
/* Updated the video player:
|
||||
|
(1) Allocates the required W x H for the model input |
||||
|
(2) Updates the video texture, and sets the current frame value */ |
||||
|
void Player::Update(ofImage &img){ |
||||
|
|
||||
|
if(!img.isAllocated() || img.getWidth() != videoPlayer.getWidth() || img.getHeight() != videoPlayer.getHeight()){ |
||||
|
img.allocate(videoPlayer.getWidth(), videoPlayer.getHeight(), OF_IMAGE_COLOR); |
||||
|
std::cout << "allocating new ofImage" << std::endl; |
||||
|
} |
||||
|
|
||||
|
if(videoPlayer.isLoaded()){ |
||||
|
hasVideo = true; |
||||
|
playerCurrentFrame = videoPlayer.getCurrentFrame(); |
||||
|
videoPlayer.update(); |
||||
|
videoPlayer.play(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void Player::Draw(){ |
||||
|
if(videoPlayer.isLoaded()){ |
||||
|
videoPlayer.draw(0, 0); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
ofPixels Player::GetVideoPixels(){ |
||||
|
return videoPlayer.getPixels(); |
||||
|
} |
||||
|
|
||||
|
/* Loads the video from path:
|
||||
|
(1) Sets the frame |
||||
|
(2) Allocates the fbo dims for final render */ |
||||
|
void Player::SetVideo(std::string path, ofFbo &fbo){ |
||||
|
videoPlayer.load(path); |
||||
|
videoPlayer.setFrame(800); |
||||
|
fbo.allocate(videoPlayer.getWidth(), videoPlayer.getHeight(), GL_RGB); |
||||
|
} |
||||
|
|
||||
|
// Sets a random frame in the active video
|
||||
|
void Player::SetRandomFrame(){ |
||||
|
int randomFrame = ofRandom(0, videoPlayer.getTotalNumFrames()); |
||||
|
std::cout << "setting frame: " << randomFrame << std::endl; |
||||
|
videoPlayer.setFrame(randomFrame); |
||||
|
} |
||||
@ -0,0 +1,39 @@ |
|||||
|
#ifndef _PLAYER |
||||
|
#define _PLAYER |
||||
|
|
||||
|
#include "ofMain.h" |
||||
|
|
||||
|
class Player { |
||||
|
|
||||
|
public: |
||||
|
|
||||
|
void Setup(); |
||||
|
void Update(ofImage &img); |
||||
|
void Draw(); |
||||
|
void SetVideo(std::string path, ofFbo &fbo); |
||||
|
ofPixels GetVideoPixels(); |
||||
|
void SetVideoPosition(); |
||||
|
void SetRandomFrame(); |
||||
|
void SetupGUI(); |
||||
|
void UpdateGUI(); |
||||
|
void UpdateVector(); |
||||
|
void CheckNewFrame(); |
||||
|
void GetCurrentFrame(); |
||||
|
|
||||
|
ofVideoPlayer videoPlayer; |
||||
|
|
||||
|
int playerCurrentFrame; |
||||
|
int playerTotalFrameNum; |
||||
|
int playerVideoIndex; |
||||
|
std::string videoPath; |
||||
|
bool hasVideo; |
||||
|
|
||||
|
glm::vec2 centerPosition; |
||||
|
|
||||
|
ofFbo fbo; |
||||
|
|
||||
|
Player(); |
||||
|
|
||||
|
}; |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,155 @@ |
|||||
|
#include "Yolo.h" |
||||
|
|
||||
|
// Takes output tensor data, processes that data, and returns an array of BoxfWithLandmarks (detected_faces)
|
||||
|
void Yolo::ParseOutput(float* &output_tensors, std::vector<types::BoxfWithLandmarks> &sorted_faces, unsigned int num_anchors) { |
||||
|
|
||||
|
std::vector<types::BoxfWithLandmarks> detected_faces; |
||||
|
|
||||
|
for (unsigned int i = 0; i < num_anchors; ++i) { |
||||
|
const float *row_ptr = output_tensors + i * 16; // Each row contains 16 values
|
||||
|
float obj_conf = row_ptr[4]; // Objectness confidence
|
||||
|
|
||||
|
if (obj_conf < 0.5) continue; // Filter out low-confidence detections
|
||||
|
|
||||
|
// Extract bounding box, confidence, and landmarks
|
||||
|
float cx = row_ptr[0]; |
||||
|
float cy = row_ptr[1]; |
||||
|
float w = row_ptr[2]; |
||||
|
float h = row_ptr[3]; |
||||
|
float cls_conf = row_ptr[15]; // Face confidence score
|
||||
|
|
||||
|
if (cls_conf < 0.5) continue; // Filter by class confidence
|
||||
|
|
||||
|
types::BoxfWithLandmarks face; |
||||
|
face.box.x1 = cx - w / 2; |
||||
|
face.box.y1 = cy - h / 2; |
||||
|
face.box.x2 = cx + w / 2; |
||||
|
face.box.y2 = cy + h / 2; |
||||
|
face.box.score = cls_conf; |
||||
|
face.box.label_text = "face"; |
||||
|
|
||||
|
// Extract landmarks
|
||||
|
for (int j = 0; j < 10; j += 2) { |
||||
|
face.landmarks.points.push_back(cv::Point2f(row_ptr[5 + j], row_ptr[5 + j + 1])); |
||||
|
} |
||||
|
|
||||
|
detected_faces.push_back(face); // Store the detected face with landmarks
|
||||
|
} |
||||
|
|
||||
|
// Apply NMS to detected faces list to remove any overlapping bounding boxes.
|
||||
|
NonMaximumSuppression(detected_faces, sorted_faces, 0.5); |
||||
|
|
||||
|
// Sort faces based on confidence value
|
||||
|
SortDetectedFaces(sorted_faces); |
||||
|
} |
||||
|
|
||||
|
// Simple helper for drawing boxes given x1, y1, x2, y2 coordinates.
|
||||
|
void Yolo::DrawBox(std::vector<types::BoxfWithLandmarks> &detected_faces){ |
||||
|
for (const auto &face : detected_faces) { |
||||
|
ofNoFill(); |
||||
|
ofDrawRectangle(face.box.x1, face.box.y1, face.box.x2 - face.box.x1, face.box.y2 - face.box.y1); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Simple helper to draw boxes at the center of the detected face.
|
||||
|
void Yolo::DrawCenter(std::vector<types::BoxfWithLandmarks> &detected_faces){ |
||||
|
ofNoFill(); |
||||
|
ofDrawCircle(detected_faces[0].box.center, 5); |
||||
|
|
||||
|
} |
||||
|
|
||||
|
// Applies NMS to an array of BoxfWithLandmarks.face.boxes, to remove any overlapping bounding boxes.
|
||||
|
void Yolo::NonMaximumSuppression(std::vector<types::BoxfWithLandmarks> &input_faces, std::vector<types::BoxfWithLandmarks> &output_faces, float iou_threshold) |
||||
|
{ |
||||
|
// Sort the boxes by their confidence scores (highest to lowest)
|
||||
|
std::sort(input_faces.begin(), input_faces.end(), |
||||
|
[](const types::BoxfWithLandmarks &a, const types::BoxfWithLandmarks &b) { |
||||
|
return a.box.score > b.box.score; |
||||
|
}); |
||||
|
|
||||
|
std::vector<int> suppressed(input_faces.size(), 0); // Suppression mask
|
||||
|
|
||||
|
// Iterate through the boxes
|
||||
|
for (size_t i = 0; i < input_faces.size(); ++i) { |
||||
|
if (suppressed[i]) continue; // Skip already suppressed boxes
|
||||
|
|
||||
|
// Add this box to the output
|
||||
|
output_faces.push_back(input_faces[i]); |
||||
|
|
||||
|
for (size_t j = i + 1; j < input_faces.size(); ++j) { |
||||
|
if (suppressed[j]) continue; |
||||
|
|
||||
|
// Calculate IoU between box i and box j
|
||||
|
float iou = input_faces[i].box.iou_of(input_faces[j].box); |
||||
|
|
||||
|
// Suppress box j if IoU is greater than the threshold
|
||||
|
if (iou > iou_threshold) { |
||||
|
suppressed[j] = 1; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Scales the coordinates of detected faces from the model output dimensions -> the original input image dimensions.
|
||||
|
void Yolo::ConvertBoxCoordsToOriginalSize(std::vector<types::BoxfWithLandmarks> &detected_faces, size_t original_width, size_t original_height){ |
||||
|
float width_scale = static_cast<float>(original_width) / modelSize; |
||||
|
float height_scale = static_cast<float>(original_height) / modelSize; |
||||
|
|
||||
|
for (auto &face : detected_faces) { |
||||
|
// Convert bounding box coordinates
|
||||
|
face.box.x1 *= width_scale; |
||||
|
face.box.y1 *= height_scale; |
||||
|
face.box.x2 *= width_scale; |
||||
|
face.box.y2 *= height_scale; |
||||
|
face.box.UpdateCenter(); |
||||
|
|
||||
|
// Convert landmarks
|
||||
|
for (size_t j = 0; j < face.landmarks.points.size(); ++j) { |
||||
|
face.landmarks.points[j].x *= width_scale; |
||||
|
face.landmarks.points[j].y *= height_scale; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void Yolo::CropFaceToImage(ofImage &inputImage, types::BoxfWithLandmarks &face, ofxCvColorImage &colorImage){ |
||||
|
|
||||
|
colorImage.resetROI(); |
||||
|
|
||||
|
// Calculate the coordinates and dimensions of the face box
|
||||
|
float x1 = face.box.x1; |
||||
|
float y1 = face.box.y1; |
||||
|
float x2 = face.box.x2; |
||||
|
float y2 = face.box.y2; |
||||
|
|
||||
|
// Ensure coordinates are within the input image bounds
|
||||
|
x1 = ofClamp(x1, 0.0f, (float)inputImage.getWidth()); |
||||
|
y1 = ofClamp(y1, 0.0f, (float)inputImage.getHeight()); |
||||
|
x2 = ofClamp(x2, 0.0f, (float)inputImage.getWidth()); |
||||
|
y2 = ofClamp(y2, 0.0f, (float)inputImage.getHeight()); |
||||
|
|
||||
|
// Calculate width and height of the cropped area
|
||||
|
float cropWidth = x2 - x1; |
||||
|
float cropHeight = y2 - y1; |
||||
|
|
||||
|
// Create cropped section, defined by the box coords
|
||||
|
ofFbo tempFbo; |
||||
|
tempFbo.allocate(cropWidth, cropHeight, GL_RGB); |
||||
|
|
||||
|
tempFbo.begin(); |
||||
|
ofClear(0); |
||||
|
inputImage.getTexture().drawSubsection(0, 0, cropWidth, cropHeight, x1, y1); |
||||
|
tempFbo.end(); |
||||
|
|
||||
|
ofFloatPixels pix; |
||||
|
tempFbo.readToPixels(pix); |
||||
|
colorImage.setFromPixels(pix); |
||||
|
|
||||
|
colorImage.resize(260, 260); |
||||
|
} |
||||
|
|
||||
|
void Yolo::SortDetectedFaces(std::vector<types::BoxfWithLandmarks> &detectedFaces){ |
||||
|
std::sort(detectedFaces.begin(), detectedFaces.end(), |
||||
|
[](const types::BoxfWithLandmarks &a, const types::BoxfWithLandmarks &b) { |
||||
|
return a.box.score > b.box.score; // Sort in descending order
|
||||
|
}); |
||||
|
} |
||||
@ -0,0 +1,81 @@ |
|||||
|
#ifndef YOLO |
||||
|
#define YOLO |
||||
|
|
||||
|
#include "ofMain.h" |
||||
|
#include "ofxOpenCv.h" |
||||
|
#include <onnxruntime_cxx_api.h> |
||||
|
#include <algorithm> |
||||
|
|
||||
|
struct Emotef{ |
||||
|
float emotions[7]; |
||||
|
}; |
||||
|
|
||||
|
namespace types { |
||||
|
|
||||
|
/*
|
||||
|
Struct for storing information about detetced faces. |
||||
|
*/ |
||||
|
struct Boxf { |
||||
|
float x1, y1, x2, y2; // Coordinates of the bounding box
|
||||
|
float score; // Confidence score
|
||||
|
glm::vec2 center; |
||||
|
int label; // Class label (e.g., "face")
|
||||
|
std::string label_text; |
||||
|
Emotef emotional_state; |
||||
|
|
||||
|
// Calculate Intersection over Union (IoU) with another box
|
||||
|
float iou_of(const Boxf &other) const { |
||||
|
float intersection_x1 = std::max(x1, other.x1); |
||||
|
float intersection_y1 = std::max(y1, other.y1); |
||||
|
float intersection_x2 = std::min(x2, other.x2); |
||||
|
float intersection_y2 = std::min(y2, other.y2); |
||||
|
|
||||
|
float intersection_area = std::max(0.0f, intersection_x2 - intersection_x1) * |
||||
|
std::max(0.0f, intersection_y2 - intersection_y1); |
||||
|
|
||||
|
float this_area = (x2 - x1) * (y2 - y1); |
||||
|
float other_area = (other.x2 - other.x1) * (other.y2 - other.y1); |
||||
|
|
||||
|
float union_area = this_area + other_area - intersection_area; |
||||
|
|
||||
|
return intersection_area / union_area; |
||||
|
} |
||||
|
|
||||
|
void UpdateCenter(){ |
||||
|
center.x = (x1 + x2) / 2; |
||||
|
center.y = (y1 + y2) / 2; |
||||
|
} |
||||
|
|
||||
|
void SetEmotionState(float* emotional_data){ |
||||
|
std::copy(emotional_data, emotional_data + 7, emotional_state.emotions); |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
struct Landmarks { |
||||
|
std::vector<cv::Point2f> points; // Facial landmarks points (e.g., eyes, nose, mouth)
|
||||
|
bool flag = false; // Indicator if landmarks are available
|
||||
|
}; |
||||
|
|
||||
|
struct BoxfWithLandmarks { |
||||
|
Boxf box; // Bounding box for the face
|
||||
|
Landmarks landmarks; // Landmark points for the face
|
||||
|
bool flag = false; // Indicator if this detection is valid
|
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
class Yolo{ |
||||
|
public: |
||||
|
Yolo(){}; |
||||
|
void ParseOutput(float* &out_ptr, std::vector<types::BoxfWithLandmarks> &sorted_faces, unsigned int num_anchors); |
||||
|
void DrawBox(std::vector<types::BoxfWithLandmarks> &detected_faces); |
||||
|
void DrawCenter(std::vector<types::BoxfWithLandmarks> &detected_faces); |
||||
|
void NonMaximumSuppression(std::vector<types::BoxfWithLandmarks> &input_faces, std::vector<types::BoxfWithLandmarks> &output_faces, float iou_threshold); |
||||
|
void ConvertBoxCoordsToOriginalSize(std::vector<types::BoxfWithLandmarks> &detected_faces, size_t original_width, size_t original_height); |
||||
|
void CropFaceToImage(ofImage &inputImage, types::BoxfWithLandmarks &face, ofxCvColorImage &colorImage); |
||||
|
void SortDetectedFaces(std::vector<types::BoxfWithLandmarks> &detectedFaces); |
||||
|
private: |
||||
|
// Input dimenions of the model -- used for coordinate scaling.
|
||||
|
size_t modelSize = 640; |
||||
|
}; |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,17 @@ |
|||||
|
#include "ofMain.h" |
||||
|
#include "ofApp.h" |
||||
|
|
||||
|
//========================================================================
|
||||
|
int main( ){ |
||||
|
|
||||
|
//Use ofGLFWWindowSettings for more options like multi-monitor fullscreen
|
||||
|
ofGLWindowSettings settings; |
||||
|
settings.setSize(1280, 720); |
||||
|
settings.windowMode = OF_WINDOW; //can also be OF_FULLSCREEN
|
||||
|
|
||||
|
auto window = ofCreateWindow(settings); |
||||
|
|
||||
|
ofRunApp(window, make_shared<ofApp>()); |
||||
|
ofRunMainLoop(); |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,210 @@ |
|||||
|
#include "ofApp.h" |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::setup(){ |
||||
|
ofSetFrameRate(24); |
||||
|
ofSetVerticalSync(true); |
||||
|
|
||||
|
player.Setup(); |
||||
|
player.SetVideo("videos/demo.mp4", fbo); |
||||
|
|
||||
|
emoteImage.allocate(260, 260); |
||||
|
tempImage.allocate(emoteImage.getWidth(), emoteImage.getHeight(), OF_IMAGE_COLOR); |
||||
|
|
||||
|
ORTCHAR_T* modelPath = "/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/apps/myApps/onnx-test/bin/data/depth_anything_v2_vitb.onnx"; |
||||
|
ORTCHAR_T* modelPath2 = "/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/apps/myApps/onnx-test/bin/data/yolov5s-face.onnx"; |
||||
|
ORTCHAR_T* modelPath3 = "/home/cailean/Desktop/openframeworks/of_v0.12.0_linux64gcc6_release/apps/myApps/onnx-test/bin/data/rgb_emotion.onnx"; |
||||
|
|
||||
|
/* Setup Models (modelPath, log, useCuda) */ |
||||
|
yolo.Setup(modelPath2, false, true); |
||||
|
depth.Setup(modelPath, false, true); |
||||
|
emotion.Setup(modelPath3, false, true); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::update(){ |
||||
|
/* Check to see if the application has moved to the first frame
|
||||
|
As the models need to load first, as the first inference is quite slow */ |
||||
|
if(ofGetFrameNum() > 0) |
||||
|
firstRun = false; |
||||
|
|
||||
|
/* Clear detetced face list */ |
||||
|
detected_faces.clear(); |
||||
|
|
||||
|
/* Setup model input using ofImage */ |
||||
|
player.Update(img); |
||||
|
img.setFromPixels(player.GetVideoPixels()); |
||||
|
|
||||
|
/* Run Models */ |
||||
|
try{ |
||||
|
auto output_tensors = depth.Run(img); |
||||
|
float* output_ptr = output_tensors.front().GetTensorMutableData<float>(); |
||||
|
size_t num_elements = output_tensors.front().GetTensorTypeAndShapeInfo().GetElementCount(); |
||||
|
|
||||
|
float min_value = depth.ReduceMin(output_ptr, num_elements); |
||||
|
float max_value = depth.ReduceMax(output_ptr, num_elements); |
||||
|
|
||||
|
depth.Normalize(output_ptr, num_elements, min_value, max_value); |
||||
|
|
||||
|
depth.DataToFbo(output_ptr, 518, 518, fbo); |
||||
|
|
||||
|
auto output_tensors_face = yolo.Run(img); |
||||
|
|
||||
|
auto output_faces = output_tensors_face.front().GetTensorTypeAndShapeInfo().GetShape(); |
||||
|
|
||||
|
unsigned int num_anchors = output_faces[1]; // Number of anchors
|
||||
|
|
||||
|
float* output_face_ptr = output_tensors_face.front().GetTensorMutableData<float>(); |
||||
|
|
||||
|
faceDetector.ParseOutput(output_face_ptr, detected_faces, num_anchors); |
||||
|
|
||||
|
faceDetector.ConvertBoxCoordsToOriginalSize(detected_faces, fbo.getWidth(), fbo.getHeight()); |
||||
|
|
||||
|
/* As no input is generated for the emotion recognition model, run a dummy vector through the model
|
||||
|
So it can load */ |
||||
|
if(firstRun){ |
||||
|
|
||||
|
/*
|
||||
|
Create a dummy initial input of batch_size = 5, as |
||||
|
when initialising the model, it will attempt to create a space in memory for this array. |
||||
|
If the batch_size does change it will completely slow down inference, due to how the cudnn_search_algo is set. |
||||
|
None of the other search alogithms bar EXHAUSTIVE will work.. no idead why. |
||||
|
*/ |
||||
|
for(int i = 0; i < emotionImageMaxBatchSize; i++){ |
||||
|
tempImage.setFromPixels(emoteImage.getPixels()); |
||||
|
croppedFaces.push_back(tempImage); |
||||
|
} |
||||
|
|
||||
|
// Run model to warmup
|
||||
|
auto emotion_output_tensor = emotion.RunBatch(croppedFaces); |
||||
|
|
||||
|
} else { |
||||
|
inferEmotionalState(); |
||||
|
} |
||||
|
|
||||
|
/* Run emotion inference */ |
||||
|
//inferEmotionalState();
|
||||
|
|
||||
|
} catch (exception e){ |
||||
|
|
||||
|
std::cout << "Model did not run" << std::endl; |
||||
|
|
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::draw(){ |
||||
|
fbo.draw(0, 0); |
||||
|
|
||||
|
if(!firstRun){ |
||||
|
faceDetector.DrawBox(detected_faces); |
||||
|
faceDetector.DrawCenter(detected_faces); |
||||
|
} |
||||
|
|
||||
|
// emoteImage.draw(640, 0);
|
||||
|
// for(auto& face : detected_faces){
|
||||
|
// ofDrawBitmapString(std::to_string(face.box.emotional_state.emotions[0]), 700, 300);
|
||||
|
// }
|
||||
|
|
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::inferEmotionalState(){ |
||||
|
|
||||
|
/*
|
||||
|
Max faces to process with the model (5) |
||||
|
*/ |
||||
|
int max_faces_to_process = std::min(emotionImageMaxBatchSize, static_cast<int>(detected_faces.size())); |
||||
|
|
||||
|
/*
|
||||
|
For the detetced faces, set the cropped image to a location in the image batch array |
||||
|
*/ |
||||
|
for (size_t i = 0; i < max_faces_to_process; i++){ |
||||
|
auto& face = detected_faces[i]; |
||||
|
faceDetector.CropFaceToImage(img, face, emoteImage); |
||||
|
tempImage.setFromPixels(emoteImage.getPixels()); |
||||
|
croppedFaces[i] = tempImage; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
auto emotion_output_tensor = emotion.RunBatch(croppedFaces); |
||||
|
|
||||
|
auto& output_tensor = emotion_output_tensor.front(); |
||||
|
auto output_shap = output_tensor.GetTensorTypeAndShapeInfo().GetShape(); |
||||
|
size_t batch_size = output_shap[0]; // Number of images in the batch
|
||||
|
size_t num_classes = output_shap[1]; // Number of emotion classes
|
||||
|
std::cout << batch_size << " : " << num_classes << std::endl; |
||||
|
|
||||
|
// for(int i = 0; i < max_faces_to_process; ++i){
|
||||
|
// auto& face = detected_faces[i];
|
||||
|
// faceDetector.CropFaceToImage(img, face, emoteImage);
|
||||
|
// tempImage.setFromPixels(emoteImage.getPixels());
|
||||
|
// auto emotion_output_tensor = emotion.Run(tempImage);
|
||||
|
// float* emotional_data = emotion_output_tensor.front().GetTensorMutableData<float>();
|
||||
|
// emotion.Softmax(emotional_data, 7);
|
||||
|
// face.box.SetEmotionState(emotional_data);
|
||||
|
// }
|
||||
|
|
||||
|
std::cout << croppedFaces.size() << std::endl; |
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::keyPressed(int key){ |
||||
|
if (key=OF_KEY_LEFT){ |
||||
|
player.SetRandomFrame(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::keyReleased(int key){ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::mouseMoved(int x, int y ){ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::mouseDragged(int x, int y, int button){ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::mousePressed(int x, int y, int button){ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::mouseReleased(int x, int y, int button){ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::mouseEntered(int x, int y){ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::mouseExited(int x, int y){ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::windowResized(int w, int h){ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::gotMessage(ofMessage msg){ |
||||
|
|
||||
|
} |
||||
|
|
||||
|
//--------------------------------------------------------------
|
||||
|
void ofApp::dragEvent(ofDragInfo dragInfo){ |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,49 @@ |
|||||
|
#pragma once |
||||
|
|
||||
|
#include "ofMain.h" |
||||
|
#include <onnxruntime_cxx_api.h> |
||||
|
#include "ofxOpenCv.h" |
||||
|
#include "Onnx.h" |
||||
|
#include "Yolo.h" |
||||
|
#include <vector> |
||||
|
#include "Player.h" |
||||
|
|
||||
|
class ofApp : public ofBaseApp{ |
||||
|
|
||||
|
public: |
||||
|
void setup(); |
||||
|
void update(); |
||||
|
void draw(); |
||||
|
|
||||
|
void keyPressed(int key); |
||||
|
void keyReleased(int key); |
||||
|
void mouseMoved(int x, int y ); |
||||
|
void mouseDragged(int x, int y, int button); |
||||
|
void mousePressed(int x, int y, int button); |
||||
|
void mouseReleased(int x, int y, int button); |
||||
|
void mouseEntered(int x, int y); |
||||
|
void mouseExited(int x, int y); |
||||
|
void windowResized(int w, int h); |
||||
|
void dragEvent(ofDragInfo dragInfo); |
||||
|
void gotMessage(ofMessage msg); |
||||
|
void inferEmotionalState(); |
||||
|
|
||||
|
ofImage img; |
||||
|
ofFbo fbo; |
||||
|
cv::Mat cvImg; |
||||
|
ofVideoGrabber webcam; |
||||
|
Player player; |
||||
|
bool firstRun = true; |
||||
|
|
||||
|
Onnx depth; |
||||
|
Onnx yolo; |
||||
|
Onnx emotion; |
||||
|
ofxCvColorImage emoteImage; |
||||
|
ofImage tempImage; |
||||
|
std::vector<ofImage> croppedFaces; |
||||
|
int emotionImageMaxBatchSize = 5; |
||||
|
|
||||
|
Emotef emo; |
||||
|
Yolo faceDetector; |
||||
|
std::vector<types::BoxfWithLandmarks> detected_faces; |
||||
|
}; |
||||
Loading…
Reference in new issue