openiss / openiss Goto Github PK

Our C image kernel driver only work on non-UEFI boots (physical or virtual). Key/signing is required for UEFI secure boot and is unavoidable.

• https://www.centos.org/forums/viewtopic.php?t=47224
• https://www.kernel.org/doc/html/v4.15/admin-guide/module-signing.html
• https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/7/html/Kernel_Administration_Guide/sect-signing-kernel-modules-for-secure-boot.html
• https://blog.ubuntu.com/2017/08/11/how-to-sign-things-for-secure-boot

Complete the OpenGL pipeline profile with OpenGL as many samples as possible from ogl, openFrameworks, opencv.

Look into the ROS project and any suitable integrations.

Last time there were compilation issues with openFrameworks on EL6, which should now be resolved and re-added back to build.sh

Describe your documentation, achievements, limitations, progress to date, experience, future work, bugs, etc. in doc/CSI230F17.md

Akin to el6.sh, we need el7.sh with proper mods elsewhere.

In #8 we used unofficial images for Travis-CI builds; now SL has official images, should switch to those:

• https://hub.docker.com/_/sl

Please create osx branch off master. We need a script similar to scripts/dependencies/el6.sh, but osx.sh to install all required dependencies to build OpenISS submodules and itself. Not urgent. You would figure out what is needed based on #14.

Complete the OpenCV pipeline profile with as many samples as possible that are non-OpenGL, but related to video, image, etc. processing.

From PR #48.

Per comment in PR #48

Per OpenKinect/libfreenect2#1042 (comment)

Hopefully distros ship newer as well.

As an offshoot of #5 -- need to add matrices for Scientific Linux 6 and 7. Current docker hub releases are:

• https://hub.docker.com/r/ringo/scientific/

1. Location should be src/api/c/issimagedrv/ instead of src/api/c/quiz3/.
2. Augment OpenISS’s build.sh/el6.sh/Makefile as necessary (target(s), option(s)) to install and configure the driver and its Kernel devel dependencies.

Akin to el6.sh, we will need ubuntu.sh and the corresponding mods to build.sh and Makefile.

Similarly to #43 -- can use docker, npm, and other packaging on GitHub:

• https://github.com/OpenISS/OpenISS/packages

Allow two or more Kinects collecting data simultaneously, and pumping it it to a single collector process. This is a multiprocess application.
See a sample design here: https://doi.org/10.1145/2945078.2945131 that was based on libfreenect2 and Protonect

Integrate libfreenect’s fakenect to replay Kinect videos and test with the OSC by having a single receiver process and two sender processes – either two fakenect senders, or one real and fake, or two ore more real senders.

Per PR #48. Not urgent.

ogl fell through the cracks in build.sh, so need to re-add it. Even through most of the deps are covered in el6.sh, we should also check it.

With or without #16, it'd needed to test Ubuntu as well as we are getting more Ubuntu deployments now.

Similarly to el6.sh, or #17 or #16 -- create an arch.sh dependencies script and make proper integrations with Makefile and build.sh

• Link child READMEs from 487
• Update the list of contributors
  • 487
  • Jash / Eric / etc.
• Update references to posts, videos, links, articles

• should include all branches and tags, merged and rebased

• for reference and simplified installs
• own dockerhub, etc. with different distros
• see https://github.com/kpsimoulis/docker/
• either as a fork or a submodule or both within OpenISS org

It seems there is a high security alert on nodejs soap package

Unfortunately there is no solution yet but there is a pull request. As soon as it's merged, we can update soap

vpulim/node-soap#1144

Need to find an ARM-based machine(s) and in particular Apple M1-based MAC to test and compile our apps and deps and the lib itself to verify if it works. The list here needs to be updated:

• https://github.com/ThatGuySam/doesitarm (https://doesitarm.com/)

in src/api/java/openiss/utils/OpenISSImageDriver.java
lines 137-144 there is logical error
looks like the line 139 should be: int height = image_1.getHeight();
please validate and fix if needed.

below is the original code:

        // check height and width
        int width = image_1.getWidth();
        int height = image_2.getHeight();

        // check equal size
        if(width != image_2.getWidth() || height != image_2.getHeight()) {
            throw new IllegalArgumentException("dimensions are not equal.");
        }

Folks, please test see if you are able to rebuild the submodules of OpenISS (libfreenect, libfreenect2, ogl, opencv, tinyosc, openFrameworks) on OS X manually or using their build instructions/scripts Try running their examples. Report progress here. This is NOT urgent.

There are two conceptual components to this part.
They will communicate over UDP-based OSC protocol using sockets.
Start with a C implementation of OSC (partial), that is based on TinyOSC that is already a submodule of OpenISS:
https://github.com/mhroth/tinyosc
but embedded into our project.
The purpose to separate skeleton capture and rendering into different computers possibly running Kinect sensors.
One computer will act as a collector and render graphics based on skeleton information from two or more computers.
(a) Using tinyosc, implement issoscsender and issoscreceiver processes with a simple pro- tocol
(b) If skeleton data are available from either libfreenct or libfreenect2 (via OpenNI2 that both have), try capturing real data and sending it over and drawing a skeleton in an OpenGL window. It is OK to re-use an appropriately licensed open source example for this purpose.
(c) OSC protocol messages would look like /player 1 /left-hand /x 1 /y 2 /z 3 etc.

1. Test and run the recording and replay tools in fakenect-record, and the corresponding driver
   library (see documentation of libfreenect on their GitHub front page).
2. First, use the dataset provided ISSv2-fakenect-record in one or more instances of your process.
3. Record at least two datasets from the lab movements 1 minute each, one per team.
4. Write a simple test app that fork()s two sub-processes that playback the recorded content from each data set concurrently.

Instead of Kinect, use a web cam for color image processing with OpenCV. Apply any related examples from OpenCV or openFrameworks using our VFX API.

Both Processing and Magenta rely on these to render in the browser.

Locate a library/sample preferably in C or worst case in C++ that can read sound files and play them back. Implement a function of OpenISS that could load and play the specified file either as a subprocess or as an idle call (called from the idle callback when animation is done), such that audio data, such as spectrum or amplitude be available to the VFX to generate sound-based visualizations.

openFrameworks has some sound processing in it; check the samples.

@laihaotao @jashanj0tsingh -- please re-test merged code here for now in branch team10

wget fails as it's not install in CentOS docker images by default

For compile tests for Linux, Windows, and OS X

Use microphone input based VFX sample to alter graphics being displayed
based on sound processing similar to the above.

Under src/api/js, per PR #48.

Implement one effect wrapper that uses that the issimgdrv and a /dev/urandom as a source.

• for libfreenect and libfreenect2
• for Processing a-la OpenKinect-for-Processing and SimpleOpenNI
• OpenCV has built, it need to unify export with libfeenect*
• ofx and others later to see what they export

Enable OpenNI2 skeleton data collection in EL6 Linux. Write/port a C app that illustrates it by visually drawing skeletons of captured subjects.
While libfreenect itself can be built using stock cmake and gcc 4.4 on EL6, enabling building OpenNI2 driver requires cmake3 and 4.8+ gcc from devtools-2. See a related examples here.

     wget -O /etc/yum.repos.d/slc6-devtoolset.repo \
         http://linuxsoft.cern.ch/cern/devtoolset/slc6-devtoolset.repo
     yum install devtoolset-2-gcc-c++
     scl enable devtoolset-2 bash
     cmake3 ... -D...OPENNI2...=ON -L ..

Complete the sample openFrameworks pipeline profile with as many samples as possible that are non-OpenGL, but related to video, image, etc. processing.

Re-implement an app based on OpenISS inspired from MultiCamTk++ design outlined here: https://doi.org/10.1145/2945078.2945131