Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
No results found
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 2589 additions and 0 deletions
examples/JUCE/regression_synth/regression_synth.jucer 0 → 100644
View file @ a0bfd689
<?xml version="1.0" encoding="UTF-8"?>
<JUCERPROJECT id="Zh7kpS" name="regression_synth" projectType="guiapp" version="1.0.0"
bundleIdentifier="com.goldsmiths.rapidmix" includeBinaryInAppConfig="1"
jucerVersion="5.2.0" displaySplashScreen="1" reportAppUsage="1"
splashScreenColour="Dark" cppLanguageStandard="11" companyWebsite="rapidmixapi.com"
companyCopyright="">
<MAINGROUP id="g6MNSM" name="regression_synth">
<GROUP id="{EEA5B7C1-BCCC-64B0-259E-056090611E46}" name="Maximilian">
<GROUP id="{E20267E7-DDC5-EF6E-1EAE-C4B745764568}" name="libs">
<FILE id="h0SFJ1" name="fft.cpp" compile="1" resource="0" file="../../../dependencies/Maximilian/libs/fft.cpp"/>
<FILE id="pYguvb" name="fft.h" compile="0" resource="0" file="../../../dependencies/Maximilian/libs/fft.h"/>
<FILE id="QKNTAJ" name="maxiAtoms.cpp" compile="1" resource="0" file="../../../dependencies/Maximilian/libs/maxiAtoms.cpp"/>
<FILE id="FFoUBX" name="maxiAtoms.h" compile="0" resource="0" file="../../../dependencies/Maximilian/libs/maxiAtoms.h"/>
<FILE id="iwzAfI" name="maxiBark.cpp" compile="1" resource="0" file="../../../dependencies/Maximilian/libs/maxiBark.cpp"/>
<FILE id="yMdl88" name="maxiBark.h" compile="0" resource="0" file="../../../dependencies/Maximilian/libs/maxiBark.h"/>
<FILE id="xngR2q" name="maxiFFT.cpp" compile="1" resource="0" file="../../../dependencies/Maximilian/libs/maxiFFT.cpp"/>
<FILE id="A78B6e" name="maxiFFT.h" compile="0" resource="0" file="../../../dependencies/Maximilian/libs/maxiFFT.h"/>
<FILE id="I4uKZC" name="maxiGrains.cpp" compile="1" resource="0" file="../../../dependencies/Maximilian/libs/maxiGrains.cpp"/>
<FILE id="iWeaAV" name="maxiGrains.h" compile="0" resource="0" file="../../../dependencies/Maximilian/libs/maxiGrains.h"/>
<FILE id="Zhejq6" name="maxim.h" compile="0" resource="0" file="../../../dependencies/Maximilian/libs/maxim.h"/>
<FILE id="sYsKW9" name="maxiMFCC.cpp" compile="1" resource="0" file="../../../dependencies/Maximilian/libs/maxiMFCC.cpp"/>
<FILE id="mCQV3j" name="maxiMFCC.h" compile="0" resource="0" file="../../../dependencies/Maximilian/libs/maxiMFCC.h"/>
<FILE id="u3TFe0" name="sineTable.h" compile="0" resource="0" file="../../../dependencies/Maximilian/libs/sineTable.h"/>
</GROUP>
<FILE id="m2Fbmi" name="maximilian.h" compile="0" resource="0" file="../../../dependencies/Maximilian/maximilian.h"/>
<FILE id="R5ZjoZ" name="maximilian.cpp" compile="1" resource="0" file="../../../dependencies/Maximilian/maximilian.cpp"/>
</GROUP>
<GROUP id="{D5573091-5DD2-23C2-72F7-033E80306961}" name="RapidLib">
<GROUP id="{9F227387-ED1A-B17B-AAF3-0B2D43546269}" name="src">
<GROUP id="{A3EB9FB3-AE6F-6CA1-169C-0FF061BD4B0C}" name="emscripten">
<FILE id="o0rrsi" name="classificationEmbindings.h" compile="0" resource="0"
file="../../../dependencies/RapidLib/src/emscripten/classificationEmbindings.h"/>
<FILE id="K95sXr" name="knnEmbindings.h" compile="0" resource="0" file="../../../dependencies/RapidLib/src/emscripten/knnEmbindings.h"/>
<FILE id="BMqYkg" name="modelSetEmbindings.h" compile="0" resource="0"
file="../../../dependencies/RapidLib/src/emscripten/modelSetEmbindings.h"/>
<FILE id="jEjfUj" name="nnEmbindings.h" compile="0" resource="0" file="../../../dependencies/RapidLib/src/emscripten/nnEmbindings.h"/>
<FILE id="gjnhIh" name="nodeEnv.js" compile="0" resource="1" file="../../../dependencies/RapidLib/src/emscripten/nodeEnv.js"/>
<FILE id="iRFc6d" name="rapidLibPost.js" compile="0" resource="1" file="../../../dependencies/RapidLib/src/emscripten/rapidLibPost.js"/>
<FILE id="PzNivx" name="rapidStreamEmbindings.h" compile="0" resource="0"
file="../../../dependencies/RapidLib/src/emscripten/rapidStreamEmbindings.h"/>
<FILE id="GHQaRa" name="regressionEmbindings.h" compile="0" resource="0"
file="../../../dependencies/RapidLib/src/emscripten/regressionEmbindings.h"/>
<FILE id="PivhZh" name="seriesClassificationEmbindings.h" compile="0"
resource="0" file="../../../dependencies/RapidLib/src/emscripten/seriesClassificationEmbindings.h"/>
<FILE id="Q4hJHG" name="svmEmbindings.h" compile="0" resource="0" file="../../../dependencies/RapidLib/src/emscripten/svmEmbindings.h"/>
</GROUP>
<FILE id="VDnAfe" name="baseModel.h" compile="0" resource="0" file="../../../dependencies/RapidLib/src/baseModel.h"/>
<FILE id="x2NkmO" name="classification.cpp" compile="1" resource="1"
file="../../../dependencies/RapidLib/src/classification.cpp"/>
<FILE id="iQdC88" name="classification.h" compile="0" resource="0"
file="../../../dependencies/RapidLib/src/classification.h"/>
<FILE id="otvyPe" name="dtw.cpp" compile="1" resource="0" file="../../../dependencies/RapidLib/src/dtw.cpp"/>
<FILE id="zh6JH2" name="dtw.h" compile="0" resource="0" file="../../../dependencies/RapidLib/src/dtw.h"/>
<FILE id="gg80D5" name="fastDTW.cpp" compile="1" resource="0" file="../../../dependencies/RapidLib/src/fastDTW.cpp"/>
<FILE id="Ga8ett" name="fastDTW.h" compile="0" resource="0" file="../../../dependencies/RapidLib/src/fastDTW.h"/>
<FILE id="d3LgeL" name="knnClassification.cpp" compile="1" resource="0"
file="../../../dependencies/RapidLib/src/knnClassification.cpp"/>
<FILE id="G5zqzw" name="knnClassification.h" compile="0" resource="0"
file="../../../dependencies/RapidLib/src/knnClassification.h"/>
<FILE id="eEEUwv" name="modelSet.cpp" compile="1" resource="0" file="../../../dependencies/RapidLib/src/modelSet.cpp"/>
<FILE id="ieo9qs" name="modelSet.h" compile="0" resource="0" file="../../../dependencies/RapidLib/src/modelSet.h"/>
<FILE id="BLEyMT" name="neuralNetwork.cpp" compile="1" resource="0"
file="../../../dependencies/RapidLib/src/neuralNetwork.cpp"/>
<FILE id="MEILfO" name="neuralNetwork.h" compile="0" resource="0" file="../../../dependencies/RapidLib/src/neuralNetwork.h"/>
<FILE id="x3ZMq1" name="rapidStream.cpp" compile="1" resource="0" file="../../../dependencies/RapidLib/src/rapidStream.cpp"/>
<FILE id="C7Nz0H" name="rapidStream.h" compile="0" resource="0" file="../../../dependencies/RapidLib/src/rapidStream.h"/>
<FILE id="wJpnuO" name="regression.cpp" compile="1" resource="0" file="../../../dependencies/RapidLib/src/regression.cpp"/>
<FILE id="ny9hho" name="regression.h" compile="0" resource="0" file="../../../dependencies/RapidLib/src/regression.h"/>
<FILE id="QwAPCf" name="searchWindow.cpp" compile="1" resource="0"
file="../../../dependencies/RapidLib/src/searchWindow.cpp"/>
<FILE id="hRP4uS" name="searchWindow.h" compile="0" resource="0" file="../../../dependencies/RapidLib/src/searchWindow.h"/>
<FILE id="INKhcY" name="seriesClassification.cpp" compile="1" resource="0"
file="../../../dependencies/RapidLib/src/seriesClassification.cpp"/>
<FILE id="B0c8F3" name="seriesClassification.h" compile="0" resource="0"
file="../../../dependencies/RapidLib/src/seriesClassification.h"/>
<FILE id="T74lKl" name="svmClassification.cpp" compile="1" resource="0"
file="../../../dependencies/RapidLib/src/svmClassification.cpp"/>
<FILE id="cVqdZA" name="svmClassification.h" compile="0" resource="0"
file="../../../dependencies/RapidLib/src/svmClassification.h"/>
<FILE id="lKTpTj" name="trainingExample.h" compile="0" resource="0"
file="../../../dependencies/RapidLib/src/trainingExample.h"/>
<FILE id="DtjqOn" name="warpPath.cpp" compile="1" resource="0" file="../../../dependencies/RapidLib/src/warpPath.cpp"/>
<FILE id="JjHvke" name="warpPath.h" compile="0" resource="0" file="../../../dependencies/RapidLib/src/warpPath.h"/>
</GROUP>
<GROUP id="{C5C7E07C-213F-8ECA-B1B6-B6BE04D35EAF}" name="dependencies">
<GROUP id="{E2AB2F69-E9EC-0A7F-8492-228002C6DB3D}" name="json">
<FILE id="vuXt8e" name="json-forwards.h" compile="0" resource="0" file="../../../dependencies/RapidLib/dependencies/json/json-forwards.h"/>
<FILE id="pVNxcf" name="json.h" compile="0" resource="0" file="../../../dependencies/RapidLib/dependencies/json/json.h"/>
</GROUP>
<GROUP id="{5C2C9ACC-885E-978B-0183-576F0DD3DA61}" name="libsvm">
<FILE id="Hh1DiU" name="libsvm.cpp" compile="1" resource="0" file="../../../dependencies/RapidLib/dependencies/libsvm/libsvm.cpp"/>
<FILE id="f5D4KB" name="libsvm.h" compile="0" resource="0" file="../../../dependencies/RapidLib/dependencies/libsvm/libsvm.h"/>
</GROUP>
<GROUP id="{655D6BCB-6FC6-1A2E-B6D7-C9170D46D415}" name="src">
<FILE id="YiXjKj" name="BayesianFilter.cpp" compile="1" resource="0"
file="../../../dependencies/RapidLib/dependencies/bayesfilter/src/BayesianFilter.cpp"/>
<FILE id="Y6sxtQ" name="BayesianFilter.h" compile="0" resource="0"
file="../../../dependencies/RapidLib/dependencies/bayesfilter/src/BayesianFilter.h"/>
<FILE id="z3J9mx" name="filter_utilities.cpp" compile="1" resource="0"
file="../../../dependencies/RapidLib/dependencies/bayesfilter/src/filter_utilities.cpp"/>
<FILE id="GT07wW" name="filter_utilities.h" compile="0" resource="0"
file="../../../dependencies/RapidLib/dependencies/bayesfilter/src/filter_utilities.h"/>
</GROUP>
<FILE id="ibbler" name="jsoncpp.cpp" compile="1" resource="0" file="../../../dependencies/RapidLib/dependencies/jsoncpp.cpp"/>
</GROUP>
</GROUP>
<GROUP id="{24ED27E9-EF99-2FF0-3FAC-40EF82C0F046}" name="Source">
<FILE id="KK8sNt" name="MainComponent.cpp" compile="1" resource="0"
file="Source/MainComponent.cpp"/>
<FILE id="vn82oj" name="Main.cpp" compile="1" resource="0" file="Source/Main.cpp"/>
</GROUP>
</MAINGROUP>
<EXPORTFORMATS>
<VS2015 targetFolder="Builds/VisualStudio2015">
<CONFIGURATIONS>
<CONFIGURATION name="Debug" winWarningLevel="4" generateManifest="1" winArchitecture="32-bit"
isDebug="1" optimisation="1" targetName="regression_synth" headerPath="../../../../dependencies/Maximilian/"
debugInformationFormat="ProgramDatabase" enablePluginBinaryCopyStep="0"/>
<CONFIGURATION name="Release" winWarningLevel="4" generateManifest="1" winArchitecture="32-bit"
isDebug="0" optimisation="3" targetName="regression_synth" headerPath="../../../../dependencies/Maximilian"
debugInformationFormat="ProgramDatabase" enablePluginBinaryCopyStep="0"
linkTimeOptimisation="1"/>
</CONFIGURATIONS>
<MODULEPATHS>
<MODULEPATH id="juce_core" path="../JUCE/modules"/>
<MODULEPATH id="juce_events" path="../JUCE/modules"/>
<MODULEPATH id="juce_graphics" path="../JUCE/modules"/>
<MODULEPATH id="juce_data_structures" path="../JUCE/modules"/>
<MODULEPATH id="juce_gui_basics" path="../JUCE/modules"/>
<MODULEPATH id="juce_gui_extra" path="../JUCE/modules"/>
<MODULEPATH id="juce_cryptography" path="../JUCE/modules"/>
<MODULEPATH id="juce_video" path="../JUCE/modules"/>
<MODULEPATH id="juce_opengl" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_basics" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_devices" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_formats" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_processors" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_utils" path="../JUCE/modules"/>
</MODULEPATHS>
</VS2015>
<XCODE_MAC targetFolder="Builds/MacOSX">
<CONFIGURATIONS>
<CONFIGURATION name="Debug" isDebug="1" optimisation="1" targetName="regression_synth"
headerPath="../../../../dependencies/Maximilian" enablePluginBinaryCopyStep="1"/>
<CONFIGURATION name="Release" isDebug="0" optimisation="3" targetName="regression_synth"
headerPath="../../../../dependencies/Maximilian" enablePluginBinaryCopyStep="1"/>
</CONFIGURATIONS>
<MODULEPATHS>
<MODULEPATH id="juce_video" path="../JUCE/modules"/>
<MODULEPATH id="juce_opengl" path="../JUCE/modules"/>
<MODULEPATH id="juce_gui_extra" path="../JUCE/modules"/>
<MODULEPATH id="juce_gui_basics" path="../JUCE/modules"/>
<MODULEPATH id="juce_graphics" path="../JUCE/modules"/>
<MODULEPATH id="juce_events" path="../JUCE/modules"/>
<MODULEPATH id="juce_data_structures" path="../JUCE/modules"/>
<MODULEPATH id="juce_cryptography" path="../JUCE/modules"/>
<MODULEPATH id="juce_core" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_utils" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_processors" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_formats" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_devices" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_basics" path="../JUCE/modules"/>
</MODULEPATHS>
</XCODE_MAC>
<LINUX_MAKE targetFolder="Builds/LinuxMakefile">
<CONFIGURATIONS>
<CONFIGURATION name="Debug" isDebug="1" optimisation="1" targetName="regression_synth"/>
<CONFIGURATION name="Release" isDebug="0" optimisation="3" targetName="regression_synth"/>
</CONFIGURATIONS>
<MODULEPATHS>
<MODULEPATH id="juce_video" path="../JUCE/modules"/>
<MODULEPATH id="juce_opengl" path="../JUCE/modules"/>
<MODULEPATH id="juce_gui_extra" path="../JUCE/modules"/>
<MODULEPATH id="juce_gui_basics" path="../JUCE/modules"/>
<MODULEPATH id="juce_graphics" path="../JUCE/modules"/>
<MODULEPATH id="juce_events" path="../JUCE/modules"/>
<MODULEPATH id="juce_data_structures" path="../JUCE/modules"/>
<MODULEPATH id="juce_cryptography" path="../JUCE/modules"/>
<MODULEPATH id="juce_core" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_utils" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_processors" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_formats" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_devices" path="../JUCE/modules"/>
<MODULEPATH id="juce_audio_basics" path="../JUCE/modules"/>
</MODULEPATHS>
</LINUX_MAKE>
</EXPORTFORMATS>
<MODULES>
<MODULE id="juce_audio_basics" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_audio_devices" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_audio_formats" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_audio_processors" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_audio_utils" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_core" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_cryptography" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_data_structures" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_events" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_graphics" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_gui_basics" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_gui_extra" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_opengl" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
<MODULE id="juce_video" showAllCode="1" useLocalCopy="0" useGlobalPath="1"/>
</MODULES>
<JUCEOPTIONS/>
<LIVE_SETTINGS>
<WINDOWS/>
</LIVE_SETTINGS>
</JUCERPROJECT>
examples/ofx/Bitalino_rapidmix/README.md 0 → 100644
View file @ a0bfd689
# BitalinoRapidMix
Implementation of Bitalino EMG and a regression model powered by RapidMix in openframeworks with maximillian for audio for interesting synthesizer control / ( recursive ) mapping.
You can find the machine learning parts in `BITSequencerThread.cpp` and `RapidMixThread.h`
examples/ofx/Bitalino_rapidmix/rapidVisualizer/BarChart.hpp 0 → 100644
View file @ a0bfd689
//
// BarChart.hpp
// RapidVisualizerOSC
//
// Created by James on 09/11/2017.
//
//
#ifndef BarChart_hpp
#define BarChart_hpp
#include <stdio.h>
#include "RealTimeGraph.hpp"
class BarChart : public RealTimeGraph
{
public:
BarChart ( GraphState* state ) : RealTimeGraph (state)
{
//
}
~BarChart ( void )
{
//
}
void updateRep ( void )
{
//
}
void drawSubGraph ( std::string subLabel, DataContainer<std::vector<double>>& data, ofRectangle subLabelRect )
{
double
minIn = 0,
minOut = 0,
maxOut = -subLabelRect.height,
startPosY = subLabelRect.height,
barSize = subLabelRect.width/data.labelData.size(),
separation = barSize/16,
halfSeparation = separation/2;
bool drawZeroSep = false;
if (data.minValue < 0)
{ // Add negative part
startPosY = subLabelRect.height/2;
minIn = -data.maxValue;
minOut = subLabelRect.height/2;
maxOut /= 2;
drawZeroSep = true;
}
for (uint32_t i = 0; i < data.labelData.size(); ++i)
{
double output = mapVals(data.labelData[i], minIn, data.maxValue, minOut, maxOut );
ofSetColor (graphColor);
ofFill();
ofDrawRectangle(subLabelRect.x + barSize * i + halfSeparation, subLabelRect.y + startPosY, barSize - separation, output );
}
if (drawZeroSep)
{
ofSetLineWidth(1.25);
ofSetColor (175,150,150);
ofDrawLine(subLabelRect.x, subLabelRect.y + startPosY,
subLabelRect.x + subLabelRect.width, subLabelRect.y + startPosY);
}
}
void update ( void )
{
//
}
};
#endif /* BarChart_hpp */
examples/ofx/Bitalino_rapidmix/rapidVisualizer/Graph.hpp 0 → 100644
View file @ a0bfd689
//
// Graph.hpp
// RapidVisualizerOSC
//
// Created by James on 09/11/2017.
//
//
#ifndef Graph_h
#define Graph_h
#include <string>
#include <vector>
#include <list>
#include "ofMain.h"
#include "ofxGui.h"
// TODO: add namespace, move funcs and struct to other header(s)
enum class TextAlignment {
LEFT,
CENTER,
RIGHT
};
static inline void drawTextLabel ( std::string label, ofVec2f position, ofColor labelBackgroundColor, ofColor stringColor, TextAlignment alignment, bool drawAbove )
{
uint32_t strLenPix = label.length()*8;
switch (alignment) {
case TextAlignment::LEFT:
// No exception
break;
case TextAlignment::CENTER:
position.x -= strLenPix / 2;
break;
case TextAlignment::RIGHT:
position.x -= strLenPix;
break;
default:
break;
}
ofSetColor (labelBackgroundColor);
ofRectangle bmpStringRect(position.x - 2,
position.y + ((drawAbove) ? -4 : 12) + 2,
strLenPix + 4, -12);
ofDrawRectangle(bmpStringRect);
ofSetColor (stringColor);
ofDrawBitmapString(label, position.x, position.y + ((drawAbove) ? -4 : 12));
}
static inline double mapVals ( double x, double in_min, double in_max, double out_min, double out_max )
{
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
template <typename T>
struct DataContainer {
T labelData;
double minValue = 0.0;
double maxValue = 1.0;
uint32_t iteratorPos = 0;
//ofColor graphColor;
void updateMinMax ( void )
{
auto mm = std::minmax_element(labelData.begin(), labelData.end());
double min = labelData[std::distance(labelData.begin(), mm.first)];
double max = labelData[std::distance(labelData.begin(), mm.second)];
if (min < minValue)
minValue = min;
if (max > maxValue)
maxValue = max;
if (fabs(min) > maxValue)
maxValue = fabs(min);
}
};
class Graph {
public:
enum graphLayout {
GRAPHS_STACKED,
GRAPHS_VERTICAL
};
struct GraphState {
std::string label;
graphLayout layout = graphLayout::GRAPHS_STACKED;
bool hasHistory = false;
ofRectangle positionAndSize;
uint32_t historySize;
};
Graph ( GraphState* state )
: state(state)
{
graphColor = ofColor(24, 219, 92);
textColor = ofColor(255, 157, 117);
}
virtual ~Graph ( void )
{
}
virtual void updateRep ( void ) = 0; // update representation
virtual void addData ( std::string subLabel, std::vector<double>& data ) = 0;
virtual void reset ( void ) = 0;
virtual void update ( void ) = 0;
virtual void draw ( void ) = 0;
virtual uint32_t getNumSubGraphs ( void ) const = 0;
protected:
GraphState *state = nullptr;
ofColor graphColor;
ofColor textColor;
};
#endif /* Graph_h */
examples/ofx/Bitalino_rapidmix/rapidVisualizer/HistoryGraph.hpp 0 → 100644
View file @ a0bfd689
//
// HistoryGraph.hpp
// RapidVisualizerOSC
//
// Created by James on 09/11/2017.
//
//
#ifndef HistoryGraph_h
#define HistoryGraph_h
#include "Graph.hpp"
#include <list>
class HistoryGraph : public Graph
{
public:
HistoryGraph ( GraphState* state )
: Graph(state)
{
}
~HistoryGraph ( void )
{
}
virtual void updateRep ( void ) = 0; // update representation
virtual void drawSubGraph ( std::string subLabel, DataContainer<std::list<double>>& data, ofRectangle subLabelrect ) = 0;
virtual void update ( void ) = 0;
void addData ( std::string subLabel, std::vector<double>& data )
{
if (data.size() < state->historySize)
{
//FIXME: can be sped up by using the result of this search instead of accessing by[] again
if ( subLabelData.find(subLabel) == subLabelData.end() ) {
// not found
DataContainer<std::list<double>> container;
container.labelData.resize(state->historySize);
std::fill(container.labelData.begin(), container.labelData.end(), 0.0);
subLabelData[subLabel] = container;
}
DataContainer<std::list<double>>& dataRef = subLabelData[subLabel];
list<double>& referencedList = dataRef.labelData;
while (referencedList.size() + data.size() >= state->historySize)
{
referencedList.pop_front();
}
for (int32_t i = data.size()-1; i >= 0; --i)
{
double val = data[i];
if (val < dataRef.minValue)
dataRef.minValue = val;
if (val > dataRef.maxValue)
dataRef.maxValue = val;
if (fabs(val) > dataRef.maxValue)
dataRef.maxValue = fabs(val);
referencedList.push_back(val);
}
}
}
void reset ( void )
{
subLabelData.clear();
}
void draw ( void )
{
uint32_t numElements = subLabelData.size();
uint16_t heightBetweenSubLabels = state->positionAndSize.height/numElements;
uint16_t subLabelY = 0;
ofSetColor (textColor);
ofDrawLine(state->positionAndSize.x, state->positionAndSize.y + heightBetweenSubLabels - 1.5,
state->positionAndSize.x + state->positionAndSize.width, state->positionAndSize.y + heightBetweenSubLabels - 1.5);
std::map<std::string, DataContainer<std::list<double>>>::iterator it;
for(it = subLabelData.begin(); it != subLabelData.end(); ++it)
{
std::string subLabel = it->first;
DataContainer<std::list<double>>& data = it->second;
drawSubGraph (subLabel, data, ofRectangle(state->positionAndSize.x,
state->positionAndSize.y + subLabelY + 3,
state->positionAndSize.width,
heightBetweenSubLabels - 6));
// Draw label and background
drawTextLabel(subLabel, ofVec2f(state->positionAndSize.x + state->positionAndSize.width,
state->positionAndSize.y + subLabelY),
ofColor(100, 100, 100), ofColor(textColor), TextAlignment::RIGHT, false);
// Draw max value
drawTextLabel(ofToString(data.maxValue),
ofVec2f(state->positionAndSize.x + state->positionAndSize.width/2,
state->positionAndSize.y + subLabelY),
ofColor(50, 50, 50), ofColor(255, 255, 255), TextAlignment::CENTER, false);
// Increment Y position
subLabelY += heightBetweenSubLabels;
// Draw min value
// Show actual min value?
drawTextLabel(ofToString((data.minValue < 0) ? -data.maxValue : 0),
ofVec2f(state->positionAndSize.x + state->positionAndSize.width/2,
state->positionAndSize.y + subLabelY),
ofColor(50, 50, 50), ofColor(255, 255, 255), TextAlignment::CENTER, true);
// Draw Line at bottom of graph
//ofSetLineWidth(2.0);
//ofSetColor (180,180,180);
/*ofDrawLine(state->positionAndSize.x, state->positionAndSize.y + subLabelY + 3,
state->positionAndSize.x + state->positionAndSize.width, state->positionAndSize.y + subLabelY + 3);*/
}
}
uint32_t getNumSubGraphs ( void ) const
{
return subLabelData.size();
}
protected:
std::map <std::string, DataContainer<std::list<double>>> subLabelData;
};
#endif /* HistoryGraph_h */
examples/ofx/Bitalino_rapidmix/rapidVisualizer/LineGraph.hpp 0 → 100644
View file @ a0bfd689
//
// LineGraph.hpp
// RapidVisualizerOSC
//
// Created by James on 09/11/2017.
//
//
#ifndef LineGraph_h
#define LineGraph_h
#include <stdio.h>
#include "RealTimeGraph.hpp"
class LineGraph : public RealTimeGraph
{
public:
LineGraph ( GraphState* state ) : RealTimeGraph (state)
{
//
}
~LineGraph ( void )
{
//
}
void updateRep ( void )
{
//
}
void drawSubGraph ( std::string subLabel, DataContainer<std::vector<double>>& data, ofRectangle subLabelRect )
{
double
minIn = 0,
minOut = 0,
maxOut = -subLabelRect.height,
startPosY = subLabelRect.height,
pointDistance = subLabelRect.width/data.labelData.size(),
separation = pointDistance/2;
//halfSeparation = separation/2;
bool drawZeroSep = false;
if (data.minValue < 0)
{ // Add negative part
startPosY = subLabelRect.height/2;
minIn = -data.maxValue;
minOut = subLabelRect.height/2;
maxOut /= 2;
drawZeroSep = true;
}
ofBeginShape();
ofFill();
ofVertex(subLabelRect.x, subLabelRect.y + startPosY);
double output = mapVals(data.labelData[0], minIn, data.maxValue, minOut, maxOut );
ofVertex(subLabelRect.x, subLabelRect.y + startPosY + output);
for (uint32_t i = 0; i < data.labelData.size(); ++i)
{
output = mapVals(data.labelData[i], minIn, data.maxValue, minOut, maxOut );
ofSetColor (graphColor);
ofVertex(subLabelRect.x + pointDistance * i + separation, subLabelRect.y + startPosY + output);
//ofDrawRectangle(subLabelRect.x + barSize * i + halfSeparation, subLabelRect.y + startPosY, barSize - separation, output );
}
output = mapVals(data.labelData[data.labelData.size()-1], minIn, data.maxValue, minOut, maxOut );
ofVertex(subLabelRect.x + subLabelRect.width, subLabelRect.y + startPosY + output);
ofVertex(subLabelRect.x + subLabelRect.width, subLabelRect.y + startPosY);
ofEndShape();
if (drawZeroSep)
{
ofSetLineWidth(1.25);
ofSetColor (175,150,150);
ofDrawLine(subLabelRect.x, subLabelRect.y + startPosY,
subLabelRect.x + subLabelRect.width, subLabelRect.y + startPosY);
}
}
void update ( void )
{
//
}
};
#endif /* LineGraph_h */
examples/ofx/Bitalino_rapidmix/rapidVisualizer/LineGraphHistory.hpp 0 → 100644
View file @ a0bfd689
//
// LineGraphHistory.hpp
// RapidVisualizerOSC
//
// Created by James on 10/11/2017.
//
//
#ifndef LineGraphHistory_h
#define LineGraphHistory_h
#include <stdio.h>
#include "HistoryGraph.hpp"
class LineGraphHistory : public HistoryGraph
{
public:
LineGraphHistory ( GraphState* state ) : HistoryGraph (state)
{
//
}
~LineGraphHistory ( void )
{
//
}
void updateRep ( void )
{
//
}
void drawSubGraph ( std::string subLabel, DataContainer<std::list<double>>& data, ofRectangle subLabelRect )
{
double
minIn = 0,
minOut = 0,
maxOut = -subLabelRect.height,
startPosY = subLabelRect.height,
pointDistance = subLabelRect.width/data.labelData.size(),
separation = pointDistance/2;
//halfSeparation = separation/2;
bool drawZeroSep = false;
if (data.minValue < 0)
{ // Add negative part
startPosY = subLabelRect.height/2;
minIn = -data.maxValue;
minOut = subLabelRect.height/2;
maxOut /= 2;
drawZeroSep = true;
}
ofBeginShape();
ofFill();
ofVertex(subLabelRect.x, subLabelRect.y + startPosY);
double output = mapVals(data.labelData.front(), minIn, data.maxValue, minOut, maxOut );
ofVertex(subLabelRect.x, subLabelRect.y + startPosY + output);
uint32_t i = 0;
for (double d : data.labelData)
{
output = mapVals(d, minIn, data.maxValue, minOut, maxOut );
ofSetColor (graphColor);
ofVertex(subLabelRect.x + pointDistance * i + separation, subLabelRect.y + startPosY + output);
//ofDrawRectangle(subLabelRect.x + barSize * i + halfSeparation, subLabelRect.y + startPosY, barSize - separation, output );
++i;
}
output = mapVals(data.labelData.back(), minIn, data.maxValue, minOut, maxOut );
ofVertex(subLabelRect.x + subLabelRect.width, subLabelRect.y + startPosY + output);
ofVertex(subLabelRect.x + subLabelRect.width, subLabelRect.y + startPosY);
ofEndShape();
if (drawZeroSep)
{
ofSetLineWidth(1.25);
ofSetColor (175,150,150);
ofDrawLine(subLabelRect.x, subLabelRect.y + startPosY,
subLabelRect.x + subLabelRect.width, subLabelRect.y + startPosY);
}
}
void update ( void )
{
//
}
};
#endif /* LineGraphHistory_h */
examples/ofx/Bitalino_rapidmix/rapidVisualizer/RapidVisualization.cpp 0 → 100644
View file @ a0bfd689
//
// RapidVisualization.cpp
// RapidVisualizerOSC
//
// Created by James on 13/11/2017.
//
//
#include <stdio.h>
#include "RapidVisualization.hpp"
RapidVisualization::RapidVisualization ( void )
{
}
RapidVisualization::~RapidVisualization ( void )
{
std::map<std::string, RapidVisualizer*>::iterator it;
for(it = visualizers.begin(); it != visualizers.end(); ++it)
{
if (it->second)
delete it->second;
}
}
void RapidVisualization::setup ( ofRectangle posAndSize, uint32_t defaultHistorySize )
{
this->posAndSize = posAndSize;
this->defaultHistorySize = defaultHistorySize;
}
std::pair<std::string, std::string> RapidVisualization::getRoute(std::string& address)
{
std::pair<std::string, std::string> ret;
size_t delimPos = address.substr(1).find("/");
if (delimPos != std::string::npos)
{
delimPos += 1;
ret.first = address.substr(0, delimPos);
ret.second = address.substr(delimPos);
}
else
{
ret.first = address.substr(0, address.length());
ret.second = "/";
}
return ret;
}
void RapidVisualization::addData ( std::string address, std::vector<double>& data )
{
std::pair<std::string, std::string> route = getRoute(address);
if ( visualizers.find(route.first) == visualizers.end() ) {
RapidVisualizer* ptr = visualizers[route.first] = new RapidVisualizer(); // Add new graph
ptr->setup(route.first, RapidVisualizer::LINE_GRAPH_WITH_HISTORY, defaultHistorySize, Graph::GRAPHS_STACKED, false, ofRectangle(0,0,100,100));
}
RapidVisualizer* rapidVizPtr = visualizers[route.first];
rapidVizPtr->addData(address, data);
updateRep();
}
void RapidVisualization::addData ( std::string graphName, std::string subGraphName, std::vector<double>& data )
{
if ( visualizers.find(graphName) == visualizers.end() ) {
RapidVisualizer* ptr = visualizers[graphName] = new RapidVisualizer(); // Add new graph
ptr->setup(graphName, RapidVisualizer::LINE_GRAPH_WITH_HISTORY, defaultHistorySize, Graph::GRAPHS_STACKED, false, ofRectangle(0,0,100,100));
}
RapidVisualizer* rapidVizPtr = visualizers[graphName];
rapidVizPtr->addData(subGraphName, data);
updateRep();
}
void RapidVisualization::reset ( void )
{
std::map<std::string, RapidVisualizer*>::iterator it;
for(it = visualizers.begin(); it != visualizers.end(); ++it)
{
if (it->second)
delete it->second;
}
visualizers.clear();
}
void RapidVisualization::update ( void )
{
uint32_t tempNumGraphs = 0;
bool resetCase = false; // This is terrible (stops jitter when selecting new graph type)
std::map<std::string, RapidVisualizer*>::iterator it;
for(it = visualizers.begin(); it != visualizers.end(); ++it)
{
it->second->update();
uint32_t tGraph = it->second->getNumGraphs();
if (tGraph == 0)
{
resetCase = true;
break;
}
tempNumGraphs += tGraph;
}
if (tempNumGraphs != numGraphs && !resetCase)
{
numGraphs = tempNumGraphs;
updateRep();
}
}
void RapidVisualization::draw ( void )
{
std::map<std::string, RapidVisualizer*>::iterator it;
for(it = visualizers.begin(); it != visualizers.end(); ++it)
{
it->second->draw();
}
if (!guiHidden)
for(it = visualizers.begin(); it != visualizers.end(); ++it)
{
it->second->drawMenu(posAndSize); // Stop menu being behind next graph
}
if (numGraphs == 0)
{
drawTextLabel("Waiting for data", ofVec2f(posAndSize.x+posAndSize.width/2, posAndSize.y), ofColor(24, 219, 92), ofColor(255, 157, 117), TextAlignment::CENTER, false );
}
}
void RapidVisualization::setPos ( ofVec2f pos )
{
posAndSize.x = pos.x;
posAndSize.y = pos.y;
updateRep();
}
void RapidVisualization::setSize ( ofVec2f size )
{
posAndSize.width = size.x;
posAndSize.height = size.y;
updateRep();
}
void RapidVisualization::setPosAndSize ( ofRectangle posAndSize )
{
this->posAndSize = posAndSize;
updateRep();
}
void RapidVisualization::setHistorySize ( uint32_t size )
{
defaultHistorySize = size;
}
void RapidVisualization::updateRep ( void )
{
double graphHeight = posAndSize.height/numGraphs; // Height of single graph
std::map<std::string, RapidVisualizer*>::iterator it;
double drawHeight = posAndSize.y;
double height;
for(it = visualizers.begin(); it != visualizers.end(); ++it)
{
height = it->second->getNumGraphs()*graphHeight;
it->second->setRect(ofRectangle(posAndSize.x,
drawHeight,
posAndSize.width,
height));
drawHeight += height;
}
}
void RapidVisualization::setGuiHidden ( bool guiHidden )
{
this->guiHidden = guiHidden;
}
examples/ofx/Bitalino_rapidmix/rapidVisualizer/RapidVisualization.hpp 0 → 100644
View file @ a0bfd689
//
// RapidVisualization.hpp
// RapidVisualizerOSC
//
// Created by James on 10/11/2017.
//
//
#ifndef RapidVisualization_h
#define RapidVisualization_h
#include "RapidVisualizer.hpp"
class RapidVisualization
{
public:
RapidVisualization ( void );
~RapidVisualization ( void );
void setup ( ofRectangle posAndSize, uint32_t defaultHistorySize=256 );
// Append multiple types of graphs to cycle through as new entry addresses are added
// Implement?
//RapidVisualizer* addGraphType ( RapidVisualizer::graphTypeRealtime graphType );
//RapidVisualizer* addGraphType ( RapidVisualizer::graphTypeWithHistory graphType, uint32_t historySize );
void addData ( std::string address, std::vector<double>& data );
void addData ( std::string graphName, std::string subGraphName, std::vector<double>& data );
void reset ( void );
void update ( void );
void draw ( void );
void setPos ( ofVec2f pos );
void setSize ( ofVec2f size );
void setPosAndSize ( ofRectangle posAndSize );
void setHistorySize ( uint32_t size );
void setGraphColor ( ofColor graphColor );
//void setGraphColor ( ofColor backgroundColor );
//void setGraphColor ( ofColor textColor );
void setGuiHidden ( bool guiHidden );
private:
bool guiHidden = false;
uint32_t numGraphs = 0;
std::map<std::string, RapidVisualizer*> visualizers;
ofRectangle posAndSize;
uint32_t defaultHistorySize;
std::pair<std::string, std::string> getRoute ( std::string& address );
void updateRep ( void );
};
#endif /* RapidVisualization_h */
examples/ofx/Bitalino_rapidmix/rapidVisualizer/RapidVisualizer.cpp 0 → 100644
View file @ a0bfd689
//
// RapidVisualizer.cpp
// RapidVisualizerOSC
//
// Created by James on 09/11/2017.
//
//
#include "RapidVisualizer.hpp"
RapidVisualizer::RapidVisualizer ( void )
{
uint32 initialHistorySize = 256;
minimumGui.setup();
expandedGui.setBackgroundColor(ofColor(0,0,0,127));
expandedGui.setup();
historySizeSlider.addListener(this, &RapidVisualizer::historySizeSliderChanged);
auto gNameRef = expandButton.setup(graphState.label, false);
expandButton.setBackgroundColor(ofColor(0, 0, 0, 127));
minimumGui.add(gNameRef);
expandedGui.add(graphTypesLabel.setup("Graph Type",""));
expandedGui.add(viewTypes[0].setup("Bar Chart", false));
expandedGui.add(viewTypes[1].setup("Line Graph", false));
expandedGui.add(viewTypes[2].setup("Line Graph History", false));
expandedGui.add(viewTypes[3].setup("Scope", false));
expandedGui.add(prefLabel.setup("Preferences",""));
expandedGui.add(splitArrayIntoGraphs.setup("Split Multiple Input", false));
expandedGui.add(historySizeSlider.setup("History Size", initialHistorySize, 4, 4096));
setHistory(initialHistorySize);
setLayout (Graph::GRAPHS_STACKED);
setSplitEachArgument (false);
setRect (ofRectangle(0,0,200,200));
}
RapidVisualizer::~RapidVisualizer ( void )
{
if (currentGraph)
{
delete currentGraph;
}
}
void RapidVisualizer::setup ( std::string label, graphTypeT graphType, Graph::graphLayout layout, bool splitEachArgument, ofRectangle positionAndSize )
{
setLabel (label);
setLayout (layout);
setSplitEachArgument (splitEachArgument);
setRect (positionAndSize);
setGraphType (graphType); // FIXME: Check if successfully initialized
}
void RapidVisualizer::setup ( std::string label, graphTypeT graphType, uint32_t historySize, Graph::graphLayout layout, bool splitEachArgument, ofRectangle positionAndSize )
{
setLabel (label);
setLayout (layout);
setSplitEachArgument (splitEachArgument);
setRect (positionAndSize);
setGraphType (graphType, historySize); // FIXME: Check if successfully initialized
}
void RapidVisualizer::setLabel ( std::string label )
{
graphState.label = label;
expandButton.setName(label);
if (currentGraph)
currentGraph->updateRep();
}
void RapidVisualizer::setGraphType ( graphTypeT graphType )
{
if (currentGraphType != graphType)
{
if (currentGraph)
{
// TODO: add lock for when doing this, or have all types loaded?
delete currentGraph;
}
switch (graphType) {
case BAR_CHART:
currentGraph = new BarChart ( &graphState );
graphState.hasHistory = false;
break;
case LINE_GRAPH:
currentGraph = new LineGraph ( &graphState );
graphState.hasHistory = false;
break;
case LINE_GRAPH_WITH_HISTORY:
currentGraph = new LineGraphHistory ( &graphState );
graphState.hasHistory = true;
break;
case SCOPE:
currentGraph = new ScopeWithHistory ( &graphState );
graphState.hasHistory = true;
break;
default:
break;
}
currentGraphType = graphType;
}
}
void RapidVisualizer::setGraphType ( graphTypeT graphType, uint32_t historySize )
{
setHistory(historySize);
setGraphType(graphType);
}
void RapidVisualizer::setLayout ( Graph::graphLayout layout )
{
graphState.layout = layout;
if (currentGraph)
currentGraph->updateRep();
}
void RapidVisualizer::setSplitEachArgument ( bool splitEachArgument )
{
this->splitEachArgument = splitEachArgument;
splitArrayIntoGraphs = splitEachArgument;
}
void RapidVisualizer::setPos ( ofVec2f pos )
{
graphState.positionAndSize.x = pos.x;
graphState.positionAndSize.y = pos.y;
if (currentGraph)
currentGraph->updateRep();
}
void RapidVisualizer::setSize ( ofVec2f size )
{
graphState.positionAndSize.width = size.x;
graphState.positionAndSize.height = size.y;
if (currentGraph)
currentGraph->updateRep();
}
void RapidVisualizer::setRect ( ofRectangle positionAndSize )
{
graphState.positionAndSize = positionAndSize;
if (currentGraph)
currentGraph->updateRep();
}
void RapidVisualizer::setHistory( uint32_t historySize )
{
graphState.historySize = historySize;
historySizeSlider = historySize;
if (currentGraph)
currentGraph->updateRep();
}
void RapidVisualizer::historySizeSliderChanged (int32_t &val)
{
setHistory(val);
}
void RapidVisualizer::addData ( std::string subLabel, std::vector<double>& data )
{
if (currentGraph)
{
if (splitEachArgument && data.size() > 1)
{
int16_t currentIndex = 0;
std::vector<double> splitData;
for (double d : data)
{
splitData = {d};
currentGraph->addData (subLabel + ofToString(currentIndex), splitData);
++currentIndex;
}
}
else
currentGraph->addData (subLabel, data);
}
}
void RapidVisualizer::update ( void )
{
if (currentGraph)
{
currentGraph->update();
}
}
void RapidVisualizer::drawMenu ( ofRectangle mainPosAndSize )
{
minimumGui.setPosition(graphState.positionAndSize.x, graphState.positionAndSize.y);
minimumGui.draw();
if (menuActive)
{
double expandedGuiXPos = graphState.positionAndSize.x + minimumGui.getWidth();
double expandedGuiYPos = graphState.positionAndSize.y;
double mainYPlusHeight = mainPosAndSize.y + mainPosAndSize.height;
double check = expandedGuiYPos + expandedGui.getHeight() - mainYPlusHeight;
if (check > 0)
{
expandedGuiYPos -= check;
}
expandedGui.setPosition(expandedGuiXPos, expandedGuiYPos);
expandedGui.draw();
}
}
void RapidVisualizer::draw ( void )
{
if (currentGraph)
{
currentGraph->draw();
}
//drawMenu();
menuActive = expandButton;
if (menuActive)
{
bool noneActive = true;
for (uint8_t i = 0; i < NUMVIEWTYPES; ++i)
{
if (viewTypes[i] && !oldTypeToggles[i])
{
std::fill(viewTypes, viewTypes + NUMVIEWTYPES, false);
viewTypes[i] = true;
setGraphType(static_cast<graphTypeT>(i));
}
if (viewTypes[i])
noneActive = false;
oldTypeToggles[i] = viewTypes[i];
}
if (noneActive && currentGraphType != NOT_INITIALIZED)
{
viewTypes[currentGraphType] = true;
}
if (splitEachArgument != splitArrayIntoGraphs)
{
// Dirty, solution for now
if (currentGraph)
currentGraph->reset();
splitEachArgument = splitArrayIntoGraphs;
}
}
}
uint32_t RapidVisualizer::getNumGraphs ( void ) const
{
if (currentGraph)
{
return currentGraph->getNumSubGraphs();
} else {
return 0;
}
}
#undef NUMVIEWTYPES
examples/ofx/Bitalino_rapidmix/rapidVisualizer/RapidVisualizer.hpp 0 → 100644
View file @ a0bfd689
//
// RapidVisualizer.hpp
// RapidVisualizerOSC
//
// Created by James on 09/11/2017.
//
//
#ifndef RapidVisualizer_hpp
#define RapidVisualizer_hpp
#include <stdio.h>
#include <map>
#include "ofMain.h"
#include "Graph.hpp"
#include "BarChart.hpp"
#include "LineGraph.hpp"
#include "LineGraphHistory.hpp"
#include "ScopeWithHistory.hpp"
#define NUMVIEWTYPES 4
// TODO add historySize slider and init with default 256 or so
class RapidVisualizer {
public:
enum graphTypeT {
BAR_CHART,
LINE_GRAPH,
LINE_GRAPH_WITH_HISTORY,
SCOPE,
NOT_INITIALIZED
};
RapidVisualizer ( void );
~RapidVisualizer ( void );
void setup ( std::string label, graphTypeT graphType, Graph::graphLayout layout, bool splitEachArgument, ofRectangle positionAndSize );
void setup ( std::string label, graphTypeT graphType, uint32_t historySize, Graph::graphLayout layout, bool splitEachArgument, ofRectangle positionAndSize );
void setLabel ( std::string label );
void setGraphType ( graphTypeT graphType );
void setGraphType ( graphTypeT graphType, uint32_t historySize );
void setLayout ( Graph::graphLayout layout );
void setSplitEachArgument ( bool splitEachArgument );
void setPos ( ofVec2f pos );
void setSize ( ofVec2f size );
void setRect ( ofRectangle rect );
void setHistory ( uint32_t historySize );
void historySizeSliderChanged (int32_t &val);
void addData ( std::string subLabel, std::vector<double>& data );
void update ( void );
void drawMenu ( ofRectangle mainPosAndSize );
void draw ( void );
uint32_t getNumGraphs ( void ) const;
private:
graphTypeT currentGraphType = NOT_INITIALIZED;
Graph::GraphState graphState;
Graph* currentGraph = nullptr;
bool splitEachArgument = false;
bool menuActive = false;
ofxLabel graphName;
ofxLabel graphTypesLabel;
ofxLabel prefLabel;
ofxPanel minimumGui;
ofxToggle expandButton;
ofxPanel expandedGui;
ofxIntSlider historySizeSlider;
ofxToggle splitArrayIntoGraphs;
bool oldTypeToggles[NUMVIEWTYPES];
ofxToggle viewTypes[NUMVIEWTYPES];
};
#endif /* RapidVisualizer_hpp */
examples/ofx/Bitalino_rapidmix/rapidVisualizer/RealTimeGraph.hpp 0 → 100644
View file @ a0bfd689
//
// RealTimeGraph.hpp
// RapidVisualizerOSC
//
// Created by James on 09/11/2017.
//
//
#ifndef RealTimeGraph_h
#define RealTimeGraph_h
#include <map>
#include <vector>
#include <string>
#include "Graph.hpp"
class RealTimeGraph : public Graph
{
public:
RealTimeGraph ( GraphState* state )
: Graph(state)
{
}
~RealTimeGraph ( void )
{
}
void addData ( std::string subLabel, std::vector<double>& data )
{
if ( subLabelData.find(subLabel) == subLabelData.end() ) {
// not found
subLabelData[subLabel] = DataContainer<std::vector<double>>();
}
subLabelData[subLabel].labelData = data;
subLabelData[subLabel].updateMinMax();
}
virtual void reset ( void )
{
subLabelData.clear();
}
virtual void updateRep ( void ) = 0; // update representation
virtual void drawSubGraph ( std::string subLabel, DataContainer<std::vector<double>>& data, ofRectangle subLabelrect ) = 0;
virtual void update ( void ) = 0;
void draw ( void )
{
uint32_t numElements = subLabelData.size();
uint16_t heightBetweenSubLabels = state->positionAndSize.height/numElements;
uint16_t subLabelY = 0;
ofSetColor (255,255,255);
ofDrawLine(state->positionAndSize.x, state->positionAndSize.y,
state->positionAndSize.x + state->positionAndSize.width, state->positionAndSize.y);
std::map<std::string, DataContainer<std::vector<double>>>::iterator it;
for(it = subLabelData.begin(); it != subLabelData.end(); ++it)
{
std::string subLabel = it->first;
DataContainer<std::vector<double>>& data = it->second;
drawSubGraph (subLabel, data, ofRectangle(state->positionAndSize.x,
state->positionAndSize.y + subLabelY,
state->positionAndSize.width,
heightBetweenSubLabels));
// Draw label and background
drawTextLabel(subLabel, ofVec2f(state->positionAndSize.x + state->positionAndSize.width,
state->positionAndSize.y + subLabelY),
ofColor(100, 100, 100), ofColor(textColor), TextAlignment::RIGHT, false);
// Draw max value
drawTextLabel(ofToString(data.maxValue),
ofVec2f(state->positionAndSize.x + state->positionAndSize.width/2,
state->positionAndSize.y + subLabelY),
ofColor(50, 50, 50), ofColor(255, 255, 255), TextAlignment::CENTER, false);
// Increment Y position
subLabelY += heightBetweenSubLabels;
// Draw min value
// Could show actually found min value
drawTextLabel(ofToString((data.minValue < 0) ? -data.maxValue : 0),
ofVec2f(state->positionAndSize.x + state->positionAndSize.width/2,
state->positionAndSize.y + subLabelY),
ofColor(50, 50, 50), ofColor(255, 255, 255), TextAlignment::CENTER, true);
// Draw Line at bottom of graph
ofSetLineWidth(2.0);
ofSetColor (180,180,180);
ofDrawLine(state->positionAndSize.x, state->positionAndSize.y + subLabelY,
state->positionAndSize.x + state->positionAndSize.width, state->positionAndSize.y + subLabelY);
}
}
uint32_t getNumSubGraphs ( void ) const
{
return subLabelData.size();
}
protected:
std::map <std::string, DataContainer<std::vector<double>>> subLabelData;
};
#endif /* RealTimeGraph_h */
examples/ofx/Bitalino_rapidmix/rapidVisualizer/ScopeWithHistory.hpp 0 → 100644
View file @ a0bfd689
//
// ScopeWithHistory.hpp
// RapidVisualizerOSC
//
// Created by James on 12/11/2017.
//
//
#ifndef ScopeWithHistory_h
#define ScopeWithHistory_h
#include <stdio.h>
#include "Graph.hpp"
class ScopeWithHistory : public Graph
{
public:
ScopeWithHistory ( GraphState* state ) : Graph (state)
{
//
}
~ScopeWithHistory ( void )
{
//
}
void addData ( std::string subLabel, std::vector<double>& data )
{
if (data.size() < state->historySize)
{
//FIXME: can be sped up by using the result of this search instead of accessing by[] again
if ( subLabelData.find(subLabel) == subLabelData.end() ) {
// not found
DataContainer<std::vector<double>> container;
container.labelData.resize(state->historySize);
std::fill(container.labelData.begin(), container.labelData.end(), 0.0);
subLabelData[subLabel] = container;
}
DataContainer<std::vector<double>>& dataRef = subLabelData[subLabel];
std::vector<double>& referencedList = dataRef.labelData;
while (referencedList.size() >= state->historySize)
{
referencedList.pop_back();
}
for (int32_t i = data.size()-1; i >= 0; --i)
{
double val = data[i];
if (val < dataRef.minValue)
dataRef.minValue = val;
if (val > dataRef.maxValue)
dataRef.maxValue = val;
if (fabs(val) > dataRef.maxValue)
dataRef.maxValue = fabs(val);
if (referencedList.size() + data.size() >= state->historySize)
{
referencedList[dataRef.iteratorPos] = val;
dataRef.iteratorPos = (dataRef.iteratorPos + data.size()) % state->historySize;
} else {
referencedList.insert(referencedList.begin(), val);
}
}
}
}
void updateRep ( void )
{
//
}
void drawSubGraph ( std::string subLabel, DataContainer<std::vector<double>>& data, ofRectangle subLabelRect )
{
double
minIn = 0,
minOut = 0,
maxOut = -subLabelRect.height,
startPosY = subLabelRect.height,
pointDistance = subLabelRect.width/data.labelData.size(),
separation = pointDistance/2;
//halfSeparation = separation/2;
bool drawZeroSep = false;
if (data.minValue < 0)
{ // Add negative part
startPosY = subLabelRect.height/2;
minIn = -data.maxValue;
minOut = subLabelRect.height/2;
maxOut /= 2;
drawZeroSep = true;
}
ofBeginShape();
ofFill();
ofVertex(subLabelRect.x, subLabelRect.y + startPosY);
double output = mapVals(data.labelData.front(), minIn, data.maxValue, minOut, maxOut );
ofVertex(subLabelRect.x, subLabelRect.y + startPosY + output);
uint32_t i = 0;
for (double d : data.labelData)
{
output = mapVals(d, minIn, data.maxValue, minOut, maxOut );
ofSetColor (graphColor);
ofVertex(subLabelRect.x + pointDistance * i + separation, subLabelRect.y + startPosY + output);
//ofDrawRectangle(subLabelRect.x + barSize * i + halfSeparation, subLabelRect.y + startPosY, barSize - separation, output );
++i;
}
output = mapVals(data.labelData.back(), minIn, data.maxValue, minOut, maxOut );
ofVertex(subLabelRect.x + subLabelRect.width, subLabelRect.y + startPosY + output);
ofVertex(subLabelRect.x + subLabelRect.width, subLabelRect.y + startPosY);
ofEndShape();
if (drawZeroSep)
{
ofSetLineWidth(1.25);
ofSetColor (175,150,150);
ofDrawLine(subLabelRect.x, subLabelRect.y + startPosY,
subLabelRect.x + subLabelRect.width, subLabelRect.y + startPosY);
}
}
void update ( void )
{
//
}
void reset ( void )
{
subLabelData.clear();
}
void draw ( void )
{
uint32_t numElements = subLabelData.size();
uint16_t heightBetweenSubLabels = state->positionAndSize.height/numElements;
uint16_t subLabelY = 0;
ofSetColor (255,255,255);
ofDrawLine(state->positionAndSize.x, state->positionAndSize.y,
state->positionAndSize.x + state->positionAndSize.width, state->positionAndSize.y);
std::map<std::string, DataContainer<std::vector<double>>>::iterator it;
for(it = subLabelData.begin(); it != subLabelData.end(); ++it)
{
std::string subLabel = it->first;
DataContainer<std::vector<double>>& data = it->second;
drawSubGraph (subLabel, data, ofRectangle(state->positionAndSize.x,
state->positionAndSize.y + subLabelY,
state->positionAndSize.width,
heightBetweenSubLabels));
// Draw label and background
drawTextLabel(subLabel, ofVec2f(state->positionAndSize.x + state->positionAndSize.width,
state->positionAndSize.y + subLabelY),
ofColor(100, 100, 100), ofColor(textColor), TextAlignment::RIGHT, false);
// Draw max value
drawTextLabel(ofToString(data.maxValue),
ofVec2f(state->positionAndSize.x + state->positionAndSize.width/2,
state->positionAndSize.y + subLabelY),
ofColor(50, 50, 50), ofColor(255, 255, 255), TextAlignment::CENTER, false);
// Increment Y position
subLabelY += heightBetweenSubLabels;
// Draw min value
// Show actual min value?
drawTextLabel(ofToString((data.minValue < 0) ? -data.maxValue : 0),
ofVec2f(state->positionAndSize.x + state->positionAndSize.width/2,
state->positionAndSize.y + subLabelY),
ofColor(50, 50, 50), ofColor(255, 255, 255), TextAlignment::CENTER, true);
// Draw Line at bottom of graph
ofSetLineWidth(2.0);
ofSetColor (180,180,180);
ofDrawLine(state->positionAndSize.x, state->positionAndSize.y + subLabelY,
state->positionAndSize.x + state->positionAndSize.width, state->positionAndSize.y + subLabelY);
}
}
uint32_t getNumSubGraphs ( void ) const
{
return subLabelData.size();
}
protected:
std::map <std::string, DataContainer<std::vector<double>>> subLabelData;
};
#endif /* ScopeWithHistory_h */
examples/ofx/Bitalino_rapidmix/src/BITEnvironment.cpp 0 → 100644
View file @ a0bfd689
//
// BITEnvironment.cpp
// Bitalino
//
// Created by James on 23/11/2017.
//
//
#include "BITEnvironment.hpp"
namespace BIT
{
void Environment::setup( std::string nameOfBitalino, ofRectangle posAndSize )
{
this->posAndSize = posAndSize;
float graphHeight = posAndSize.height / ( NUM_SYNTH_PARAMS + 1 );
bst.setup( nameOfBitalino );
ofRectangle bitGraphRect( posAndSize.x, posAndSize.y, posAndSize.width, graphHeight );
bitalinoGraph.setup( "Bitalino", ofColor( 100, 100, 255 ),
ofColor( 100, 255, 100 ), ofColor( 100, 100, 100 ), bitGraphRect, true, true, 2000 );
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
ofRectangle graphRect( posAndSize.x, posAndSize.y + ( i + 1 ) * graphHeight, posAndSize.width, graphHeight );
graphs[ i ].setup( ParamNames[ i ], ofColor( 255, 255, 255 ),
ofColor( 255, 100, 100 ), ofColor( 100, 100, 100 ), graphRect, true, false, 2000 );
// Link buffers together
bst.loopDataBuffers[ i ].linkTo( &graphs[ i ].memory );
graphs[ i ].memory.linkTo( &bst.loopDataBuffers[ i ] );
}
// Only needs one way link
bst.bitalinoChannel.linkTo( &bitalinoGraph.memory );
}
void Environment::update ( void )
{ // This runs concurrent with ofx
// THIS can dissapear
RingBufferAny::VariableHeader headerInfo;
while ( bst.toEnvironment.anyAvailableForPop( headerInfo ) )
{
if ( headerInfo.type_index == typeid( RecordingSelection ) ) {
RecordingSelection sel;
bst.toEnvironment.pop( &sel, 1 );
if ( sel.position < 0 )
selectedTrainingParts.clear( );
else
selectedTrainingParts.push_back( sel.position );
} else if ( headerInfo.type_index == typeid( State ) ) {
selectedTrainingParts.clear( );
bst.toEnvironment.pop( &currentState, 1 );
switch ( currentState )
{
case PERFORMING:
bitalinoGraph.graphColor = ofColor( 100, 255, 100 );
bitalinoGraph.redraw( );
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
graphs[ i ].graphColor = ofColor( 100, 100, 255 );
graphs[ i ].backgroundColor = ofColor( 255, 255, 255 );
graphs[ i ].redraw( );
}
break;
case RECORDING:
bitalinoGraph.graphColor = ofColor( 100, 255, 100 );
bitalinoGraph.redraw( );
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
graphs[ i ].graphColor = ofColor( 255, 255, 255 );
graphs[ i ].backgroundColor = ofColor( 180, 100, 100 );
graphs[ i ].redraw( );
}
break;
case PLAYING:
bitalinoGraph.graphColor = ofColor( 100, 255, 100 );
bitalinoGraph.redraw( );
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
graphs[ i ].graphColor = ofColor( 255, 100, 100 );
graphs[ i ].backgroundColor = ofColor( 100, 100, 100 );
graphs[ i ].redraw( );
}
break;
case TRAINING:
// Fallthrough style
case IDLE:
bitalinoGraph.graphColor = ofColor( 100, 100, 100 );
bitalinoGraph.redraw( );
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
graphs[ i ].graphColor = ofColor( 100, 100, 100 );
graphs[ i ].backgroundColor = ofColor( 100, 100, 100 );
graphs[ i ].redraw( );
}
break;
default:
break;
}
} else if ( headerInfo.type_index == typeid( BITSequencerThread::RealtimeViewData ) ) {
BITSequencerThread::RealtimeViewData data[ headerInfo.valuesPassed ];
bst.toEnvironment.pop( data, headerInfo.valuesPassed );
for ( size_t i = 0; i < headerInfo.valuesPassed; ++i )
{
transport = data[ i ].transportPosition;
}
}
}
bitalinoGraph.update( );
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
graphs[ i ].update( );
}
}
bool Environment::isMouseInside ( ofVec2f mousePos)
{
return posAndSize.inside( mousePos );
}
void Environment::mouseActive ( ofVec2f mousePos, int8_t mouseState, bool mouseStateChanged )
{
if ( currentState == PLAYING && selectedTrainingParts.empty( ) ) // Only then are buffers to be altered
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
PokeGraph& currentGraph = graphs[ i ];
if ( currentGraph.isMouseInside( mousePos ) )
{
if ( previousActive && previousActive != &currentGraph )
{
previousActive->mouseActive( mousePos, -1, true );
}
currentGraph.mouseActive( mousePos, mouseState, mouseStateChanged );
previousActive = &currentGraph;
}
}
}
void Environment::drawSelectedTrainingParts( void )
{
ofColor highlight( 255, 255, 255, 50 );
ofColor pillars( 255, 255, 255, 150 );
size_t size = selectedTrainingParts.size( );
int8_t complete = 0;
double previousPoint = 0;
for ( uint32_t i = 0; i < size; ++i )
{ // TODO fix wrap cases
double point = selectedTrainingParts[ i ];
complete = i % 2;
if ( i + 1 == size && complete == 0)
{
double transp = ( transport - point );
if ( transp < 0 )
{
selectedTrainingParts.insert( selectedTrainingParts.begin( ) + ( i + 1 ), 1.0 );
selectedTrainingParts.insert( selectedTrainingParts.begin( ) + ( i + 2 ), 0.0 );
i -= 1;
size += 2;
continue;
}
ofRectangle rect( posAndSize.x + point * posAndSize.width, posAndSize.y,
transp * posAndSize.width, posAndSize.height );
ofSetColor( highlight );
ofFill( );
ofDrawRectangle( rect );
ofSetColor( pillars );
ofSetLineWidth( 1.5f );
ofNoFill( );
ofDrawRectangle( rect );
ofSetColor( 255, 255, 255, 255 );
return;
}
if ( complete == 1 )
{
ofRectangle rect( posAndSize.x + previousPoint * posAndSize.width, posAndSize.y,
( point - previousPoint ) * posAndSize.width, posAndSize.height );
ofSetColor( highlight );
ofFill( );
ofDrawRectangle( rect );
ofSetColor( pillars );
ofSetLineWidth( 1.5f );
ofNoFill( );
ofDrawRectangle( rect );
}
previousPoint = point;
}
ofSetColor( 255, 255, 255, 255 );
}
void Environment::draw ( void )
{ // This runs concurrent with ofx
double xPosTransport = posAndSize.x + posAndSize.width * transport;
ofDrawLine( xPosTransport, posAndSize.y, xPosTransport, posAndSize.y + posAndSize.height );
bitalinoGraph.draw( );
if ( !selectedTrainingParts.empty( ) )
drawSelectedTrainingParts( );
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
graphs[ i ].draw( );
}
bool connected = bst.rapidBitalino.bitalinoThread.isConnected( );
drawTextLabel( stateStrings[ static_cast< uint8_t >( currentState ) ], ofVec2f( posAndSize.x + 4, posAndSize.y + 21 ),
(( connected ) ? ofColor( 24, 219, 92 ) : ofColor( 255, 24, 24 ) ), ofColor( 10, 10, 10 ),
ofxBitmapText::TextAlignment::LEFT, false );
}
void Environment::resize ( ofRectangle posAndSize )
{
this->posAndSize = posAndSize;
float graphHeight = posAndSize.height / ( NUM_SYNTH_PARAMS + 1 );
bitalinoGraph.setRect( ofRectangle( posAndSize.x, posAndSize.y, posAndSize.width, graphHeight ) );
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
graphs[ i ].setRect( ofRectangle( posAndSize.x, posAndSize.y + ( i + 1 ) * graphHeight, posAndSize.width, graphHeight ) );
}
}
void Environment::stop( void )
{
bst.stop();
}
void Environment::audioOut( float *output, int bufferSize, int nChannels )
{ // Audio thread sync callback
bst.audioOut(output, bufferSize, nChannels);
}
} // End namespace BIT::
examples/ofx/Bitalino_rapidmix/src/BITEnvironment.hpp 0 → 100644
View file @ a0bfd689
//
// BITEnvironment.hpp
// Bitalino
//
// Created by James on 23/11/2017.
//
//
#ifndef BITEnvironment_hpp
#define BITEnvironment_hpp
#include <stdio.h>
#include <vector>
#include <atomic>
#include "ofMain.h"
#include "BITSequencerThread.hpp"
#include "PokeGraph.hpp"
namespace BIT
{
// ML Bitalino Synth environment
// Functions as the view + a portion of the controller ( PokeGraphs )
class Environment
{
public:
BITSequencerThread bst;
void setup ( std::string nameOfBitalino, ofRectangle posAndSize );
void update ( void );
bool isMouseInside ( ofVec2f mousePos );
void mouseActive ( ofVec2f mousePos, int8_t mouseState, bool mouseStateChanged );
void draw ( void );
void drawSelectedTrainingParts ( void );
void resize ( ofRectangle posAndSize );
void stop ( void );
void audioOut(float * output, int bufferSize, int nChannels);
private:
std::vector< double > selectedTrainingParts;
ofRectangle posAndSize;
PokeGraph* previousActive = nullptr;
PokeGraph bitalinoGraph; // To show the input in sync with output parameters
PokeGraph graphs[ NUM_SYNTH_PARAMS ]; // To show and allow editing of parameters
double transport;
State currentState;
};
} // End namespace BIT::
#endif /* BITSynth_hpp */
examples/ofx/Bitalino_rapidmix/src/BITSequencerThread.cpp 0 → 100644
View file @ a0bfd689
//
// BITSequencerThread.cpp
// Bitalino
//
// Created by James on 08/12/2017.
//
//
#include "BITSequencerThread.hpp"
namespace BIT
{
BITSequencerThread::BITSequencerThread ( void ) : ThreadedProcess ()
{
setState(IDLE);
recording.store(false);
selectingData.store(false);
transport.store(0.0);
}
BITSequencerThread::~BITSequencerThread ( void )
{
}
void BITSequencerThread::setup( std::string nameOfBitalino )
{
// Set callback for when model is done training (called in rapidMixThread.update method)
rapidMixThread.doneTrainingCallback = [&] ( void )
{
//printf("New Model Trained\n");
sendRunDataToOFX();
trainingDone = true;
transport.store(0.0);
setState( PERFORMING );
//trainingText = "New Model Trained";
};
// Set buttonPressedCallback for rapidBitalino
rapidBitalino.buttonPressedCallback = std::bind(&BITSequencerThread::buttonPressed, this);
// Set buttonReasedCallback for rapidBitalino
rapidBitalino.buttonReleasedCallback = std::bind(&BITSequencerThread::buttonReleased, this);
// Set up training thread
rapidMixThread.setup();
// Set up BITalino accessor + thread
rapidBitalino.setup( nameOfBitalino, 10 ); // downsampling 10 of the data (TODO experiment with different settings with bayes)
toEnvironment.setup( 8192 ); // Leave room for 16kb of memory to be used in the ring-queue
bitalinoChannel.setup( 2000 );
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
loopDataBuffers[ i ].setup( 2000 );
}
State s = currentState.load( );
toEnvironment.push( &s, 1 ); // Send initial state
// Start the thread
startThread( 10000 ); // Sleep 10 ms
}
void BITSequencerThread::setState ( State state )
{
toEnvironment.push ( &state, 1 );
this->currentState.store(state);
}
State BITSequencerThread::getState ( void ) const
{
return this->currentState.load();
}
const char* BITSequencerThread::getStateString ( void )
{
return stateStrings[static_cast<uint8_t>(getState())];
}
void BITSequencerThread::stop( void )
{
// Stop all asynchronous threads
this->stopThread();
rapidMixThread.stopThread();
rapidBitalino.stop();
}
void BITSequencerThread::audioOut( float *output, int bufferSize, int nChannels )
{ // Audio thread sync callback
synthesizer.audioOut(output, bufferSize, nChannels);
}
double BITSequencerThread::getTransport ( void )
{
return transport.load( );
}
void BITSequencerThread::buttonPressed ( void )
{ // Bitalino button press
longSelectionTimer.reset( );
switch ( currentState.load( ) )
{ // Run update for state
case IDLE:
//printf( "Started \n" );
generateFirstData( );
setState( PLAYING );
break;
case PERFORMING:
{
if ( trainingDone )
{
if ( recording.load( ) )
{
//printf( "Playing recorded gestures \n" );
recording.store( false );
setState( PLAYING );
} else {
//printf( "Started recording \n" );
recording.store( true );
transport.store( 0.0 );
// TODO: create extra state for just recording?
State recState = RECORDING; // Only used by environment for color change
toEnvironment.push( &recState, 1 );
}
}
break;
}
case PLAYING:
{
if ( !selectingData.load( ) )
{
RecordingSelection sel{ static_cast< double >( loopPosition ) / loopSize };
toEnvironment.push( &sel, 1 );
//printf( "Selecting data for example \n" );
trainingData.createNewPhrase( "NewPhrase" );
//printf( "Added training element, now size of %lu\n", trainingData.trainingSet.size( ) );
selectingData.store( true );
}
break;
}
default:
break;
}
}
void BITSequencerThread::buttonReleased( void )
{ // Bitalino button release
State s = currentState.load();
switch ( s )
{ // Run update for state
case PLAYING:
{
if (selectingData.load())
{
if (longSelectionTimer.getTimeElapsed() > longPress)
{
RecordingSelection sel{ static_cast< double >( loopPosition ) / loopSize };
toEnvironment.push( &sel, 1 );
//printf("Recorded example \n");
selectingData.store(false);
} else {
//printf("Throwing away last training sample, press was for stopping \n");
trainingData.trainingSet.pop_back();
RecordingSelection sel{ -1.0 };
toEnvironment.push( &sel, 1 );
bitalinoChannel.setRangeToConstant( 0, loopSize, 0.0 );
// Draw line here for next part ?
if (trainingData.trainingSet.size() >= 1)
{
//printf("Training on selected data \n");
RecordingSelection sel{ -1.0 };
toEnvironment.push( &sel, 1 );
trainingDone = false;
rapidMixThread.train(trainingData);
setState( TRAINING );
} else {
//printf("Reinitializing");
generateFirstData();
toEnvironment.push(&s, 1); // Make sure everything gets reinitialized
}
selectingData.store(false);
}
}
break;
}
default:
break;
}
}
void BITSequencerThread::mainThreadCallback( void )
{ // Process thread sync callback
// Get input data (BITalino):
RealtimeViewData viewData;
std::vector< double > inputData = rapidBitalino.update( ); // Update method uses ringbuffer and is threadsafe
State curState = currentState.load( );
bool newState = ( curState != previousState );
if ( newState )
{
dataPlayTimer.reset( );
longSelectionTimer.reset( );
switch ( curState )
{ // Run inits for states
case PERFORMING:
loop.clear( );
loopSize = 0;
break;
case PLAYING:
loopPosition = 0;
trainingData.trainingSet.clear( );
break;
default:
break;
}
} else
switch ( curState )
{ // Run update for state
case PERFORMING:
{ // Update case for performing state
if (dataPlayTimer.getTimeElapsed( ) > controlRate && trainingDone)
{
if ( !recording.load( ) )
transport.store( inputData[0] / maxValueEMG );
SynthControlData ctrlData( rapidMixThread.model->run( inputData ) );
synthesizer.controlDataBuffer.push( &ctrlData, 1 );
currentControlData = ctrlData;
if ( recording.load( ) )
{
bitalinoChannel.resizeBounded( loopSize + 1 );
bitalinoChannel[ loopSize ] = inputData[ 0 ];
for ( uint32_t p = 0; p < NUM_SYNTH_PARAMS; ++p )
{
loopDataBuffers[ p ].resizeBounded( loopSize + 1 );
loopDataBuffers[ p ][ loopSize ] = ctrlData.values[ p ];
}
++loopSize;
}
dataPlayTimer.reset( );
}
break;
}
case PLAYING:
{ // Update case for playing state
if (dataPlayTimer.getTimeElapsed() > controlRate)
{
bitalinoChannel[ loopPosition ] = inputData[ 0 ];
SynthControlData ctrlData;
for ( uint32_t p = 0; p < NUM_SYNTH_PARAMS; ++p )
{
ctrlData.values[ p ] = loopDataBuffers[ p ][ loopPosition ];
}
synthesizer.controlDataBuffer.push(&ctrlData, 1);
currentControlData = ctrlData;
if (++loopPosition >= loopSize)
loopPosition = 0;
transport.store( static_cast< double >( loopPosition ) / loopSize );
if (selectingData.load())
{ // Add element to trainingData
std::vector<double> outputTraining = ctrlData.getValuesAsVector( );
trainingData.addElement(inputData, outputTraining);
}
dataPlayTimer.reset();
}
break;
}
default:
break;
}
if ( currentState.load( ) != IDLE )
{
viewData.transportPosition = transport.load( );
toEnvironment.push( &viewData, 1 );
}
bitalinoChannel.update( );
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
loopDataBuffers[ i ].update( );
}
rapidMixThread.update();
previousState = curState;
}
void BITSequencerThread::generateFirstData ( void )
{
uint8_t midiStart = 55;
uint32_t doremiSize = 2;
// Calculate new size of buffers
uint32_t resizeSize = doremiSize * majorScaleSize * samplesPerExample;
// Resize all buffers
bitalinoChannel.resizeBounded( resizeSize );
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
loopDataBuffers[ i ].resizeBounded( resizeSize );
}
// Calculate doremi ladder and also random data blocks for other parameters
int index = 0;
for (uint32_t i = 0; i < doremiSize; ++i)
{
for (uint32_t step = 0; step < majorScaleSize; ++step)
{
double frequency = MTOF( midiStart + ( i * 12 ) + majorScale[ step ] );
SynthControlData ctrlData;
ctrlData.values[ CARRIER ] = frequency;
for ( uint16_t x = 0; x < NUM_SYNTH_PARAMS; ++x )
{
if ( x != static_cast< uint8_t >( CARRIER ) )
ctrlData.values[ x ] = ( ( double ) rand( ) / RAND_MAX );
}
for ( uint32_t p = 0; p < NUM_SYNTH_PARAMS; ++p )
{
loopDataBuffers[ p ].setRangeToConstant( index, index + samplesPerExample, ctrlData.values[ p ] );
}
index += samplesPerExample;
}
}
bitalinoChannel.setRangeToConstant( 0, resizeSize, 0 );
loopPosition = 0;
loopSize = resizeSize;
}
void BITSequencerThread::generateFirstRandomData ( void )
{ // NO LONGER USED
for (uint32_t i = 0; i < 10; ++i)
{
SynthControlData ctrlData;
for (uint16_t x = 0; x < NUM_SYNTH_PARAMS; ++x)
{
ctrlData.values[x] = ((double)rand()/RAND_MAX);
}
for (uint32_t y = 0; y < samplesPerExample; ++y)
loop.push_back(ctrlData);
}
}
void BITSequencerThread::sendRunDataToOFX ( void )
{ // Sweeps through the trained model and shows the input vs the outputs
uint32_t numValues = 256;
bitalinoChannel.resizeBounded( numValues );
for ( uint32_t i = 0; i < NUM_SYNTH_PARAMS; ++i )
{
loopDataBuffers[ i ].resizeBounded( numValues );
}
for ( int i = 0.0; i < numValues; i += 1 )
{
double inp = static_cast< double >( i * 2 );
std::vector< double > input( NUM_INPUTS_FOR_TRAINING, inp );
bitalinoChannel[ i ] = inp;
std::vector< double > outputs = rapidMixThread.model->run( input );
for ( uint32_t p = 0; p < NUM_SYNTH_PARAMS; ++p )
{
loopDataBuffers[ p ][ i ] = outputs[ p ];
}
}
}
}
examples/ofx/Bitalino_rapidmix/src/BITSequencerThread.hpp 0 → 100644
View file @ a0bfd689
//
// BITSequencerThread.hpp
// Bitalino
//
// Created by James on 08/12/2017.
//
//
#ifndef BITSequencerThread_hpp
#define BITSequencerThread_hpp
#include <stdio.h>
#include <functional>
#include "Timer.h"
#include "SigTools.hpp"
#include "RapidBitalino.h"
#include "RapidMixThread.h"
#include "BITSynth.hpp"
#include "ThreadedProcess.h"
#include "RingBufferAny.hpp"
#include "LinkedBuffer.hpp"
namespace BIT
{
class BITSequencerThread : public ThreadedProcess
{
// Functions as the model
public:
LinkedBuffer< double > bitalinoChannel;
LinkedBuffer< double > loopDataBuffers[ NUM_SYNTH_PARAMS ];
// Todo move back to protected/private (public for testing w/o bitalino)
void buttonPressed ( void );
void buttonReleased ( void );
// BITalino thread, TODO: threadsafe accessors etc
RapidBitalino rapidBitalino;
// Synth which can only be changed by ringbuffer (threadsafe)
Synth synthesizer;
// Threadsafe queue of events
RingBufferAny toEnvironment;
BITSequencerThread ( void );
~BITSequencerThread ( void );
void setup ( std::string nameOfBitalino );
void setState ( State state ); // Atomic set
State getState ( void ) const; // Atomic get
const char* getStateString ( void );
void stop ( void );
void audioOut(float * output, int bufferSize, int nChannels);
double getTransport ( void );
struct RealtimeViewData {
double transportPosition = 0.0;
};
protected:
//void buttonPressed ( void );
//void buttonReleased ( void );
void mainThreadCallback ( void );
void generateFirstData ( void );
void generateFirstRandomData ( void );
void sendRunDataToOFX ( void );
private:
// Rapidmix stuff
RapidMixThread rapidMixThread;
rapidmix::trainingData trainingData;
bool gatheringTrainingData = false;
bool trainingDone = false;
// Other stuff
uint32_t sampleRate = 44100;
uint32_t controlRate = 15; // 15ms
uint32_t samplesPerExample = 50;
// DEBUGDEBUG
//--
// State
std::atomic< State > currentState;
State previousState; // (synced with Data thread)
std::atomic< bool > recording;
std::atomic< bool > selectingData;
// Data thread synced
BIT::SynthControlData currentControlData;
std::vector< BIT::SynthControlData > loop;
int loopSize;
int loopPosition;
// Timers
Timer dataPlayTimer;
Timer longSelectionTimer;
uint32_t longPress = 400; // 400ms
double maxValueEMG = 512.0;
std::atomic< double > transport;
};
}
#endif /* BITSequencerThread_hpp */
examples/ofx/Bitalino_rapidmix/src/BITSynth.cpp 0 → 100644
View file @ a0bfd689
//
// BITSynth.cpp
// Bitalino
//
// Created by James on 07/12/2017.
//
//
#include "BITSynth.hpp"
namespace BIT {
// Simple fm synth
Synth::Synth ( void )
{
// Set up the ringbuffer for controldata which is pushed in to the audio thread
controlDataBuffer.setup( 100 ); // Leave room for 10 control data to sync over to audio thread
}
void Synth::audioOut ( float *output, int bufferSize, int nChannels )
{ // Audio thread sync callback
for ( uint32_t i = 0; i < bufferSize; ++i )
{
if ( controlDataBuffer.items_available_for_read( ) )
controlDataBuffer.pop( &audioControlData, 1 );
SVF.setCutoff( dFilt1.lopass( 110 + fmin( fabs( audioControlData[ CUTOFF ] ), 0.95 ) * 5000, 0.001 ) );
SVF.setResonance( 0.1 + fmin( fabs( audioControlData[ RESONANCE ] ), 0.9 ) );
double modulator = VCO2.sinewave( fabs( 20 + audioControlData[ MODULATOR ] * 1000 ) ) * ( 500 * fabs( audioControlData[ AMP ] ) );
double carrier = VCO1.sinewave( fabs( audioControlData[ CARRIER ] + modulator ) );
double filtered = SVF.play( carrier, 1.0, 0, 0, 0 ) * 0.25;
double delay1 = DL1.dl( filtered, dFilt2.lopass( fmin( fabs( audioControlData[ SIZE_A ] ) * 88200, 88199 ), 0.01 ),
fabs( audioControlData[ FB_A ] ) );
double delay2 = DL2.dl( filtered, dFilt3.lopass( fmin( fabs( audioControlData[ SIZE_B ] ) * 88200, 88199 ), 0.01 ),
fabs( audioControlData[ FB_B ] ) );
output[ i * nChannels ] = filtered * 0.75 + delay1 * 0.125 + delay2 * 0.0125;
output[ i * nChannels + 1 ] = filtered * 0.75 + delay1 * 0.0125 + delay2 * 0.125;
}
}
}
examples/ofx/Bitalino_rapidmix/src/BITSynth.hpp 0 → 100644
View file @ a0bfd689
//
// BITSynth.hpp
// Bitalino
//
// Created by James on 07/12/2017.
//
//
#ifndef BITSynth_hpp
#define BITSynth_hpp
#include <stdio.h>
#include <vector>
#include "ofxMaxim.h"
#include "RingBuffer.hpp"
#include "GlobalDefs.h"
namespace BIT {
// Synthesizer
class Synth {
public:
// From data thread to Audio thread
RingBuffer<BIT::SynthControlData> controlDataBuffer;
Synth ( void );
void audioOut( float *output, int bufferSize, int nChannels );
private:
// ofMaxim audio stuff
maxiOsc VCO1, VCO2;
maxiSVF SVF;
maxiFractionalDelay DL1, DL2;
// For smoothing parameter changes:
maxiFilter dFilt1, dFilt2, dFilt3;
// Audio thread synced
BIT::SynthControlData audioControlData;
};
}
#endif /* BITSynth_hpp */
examples/ofx/Bitalino_rapidmix/src/BitalinoThread.h 0 → 100644
View file @ a0bfd689
//
// BitalinoThread.h
// Bitalino
//
// Created by James on 19/11/2017.
//
//
#ifndef BitalinoThread_h
#define BitalinoThread_h
#include <stdio.h>
#include "ThreadedProcess.h"
#include "RingBuffer.hpp"
#include "bitalino.h"
class BitalinoThread : public ThreadedProcess {
public:
RingBuffer< BITalino::Frame > data; // The data gathered in the main thread, safely accessable from outside
BitalinoThread ( void ) : ThreadedProcess ( )
{
connected.store( false );
recording.store( false );
tries.store( 0 );
// NOTE THAT DEVICE NAME CAN BE SET IN SETUP
this->deviceName = "/dev/cu.BITalino-DevB"; // Debug init ( Mac OS virt. serial over bt )
}
~BitalinoThread ( void )
{
}
void setup ( std::string deviceName, uint64_t bufferSize,
uint16_t sampleRate, std::vector<int32_t> channels,
uint16_t frameCount=100 )
{
this->deviceName = deviceName;
this->sampleRate = sampleRate;
this->channels = channels;
frameBuffer.resize( frameCount );
pollTestBuffer.resize( 1 );
data.setup( bufferSize );
startThread( 500 ); // sleep for 0.5 ms after each callback
}
void setRecording ( bool v )
{ // Allow data to be pushed in to the ringbuffer
recording.store( v );
}
bool isRecording ( void ) const
{
return recording.load( );
}
bool isConnected ( void ) const
{
return connected.load( );
}
uint32_t getConnectionTries( void ) const
{
return tries.load( );
}
protected:
void mainThreadCallback ( void ) override
{
try {
switch ( threadState )
{
case SEARCHING_FOR_DEVICE:
++currentTries;
tries.store( currentTries );
if ( !dev )
dev = new BITalino( deviceName.c_str( ) );
dev->start( sampleRate, channels );
threadState = IDLE_BUT_CONNECTED;
connected.store( true );
currentTries = 0;
break;
case IDLE_BUT_CONNECTED:
if ( recording.load( ) )
{
threadState = RECORDING_DATA;
} else {
dev->read( pollTestBuffer ); // Poll small data to check if alive
usleep( 100000 ); // Wait 100 ms
}
break;
case RECORDING_DATA:
if ( !recording.load( ) )
{
threadState = IDLE_BUT_CONNECTED;
} else {
dev->read( frameBuffer );
if ( data.items_available_for_write( ) >= frameBuffer.size( ) )
data.push( &frameBuffer[ 0 ], frameBuffer.size( ) );
// Else skipped frame... notify?
}
break;
default:
break;
}
} catch ( BITalino::Exception &e ) {
// printf( "BITalino exception: %s\n", e.getDescription( ) );
// TODO: check which exact exception is communication lost etc.
threadState = SEARCHING_FOR_DEVICE;
connected.store( false );
if ( dev )
{
delete dev;
dev = nullptr;
}
usleep( 500000 ); // 500ms Timeout before trying to reconnect again
}
}
std::atomic< bool > connected;
std::atomic< bool > recording;
std::string deviceName;
BITalino* dev = nullptr;
uint16_t sampleRate = 1000;
std::vector< int32_t > channels;
std::atomic< uint32_t > tries;
uint32_t currentTries = 0;
private:
enum State {
SEARCHING_FOR_DEVICE,
IDLE_BUT_CONNECTED,
RECORDING_DATA
};
State threadState = SEARCHING_FOR_DEVICE;
BITalino::VFrame frameBuffer;
BITalino::VFrame pollTestBuffer;
};
#endif /* BitalinoThread_h */