void
basic_shifter(string infile, string outfile)
{
MarSystem* pnet = mng.create("Series", "pnet");
addSource( pnet, infile );
pnet->addMarSystem(mng.create("Shifter", "shift"));
pnet->updctrl("Shifter/shift/mrs_natural/shift", 16);
addDest( pnet, outfile);
while (pnet->getctrl("mrs_bool/hasData")->to<mrs_bool>())
{
pnet->tick();
}
delete pnet;
}
// TODO: move
void
basic_vibrato(string infile, string outfile)
{
MarSystem* pnet = mng.create("Series", "pnet");
addSource( pnet, infile );
pnet->addMarSystem(mng.create("Vibrato", "vib"));
addDest( pnet, outfile);
pnet->updctrl("Vibrato/vib/mrs_real/mod_freq", 10.0);
while (pnet->getctrl("mrs_bool/hasData")->to<mrs_bool>())
{
pnet->tick();
}
delete pnet;
}
MslModel::~MslModel() {
map<string, MarSystem *>::const_iterator iter;
for (iter=workingSet.begin(); iter != workingSet.end(); ++iter) {
// we actually should only have to delete the most top
// level composite marsystem as they take care of
// deleting their internal marsystems... here we assume
// that there is only one type Series and its the top level.
MarSystem* tmp = (MarSystem*)iter->second;
string type = tmp->getType();
if (type.compare("Series") == 0) {
delete iter->second;
}
}
}
void
basic_windowing(string infile, string outfile)
{
MarSystem* pnet = mng.create("Series", "pnet");
addSource( pnet, infile );
pnet->addMarSystem(mng.create("Windowing", "win"));
pnet->updctrl("Windowing/win/mrs_string/type", "Hanning");
addDest( pnet, outfile);
while (pnet->getctrl("mrs_bool/hasData")->to<mrs_bool>())
{
pnet->tick();
}
delete pnet;
}
int
main(int argc, const char **argv)
{
(void) argc; // tells the compiler that we know that we're not
(void) argv; // using these two variables
MRSDIAG("helloWorld.cpp - main");
// cout << "This is probably the simplest Marsyas example code: it simply
// generates a sine wave with a frequency of 440Hz and send it to the audio
// card output. Simple press CTRL+C to quit." << endl;
//we usualy start by creating a MarSystem manager
//to help us on MarSystem creation
MarSystemManager mng;
//create the network, which is a simple Series network with a sine wave
//oscilator and a audio sink object to send the ausio data for playing
//in the sound card
MarSystem *network = mng.create("Series", "network");
network->addMarSystem(mng.create("SineSource", "src"));
network->addMarSystem(mng.create("AudioSink", "dest"));
network->addMarSystem(mng.create("SoundFileSink", "dest2"));
//set the window (i.e. audio frame) size (in samples). Let's say, 256 samples.
//This is done in the outmost MarSystem (i.e. the Series/network) because flow
//controls (as is the case of inSamples) are propagated through the network.
//Check the Marsyas documentation for mode details.
network->updControl("mrs_natural/inSamples", 4096);
//set oscilator frequency to 440Hz
network->updControl("SineSource/src/mrs_real/frequency", 440.0);
// set the sampling to 44100 - a safe choice in most configurations
network->updControl("mrs_real/israte", 44100.0);
network->updControl("AudioSink/dest/mrs_bool/initAudio", true);
network->updControl("SoundFileSink/dest2/mrs_string/filename", "helloworld.wav");
//now it's time for ticking the network,
//ad aeternum (i.e. until the user quits by CTRL+C)
while (1)
{
network->tick();
}
//ok, this is not really necessary because we are quiting by CTRL+C,
//but it's a good habit anyway ;-)
delete network;
return(0);
}
void
TranscriberExtract::getAllFromAudio(const std::string audioFilename, realvec&
pitchList, realvec& ampList,
realvec& boundaries)
{
MarSystem* pitchSink = mng.create("RealvecSink", "pitchSink");
MarSystem* ampSink = mng.create("RealvecSink", "ampSink");
MarSystem* pnet = mng.create("Series", "pnet");
mrs_real srate = addFileSource(pnet, audioFilename);
// TODO: double the number of observations?
// pnet->updControl("SoundFileSource/src/mrs_natural/inSamples",256);
// pnet->addMarSystem(mng.create("ShiftInput", "shift"));
// pnet->updControl("ShiftInput/shift/mrs_natural/winSize",512);
MarSystem* fanout = mng.create("Fanout", "fanout");
fanout->addMarSystem(makePitchNet(srate, 100.0, pitchSink));
fanout->addMarSystem(makeAmplitudeNet(ampSink));
pnet->addMarSystem(fanout);
while ( pnet->getctrl("mrs_bool/hasData")->to<mrs_bool>() )
pnet->tick();
pitchList = getPitchesFromRealvecSink(pitchSink, srate);
ampList = getAmpsFromRealvecSink(ampSink);
boundaries.create(2);
boundaries(0) = 0;
boundaries(1) = pitchList.getSize();
delete pnet;
}
void
WHaSp::createSimMatrixNet()
{
if(HWPSnet_)
return;
HWPSnet_ = new Series("HWPSnet");
//add a feat selector and
//set the features needed for HWPS
MarSystem* peFeatSelect = new PeakFeatureSelect("peFeatSelect");
peFeatSelect->updControl("mrs_natural/selectedFeatures",
PeakFeatureSelect::pkFrequency | PeakFeatureSelect::pkSetFrequencies| PeakFeatureSelect::pkSetAmplitudes);
HWPSnet_->addMarSystem(peFeatSelect);
//create a similarityMatrix MarSystem that uses the HPWS metric
SelfSimilarityMatrix* simMat = new SelfSimilarityMatrix("simMat");
simMat->addMarSystem(new HWPS("hwps"));
HWPSnet_->addMarSystem(simMat);
//link totalNumPeaks control to PeakFeatureSelect
HWPSnet_->getctrl("PeakFeatureSelect/peFeatSelect/mrs_natural/totalNumPeaks")->linkTo(ctrl_totalNumPeaks_, NOUPDATE);
HWPSnet_->update(); //only call update to HWPSnet_ since this is being called from WHaSp::update()! -> avoid potential infinite recursion!
//link frameMaxNumPeaks control to PeakFeatureSelect
HWPSnet_->getctrl("PeakFeatureSelect/peFeatSelect/mrs_natural/frameMaxNumPeaks")->linkTo(ctrl_frameMaxNumPeaks_, NOUPDATE);
HWPSnet_->update(); //only call update to HWPSnet_ since this is being called from WHaSp::update()! -> avoid potential infinite recursion!
//link histSize control to HWPS metric
HWPSnet_->getctrl("SelfSimilarityMatrix/simMat/HWPS/hwps/mrs_natural/histSize")->linkTo(ctrl_histSize_, NOUPDATE);
HWPSnet_->update(); //only call update to HWPSnet_ since this is being called from WHaSp::update()! -> avoid potential infinite recursion!
HWPSnet_->setctrl("SelfSimilarityMatrix/simMat/HWPS/hwps/mrs_natural/histSize", 20);
HWPSnet_->update(); //only call update to HWPSnet_ since this is being called from WHaSp::update()! -> avoid potential infinite recursion!
HWPSnet_->updControl("SelfSimilarityMatrix/simMat/HWPS/hwps/mrs_bool/calcDistance", true);
//HWPSnet_->setctrl("SelfSimilarityMatrix/simMat/HWPS/hwps/mrs_natural/histSize", 100);
HWPSnet_->update(); //only call update to HWPSnet_ since this is being called from WHaSp::update()! -> avoid potential infinite recursion!
}
mrs_natural
BeatAgent::getChildIndex()
{
//check for parent:
MarSystem* parent = this->getParent();
myIndex_ = -1;
if(parent)
{
vector<MarSystem*> siblings = parent->getChildren();
for(mrs_natural i = 0; i < (mrs_natural)siblings.size(); i++)
{
if(this == siblings[i])
{
myIndex_ = i;
break;
}
}
}
return myIndex_;
}
MarsyasBExtractRolloff::MarsyasBExtractRolloff(float inputSampleRate) :
Plugin(inputSampleRate),
m_stepSize(0),
m_previousSample(0.f),
m_network(0)
{
MarSystemManager mng;
// Overall extraction and classification network
m_network = mng.create("Series", "mainNetwork");
// Build the overall feature calculation network
MarSystem *featureNetwork = mng.create("Series", "featureNetwork");
// Add a realvec as the source
featureNetwork->addMarSystem(mng.create("RealvecSource", "src"));
// Convert the data to mono
featureNetwork->addMarSystem(mng.create("Stereo2Mono", "m2s"));
// Setup the feature extractor
MarSystem* featExtractor = mng.create("TimbreFeatures", "featExtractor");
featExtractor->updctrl("mrs_string/enableSPChild", "Rolloff/rlf");
featureNetwork->addMarSystem(featExtractor);
// Add the featureNetwork to the main network
m_network->addMarSystem(featureNetwork);
}
realvec
TranscriberExtract::getAmpsFromAudio(const std::string audioFilename)
{
mrs_real normalize = getNormalizingGain(audioFilename);
MarSystem* pnet = mng.create("Series", "pnet");
mrs_real srate;
srate = addFileSource(pnet, audioFilename);
pnet->addMarSystem(mng.create("Gain", "normalizing"));
pnet->updControl("Gain/normalizing/mrs_real/gain",normalize);
MarSystem* rvSink = mng.create("RealvecSink", "rvSink");
pnet->addMarSystem(makeAmplitudeNet(rvSink));
while ( pnet->getctrl("mrs_bool/hasData")->to<mrs_bool>() )
pnet->tick();
realvec rmsList = getAmpsFromRealvecSink(rvSink);
delete pnet;
// normalize RMS
rmsList -= rmsList.minval();
mrs_real maxRms = rmsList.maxval();
if (maxRms != 0)
rmsList /= maxRms;
return rmsList;
}
int run( const string system_filename, const CommandLineOptions & opt )
{
int ticks = 0;
if (opt.has("count"))
{
ticks = opt.value<int>("count");
if (ticks < 1)
{
cerr << "Invalid value for option 'count' (must be > 0)." << endl;
return 1;
}
}
ifstream system_istream(system_filename);
MarSystemManager mng;
MarSystem* system = mng.getMarSystem(system_istream);
if (!system) {
cerr << "Could not load filesystem file:" << system;
return 1;
}
bool realtime = opt.value<bool>("realtime");
mrs_real sr = opt.value<mrs_real>("samplerate");
mrs_natural block = opt.value<mrs_natural>("block");
if (sr > 0)
system->setControl("mrs_real/israte", sr);
if (block > 0)
system->setControl("mrs_natural/inSamples", block);
system->update();
RealTime::Runner runner(system);
runner.setRtPriorityEnabled(realtime);
runner.start((unsigned int)ticks);
runner.wait();
return 0;
}
MarSystem* TranscriberExtract::makeAmplitudeNet(MarSystem* rvSink)
{
MarSystem *net = mng.create("Series", "amplitudeNet");
net->addMarSystem(mng.create("ShiftInput", "sfiAmp"));
net->addMarSystem(mng.create("Rms", "rms"));
if (rvSink != NULL)
net->addMarSystem(rvSink);
net->updControl("mrs_natural/inSamples", 512);
net->updControl("ShiftInput/sfiAmp/mrs_natural/winSize", 512);
return net;
}
void
basic_delay(string infile, string outfile)
{
MarSystem* pnet = mng.create("Series", "pnet");
addSource( pnet, infile );
pnet->addMarSystem(mng.create("Delay", "delay"));
pnet->updctrl("Delay/delay/mrs_natural/delaySamples", 16);
pnet->updctrl("Delay/delay/mrs_real/feedback", (mrs_real) 0.5);
addDest( pnet, outfile);
while (pnet->getctrl("mrs_bool/hasData")->to<mrs_bool>())
{
pnet->tick();
}
delete pnet;
}
// take advantage of MarSystemManager
void
tempotest_sfplay(string sfName)
{
cout << "Playing " << sfName << endl;
MarSystemManager mng;
// Create a series Composite
MarSystem* series = mng.create("Series", "series");
series->addMarSystem(mng.create("SoundFileSource", "src"));
series->addMarSystem(mng.create("AudioSink", "dest"));
// only update controls from Composite level
series->updctrl("mrs_natural/inSamples", 128);
series->updctrl("SoundFileSource/src/mrs_string/filename", sfName);
while (series->getctrl("SoundFileSource/src/mrs_bool/hasData")->to<mrs_bool>())
series->tick();
delete series;
}
realvec
TranscriberExtract::getPitchesFromAudio(const std::string audioFilename)
{
mrs_real normalize = getNormalizingGain(audioFilename);
MarSystem* pnet = mng.create("Series", "pnet");
mrs_real srate = addFileSource(pnet, audioFilename);
pnet->addMarSystem(mng.create("Gain", "normalizing"));
pnet->updControl("Gain/normalizing/mrs_real/gain",normalize);
MarSystem* rvSink = mng.create("RealvecSink", "rvSink");
pnet->addMarSystem(makePitchNet(srate, 100.0, rvSink));
while ( pnet->getctrl("mrs_bool/hasData")->to<mrs_bool>() )
pnet->tick();
realvec pitchList = getPitchesFromRealvecSink(rvSink, srate);
delete pnet;
return pitchList;
}
void
toy_with_csv_input(mrs_string sfname)
{
MarSystemManager mng;
MarSystem *net = mng.create("Series", "net");
net->addMarSystem(mng.create("CsvFileSource", "src"));
net->updControl("CsvFileSource/src/mrs_string/filename", sfname);
net->updControl("mrs_natural/inSamples", 1);
while ( net->getctrl("CsvFileSource/src/mrs_bool/hasData")->to<mrs_bool>() )
{
net->tick();
mrs_realvec v = net->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
for (mrs_natural i = 0; i<v.getSize(); ++i)
{
printf("%.5g\t", v(i));
}
cout<<endl;
}
delete net;
}
void
peakClusteringEval(realvec &peakSet, string sfName, string outsfname, string noiseName, string mixName, string intervalFrequency, string panningInfo, mrs_real noiseDelay, string T, mrs_natural N, mrs_natural Nw,
mrs_natural D, mrs_natural S, mrs_natural C,
mrs_natural accSize, mrs_natural synthetize, mrs_real *snr0)
{
//FIXME: D is the same as hopSize_ -> fix to avoid confusion!
MATLAB_EVAL("clear");
MarSystemManager mng;
cout << "Extracting Peaks and Computing Clusters..." << endl;
//**************************************************
// create the peakClusteringEval network
//**************************************************
MarSystem* mainNet = mng.create("Series", "mainNet");
//**************************************************************************
//create accumulator for the texture window and add it to the main network
//**************************************************************************
MarSystem* textWinNet = mng.create("Accumulator", "textWinNet");
mainNet->addMarSystem(textWinNet);
//************************************************************************
//create Analysis Network and add it to the texture window accumulator
//************************************************************************
MarSystem* analysisNet = mng.create("Series", "analysisNet");
textWinNet->addMarSystem(analysisNet);
//************************************************************************
//create FanInOut for mixing with a noise source and add to Analysis Net
//************************************************************************
MarSystem* mixer = mng.create("FanOutIn", "mixer");
//---- create original series and add it to mixer
MarSystem* oriNet = mng.create("Series", "oriNet");
if (microphone_)
oriNet->addMarSystem(mng.create("AudioSource", "src"));
else
{
//oriNet->addMarSystem(mng.create("SoundFileSource", "src"));
oriNet->addMarSystem(mng.create("MidiFileSynthSource", "src")); //[!]
}
oriNet->addMarSystem(mng.create("Gain", "oriGain"));
mixer->addMarSystem(oriNet);
//---- create a series for the noiseSource
if(noiseName != EMPTYSTRING)
{
MarSystem* mixseries = mng.create("Series", "mixseries");
if(noiseName == "white")
mixseries->addMarSystem(mng.create("NoiseSource", "noise"));
else
mixseries->addMarSystem(mng.create("SoundFileSource", "noise"));
mixseries->addMarSystem(mng.create("Delay", "noiseDelay"));
MarSystem* noiseGain = mng.create("Gain", "noiseGain");
mixseries->addMarSystem(noiseGain);
// add this series in the fanout
mixer->addMarSystem(mixseries);
}
//add Mixer to analysis network
analysisNet->addMarSystem(mixer);
//********************************************************
// create SoundFileSink and add it to the analysis net
//********************************************************
if(noiseName != EMPTYSTRING)
analysisNet->addMarSystem(mng.create("SoundFileSink", "mixSink"));
//***********************************************************
// create peakExtract network and add it to the analysis net
//***********************************************************
MarSystem* peakExtract = mng.create("Series","peakExtract");
peakExtract->addMarSystem(mng.create("ShiftInput", "si")); //[?]
MarSystem* stereoFo = mng.create("Fanout","stereoFo");
// create Spectrum Network and add it to the analysis net
MarSystem* spectrumNet = mng.create("Series", "spectrumNet");
spectrumNet->addMarSystem(mng.create("Stereo2Mono","s2m"));
//onset detector
MarSystem* onsetdetector = mng.create("FlowThru", "onsetdetector");
//onsetdetector->addMarSystem(mng.create("ShiftInput", "si"));
onsetdetector->addMarSystem(mng.create("Windowing", "win"));
onsetdetector->addMarSystem(mng.create("Spectrum","spk"));
onsetdetector->addMarSystem(mng.create("PowerSpectrum", "pspk"));
onsetdetector->addMarSystem(mng.create("Flux", "flux"));
onsetdetector->addMarSystem(mng.create("ShiftInput","sif"));
onsetdetector->addMarSystem(mng.create("Filter","filt1"));
onsetdetector->addMarSystem(mng.create("Reverse","rev1"));
onsetdetector->addMarSystem(mng.create("Filter","filt2"));
onsetdetector->addMarSystem(mng.create("Reverse","rev2"));
onsetdetector->addMarSystem(mng.create("PeakerOnset","peaker"));
spectrumNet->addMarSystem(onsetdetector);
spectrumNet->addMarSystem(mng.create("Shifter", "sh"));
spectrumNet->addMarSystem(mng.create("Windowing", "wi"));
MarSystem* parallel = mng.create("Parallel", "par");
parallel->addMarSystem(mng.create("Spectrum", "spk1"));
parallel->addMarSystem(mng.create("Spectrum", "spk2"));
spectrumNet->addMarSystem(parallel);
// add spectrumNet to stereo fanout
stereoFo->addMarSystem(spectrumNet);
//
//create stereo spectrum net
MarSystem* stereoSpkNet = mng.create("Series","stereoSpkNet");
MarSystem* LRnet = mng.create("Parallel","LRnet");
//
MarSystem* spkL = mng.create("Series","spkL");
spkL->addMarSystem(mng.create("Windowing","win"));
spkL->addMarSystem(mng.create("Spectrum","spk"));
LRnet->addMarSystem(spkL);
//
MarSystem* spkR = mng.create("Series","spkR");
spkR->addMarSystem(mng.create("Windowing","win"));
spkR->addMarSystem(mng.create("Spectrum","spk"));
LRnet->addMarSystem(spkR);
//
//add it to the stereo spectrum net series
stereoSpkNet->addMarSystem(LRnet);
//
//add stereo spectrum object to stereo spectrum net
//stereoSpkNet->addMarSystem(mng.create("StereoSpectrum","stereoSpk")); //AVENDANO
stereoSpkNet->addMarSystem(mng.create("EnhADRess","ADRess"));//enhADRess_1
stereoSpkNet->addMarSystem(mng.create("EnhADRessStereoSpectrum","stereoSpk")); //enhADRess_2
//
// add the stereo Spectrum net to the Fanout
stereoFo->addMarSystem(stereoSpkNet);
//
// add the fanout to the peakExtract net
peakExtract->addMarSystem(stereoFo);
//
//add peakExtract net to analysis net
analysisNet->addMarSystem(peakExtract);
//***************************************************************
//add PeakConvert to main SERIES for processing texture windows
//***************************************************************
mainNet->addMarSystem(mng.create("PeakConvert", "conv"));
mainNet->linkControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_natural/winSize",
"Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/ShiftInput/si/mrs_natural/winSize");
//***************************************************************
//create a FlowThru for the Clustering Network and add to main net
//***************************************************************
MarSystem* clustNet = mng.create("FlowThru", "clustNet");
mainNet->addMarSystem(clustNet);
//***************************************************************
// create Similarities Network and add it to ClustNet
//***************************************************************
MarSystem* simNet = mng.create("FanOutIn", "simNet");
simNet->updControl("mrs_string/combinator", "*");
//
//create Frequency similarity net and add it to simNet
//
MarSystem* freqSim = mng.create("Series","freqSim");
//--------
freqSim->addMarSystem(mng.create("PeakFeatureSelect","FREQfeatSelect"));
freqSim->updControl("PeakFeatureSelect/FREQfeatSelect/mrs_natural/selectedFeatures",
PeakFeatureSelect::pkFrequency | PeakFeatureSelect::barkPkFreq);
//--------
MarSystem* fsimMat = mng.create("SelfSimilarityMatrix","FREQsimMat");
fsimMat->addMarSystem(mng.create("Metric","FreqL2Norm"));
fsimMat->updControl("Metric/FreqL2Norm/mrs_string/metric","euclideanDistance");
fsimMat->updControl("mrs_natural/calcCovMatrix", SelfSimilarityMatrix::diagCovMatrix);
//fsimMat->updControl("mrs_string/normalize", "MinMax");
//fsimMat->linkControl("mrs_realvec/covMatrix", "Metric/FreqL2Norm/mrs_realvec/covMatrix");
freqSim->addMarSystem(fsimMat);
//--------
freqSim->addMarSystem(mng.create("RBF","FREQrbf"));
freqSim->updControl("RBF/FREQrbf/mrs_string/RBFtype","Gaussian");
freqSim->updControl("RBF/FREQrbf/mrs_bool/symmetricIn",true);
//--------
simNet->addMarSystem(freqSim);
//
//create Amplitude similarity net and add it to simNet
//
MarSystem* ampSim = mng.create("Series","ampSim");
//--------
ampSim->addMarSystem(mng.create("PeakFeatureSelect","AMPfeatSelect"));
ampSim->updControl("PeakFeatureSelect/AMPfeatSelect/mrs_natural/selectedFeatures",
PeakFeatureSelect::pkAmplitude | PeakFeatureSelect::dBPkAmp);
//--------
MarSystem* asimMat = mng.create("SelfSimilarityMatrix","AMPsimMat");
asimMat->addMarSystem(mng.create("Metric","AmpL2Norm"));
asimMat->updControl("Metric/AmpL2Norm/mrs_string/metric","euclideanDistance");
asimMat->updControl("mrs_natural/calcCovMatrix", SelfSimilarityMatrix::diagCovMatrix);
//asimMat->updControl("mrs_string/normalize", "MinMax");
//asimMat->linkControl("mrs_realvec/covMatrix", "Metric/AmpL2Norm/mrs_realvec/covMatrix");
ampSim->addMarSystem(asimMat);
//--------
ampSim->addMarSystem(mng.create("RBF","AMPrbf"));
ampSim->updControl("RBF/AMPrbf/mrs_string/RBFtype","Gaussian");
ampSim->updControl("RBF/AMPrbf/mrs_bool/symmetricIn",true);
//--------
simNet->addMarSystem(ampSim);
//
//create HWPS similarity net and add it to simNet
//
MarSystem* HWPSim = mng.create("Series","HWPSim");
//--------
HWPSim->addMarSystem(mng.create("PeakFeatureSelect","HWPSfeatSelect"));
HWPSim->updControl("PeakFeatureSelect/HWPSfeatSelect/mrs_natural/selectedFeatures",
PeakFeatureSelect::pkFrequency | PeakFeatureSelect::pkSetFrequencies | PeakFeatureSelect::pkSetAmplitudes);
//--------
MarSystem* HWPSsimMat = mng.create("SelfSimilarityMatrix","HWPSsimMat");
HWPSsimMat->addMarSystem(mng.create("HWPS","hwps"));
HWPSsimMat->updControl("HWPS/hwps/mrs_bool/calcDistance", true);
HWPSim->addMarSystem(HWPSsimMat);
//--------
HWPSim->addMarSystem(mng.create("RBF","HWPSrbf"));
HWPSim->updControl("RBF/HWPSrbf/mrs_string/RBFtype","Gaussian");
HWPSim->updControl("RBF/HWPSrbf/mrs_bool/symmetricIn",true);
//--------
simNet->addMarSystem(HWPSim);
//
//create Panning similarity net and add it to simNet
//
MarSystem* panSim = mng.create("Series","panSim");
//--------
panSim->addMarSystem(mng.create("PeakFeatureSelect","PANfeatSelect"));
panSim->updControl("PeakFeatureSelect/PANfeatSelect/mrs_natural/selectedFeatures",
PeakFeatureSelect::pkPan);
//--------
MarSystem* psimMat = mng.create("SelfSimilarityMatrix","PANsimMat");
psimMat->addMarSystem(mng.create("Metric","PanL2Norm"));
psimMat->updControl("Metric/PanL2Norm/mrs_string/metric","euclideanDistance");
psimMat->updControl("mrs_natural/calcCovMatrix", SelfSimilarityMatrix::diagCovMatrix);
//psimMat->updControl("mrs_string/normalize", "MinMax");
//psimMat->linkControl("mrs_realvec/covMatrix", "Metric/PanL2Norm/mrs_realvec/covMatrix");
panSim->addMarSystem(psimMat);
//--------
panSim->addMarSystem(mng.create("RBF","PANrbf"));
panSim->updControl("RBF/PANrbf/mrs_string/RBFtype","Gaussian");
panSim->updControl("RBF/PANrbf/mrs_bool/symmetricIn",true);
//--------
simNet->addMarSystem(panSim);
//
// LINK controls of PeakFeatureSelects in each similarity branch
//
simNet->linkControl("Series/ampSim/PeakFeatureSelect/AMPfeatSelect/mrs_natural/totalNumPeaks",
"Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/totalNumPeaks");
simNet->linkControl("Series/HWPSim/PeakFeatureSelect/HWPSfeatSelect/mrs_natural/totalNumPeaks",
"Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/totalNumPeaks");
simNet->linkControl("Series/panSim/PeakFeatureSelect/PANfeatSelect/mrs_natural/totalNumPeaks",
"Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/totalNumPeaks");
//------
simNet->linkControl("Series/ampSim/PeakFeatureSelect/AMPfeatSelect/mrs_natural/frameMaxNumPeaks",
"Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/frameMaxNumPeaks");
simNet->linkControl("Series/HWPSim/PeakFeatureSelect/HWPSfeatSelect/mrs_natural/frameMaxNumPeaks",
"Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/frameMaxNumPeaks");
simNet->linkControl("Series/panSim/PeakFeatureSelect/PANfeatSelect/mrs_natural/frameMaxNumPeaks",
"Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/frameMaxNumPeaks");
//++++++++++++++++++++++++++++++++++++++++++++++++++++++
//add simNet to clustNet
clustNet->addMarSystem(simNet);
//
// LINK controls related to variable number of peak from PeakConvert to simNet
//
mainNet->linkControl("FlowThru/clustNet/FanOutIn/simNet/Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/totalNumPeaks",
"PeakConvert/conv/mrs_natural/totalNumPeaks");
mainNet->linkControl("FlowThru/clustNet/FanOutIn/simNet/Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/frameMaxNumPeaks",
"PeakConvert/conv/mrs_natural/frameMaxNumPeaks");
//***************************************************************
// create NCutNet MarSystem and add it to clustNet
//***************************************************************
// MarSystem* NCutNet = mng.create("Series","NCutNet");
// clustNet->addMarSystem(NCutNet);
// //---add NCutNet components
// // add a stack to stack the
// MarSystem* stack = mng.create("Fanout","stack");
// NCutNet->addMarSystem(stack);
// stack->addMarSystem(mng.create("NormCut","NCut"));
// stack->addMarSystem(mng.create("Gain", "ID"));
// // add the cluster selection module
// NCutNet->addMarSystem(mng.create("PeakClusterSelect","clusterSelect"));
// Do not select most prominent clusters anymore
clustNet->addMarSystem(mng.create("NormCut","NCut")); //[!]
//***************************************************************
// create PeakLabeler MarSystem and add it to mainNet
//***************************************************************
MarSystem* labeler = mng.create("PeakLabeler","labeler");
mainNet->addMarSystem(labeler);
//---- link labeler label control to the NCut output control
mainNet->linkControl("PeakLabeler/labeler/mrs_realvec/peakLabels", "FlowThru/clustNet/mrs_realvec/innerOut");
//***************************************************************
// create PeakViewSink MarSystem and add it to mainNet
//***************************************************************
if(peakStore_)
{
mainNet->addMarSystem(mng.create("PeakViewSink", "peSink"));
mainNet->updControl("PeakViewSink/peSink/mrs_string/filename", filePeakName);
}
//****************************************************************
// Create Synthesis Network
//****************************************************************
MarSystem* postNet = mng.create("Series", "postNet");
// Create Peak Synth ////////////////////////////////////
MarSystem* peakSynth = mng.create("Series", "peakSynth");
peakSynth->addMarSystem(mng.create("PeakSynthOsc", "pso"));
peakSynth->addMarSystem(mng.create("Windowing", "wiSyn"));
peakSynth->addMarSystem(mng.create("OverlapAdd", "ov"));
peakSynth->addMarSystem(mng.create("Gain", "outGain"));
// MarSystem *dest;
// dest = new SoundFileSink("dest");
// //dest->updControl("mrs_string/filename", outsfname);
// peakSynth->addMarSystem(dest);
mng.registerPrototype("PeakSynth", peakSynth);
// Create Bank of Synths ////////////////////////////////////////////////
MarSystem* synthBank = mng.create("Fanout","synthBank");
mrs_natural numSynths = 10; // HARDCODED FOR NOW [!]
synthBank->addMarSystem(mng.create("PeakSynth", "synthCluster_0"));
synthBank->updControl("PeakSynth/synthCluster_0/PeakSynthOsc/pso/mrs_natural/peakGroup2Synth", 0);
for(mrs_natural s=1; s < numSynths; ++s)
{
ostringstream oss;
oss << "synthCluster_" << s;
synthBank->addMarSystem(mng.create("PeakSynth", oss.str()));
//link controls between branches
synthBank->linkControl("PeakSynth/"+oss.str()+"/PeakSynthOsc/pso/mrs_real/samplingFreq",
"PeakSynth/synthCluster_0/PeakSynthOsc/pso/mrs_real/samplingFreq");
synthBank->linkControl("PeakSynth/"+oss.str()+"/PeakSynthOsc/pso/mrs_natural/delay",
"PeakSynth/synthCluster_0/PeakSynthOsc/pso/mrs_natural/delay");
synthBank->linkControl("PeakSynth/"+oss.str()+"/PeakSynthOsc/pso/mrs_natural/synSize",
"PeakSynth/synthCluster_0/PeakSynthOsc/pso/mrs_natural/synSize");
synthBank->linkControl("PeakSynth/"+oss.str()+"/Windowing/wiSyn/mrs_string/type",
"PeakSynth/synthCluster_0/Windowing/wiSyn/mrs_string/type");
synthBank->updControl("PeakSynth/"+oss.str()+"/PeakSynthOsc/pso/mrs_natural/peakGroup2Synth", s);
}
postNet->addMarSystem(synthBank);
// SHREDDER /////////////////////////////////////////////////
MarSystem* synthNet = mng.create("Shredder", "synthNet");
synthNet->addMarSystem(postNet);
synthNet->updControl("mrs_bool/accumulate", true); //accumulate output
mainNet->addMarSystem(synthNet);
//link Shredder nTimes to Accumulator nTimes
mainNet->linkControl("Shredder/synthNet/mrs_natural/nTimes",
"Accumulator/textWinNet/mrs_natural/nTimes");
// add a MATLAB sink at the very end of the network!
mainNet->addMarSystem(mng.create("PlotSink", "send2MATLAB"));
mainNet->updControl("PlotSink/send2MATLAB/mrs_bool/sequence", false);
mainNet->updControl("PlotSink/send2MATLAB/mrs_bool/messages", false);
mainNet->updControl("PlotSink/send2MATLAB/mrs_bool/matlab", true);
mainNet->updControl("PlotSink/send2MATLAB/mrs_string/matlabCommand",
"evaluateTextWin;");
//****************************************************************
////////////////////////////////////////////////////////////////
// update the controls
////////////////////////////////////////////////////////////////
//mainNet->updControl("Accumulator/textWinNet/mrs_natural/nTimes", accSize);
if (microphone_)
{
mainNet->updControl("mrs_natural/inSamples", D);
mainNet->updControl("mrs_natural/inObservations", 1);
}
else
{
cout << ">> Loading MIDI file and synthetizing audio data..." << endl;
mainNet->updControl("mrs_natural/inSamples", D);
mainNet->updControl("mrs_real/israte", samplingFrequency_);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_real/start", 10.0);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_real/end", 20.0);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_string/filename", sfName);
//mainNet->updControl("mrs_natural/inObservations", 1);
//samplingFrequency_ = mainNet->getctrl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_real/osrate")->to<mrs_real>();
}
if(noiseName != EMPTYSTRING)
{
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/mixseries/SoundFileSource/noise/mrs_string/filename", noiseName);
mainNet->updControl("mrs_natural/inSamples", D);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/mixseries/NoiseSource/noise/mrs_string/mode", "rand");
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Seriesmixseries/Delay/noiseDelay/mrs_real/delaySeconds", noiseDelay);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/mixseries/Gain/noiseGain/mrs_real/gain", noiseGain_);
}
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/ShiftInput/si/mrs_natural/winSize", Nw+1);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/spectrumNet/Shifter/sh/mrs_natural/shift", 1);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/spectrumNet/Windowing/wi/mrs_natural/size", N);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/spectrumNet/Windowing/wi/mrs_string/type", "Hanning");
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/spectrumNet/Windowing/wi/mrs_bool/zeroPhasing", true);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/stereoSpkNet/Parallel/LRnet/Series/spkL/Windowing/win/mrs_natural/size", N);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/stereoSpkNet/Parallel/LRnet/Series/spkL/Windowing/win/mrs_string/type", "Hanning");
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/stereoSpkNet/Parallel/LRnet/Series/spkL/Windowing/win/mrs_bool/zeroPhasing", true);
//
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/stereoSpkNet/Parallel/LRnet/Series/spkR/Windowing/win/mrs_natural/size", N);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/stereoSpkNet/Parallel/LRnet/Series/spkR/Windowing/win/mrs_string/type", "Hanning");
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/stereoSpkNet/Parallel/LRnet/Series/spkR/Windowing/win/mrs_bool/zeroPhasing", true);
if(unprecise_)
mainNet->updControl("PeakConvert/conv/mrs_bool/improvedPrecision", false);
else
mainNet->updControl("PeakConvert/conv/mrs_bool/improvedPrecision", true);
if(noPeakPicking_)
mainNet->updControl("PeakConvert/conv/mrs_bool/picking", false);
mainNet->updControl("PeakConvert/conv/mrs_natural/frameMaxNumPeaks", S);
mainNet->updControl("PeakConvert/conv/mrs_string/frequencyInterval", intervalFrequency);
mainNet->updControl("PeakConvert/conv/mrs_natural/nbFramesSkipped", 0);//(N/D));
//mainNet->updControl("FlowThru/clustNet/Series/NCutNet/Fanout/stack/NormCut/NCut/mrs_natural/numClusters", C); [!]
//mainNet->updControl("FlowThru/clustNet/Series/NCutNet/PeakClusterSelect/clusterSelect/mrs_natural/numClustersToKeep", nbSelectedClusters_);//[!]
//
if(C > 0) //use fixed and manually set number of clusters
{
cout << ">> Using fixed number of clusters: " << C << " clusters." << endl;
mainNet->updControl("FlowThru/clustNet/NormCut/NCut/mrs_natural/numClusters", C); //[!]
}
else if(C==0) //use GT number of clusters
{
cout << "** Using GT number of clusters." << endl;
mainNet->linkControl("FlowThru/clustNet/NormCut/NCut/mrs_natural/numClusters",
"Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_natural/numActiveNotes");
}
else if(C==-1) //automatically estimate number of clusters
{
cout << "Automatic Estimation of number of clusters: NOT YET IMPLEMENTED! Exiting...";
exit(0);
}
// //[TODO]
// mainNet->setctrl("PeClust/peClust/mrs_natural/selectedClusters", nbSelectedClusters_);
// mainNet->setctrl("PeClust/peClust/mrs_natural/hopSize", D);
// mainNet->setctrl("PeClust/peClust/mrs_natural/storePeaks", (mrs_natural) peakStore_);
// mainNet->updControl("PeClust/peClust/mrs_string/similarityType", T);
//
// similarityWeight_.stretch(3);
// similarityWeight_(0) = 1;
// similarityWeight_(1) = 10; //[WTF]
// similarityWeight_(2) = 1;
// mainNet->updControl("PeClust/peClust/mrs_realvec/similarityWeight", similarityWeight_);
if(noiseName != EMPTYSTRING)
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/SoundFileSink/mixSink/mrs_string/filename", mixName);
mainNet->update();
//check if input is a stereo signal
if(mainNet->getctrl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/mrs_natural/onObservations")->to<mrs_natural>() == 1)
{
//if a not a stereo signal, we must set the Stereo2Mono weight to 1.0 (i.e. do no mixing)!
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/spectrumNet/Stereo2Mono/s2m/mrs_real/weight", 1.0);
}
//------------------------------------------------------------------------
//check which similarity computations should be disabled (if any)
//------------------------------------------------------------------------
// Frequency Similarity
if(ignoreFrequency)
{
cout << "** Frequency Similarity Computation disabled!" << endl;
mainNet->updControl("FlowThru/clustNet/FanOutIn/simNet/mrs_string/disableChild",
"Series/freqSim");
}
else
cout << "** Frequency Similarity Computation enabled!" << endl;
// amplitude similarity
if(ignoreAmplitude)
{
cout << "** Amplitude Similarity Computation disabled!" << endl;
mainNet->updControl("FlowThru/clustNet/FanOutIn/simNet/mrs_string/disableChild",
"Series/ampSim");
}
else
cout << "** Amplitude Similarity Computation enabled!" << endl;
// HWPS similarity
if(ignoreHWPS)
{
cout << "** HWPS (harmonicity) Similarity Computation disabled!" << endl;
mainNet->updControl("FlowThru/clustNet/FanOutIn/simNet/mrs_string/disableChild",
"Series/HWPSim");
}
else
cout << "** HWPS (harmonicity) Similarity Computation enabled!" << endl;
//
//Panning Similarity
if(mainNet->getctrl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/mrs_natural/onObservations")->to<mrs_natural>() == 2 &&
!ignorePan)
{
cout << "** Panning Similarity Computation enabled!" << endl;
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/mrs_string/enableChild",
"Series/stereoSpkNet");
mainNet->updControl("FlowThru/clustNet/FanOutIn/simNet/mrs_string/enableChild",
"Series/panSim");
}
else //if not stereo or if stereo to be ignored, disable some branches
{
cout << "** Panning Similarity Computation disabled!" << endl;
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/mrs_string/disableChild",
"Series/stereoSpkNet");
mainNet->updControl("FlowThru/clustNet/FanOutIn/simNet/mrs_string/disableChild",
"Series/panSim");
}
//
mainNet->update(); //probably not necessary... [!]
//------------------------------------------------------------------------
if(noiseDuration_) //[WTF]
{
ostringstream ossi;
ossi << ((noiseDelay_+noiseDuration_)) << "s";
cout << ossi.str() << endl;
// touch the gain directly
// noiseGain->updControl("0.1s", Repeat("0.1s", 1), new EvValUpd(noiseGain,"mrs_real/gain", 0.0));
}
//ONSET DETECTION CONFIGURATION (if enabled)
if(useOnsets)
{
cout << "** Onset detector enabled -> using dynamically adjusted texture windows!" << endl;
cout << "WinSize = " << winSize_ << endl;
cout << "N = " << N << endl;
cout << "Nw = " << Nw << endl;
cout << "hopSize = " << hopSize_ << endl;
cout << "D = " << D << endl;
cout << "fs = " << samplingFrequency_ << endl;
//link controls for onset detector
onsetdetector->linkControl("Filter/filt2/mrs_realvec/ncoeffs",
"Filter/filt1/mrs_realvec/ncoeffs");
onsetdetector->linkControl("Filter/filt2/mrs_realvec/dcoeffs",
"Filter/filt1/mrs_realvec/dcoeffs");
//link onset detector to accumulator and if onsets enabled, set "explicitFlush" mode
textWinNet->linkControl("mrs_bool/flush",
"Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/spectrumNet/FlowThru/onsetdetector/PeakerOnset/peaker/mrs_bool/onsetDetected");
//update onset detector controls
onsetdetector->updControl("PowerSpectrum/pspk/mrs_string/spectrumType", "wrongdBonsets");
onsetdetector->updControl("Flux/flux/mrs_string/mode", "DixonDAFX06");
realvec bcoeffs(1,3);//configure zero-phase Butterworth filter of Flux time series -> butter(2, 0.28)
bcoeffs(0) = 0.1174;
bcoeffs(1) = 0.2347;
bcoeffs(2) = 0.1174;
realvec acoeffs(1,3);
acoeffs(0) = 1.0;
acoeffs(1) = -0.8252;
acoeffs(2) = 0.2946;
onsetdetector->updControl("Filter/filt1/mrs_realvec/ncoeffs", bcoeffs);
onsetdetector->updControl("Filter/filt1/mrs_realvec/dcoeffs", acoeffs);
mrs_natural lookAheadSamples = 6;
onsetdetector->updControl("PeakerOnset/peaker/mrs_natural/lookAheadSamples", lookAheadSamples); //!!
onsetdetector->updControl("PeakerOnset/peaker/mrs_real/threshold", 1.5); //!!!
onsetdetector->updControl("ShiftInput/sif/mrs_natural/winSize", 4*lookAheadSamples+1);
//set Accumulator controls for explicit flush mode
mrs_natural winds = 1+lookAheadSamples+mrs_natural(ceil(mrs_real(winSize_)/hopSize_/2.0));
cout << "Accumulator/textWinNet timesToKeep = " << winds << endl;
mrs_real textureWinMinLen = 0.050; //secs
mrs_real textureWinMaxLen = 1.0; //secs
mrs_natural minTimes = (mrs_natural)(textureWinMinLen*samplingFrequency_/hopSize_);
mrs_natural maxTimes = (mrs_natural)(textureWinMaxLen*samplingFrequency_/hopSize_);
cout << "Accumulator/textWinNet MinTimes = " << minTimes << " (i.e. " << textureWinMinLen << " secs)" << endl;
cout << "Accumulator/textWinNet MaxTimes = " << maxTimes << " (i.e. " << textureWinMaxLen << " secs)" <<endl;
textWinNet->updControl("mrs_string/mode", "explicitFlush");
textWinNet->updControl("mrs_natural/timesToKeep", winds);
//textWinNet->updControl("mrs_string/mode","explicitFlush");
textWinNet->updControl("mrs_natural/maxTimes", maxTimes);
textWinNet->updControl("mrs_natural/minTimes", minTimes);
//set MidiFileSynthSource to receive a signal for each texture window
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_bool/sigNewTextWin", false);
mainNet->linkControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_bool/newTextWin",
"Accumulator/textWinNet/mrs_bool/flush");
}
else
{
cout << "** Onset detector disabled ->";
if(accSize_>0)//manually set texture window length
{
cout << " using fixed length texture windows" << endl;
cout << "Accumulator/textWinNet nTimes = " << accSize << " (i.e. " << accSize*hopSize_/samplingFrequency_ << " secs)" << endl;
mainNet->updControl("Accumulator/textWinNet/mrs_natural/nTimes", accSize);
//set MidiFileSynthSource to receive a signal for each texture window
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_bool/sigNewTextWin", false);
mainNet->linkControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_bool/newTextWin",
"Accumulator/textWinNet/mrs_bool/flush");
}
else //use GT for texture window length
{
cout << " using GT length texture windows" << endl;
//set texture window
mainNet->updControl("Accumulator/textWinNet/mrs_string/mode", "explicitFlush");
mrs_real textureWinMinLen = 0.0; //secs - let GT take care of this...
mrs_real textureWinMaxLen = 15.0; //secs - just a majorant...
mrs_natural minTimes = (mrs_natural)(textureWinMinLen*samplingFrequency_/hopSize_);
mrs_natural maxTimes = (mrs_natural)(textureWinMaxLen*samplingFrequency_/hopSize_);
cout << "Accumulator/textWinNet MinTimes = " << minTimes << " (i.e. " << textureWinMinLen << " secs)" << endl;
cout << "Accumulator/textWinNet MaxTimes = " << maxTimes << " (i.e. " << textureWinMaxLen << " secs)" <<endl;
mainNet->updControl("Accumulator/textWinNet/mrs_natural/maxTimes", maxTimes);
mainNet->updControl("Accumulator/textWinNet/mrs_natural/minTimes", minTimes);
//set MidiFileSynthSource to send a signal for each texture window
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_bool/sigNewTextWin", true);
mainNet->linkControl("Accumulator/textWinNet/mrs_bool/flush",
"Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_bool/newTextWin");
}
}
mrs_natural delay = -(winSize_/2 - hopSize_);
mainNet->updControl("Shredder/synthNet/Series/postNet/Fanout/synthBank/PeakSynth/synthCluster_0/PeakSynthOsc/pso/mrs_real/samplingFreq", samplingFrequency_);
mainNet->updControl("Shredder/synthNet/Series/postNet/Fanout/synthBank/PeakSynth/synthCluster_0/PeakSynthOsc/pso/mrs_natural/delay", delay); // Nw/2+1
mainNet->updControl("Shredder/synthNet/Series/postNet/Fanout/synthBank/PeakSynth/synthCluster_0/PeakSynthOsc/pso/mrs_natural/synSize", hopSize_*2);
mainNet->updControl("Shredder/synthNet/Series/postNet/Fanout/synthBank/PeakSynth/synthCluster_0/Windowing/wiSyn/mrs_string/type", "Hanning");
//[!]
//if (outsfname == "MARSYAS_EMPTY")
// mainNet->updControl("Shredder/synthNet/Series/postNet/AudioSink/dest/mrs_natural/bufferSize", bopt_);
// else
// mainNet->updControl("Shredder/synthNet/Series/postNet/SoundFileSink/dest/mrs_string/filename", outsfname);//[!]
//***************************************************************************************************************
// MAIN TICKING LOOP
//***************************************************************************************************************
cout <<">> Start processing..." << endl;
//ofstream cfile("density.txt", ios::app); //[WTF] [TODO]
mrs_real globalSnr = 0;
mrs_natural frameCount = 0;
// mrs_real time=0;
mrs_natural numTextWinds = 0;
while(analysisNet->getctrl("FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_bool/hasData")->to<mrs_bool>())//(1)
{
mainNet->tick();
numTextWinds++;
//if(numTextWinds == 63)
//{
// cout << "!!!!" << endl;
//}
if (!microphone_)
{
//bool temp = mainNet->getctrl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_bool/hasData")->to<mrs_bool>();
//bool temp1 = textWinNet->getctrl("Series/analysisNet/FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_bool/hasData")->to<mrs_bool>();
//bool temp2 = analysisNet->getctrl("FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_bool/hasData")->to<mrs_bool>();
mrs_real timeRead = analysisNet->getctrl("FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_natural/pos")->to<mrs_natural>()/samplingFrequency_;
mrs_real timeLeft;
//if(!stopAnalyse_)
timeLeft = analysisNet->getctrl("FanOutIn/mixer/Series/oriNet/MidiFileSynthSource/src/mrs_natural/size")->to<mrs_natural>()/samplingFrequency_;
//else
// timeLeft = stopAnalyse_;
// string fname = mainNet->getctrl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/SoundFileSource/src/mrs_string/filename")->to<mrs_string>();
printf("Processed texture window %d : %.2f / %.2f \r", (int)numTextWinds, timeRead, timeLeft);
fflush(stdout);
//cout << fixed << setprecision(2) << timeRead << "/" << setprecision(2) << timeLeft;
///*bool*/ temp = mainNet->getctrl("Accumulator/textWinNet/Series/analysisNet/SoundFileSource/src/mrs_bool/hasData")->to<mrs_bool>();
//[TODO]
// mrs_real density = mainNet->getctrl("PeClust/peClust/mrs_real/clusterDensity")->to<mrs_real>();
// cfile << density << " " << oriGain << endl;
// //cout << oriGain << endl;
//if (temp2 == false || (stopAnalyse_ !=0 && stopAnalyse_<timeRead))
// break;
}
}
if(synthetize_ > -1 && residual_ && frameCount != 0)
{
cout << "Global SNR : " << globalSnr/frameCount << endl;
*snr0 = globalSnr/frameCount;
}
if(peakStore_)
{
// mainNet->updControl("PeakViewSink/peSink/mrs_real/fs", samplingFrequency_);
// mainNet->updControl("PeakViewSink/peSink/mrs_natural/frameSize", D);
// mainNet->updControl("PeakViewSink/peSink/mrs_string/filename", filePeakName);
// mainNet->updControl("PeakViewSink/peSink/mrs_bool/done", true);
}
//cout << ">> Saving .mat file with results so they can be opened in MATLAB in: " << fileMatName << endl;
//MATLAB_EVAL("save " + fileMatName);
if(numTextWinds > 0)
{
cout << ">> Saving SDR results to SDR.mat" << endl;
MATLAB_EVAL("saveSDRresults");
}
cout << endl << ">> End of processing. Bye!" << endl;
//cfile.close(); [TODO]
}
void
distance_matrix_MIREX()
{
if (!wekafname_Set()) return;
cout << "Distance matrix calculation using " << wekafname_ << endl;
wekafname_ = inputdir_ + wekafname_;
MarSystemManager mng;
MarSystem* net = mng.create("Series", "net");
MarSystem* accum = mng.create("Accumulator", "accum");
MarSystem* wsrc = mng.create("WekaSource", "wsrc");
accum->addMarSystem(wsrc);
accum->updControl("WekaSource/wsrc/mrs_bool/normMaxMin", true);
accum->updControl("WekaSource/wsrc/mrs_string/filename", wekafname_);
mrs_natural nInstances =
accum->getctrl("WekaSource/wsrc/mrs_natural/nInstances")->to<mrs_natural>();
accum->updControl("mrs_natural/nTimes", nInstances);
MarSystem* dmatrix = mng.create("SelfSimilarityMatrix", "dmatrix");
dmatrix->addMarSystem(mng.create("Metric", "dmetric"));
dmatrix->updControl("Metric/dmetric/mrs_string/metric", "euclideanDistance");
net->addMarSystem(accum);
net->addMarSystem(dmatrix);
net->tick();
ofstream oss;
oss.open(distancematrix_.c_str());
oss << "Marsyas-kea distance matrix for MIREX 2007 Audio Similarity Exchange " << endl;
// collection simply for naming the entries
Collection l;
l.read(inputdir_ + predictcollectionfname_);
for (size_t i=1; i <= l.size(); ++i)
{
oss << i << "\t" << l.entry(i-1) << endl;
}
oss << "Q/R";
const mrs_realvec& dmx = net->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
for (int i=1; i <= nInstances; ++i)
{
oss << "\t" << i;
}
oss << endl;
for (int i=1; i <= nInstances; ++i)
{
oss << i;
for (int j=0; j < nInstances; j++)
oss <<"\t" << dmx(i-1, j);
oss << endl;
}
oss << endl;
}
void tags() {
if (!wekafname_Set()) return;
if (!twekafname_Set()) return;
// The file paths we will be reading/writing to.
string testing_arff = inputdir_ + twekafname_;
string training_arff = inputdir_ + wekafname_;
string testing_predictions = outputdir_ + predictcollectionfname_;
string testing_predictions_arff = outputdir_ + twekafname_ + ".affinities.arff";
string training_predictions_arff = outputdir_ + wekafname_ + ".affinities.arff";
// Initialize the network, classifier, and weka source through which
// we will read our .arff files
MarSystemManager mng;
MarSystem* net = mng.create("Series", "series");
net->addMarSystem(mng.create("WekaSource", "wsrc"));
MarSystem* classifier = mng.create("Classifier", "cl");
net->addMarSystem(classifier);
net->addMarSystem(mng.create("Gain/gain"));
// Instantiate the correct classifier:
cout << "Selected classifier type = " << classifier_ << endl;
if (classifier_ == "GS") {
net->updControl("Classifier/cl/mrs_string/enableChild", "GaussianClassifier/gaussiancl");
} else if (classifier_ == "ZEROR") {
net->updControl("Classifier/cl/mrs_string/enableChild", "ZeroRClassifier/zerorcl");
} else if (classifier_ == "SVM") {
net->updControl("Classifier/cl/mrs_string/enableChild", "SVMClassifier/svmcl");
} else {
// TODO: ERROR CONDITION; ADD ERROR HANDLING HERE
}
/**
* TRAINING
*
* Read in the training arff data, and train the classifier.
**/
// Set up the weka source to read the training .arff
// and hook together some controls.
cout << "Training Filename = " << training_arff << endl;
net->updControl("WekaSource/wsrc/mrs_string/filename", training_arff);
net->updControl("mrs_natural/inSamples", 1);
net->updControl("Classifier/cl/mrs_natural/nClasses", net->getctrl("WekaSource/wsrc/mrs_natural/nClasses"));
net->linkControl("Classifier/cl/mrs_string/mode", "mrs_string/train");
// Tick over the training WekaSource until all lines in the training file have been read.
// FIXME: Remove the mode updates, unless someone can justify their existence.
// The mode is not switched to 'predict' until further down.
cout << "Reading features" << endl;
while (!net->getctrl("WekaSource/wsrc/mrs_bool/done")->to<mrs_bool>())
{
string mode = net->getctrl("WekaSource/wsrc/mrs_string/mode")->to<mrs_string>();
net->tick();
net->updControl("Classifier/cl/mrs_string/mode", mode);
}
// Switch the Classifier's mode to predict:
// This causes the classifier to train itself on all input data so far.
cout << "Training" << endl;
net->updControl("Classifier/cl/mrs_string/mode", "predict");
// Collect information about the labels (classes) in this dataset
mrs_natural nLabels = net->getctrl("WekaSource/wsrc/mrs_natural/nClasses")->to<mrs_natural>();
mrs_string labelNames = net->getctrl("WekaSource/wsrc/mrs_string/classNames")->to<mrs_string>();
vector<string> classNames;
// TODO: you could probably replace "s = ..." with "s = labelNames"
string s = net->getctrl("WekaSource/wsrc/mrs_string/classNames")->to<mrs_string>();
for (int i=0; i < nLabels; ++i)
{
string className;
string temp;
className = s.substr(0, s.find(","));
temp = s.substr(s.find(",") + 1, s.length());
s = temp;
classNames.push_back(className);
}
/**
* PREDICT STEP 1
*
* Predictions for the testing arff data.
**/
// Initialize the weka sink that we will use to write an .arff file
// for the testing dataset, where the features are the predicted
// probabilities from our classifier
MarSystem* testpSink = mng.create("WekaSink/testpSink");
testpSink->updControl("mrs_natural/inSamples", 1);
testpSink->updControl("mrs_natural/inObservations", nLabels+1);
testpSink->updControl("mrs_natural/nLabels", nLabels);
testpSink->updControl("mrs_string/labelNames", labelNames);
testpSink->updControl("mrs_string/inObsNames", labelNames);
testpSink->updControl("mrs_string/filename", testing_predictions_arff);
// Set up the weka source to read the testing data
cout << "Testing Filename = " << testing_arff << endl;
net->updControl("WekaSource/wsrc/mrs_string/filename", testing_arff);
cout << "Starting Prediction for Testing Collection" << endl;
cout << "Writing .mf style predictions to " << testing_predictions << endl;
cout << "The following output file can serve as a stacked testing .arff" << endl;
cout << "Writing .arff style predictions to " << testing_predictions_arff << endl;
mrs_realvec probs;
mrs_realvec testpSinkOut;
mrs_string currentlyPlaying;
realvec data;
realvec wsourcedata;
vector<string> previouslySeenFilenames;
// Open the non-stacked predictions output file to write to.
ofstream prout;
prout.open(testing_predictions.c_str());
// Tick over the test WekaSource, saving our predictions for each line,
// until all lines in the test file have been read.
testpSinkOut.create(nLabels+1,1);
while (!net->getctrl("WekaSource/wsrc/mrs_bool/done")->to<mrs_bool>())
{
net->tick();
wsourcedata = net->getctrl("WekaSource/wsrc/mrs_realvec/processedData")->to<mrs_realvec>();
data = net->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
currentlyPlaying = net->getctrl("WekaSource/wsrc/mrs_string/currentFilename")->to<mrs_string>();
if (!alreadySeen(currentlyPlaying, previouslySeenFilenames))
{
probs = net->getctrl("Classifier/cl/mrs_realvec/processedData")->to<mrs_realvec>();
for (mrs_natural i=0; i < probs.getSize()-2; i++)
{
testpSinkOut(i,0) = probs(2+i);
prout << currentlyPlaying << "\t" << classNames[i] << "\t" << probs(2+i) << endl;
}
testpSinkOut(probs.getSize()-2,0) = probs(0);
testpSink->updControl("mrs_string/currentlyPlaying", currentlyPlaying);
testpSink->process(testpSinkOut, testpSinkOut);
// Mark this filename as seen!
previouslySeenFilenames.push_back(currentlyPlaying);
}
}
// Close the non-stacked predictions; they are written!
prout.close();
/**
* PREDICT STEP 2
*
* Predictions for the training arff data
**/
// Initialize the weka sink that we will use to write an .arff file
// for the training dataset, where the features are the predicted
// probabilities from our classifier
MarSystem* trainpSink = mng.create("WekaSink/trainpSink");
trainpSink->updControl("mrs_natural/inSamples", 1);
trainpSink->updControl("mrs_natural/inObservations", nLabels+1);
trainpSink->updControl("mrs_natural/nLabels", nLabels);
trainpSink->updControl("mrs_string/labelNames", labelNames);
trainpSink->updControl("mrs_string/inObsNames", labelNames);
trainpSink->updControl("mrs_string/filename", training_predictions_arff);
cout << "Starting prediction for training collection (for stacked generalization)" << endl;
cout << "The following output file can serve as a stacked training .arff" << endl;
cout << "Writing .arff style predictions to " << training_predictions_arff << endl;
// Empty our list of previously seen filenames; we will reuse it.
previouslySeenFilenames.clear();
mrs_realvec trainpSinkOut;
trainpSinkOut.create(nLabels+1,1);
mrs_natural label;
net->updControl("WekaSource/wsrc/mrs_string/filename", training_arff);
// Tick over the test WekaSource, saving our predictions for each line in
// the training file until all lines in the training file have been read.
while (!net->getctrl("WekaSource/wsrc/mrs_bool/done")->to<mrs_bool>())
{
net->tick();
currentlyPlaying = net->getctrl("WekaSource/wsrc/mrs_string/currentFilename")->to<mrs_string>();
wsourcedata = net->getctrl("WekaSource/wsrc/mrs_realvec/processedData")->to<mrs_realvec>();
label = wsourcedata(wsourcedata.getSize()-1,0);
probs = net->getctrl("Classifier/cl/mrs_realvec/processedData")->to<mrs_realvec>();
if (!alreadySeen(currentlyPlaying, previouslySeenFilenames))
{
// Store the predicted probabilities for this file and mark the file as seen!
for (mrs_natural i=0; i < probs.getSize()-2; i++)
{
trainpSinkOut(i,0) = probs(2+i);
}
previouslySeenFilenames.push_back(currentlyPlaying);
}
// Write out a line in the arff file.
trainpSinkOut(probs.getSize()-2,0) = label;
trainpSink->updControl("mrs_string/currentlyPlaying", currentlyPlaying);
trainpSink->process(trainpSinkOut, trainpSinkOut);
}
cout << "DONE" << endl;
}
void
train_evaluate()
{
if (!wekafname_Set()) return;
wekafname_ = inputdir_ + wekafname_;
cout << "Training classifier using .arff file: " << wekafname_ << endl;
cout << "Classifier type : " << classifier_ << endl;
MarSystemManager mng;
MarSystem* net;
net = mng.create("Series", "net");
net->addMarSystem(mng.create("WekaSource", "wsrc"));
net->addMarSystem(mng.create("Classifier", "cl"));
net->addMarSystem(mng.create("ClassificationReport", "summary"));
if (classifier_ == "GS")
net->updControl("Classifier/cl/mrs_string/enableChild", "GaussianClassifier/gaussiancl");
if (classifier_ == "ZEROR")
net->updControl("Classifier/cl/mrs_string/enableChild", "ZeroRClassifier/zerorcl");
if (classifier_ == "SVM")
net->updControl("Classifier/cl/mrs_string/enableChild", "SVMClassifier/svmcl");
// net->updControl("WekaSource/wsrc/mrs_string/attributesToInclude", "1,2,3");
// net->updControl("WekaSource/wsrc/mrs_string/validationMode", "PercentageSplit,50%");
net->updControl("WekaSource/wsrc/mrs_string/validationMode", "kFold,NS,10");
// net->updControl("WekaSource/wsrc/mrs_string/validationMode", "UseTestSet,lg.arff");
net->updControl("WekaSource/wsrc/mrs_string/filename", wekafname_);
net->updControl("mrs_natural/inSamples", 1);
if (classifier_ == "SVM") {
if (svm_svm_ != EMPTYSTRING) {
net->updControl("Classifier/cl/SVMClassifier/svmcl/mrs_string/svm",
svm_svm_);
}
if (svm_kernel_ != EMPTYSTRING) {
net->updControl("Classifier/cl/SVMClassifier/svmcl/mrs_string/kernel",
svm_kernel_);
}
}
if (net->getctrl("WekaSource/wsrc/mrs_bool/regression")->isTrue()) {
// TODO: enable regression for ZeroRClassifier and GaussianClassifier,
// and don't assume we're only dealing with svm
net->updControl("Classifier/cl/SVMClassifier/svmcl/mrs_bool/output_classPerms", false);
net->updControl("Classifier/cl/mrs_natural/nClasses", 1);
net->updControl("ClassificationReport/summary/mrs_natural/nClasses", 1);
net->updControl("ClassificationReport/summary/mrs_bool/regression", true);
} else {
net->updControl("ClassificationReport/summary/mrs_natural/nClasses", net->getctrl("WekaSource/wsrc/mrs_natural/nClasses"));
net->updControl("ClassificationReport/summary/mrs_string/classNames",
net->getctrl("WekaSource/wsrc/mrs_string/classNames"));
net->updControl("Classifier/cl/mrs_natural/nClasses", net->getctrl("WekaSource/wsrc/mrs_natural/nClasses"));
}
net->linkControl("Classifier/cl/mrs_string/mode", "ClassificationReport/summary/mrs_string/mode");
int i = 0;
while(net->getctrl("WekaSource/wsrc/mrs_bool/done")->to<mrs_bool>() == false)
{
net->tick();
// cout << net->getControl("WekaSource/wsrc/mrs_realvec/processedData")->to<mrs_realvec>() << endl;
string mode = net->getctrl("WekaSource/wsrc/mrs_string/mode")->to<mrs_string>();
net->updControl("Classifier/cl/mrs_string/mode", mode);
++i;
}
net->updControl("Classifier/cl/mrs_string/mode", "predict");
net->updControl("ClassificationReport/summary/mrs_bool/done", true);
net->tick();
delete net;
}
void
train_predict(mrs_string mode)
{
if (!wekafname_Set()) return;
if (!twekafname_Set()) return;
wekafname_ = inputdir_ + wekafname_;
cout << "Training classifier using .arff file: " << wekafname_ << endl;
cout << "Classifier type : " << classifier_ << endl;
cout << "Predicting classes for .arff file: " << twekafname_ << endl;
MarSystemManager mng;
////////////////////////////////////////////////////////////
//
// The network that we will use to train and predict
//
MarSystem* net = mng.create("Series", "series");
////////////////////////////////////////////////////////////
//
// The WekaSource we read the train and test .arf files into
//
net->addMarSystem(mng.create("WekaSource", "wsrc"));
////////////////////////////////////////////////////////////
//
// The classifier
//
MarSystem* classifier = mng.create("Classifier", "cl");
net->addMarSystem(classifier);
////////////////////////////////////////////////////////////
//
// Which classifier function to use
//
if (classifier_ == "GS")
net->updControl("Classifier/cl/mrs_string/enableChild", "GaussianClassifier/gaussiancl");
if (classifier_ == "ZEROR")
net->updControl("Classifier/cl/mrs_string/enableChild", "ZeroRClassifier/zerorcl");
if (classifier_ == "SVM")
net->updControl("Classifier/cl/mrs_string/enableChild", "SVMClassifier/svmcl");
////////////////////////////////////////////////////////////
//
// The training file we are feeding into the WekaSource
//
net->updControl("WekaSource/wsrc/mrs_string/filename", wekafname_);
net->updControl("mrs_natural/inSamples", 1);
////////////////////////////////////////////////////////////
//
// Set the classes of the Summary and Classifier to be
// the same as the WekaSource
//
net->updControl("Classifier/cl/mrs_natural/nClasses", net->getctrl("WekaSource/wsrc/mrs_natural/nClasses"));
net->updControl("Classifier/cl/mrs_string/mode", "train");
////////////////////////////////////////////////////////////
//
// Tick over the training WekaSource until all lines in the
// training file have been read.
//
while (!net->getctrl("WekaSource/wsrc/mrs_bool/done")->to<mrs_bool>()) {
string mode = net->getctrl("WekaSource/wsrc/mrs_string/mode")->to<mrs_string>();
net->tick();
net->updControl("Classifier/cl/mrs_string/mode", mode);
}
cout << "Done training " << endl;
// cout << "------------------------------" << endl;
// cout << "Class names" << endl;
// cout << net->getctrl("WekaSource/wsrc/mrs_string/classNames") << endl;
// cout << "------------------------------\n" << endl;
vector<string> classNames;
string s = net->getctrl("WekaSource/wsrc/mrs_string/classNames")->to<mrs_string>();
char *str = (char *)s.c_str();
char * pch;
pch = strtok (str,",");
classNames.push_back(pch);
while (pch != NULL) {
pch = strtok (NULL, ",");
if (pch != NULL)
classNames.push_back(pch);
}
////////////////////////////////////////////////////////////
//
// Predict the classes of the test data
//
net->updControl("WekaSource/wsrc/mrs_string/filename", twekafname_);
net->updControl("Classifier/cl/mrs_string/mode", "predict");
////////////////////////////////////////////////////////////
//
// Tick over the test WekaSource until all lines in the
// test file have been read.
//
ofstream prout;
prout.open(predictcollectionfname_.c_str());
ofstream prtout;
prtout.open(predicttimeline_.c_str());
realvec data;
int end=0;
int start=0;
mrs_string prev_name = "";
mrs_string output_name = "";
mrs_string name;
mrs_real srate;
while (!net->getctrl("WekaSource/wsrc/mrs_bool/done")->to<mrs_bool>()) {
net->tick();
data = net->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
srate = net->getctrl("WekaSource/wsrc/mrs_real/currentSrate")->to<mrs_real>();
if (mode == "default")
{
cout << net->getctrl("WekaSource/wsrc/mrs_string/currentFilename")->to<mrs_string>() << "\t";
cout << classNames[(int)data(0,0)] << endl;
prout << net->getctrl("WekaSource/wsrc/mrs_string/currentFilename")->to<mrs_string>() << "\t";
prout << classNames[(int)data(0,0)] << endl;
}
else if (mode == "timeline")
{
mrs_real srate = net->getctrl("WekaSource/wsrc/mrs_real/currentSrate")->to<mrs_real>();
name = classNames[(int)data(0,0)];\
// cout << name << endl;
if (name != prev_name)
{
if (end * (1.0/srate)-start*(1.0 / srate) <= minspan_) // not background
{
}
else
{
if (predicttimeline_ == EMPTYSTRING)
{
if (label_ == EMPTYSTRING)
{
cout << start*(1.0 / srate) << "\t" << end*(1.0 / srate) << "\t";
cout << prev_name << endl;
}
else
{
if (label_ == prev_name)
{
cout << start*(1.0 / srate) << "\t" << end*(1.0 / srate) << "\t";
cout << prev_name << endl;
}
}
output_name = prev_name;
}
else
{
if (label_ == EMPTYSTRING)
{
prtout << start*(1.0 / srate) << "\t" << end*(1.0 / srate) << "\t";
prtout << prev_name << endl;
}
else
{
if (label_ == prev_name)
{
prtout << start*(1.0 / srate) << "\t" << end*(1.0 / srate) << "\t";
prtout << prev_name << endl;
}
}
output_name = prev_name;
}
}
start = end;
}
// else
// {
// }
prev_name = name;
}
else
cout << "Unsupported mode" << endl;
// cout << data(0,0) << endl;
end++;
}
prout.close();
cout << "DONE" << endl;
delete net;
}
void
predict(mrs_string mode)
{
MarSystemManager mng;
cout << "Predicting using " << trainedclassifier_ << endl;
ifstream pluginStream(trainedclassifier_.c_str());
MRS_WARNINGS_OFF;
MarSystem* net = mng.getMarSystem(pluginStream);
MRS_WARNINGS_ON;
if (!twekafname_Set()) return;
vector<string> classNames;
string s = net->getctrl("WekaSource/wsrc/mrs_string/classNames")->to<mrs_string>();
char *str = (char *)s.c_str();
char * pch;
pch = strtok (str,",");
classNames.push_back(pch);
while (pch != NULL) {
pch = strtok (NULL, ",");
if (pch != NULL)
classNames.push_back(pch);
}
////////////////////////////////////////////////////////////
//
// Predict the classes of the test data
//
net->updControl("WekaSource/wsrc/mrs_string/filename", twekafname_);
net->updControl("Classifier/cl/mrs_string/mode", "predict");
////////////////////////////////////////////////////////////
//
// Tick over the test WekaSource until all lines in the
// test file have been read.
//
ofstream prout;
prout.open(predictcollectionfname_.c_str());
ofstream prtout;
prtout.open(predicttimeline_.c_str());
realvec data;
int end=0;
int start=0;
mrs_string prev_name = "";
mrs_string name;
mrs_real srate;
while (!net->getctrl("WekaSource/wsrc/mrs_bool/done")->to<mrs_bool>()) {
net->tick();
data = net->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
srate = net->getctrl("WekaSource/wsrc/mrs_real/currentSrate")->to<mrs_real>();
if (mode == "default")
{
cout << net->getctrl("WekaSource/wsrc/mrs_string/currentFilename")->to<mrs_string>() << "\t";
cout << classNames[(int)data(0,0)] << endl;
prout << net->getctrl("WekaSource/wsrc/mrs_string/currentFilename")->to<mrs_string>() << "\t";
prout << classNames[(int)data(0,0)] << endl;
}
else if (mode == "timeline")
{
name = classNames[(int)data(0,0)];
if (name != prev_name)
{
if ((end * (1.0/srate)-start*(1.0 / srate) > minspan_))
{
if (predicttimeline_ == EMPTYSTRING)
{
cout << start*(1.0 / srate) << "\t" << end*(1.0 / srate) << "\t";
cout << prev_name << endl;
}
else
{
prtout << start*(1.0 / srate) << "\t" << end*(1.0 / srate) << "\t";
prtout << prev_name << endl;
}
}
start = end;
}
else
{
}
prev_name = name;
}
else
cout << "Unsupported mode" << endl;
// cout << data(0,0) << endl;
end++;
}
prout.close();
// cout << "DONE" << endl;
// sness - hmm, I really should be able to delete net, but I get a
// coredump when I do. Maybe I need to destroy something else first?
// delete net;
}
void
train_classifier()
{
if (!wekafname_Set()) return;
wekafname_ = inputdir_ + wekafname_;
cout << "Training classifier using .arff file: " << wekafname_ << endl;
cout << "Classifier type : " << classifier_ << endl;
MarSystemManager mng;
////////////////////////////////////////////////////////////
//
// The network that we will use to train and predict
//
MarSystem* net = mng.create("Series", "series");
////////////////////////////////////////////////////////////
//
// The WekaSource we read the train and test .arf files into
//
net->addMarSystem(mng.create("WekaSource", "wsrc"));
////////////////////////////////////////////////////////////
//
// The classifier
//
MarSystem* classifier = mng.create("Classifier", "cl");
net->addMarSystem(classifier);
////////////////////////////////////////////////////////////
//
// Which classifier function to use
//
if (classifier_ == "GS")
net->updControl("Classifier/cl/mrs_string/enableChild", "GaussianClassifier/gaussiancl");
if (classifier_ == "ZEROR")
net->updControl("Classifier/cl/mrs_string/enableChild", "ZeroRClassifier/zerorcl");
if (classifier_ == "SVM")
net->updControl("Classifier/cl/mrs_string/enableChild", "SVMClassifier/svmcl");
////////////////////////////////////////////////////////////
//
// The training file we are feeding into the WekaSource
//
net->updControl("WekaSource/wsrc/mrs_string/filename", wekafname_);
net->updControl("mrs_natural/inSamples", 1);
////////////////////////////////////////////////////////////
//
// Set the classes of the Summary and Classifier to be
// the same as the WekaSource
//
net->updControl("Classifier/cl/mrs_natural/nClasses", net->getctrl("WekaSource/wsrc/mrs_natural/nClasses"));
net->updControl("Classifier/cl/mrs_string/mode", "train");
////////////////////////////////////////////////////////////
//
// Tick over the training WekaSource until all lines in the
// training file have been read.
//
while (!net->getctrl("WekaSource/wsrc/mrs_bool/done")->to<mrs_bool>()) {
string mode = net->getctrl("WekaSource/wsrc/mrs_string/mode")->to<mrs_string>();
net->tick();
net->updControl("Classifier/cl/mrs_string/mode", mode);
}
ofstream clout;
clout.open(trainedclassifier_.c_str());
net->updControl("Classifier/cl/mrs_string/mode", "predict");
clout << *net << endl;
cout << "Done training " << endl;
}
void
pca()
{
cout << "Principal Component Analysis of .arff file" << endl;
if (!wekafname_Set()) return;
wekafname_ = inputdir_ + wekafname_;
cout << "PCA using .arff file: " << wekafname_ << endl;
MarSystemManager mng;
MarSystem* net = mng.create("Series", "net");
MarSystem* accum = mng.create("Accumulator", "accum");
MarSystem* wsrc = mng.create("WekaSource", "wsrc");
accum->addMarSystem(wsrc);
accum->updControl("WekaSource/wsrc/mrs_string/filename", wekafname_);
mrs_natural nInstances =
accum->getctrl("WekaSource/wsrc/mrs_natural/nInstances")->to<mrs_natural>();
cout << "nInstances = " << nInstances << endl;
accum->updControl("mrs_natural/nTimes", nInstances);
net->addMarSystem(accum);
net->addMarSystem(mng.create("PCA", "pca"));
net->addMarSystem(mng.create("NormMaxMin", "norm"));
net->addMarSystem(mng.create("WekaSink", "wsink"));
net->updControl("PCA/pca/mrs_natural/npc", 2);
net->updControl("NormMaxMin/norm/mrs_natural/ignoreLast", 1);
net->updControl("NormMaxMin/norm/mrs_string/mode", "twopass");
net->updControl("NormMaxMin/norm/mrs_real/lower", 0.0);
net->updControl("NormMaxMin/norm/mrs_real/upper", 11.0);
net->updControl("WekaSink/wsink/mrs_natural/nLabels",
net->getctrl("Accumulator/accum/WekaSource/wsrc/mrs_natural/nClasses"));
net->updControl("WekaSink/wsink/mrs_string/labelNames", net->getctrl("Accumulator/accum/WekaSource/wsrc/mrs_string/classNames"));
net->updControl("WekaSink/wsink/mrs_string/filename", "pca_out.arff");
net->tick();
// the output of the PCA
const mrs_realvec& pca_transformed_data = net->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
cout << "Output transformed features using PCA" << endl;
string classNames = net->getctrl("Accumulator/accum/WekaSource/wsrc/mrs_string/classNames")->to<mrs_string>();
vector<string> labelNames;
labelNames.clear();
for (int i = 0; i < net->getctrl("Accumulator/accum/WekaSource/wsrc/mrs_natural/nClasses")->to<mrs_natural>(); ++i)
{
string labelName;
string temp;
labelName = classNames.substr(0, classNames.find(","));
temp = classNames.substr(classNames.find(",")+1, classNames.length());
classNames = temp;
labelNames.push_back(labelName);
}
cout << "12" << endl;
cout << "12" << endl;
for (int t=0; t < pca_transformed_data.getCols(); t++)
{
cout << (int)pca_transformed_data(0,t) * 12 + (int)pca_transformed_data(1,t) << ",";
cout << labelNames[(int)pca_transformed_data(2,t)];
cout << endl;
// cout << (int)pca_transformed_data(0,t) << "\t";
// cout << (int)pca_transformed_data(1,t) << "\t";
// cout << (int)pca_transformed_data(2,t) << "\t";
// cout << pca_transformed_data(3,t) << "\t";
// cout << endl;
}
}
void
distance_matrix()
{
if (!wekafname_Set()) return;
cout << "Distance matrix calculation using " << wekafname_ << endl;
wekafname_ = inputdir_ + wekafname_;
MarSystemManager mng;
MarSystem* net = mng.create("Series", "net");
MarSystem* wsrc = mng.create("WekaSource", "wsrc");
net->addMarSystem(wsrc);
//!!!: mode control
net->updControl("WekaSource/wsrc/mrs_string/validationMode", "OutputInstancePair");
net->updControl("WekaSource/wsrc/mrs_bool/normMaxMin", true);
net->updControl("WekaSource/wsrc/mrs_string/filename", wekafname_);
MarSystem* dmatrix = mng.create("SelfSimilarityMatrix", "dmatrix");
dmatrix->addMarSystem(mng.create("Metric", "dmetric"));
dmatrix->updControl("Metric/dmetric/mrs_string/metric", "euclideanDistance");
//!!!: lmartins: normalization can only be applied when we have all feature vectors in memory...
//... which is what we are trying to avoid here (having big realvecs in memory)...
//dmatrix->updControl("mrs_string/normalize", "MinMax");
net->addMarSystem(dmatrix);
//!!!: mode control
net->updControl("SelfSimilarityMatrix/dmatrix/mrs_natural/mode", 1); //FIXME: replace use of enum for strings?
//link controls between WekaSource and SelfSimilarityMatrix
net->linkControl("SelfSimilarityMatrix/dmatrix/mrs_natural/nInstances",
"WekaSource/wsrc/mrs_natural/nInstances");
net->linkControl("WekaSource/wsrc/mrs_realvec/instanceIndexes",
"SelfSimilarityMatrix/dmatrix/mrs_realvec/instanceIndexes");
ofstream oss;
oss.open(distancematrix_.c_str());
oss << "Marsyas-kea distance matrix" << endl;
while(!net->getctrl("SelfSimilarityMatrix/dmatrix/mrs_bool/done")->to<bool>())
{
const mrs_realvec& idxs = net->getctrl("SelfSimilarityMatrix/dmatrix/mrs_realvec/instanceIndexes")->to<mrs_realvec>();
oss << "(" << mrs_natural(idxs(0)) << "," << mrs_natural(idxs(1)) << ") = ";
net->tick();
const mrs_realvec& value = net->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
oss << value(0) << endl;
}
oss << endl;
}
void
distance_matrix_MIREX()
{
if (!wekafname_Set()) return;
string train_file_path =
FileName(inputdir_).append(train_weka_fname_).fullname();
string predict_collection_path =
FileName(inputdir_).append(predictcollectionfname_).fullname();
cout << "Distance matrix calculation using " << train_file_path << endl;
MarSystemManager mng;
MarSystem* net = mng.create("Series", "net");
MarSystem* accum = mng.create("Accumulator", "accum");
MarSystem* wsrc = mng.create("WekaSource", "wsrc");
accum->addMarSystem(wsrc);
accum->updControl("WekaSource/wsrc/mrs_bool/normMaxMin", true);
accum->updControl("WekaSource/wsrc/mrs_string/filename", train_file_path);
mrs_natural nInstances =
accum->getctrl("WekaSource/wsrc/mrs_natural/nInstances")->to<mrs_natural>();
accum->updControl("mrs_natural/nTimes", nInstances);
MarSystem* dmatrix = mng.create("SelfSimilarityMatrix", "dmatrix");
dmatrix->addMarSystem(mng.create("Metric", "dmetric"));
dmatrix->updControl("Metric/dmetric/mrs_string/metric", "euclideanDistance");
net->addMarSystem(accum);
net->addMarSystem(dmatrix);
net->tick();
string out_file_name = FileName(outputdir_).append(distancematrix_).fullname();
ofstream oss(out_file_name.c_str());
if (!oss.is_open())
{
MRSERR("Failed to open output file: " << out_file_name);
return;
}
oss << "Marsyas-kea distance matrix for MIREX 2007 Audio Similarity Exchange " << endl;
// collection simply for naming the entries
Collection l;
l.read(predict_collection_path);
for (mrs_natural i=1; i <= l.size(); ++i)
{
oss << i << "\t" << l.entry(i-1) << endl;
}
oss << "Q/R";
const mrs_realvec& dmx = net->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
for (int i=1; i <= nInstances; ++i)
{
oss << "\t" << i;
}
oss << endl;
for (int i=1; i <= nInstances; ++i)
{
oss << i;
for (int j=0; j < nInstances; j++)
oss <<"\t" << dmx(i-1, j);
oss << endl;
}
oss << endl;
}
void
peakClustering(realvec &peakSet, string sfName, string outsfname, string noiseName, string mixName, string intervalFrequency, string panningInfo, mrs_real noiseDelay, string T, mrs_natural N, mrs_natural Nw,
mrs_natural D, mrs_natural S, mrs_natural C,
mrs_natural accSize, mrs_natural synthetize, mrs_real *snr0)
{
MarSystemManager mng;
cout << "Extracting Peaks and Computing Clusters..." << endl;
cout << "Nw = " << Nw << endl;
cout << "N = " << N << endl;
cout << "winSize_ = " << winSize_ << endl;
cout << "D = " << D << endl;
cout << "hopSize_ = " << hopSize_ << endl;
//**************************************************
// create the peakClustering network
//**************************************************
MarSystem* mainNet = mng.create("Series", "mainNet");
//**************************************************************************
//create accumulator for the texture window and add it to the main network
//**************************************************************************
MarSystem* textWinNet = mng.create("Accumulator", "textWinNet");
mainNet->addMarSystem(textWinNet);
//************************************************************************
//create Analysis Network and add it to the texture window accumulator
//************************************************************************
MarSystem* analysisNet = mng.create("Series", "analysisNet");
textWinNet->addMarSystem(analysisNet);
//************************************************************************
//create FanInOut for mixing with a noise source and add to Analysis Net
//************************************************************************
MarSystem* mixer = mng.create("FanOutIn", "mixer");
//---- create original series and add it to mixer
MarSystem* oriNet = mng.create("Series", "oriNet");
if (microphone_)
oriNet->addMarSystem(mng.create("AudioSource", "src"));
else
oriNet->addMarSystem(mng.create("SoundFileSource", "src"));
oriNet->addMarSystem(mng.create("Gain", "oriGain"));
mixer->addMarSystem(oriNet);
//---- create a series for the noiseSource
if(noiseName != EMPTYSTRING)
{
MarSystem* mixseries = mng.create("Series", "mixseries");
if(noiseName == "white")
mixseries->addMarSystem(mng.create("NoiseSource", "noise"));
else
mixseries->addMarSystem(mng.create("SoundFileSource", "noise"));
mixseries->addMarSystem(mng.create("Delay", "noiseDelay"));
MarSystem* noiseGain = mng.create("Gain", "noiseGain");
mixseries->addMarSystem(noiseGain);
// add this series in the fanout
mixer->addMarSystem(mixseries);
}
//add Mixer to analysis network
analysisNet->addMarSystem(mixer);
//********************************************************
// create SoundFileSink and add it to the analysis net
//********************************************************
if(noiseName != EMPTYSTRING)
analysisNet->addMarSystem(mng.create("SoundFileSink", "mixSink"));
//***********************************************************
// create peakExtract network and add it to the analysis net
//***********************************************************
MarSystem* peakExtract = mng.create("Series","peakExtract");
peakExtract->addMarSystem(mng.create("ShiftInput", "si"));
MarSystem* stereoFo = mng.create("Fanout","stereoFo");
// create Spectrum Network and add it to the analysis net
MarSystem* spectrumNet = mng.create("Series", "spectrumNet");
spectrumNet->addMarSystem(mng.create("Stereo2Mono","s2m"));
//onset detector
MarSystem* onsetdetector = mng.create("FlowThru", "onsetdetector");
//onsetdetector->addMarSystem(mng.create("ShiftInput", "si"));
onsetdetector->addMarSystem(mng.create("Windowing", "win"));
onsetdetector->addMarSystem(mng.create("Spectrum","spk"));
onsetdetector->addMarSystem(mng.create("PowerSpectrum", "pspk"));
onsetdetector->addMarSystem(mng.create("Flux", "flux"));
onsetdetector->addMarSystem(mng.create("ShiftInput","sif"));
onsetdetector->addMarSystem(mng.create("Filter","filt1"));
onsetdetector->addMarSystem(mng.create("Reverse","rev1"));
onsetdetector->addMarSystem(mng.create("Filter","filt2"));
onsetdetector->addMarSystem(mng.create("Reverse","rev2"));
onsetdetector->addMarSystem(mng.create("PeakerOnset","peaker"));
spectrumNet->addMarSystem(onsetdetector);
spectrumNet->addMarSystem(mng.create("Shifter", "sh"));
spectrumNet->addMarSystem(mng.create("Windowing", "wi"));
MarSystem* parallel = mng.create("Parallel", "par");
parallel->addMarSystem(mng.create("Spectrum", "spk1"));
parallel->addMarSystem(mng.create("Spectrum", "spk2"));
spectrumNet->addMarSystem(parallel);
// add spectrumNet to stereo fanout
stereoFo->addMarSystem(spectrumNet);
//
//create stereo spectrum net
MarSystem* stereoSpkNet = mng.create("Series","stereoSpkNet");
MarSystem* LRnet = mng.create("Parallel","LRnet");
//
MarSystem* spkL = mng.create("Series","spkL");
spkL->addMarSystem(mng.create("Windowing","win"));
spkL->addMarSystem(mng.create("Spectrum","spk"));
LRnet->addMarSystem(spkL);
//
MarSystem* spkR = mng.create("Series","spkR");
spkR->addMarSystem(mng.create("Windowing","win"));
spkR->addMarSystem(mng.create("Spectrum","spk"));
LRnet->addMarSystem(spkR);
//
//add it to the stereo spectrum net series
stereoSpkNet->addMarSystem(LRnet);
//
//add stereo spectrum object to stereo spectrum net
//stereoSpkNet->addMarSystem(mng.create("StereoSpectrum","stereoSpk")); //AVENDANO
stereoSpkNet->addMarSystem(mng.create("EnhADRess","ADRess"));//enhADRess_1
stereoSpkNet->addMarSystem(mng.create("EnhADRessStereoSpectrum","stereoSpk")); //enhADRess_2
//
// add the stereo Spectrum net to the Fanout
stereoFo->addMarSystem(stereoSpkNet);
//
// add the fanout to the peakExtract net
peakExtract->addMarSystem(stereoFo);
//
//add peakExtract net to analysis net
analysisNet->addMarSystem(peakExtract);
//***************************************************************
//add PeakConvert to main SERIES for processing texture windows
//***************************************************************
mainNet->addMarSystem(mng.create("PeakConvert", "conv"));
//***************************************************************
//create a FlowThru for the Clustering Network and add to main net
//***************************************************************
MarSystem* clustNet = mng.create("FlowThru", "clustNet");
if (!disableClustering)
mainNet->addMarSystem(clustNet);
//***************************************************************
// create Similarities Network and add it to ClustNet
//***************************************************************
MarSystem* simNet = mng.create("FanOutIn", "simNet");
simNet->updControl("mrs_string/combinator", "*");
//
//create Frequency similarity net and add it to simNet
//
MarSystem* freqSim = mng.create("Series","freqSim");
//--------
freqSim->addMarSystem(mng.create("PeakFeatureSelect","FREQfeatSelect"));
freqSim->updControl("PeakFeatureSelect/FREQfeatSelect/mrs_natural/selectedFeatures",
PeakFeatureSelect::pkFrequency | PeakFeatureSelect::barkPkFreq);
//--------
MarSystem* fsimMat = mng.create("SelfSimilarityMatrix","FREQsimMat");
fsimMat->addMarSystem(mng.create("Metric","FreqL2Norm"));
fsimMat->updControl("Metric/FreqL2Norm/mrs_string/metric","euclideanDistance");
fsimMat->updControl("mrs_natural/calcCovMatrix", SelfSimilarityMatrix::diagCovMatrix);
//fsimMat->updControl("mrs_string/normalize", "MinMax");
//fsimMat->linkControl("mrs_realvec/covMatrix", "Metric/FreqL2Norm/mrs_realvec/covMatrix");
freqSim->addMarSystem(fsimMat);
//--------
freqSim->addMarSystem(mng.create("RBF","FREQrbf"));
freqSim->updControl("RBF/FREQrbf/mrs_string/RBFtype","Gaussian");
freqSim->updControl("RBF/FREQrbf/mrs_bool/symmetricIn",true);
//--------
simNet->addMarSystem(freqSim);
//
//create Amplitude similarity net and add it to simNet
//
MarSystem* ampSim = mng.create("Series","ampSim");
//--------
ampSim->addMarSystem(mng.create("PeakFeatureSelect","AMPfeatSelect"));
ampSim->updControl("PeakFeatureSelect/AMPfeatSelect/mrs_natural/selectedFeatures",
PeakFeatureSelect::pkAmplitude | PeakFeatureSelect::dBPkAmp);
//--------
MarSystem* asimMat = mng.create("SelfSimilarityMatrix","AMPsimMat");
asimMat->addMarSystem(mng.create("Metric","AmpL2Norm"));
asimMat->updControl("Metric/AmpL2Norm/mrs_string/metric","euclideanDistance");
asimMat->updControl("mrs_natural/calcCovMatrix", SelfSimilarityMatrix::diagCovMatrix);
//asimMat->updControl("mrs_string/normalize", "MinMax");
//asimMat->linkControl("mrs_realvec/covMatrix", "Metric/AmpL2Norm/mrs_realvec/covMatrix");
ampSim->addMarSystem(asimMat);
//--------
ampSim->addMarSystem(mng.create("RBF","AMPrbf"));
ampSim->updControl("RBF/AMPrbf/mrs_string/RBFtype","Gaussian");
ampSim->updControl("RBF/AMPrbf/mrs_bool/symmetricIn",true);
//--------
simNet->addMarSystem(ampSim);
//
//create HWPS similarity net and add it to simNet
//
MarSystem* HWPSim = mng.create("Series","HWPSim");
//--------
HWPSim->addMarSystem(mng.create("PeakFeatureSelect","HWPSfeatSelect"));
HWPSim->updControl("PeakFeatureSelect/HWPSfeatSelect/mrs_natural/selectedFeatures",
PeakFeatureSelect::pkFrequency | PeakFeatureSelect::pkSetFrequencies | PeakFeatureSelect::pkSetAmplitudes);
//--------
MarSystem* HWPSsimMat = mng.create("SelfSimilarityMatrix","HWPSsimMat");
HWPSsimMat->addMarSystem(mng.create("HWPS","hwps"));
HWPSsimMat->updControl("HWPS/hwps/mrs_bool/calcDistance", true);
HWPSim->addMarSystem(HWPSsimMat);
//--------
HWPSim->addMarSystem(mng.create("RBF","HWPSrbf"));
HWPSim->updControl("RBF/HWPSrbf/mrs_string/RBFtype","Gaussian");
HWPSim->updControl("RBF/HWPSrbf/mrs_bool/symmetricIn",true);
//--------
simNet->addMarSystem(HWPSim);
//
//create Panning similarity net and add it to simNet
//
MarSystem* panSim = mng.create("Series","panSim");
//--------
panSim->addMarSystem(mng.create("PeakFeatureSelect","PANfeatSelect"));
panSim->updControl("PeakFeatureSelect/PANfeatSelect/mrs_natural/selectedFeatures",
PeakFeatureSelect::pkPan);
//--------
MarSystem* psimMat = mng.create("SelfSimilarityMatrix","PANsimMat");
psimMat->addMarSystem(mng.create("Metric","PanL2Norm"));
psimMat->updControl("Metric/PanL2Norm/mrs_string/metric","euclideanDistance");
psimMat->updControl("mrs_natural/calcCovMatrix", SelfSimilarityMatrix::diagCovMatrix);
//psimMat->updControl("mrs_string/normalize", "MinMax");
//psimMat->linkControl("mrs_realvec/covMatrix", "Metric/PanL2Norm/mrs_realvec/covMatrix");
panSim->addMarSystem(psimMat);
//--------
panSim->addMarSystem(mng.create("RBF","PANrbf"));
panSim->updControl("RBF/PANrbf/mrs_string/RBFtype","Gaussian");
panSim->updControl("RBF/PANrbf/mrs_bool/symmetricIn",true);
//--------
simNet->addMarSystem(panSim);
//
// LINK controls of PeakFeatureSelects in each similarity branch
//
simNet->linkControl("Series/ampSim/PeakFeatureSelect/AMPfeatSelect/mrs_natural/totalNumPeaks",
"Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/totalNumPeaks");
simNet->linkControl("Series/HWPSim/PeakFeatureSelect/HWPSfeatSelect/mrs_natural/totalNumPeaks",
"Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/totalNumPeaks");
simNet->linkControl("Series/panSim/PeakFeatureSelect/PANfeatSelect/mrs_natural/totalNumPeaks",
"Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/totalNumPeaks");
//------
simNet->linkControl("Series/ampSim/PeakFeatureSelect/AMPfeatSelect/mrs_natural/frameMaxNumPeaks",
"Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/frameMaxNumPeaks");
simNet->linkControl("Series/HWPSim/PeakFeatureSelect/HWPSfeatSelect/mrs_natural/frameMaxNumPeaks",
"Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/frameMaxNumPeaks");
simNet->linkControl("Series/panSim/PeakFeatureSelect/PANfeatSelect/mrs_natural/frameMaxNumPeaks",
"Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/frameMaxNumPeaks");
//++++++++++++++++++++++++++++++++++++++++++++++++++++++
//add simNet to clustNet
clustNet->addMarSystem(simNet);
//
// LINK controls related to variable number of peak from PeakConvert to simNet
//
if (!disableClustering)
{
mainNet->linkControl("FlowThru/clustNet/FanOutIn/simNet/Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/totalNumPeaks",
"PeakConvert/conv/mrs_natural/totalNumPeaks");
mainNet->linkControl("FlowThru/clustNet/FanOutIn/simNet/Series/freqSim/PeakFeatureSelect/FREQfeatSelect/mrs_natural/frameMaxNumPeaks",
"PeakConvert/conv/mrs_natural/frameMaxNumPeaks");
}
//***************************************************************
// create NCutNet MarSystem and add it to clustNet
//***************************************************************
MarSystem* NCutNet = mng.create("Series","NCutNet");
clustNet->addMarSystem(NCutNet);
//---add NCutNet components
// add a stack to stack the
MarSystem* stack = mng.create("Fanout","stack");
NCutNet->addMarSystem(stack);
stack->addMarSystem(mng.create("NormCut","NCut"));
stack->addMarSystem(mng.create("Gain", "ID"));
// add the cluster selection module
NCutNet->addMarSystem(mng.create("PeakClusterSelect","clusterSelect"));
//***************************************************************
// create PeakLabeler MarSystem and add it to mainNet
//***************************************************************
MarSystem* labeler = mng.create("PeakLabeler","labeler");
mainNet->addMarSystem(labeler);
if (!disableClustering)
{
//---- link labeler label control to the NCut output control
mainNet->linkControl("PeakLabeler/labeler/mrs_realvec/peakLabels", "FlowThru/clustNet/mrs_realvec/innerOut");
}
//***************************************************************
// create PeakViewSink MarSystem and add it to mainNet
//***************************************************************
if(peakStore_)
{
mainNet->addMarSystem(mng.create("PeakViewSink", "peSink"));
mainNet->updControl("PeakViewSink/peSink/mrs_string/filename", filePeakName);
}
//****************************************************************
// Create Synthesis Network
//****************************************************************
if(synthetize >-1)
{
//create Shredder series
MarSystem* postNet = mng.create("Series", "postNet");
// postNet->addMarSystem(mng->create("PeOverlapadd", "ob"));
if (synthetize < 3)
{
if(synthetize == 0)
{
postNet->addMarSystem(mng.create("PeakSynthOsc", "pso"));
postNet->addMarSystem(mng.create("Windowing", "wiSyn"));
}
else
{
// put a fake object for probing the series
postNet->addMarSystem(mng.create("Gain", "fakeGain"));
postNet->addMarSystem(mng.create("FlowCutSource", "fcs"));
// put the original source
if (microphone_)
postNet->addMarSystem(mng.create("AudioSource", "srcSyn"));
else
postNet->addMarSystem(mng.create("SoundFileSource", "srcSyn"));
// set the correct buffer size
postNet->addMarSystem(mng.create("ShiftInput", "siSyn"));
// perform an FFT
postNet->addMarSystem(mng.create("Spectrum", "specSyn"));
// convert to polar
postNet->addMarSystem(mng.create("Cartesian2Polar", "c2p"));
// perform amplitude and panning change
postNet->addMarSystem(mng.create("PeakSynthFFT", "psf"));
// convert back to cartesian
postNet->addMarSystem(mng.create("Polar2Cartesian", "p2c"));
// perform an IFFT
// postNet->addMarSystem(mng.create("PlotSink", "plot"));
postNet->addMarSystem(mng.create("InvSpectrum", "invSpecSyn"));
// postNet->addMarSystem(mng.create("PlotSink", "plot2"));
postNet->addMarSystem(mng.create("Windowing", "wiSyn"));
}
postNet->addMarSystem(mng.create("OverlapAdd", "ov"));
}
else
{
postNet->addMarSystem(mng.create("PeakSynthOscBank", "pso"));
// postNet->addMarSystem(mng.create("ShiftOutput", "so"));
}
postNet->addMarSystem(mng.create("Gain", "outGain"));
MarSystem *dest;
if (outsfname == "MARSYAS_EMPTY")
dest = mng.create("AudioSink/dest");
else
{
dest = mng.create("SoundFileSink/dest");
//dest->updControl("mrs_string/filename", outsfname);
}
if(residual_)
{
MarSystem* fanout = mng.create("Fanout", "fano");
fanout->addMarSystem(dest);
MarSystem* fanSeries = mng.create("Series", "fanSeries");
if (microphone_)
fanSeries->addMarSystem(mng.create("AudioSource", "src2"));
else
fanSeries->addMarSystem(mng.create("SoundFileSource", "src2"));
fanSeries->addMarSystem(mng.create("Delay", "delay"));
fanout->addMarSystem(fanSeries);
postNet->addMarSystem(fanout);
postNet->addMarSystem(mng.create("PeakResidual", "res"));
MarSystem *destRes;
if (outsfname == "MARSYAS_EMPTY")
destRes = mng.create("AudioSink/destRes");
else
{
destRes = mng.create("SoundFileSink/destRes");
//dest->updControl("mrs_string/filename", outsfname);
}
postNet->addMarSystem(destRes);
}
else
postNet->addMarSystem(dest);
MarSystem* synthNet = mng.create("Shredder", "synthNet");
synthNet->addMarSystem(postNet);
mainNet->addMarSystem(synthNet);
//link Shredder nTimes to Accumulator nTimes
mainNet->linkControl("Shredder/synthNet/mrs_natural/nTimes",
"Accumulator/textWinNet/mrs_natural/nTimes");
}
//****************************************************************
////////////////////////////////////////////////////////////////
// update the controls
////////////////////////////////////////////////////////////////
//mainNet->updControl("Accumulator/textWinNet/mrs_natural/nTimes", accSize);
if (microphone_)
{
mainNet->updControl("mrs_natural/inSamples", D);
mainNet->updControl("mrs_natural/inObservations", 1);
}
else
{
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/SoundFileSource/src/mrs_string/filename", sfName);
mainNet->updControl("mrs_natural/inSamples", D);
mainNet->updControl("mrs_natural/inObservations", 1);
samplingFrequency_ = mainNet->getctrl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/SoundFileSource/src/mrs_real/osrate")->to<mrs_real>();
}
if(noiseName != EMPTYSTRING)
{
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/mixseries/SoundFileSource/noise/mrs_string/filename", noiseName);
mainNet->updControl("mrs_natural/inSamples", D);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/mixseries/NoiseSource/noise/mrs_string/mode", "rand");
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Seriesmixseries/Delay/noiseDelay/mrs_real/delaySeconds", noiseDelay);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/mixseries/Gain/noiseGain/mrs_real/gain", noiseGain_);
}
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/ShiftInput/si/mrs_natural/winSize", Nw+1);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/spectrumNet/Shifter/sh/mrs_natural/shift", 1);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/spectrumNet/Windowing/wi/mrs_natural/size", N);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/spectrumNet/Windowing/wi/mrs_string/type", "Hanning");
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/spectrumNet/Windowing/wi/mrs_bool/zeroPhasing", true);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/stereoSpkNet/Parallel/LRnet/Series/spkL/Windowing/win/mrs_natural/size", N);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/stereoSpkNet/Parallel/LRnet/Series/spkL/Windowing/win/mrs_string/type", "Hanning");
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/stereoSpkNet/Parallel/LRnet/Series/spkL/Windowing/win/mrs_bool/zeroPhasing", true);
//
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/stereoSpkNet/Parallel/LRnet/Series/spkR/Windowing/win/mrs_natural/size", N);
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/stereoSpkNet/Parallel/LRnet/Series/spkR/Windowing/win/mrs_string/type", "Hanning");
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/stereoSpkNet/Parallel/LRnet/Series/spkR/Windowing/win/mrs_bool/zeroPhasing", true);
if(unprecise_)
mainNet->updControl("PeakConvert/conv/mrs_bool/improvedPrecision", false);
else
mainNet->updControl("PeakConvert/conv/mrs_bool/improvedPrecision", true);
if(noPeakPicking_)
mainNet->updControl("PeakConvert/conv/mrs_bool/picking", false);
mainNet->updControl("PeakConvert/conv/mrs_natural/frameMaxNumPeaks", S);
mainNet->updControl("PeakConvert/conv/mrs_string/frequencyInterval", intervalFrequency);
mainNet->updControl("PeakConvert/conv/mrs_natural/nbFramesSkipped", 0);//(N/D));
if (!disableClustering)
{
mainNet->updControl("FlowThru/clustNet/Series/NCutNet/Fanout/stack/NormCut/NCut/mrs_natural/numClusters", C);
mainNet->updControl("FlowThru/clustNet/Series/NCutNet/PeakClusterSelect/clusterSelect/mrs_natural/numClustersToKeep", nbSelectedClusters_);
}
// //[TODO]
// mainNet->setctrl("PeClust/peClust/mrs_natural/selectedClusters", nbSelectedClusters_);
// mainNet->setctrl("PeClust/peClust/mrs_natural/hopSize", D);
// mainNet->setctrl("PeClust/peClust/mrs_natural/storePeaks", (mrs_natural) peakStore_);
// mainNet->updControl("PeClust/peClust/mrs_string/similarityType", T);
//
// similarityWeight_.stretch(3);
// similarityWeight_(0) = 1;
// similarityWeight_(1) = 10; //[WTF]
// similarityWeight_(2) = 1;
// mainNet->updControl("PeClust/peClust/mrs_realvec/similarityWeight", similarityWeight_);
if(noiseName != EMPTYSTRING)
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/SoundFileSink/mixSink/mrs_string/filename", mixName);
mainNet->update();
//check if input is a stereo signal
if(mainNet->getctrl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/mrs_natural/onObservations")->to<mrs_natural>() == 1)
{
//if a not a stereo signal, we must set the Stereo2Mono weight to 1.0 (i.e. do no mixing)!
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/spectrumNet/Stereo2Mono/s2m/mrs_real/weight", 1.0);
}
//------------------------------------------------------------------------
//check which similarity computations should be disabled (if any)
//------------------------------------------------------------------------
if (!disableClustering)
{
// Frequency Similarity
if(ignoreFrequency)
{
cout << "** Frequency Similarity Computation disabled!" << endl;
mainNet->updControl("FlowThru/clustNet/FanOutIn/simNet/mrs_string/disableChild",
"Series/freqSim");
}
else
cout << "** Frequency Similarity Computation enabled!" << endl;
// amplitude similarity
if(ignoreAmplitude)
{
cout << "** Amplitude Similarity Computation disabled!" << endl;
mainNet->updControl("FlowThru/clustNet/FanOutIn/simNet/mrs_string/disableChild",
"Series/ampSim");
}
else
cout << "** Amplitude Similarity Computation enabled!" << endl;
// HWPS similarity
if(ignoreHWPS)
{
cout << "** HWPS (harmonicity) Similarity Computation disabled!" << endl;
mainNet->updControl("FlowThru/clustNet/FanOutIn/simNet/mrs_string/disableChild",
"Series/HWPSim");
}
else
cout << "** HWPS (harmonicity) Similarity Computation enabled!" << endl;
//
//Panning Similarity
if(mainNet->getctrl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/mrs_natural/onObservations")->to<mrs_natural>() == 2 &&
!ignorePan)
{
cout << "** Panning Similarity Computation enabled!" << endl;
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/mrs_string/enableChild",
"Series/stereoSpkNet");
mainNet->updControl("FlowThru/clustNet/FanOutIn/simNet/mrs_string/enableChild",
"Series/panSim");
}
else //if not stereo or if stereo to be ignored, disable some branches
{
cout << "** Panning Similarity Computation disabled!" << endl;
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/mrs_string/disableChild",
"Series/stereoSpkNet");
mainNet->updControl("FlowThru/clustNet/FanOutIn/simNet/mrs_string/disableChild",
"Series/panSim");
}
}
else
{
mainNet->updControl("Accumulator/textWinNet/Series/analysisNet/Series/peakExtract/Fanout/stereoFo/mrs_string/disableChild",
"Series/stereoSpkNet");
}
//
mainNet->update(); //probably not necessary... [!]
//------------------------------------------------------------------------
if(noiseDuration_) //[WTF]
{
ostringstream ossi;
ossi << ((noiseDelay_+noiseDuration_)) << "s";
cout << ossi.str() << endl;
// touch the gain directly
// noiseGain->updControl("0.1s", Repeat("0.1s", 1), new EvValUpd(noiseGain,"mrs_real/gain", 0.0));
}
//ONSET DETECTION CONFIGURATION (if enabled)
if(useOnsets)
{
cout << "** Onset detector enabled -> using dynamically adjusted texture windows!" << endl;
cout << "WinSize = " << winSize_ << endl;
cout << "N = " << N << endl;
cout << "Nw = " << Nw << endl;
cout << "hopSize = " << hopSize_ << endl;
cout << "D = " << D << endl;
cout << "fs = " << samplingFrequency_ << endl;
//link controls for onset detector
onsetdetector->linkControl("Filter/filt2/mrs_realvec/ncoeffs",
"Filter/filt1/mrs_realvec/ncoeffs");
onsetdetector->linkControl("Filter/filt2/mrs_realvec/dcoeffs",
"Filter/filt1/mrs_realvec/dcoeffs");
//link onset detector to accumulator and if onsets enabled, set "explicitFlush" mode
textWinNet->linkControl("mrs_bool/flush",
"Series/analysisNet/Series/peakExtract/Fanout/stereoFo/Series/spectrumNet/FlowThru/onsetdetector/PeakerOnset/peaker/mrs_bool/onsetDetected");
//update onset detector controls
onsetdetector->updControl("PowerSpectrum/pspk/mrs_string/spectrumType", "wrongdBonsets");
onsetdetector->updControl("Flux/flux/mrs_string/mode", "DixonDAFX06");
realvec bcoeffs(1,3);//configure zero-phase Butterworth filter of Flux time series -> butter(2, 0.28)
bcoeffs(0) = 0.1174;
bcoeffs(1) = 0.2347;
bcoeffs(2) = 0.1174;
realvec acoeffs(1,3);
acoeffs(0) = 1.0;
acoeffs(1) = -0.8252;
acoeffs(2) = 0.2946;
onsetdetector->updControl("Filter/filt1/mrs_realvec/ncoeffs", bcoeffs);
onsetdetector->updControl("Filter/filt1/mrs_realvec/dcoeffs", acoeffs);
mrs_natural lookAheadSamples = 6;
onsetdetector->updControl("PeakerOnset/peaker/mrs_natural/lookAheadSamples", lookAheadSamples); //!!
onsetdetector->updControl("PeakerOnset/peaker/mrs_real/threshold", 1.5); //!!!
onsetdetector->updControl("ShiftInput/sif/mrs_natural/winSize", 4*lookAheadSamples+1);
//set Accumulator controls for explicit flush mode
mrs_natural winds = 1+lookAheadSamples+mrs_natural(ceil(mrs_real(winSize_)/hopSize_/2.0));
cout << "Accumulator/textWinNet timesToKeep = " << winds << endl;
mrs_real textureWinMinLen = 0.050; //secs
mrs_real textureWinMaxLen = 1.0; //secs
mrs_natural minTimes = (mrs_natural)(textureWinMinLen*samplingFrequency_/hopSize_);
mrs_natural maxTimes = (mrs_natural)(textureWinMaxLen*samplingFrequency_/hopSize_);
cout << "Accumulator/textWinNet MinTimes = " << minTimes << " (i.e. " << textureWinMinLen << " secs)" << endl;
cout << "Accumulator/textWinNet MaxTimes = " << maxTimes << " (i.e. " << textureWinMaxLen << " secs)" <<endl;
textWinNet->updControl("mrs_string/mode", "explicitFlush");
textWinNet->updControl("mrs_natural/timesToKeep", winds);
textWinNet->updControl("mrs_string/mode","explicitFlush");
textWinNet->updControl("mrs_natural/maxTimes", maxTimes);
textWinNet->updControl("mrs_natural/minTimes", minTimes);
}
else
{
cout << "** Onset detector disabled -> using fixed length texture windows" << endl;
cout << "Accumulator/textWinNet nTimes = " << accSize << " (i.e. " << accSize*hopSize_/samplingFrequency_ << " secs)" << endl;
mainNet->updControl("Accumulator/textWinNet/mrs_natural/nTimes", accSize);
}
if(synthetize>-1)
{
mrs_natural delay = -(winSize_/2 - hopSize_);
cout << "Delay = " << delay << endl;
if (synthetize < 3)
{
if(synthetize==0)
{
mainNet->updControl("Shredder/synthNet/Series/postNet/PeakSynthOsc/pso/mrs_real/samplingFreq", samplingFrequency_);
mainNet->updControl("Shredder/synthNet/Series/postNet/PeakSynthOsc/pso/mrs_natural/delay", delay); // Nw/2+1
mainNet->updControl("Shredder/synthNet/Series/postNet/PeakSynthOsc/pso/mrs_natural/synSize", hopSize_*2);//D*2);
mainNet->updControl("Shredder/synthNet/Series/postNet/Windowing/wiSyn/mrs_string/type", "Hanning");
// changed the cluster labeling from -1 (don't use) and 0 (use) to negative (don't use) and positive (use) indices
mainNet->updControl("Shredder/synthNet/Series/postNet/PeakSynthOsc/pso/mrs_natural/peakGroup2Synth", -1);
}
else
{
// linking between the first slice and the psf
mainNet->linkControl("Shredder/synthNet/Series/postNet/mrs_realvec/input0", "PeSynthetize/synthNet/Series/postNet/PeakSynthFFT/psf/mrs_realvec/peaks");
//
mainNet->updControl("Shredder/synthNet/Series/postNet/Windowing/wiSyn/mrs_string/type", "Hanning");
mainNet->updControl("Shredder/synthNet/Series/postNet/FlowCutSource/fcs/mrs_natural/setSamples", D);
mainNet->updControl("Shredder/synthNet/Series/postNet/FlowCutSource/fcs/mrs_natural/setObservations", 1);
// setting the panning mode mono/stereo
mainNet->updControl("Shredder/synthNet/Series/postNet/PeakSynthFFT/psf/mrs_natural/nbChannels", synthetize_);
mainNet->updControl("Shredder/synthNet/Series/postNet/PeakSynthFFT/psf/mrs_string/panning", panningInfo);
// setting the FFT size
mainNet->updControl("Shredder/synthNet/Series/postNet/ShiftInput/siSyn/mrs_natural/winSize", D*2);
// setting the name of the original file
if (microphone_)
{
mainNet->updControl("Shredder/synthNet/Series/postNet/AudioSource/srcSyn/mrs_natural/inSamples", D);
mainNet->updControl("Shredder/synthNet/Series/postNet/AudioSource/srcSyn/mrs_natural/inObservations", 1);
}
else
{
mainNet->updControl("Shredder/synthNet/Series/postNet/SoundFileSource/srcSyn/mrs_string/filename", sfName);
// pvseries->updControl("Shredder/synthNet/Series/postNet/SoundFileSource/srcSyn/mrs_natural/pos", 0);
mainNet->updControl("Shredder/synthNet/Series/postNet/SoundFileSource/srcSyn/mrs_natural/onSamples", D);
mainNet->updControl("Shredder/synthNet/Series/postNet/SoundFileSource/srcSyn/mrs_natural/onObservations", 1);
}
// setting the synthesis starting time (default 0)
}
}
//else
// mainNet->updControl("Shredder/synthNet/Series/postNet/PeakSynthOscBank/pso/mrs_natural/Interpolation", D); //this control exists?!? [WTF]
//mainNet->updControl("Shredder/synthNet/Series/postNet/ShiftOutput/so/mrs_natural/Interpolation", D); //[WTF]
if (outsfname == "MARSYAS_EMPTY")
mainNet->updControl("Shredder/synthNet/Series/postNet/AudioSink/dest/mrs_natural/bufferSize", bopt_);
if(residual_)
{
mainNet->updControl("Shredder/synthNet/Series/postNet/Fanout/fano/Series/fanSeries/Delay/delay/mrs_natural/delay", delay); // Nw+1-D
if (microphone_)
{
mainNet->updControl("PeSynthetize/synthNet/Series/postNet/Fanout/fano/Series/fanSeries/AudioSource/src2/mrs_natural/inSamples", D);
mainNet->updControl("PeSynthetize/synthNet/Series/postNet/Fanout/fano/Series/fanSeries/AudioSource/src2/mrs_natural/inObservations", 1);
}
else
{
mainNet->updControl("Shredder/synthNet/Series/postNet/Fanout/fano/Series/fanSeries/SoundFileSource/src2/mrs_string/filename", sfName);
mainNet->updControl("Shredder/synthNet/Series/postNet/Fanout/fano/Series/fanSeries/SoundFileSource/src2/mrs_natural/pos", 0);
mainNet->updControl("Shredder/synthNet/Series/postNet/Fanout/fano/Series/fanSeries/SoundFileSource/src2/mrs_natural/inSamples", D);
mainNet->updControl("Shredder/synthNet/Series/postNet/Fanout/fano/Series/fanSeries/SoundFileSource/src2/mrs_natural/inObservations", 1);
}
mainNet->updControl("Shredder/synthNet/Series/postNet/Fanout/fano/SoundFileSink/dest/mrs_string/filename", outsfname);//[!]
mainNet->updControl("Shredder/synthNet/Series/postNet/SoundFileSink/destRes/mrs_string/filename", fileResName);//[!]
}
else
mainNet->updControl("Shredder/synthNet/Series/postNet/SoundFileSink/dest/mrs_string/filename", outsfname);//[!]
}
//***************************************************************************************************************
// MAIN TICKING LOOP
//***************************************************************************************************************
//ofstream cfile("density.txt", ios::app); //[WTF] [TODO]
mrs_real globalSnr = 0;
mrs_natural frameCount = 0;
// mrs_real time=0;
while(1)
{
mainNet->tick();
if(synthetize > -1 && residual_)
{
mrs_real snr = mainNet->getctrl("PeSynthetize/synthNet/Series/postNet/PeakResidual/res/mrs_real/SNR")->to<mrs_real>();
globalSnr += snr;
frameCount++;
// cout << "Frame " << frameCount << " SNR : "<< snr << endl;
}
if (!microphone_)
{
bool temp2 = analysisNet->getctrl("FanOutIn/mixer/Series/oriNet/SoundFileSource/src/mrs_bool/hasData")->to<mrs_bool>();
mrs_real timeRead = analysisNet->getctrl("FanOutIn/mixer/Series/oriNet/SoundFileSource/src/mrs_natural/pos")->to<mrs_natural>()/samplingFrequency_;
mrs_real timeLeft;
if(!stopAnalyse_)
timeLeft = analysisNet->getctrl("FanOutIn/mixer/Series/oriNet/SoundFileSource/src/mrs_natural/size")->to<mrs_natural>()/samplingFrequency_;
else
timeLeft = stopAnalyse_;
// string fname = mainNet->getctrl("Accumulator/textWinNet/Series/analysisNet/FanOutIn/mixer/Series/oriNet/SoundFileSource/src/mrs_string/filename")->to<mrs_string>();
printf(" %.2f / %.2f \r", timeRead, timeLeft);
fflush(stdout);
//cout << fixed << setprecision(2) << timeRead << "/" << setprecision(2) << timeLeft;
///*bool*/ temp = mainNet->getctrl("Accumulator/textWinNet/Series/analysisNet/SoundFileSource/src/mrs_bool/hasData")->to<mrs_bool>();
//[TODO]
// mrs_real density = mainNet->getctrl("PeClust/peClust/mrs_real/clusterDensity")->to<mrs_real>();
// cfile << density << " " << oriGain << endl;
// //cout << oriGain << endl;
if (temp2 == false || (stopAnalyse_ !=0 && stopAnalyse_<timeRead))
break;
}
}
if(synthetize_ > -1 && residual_)
{
cout << "Global SNR : " << globalSnr/frameCount << endl;
*snr0 = globalSnr/frameCount;
}
if(peakStore_)
{
mainNet->updControl("PeakViewSink/peSink/mrs_real/fs", samplingFrequency_);
mainNet->updControl("PeakViewSink/peSink/mrs_natural/frameSize", D);
mainNet->updControl("PeakViewSink/peSink/mrs_string/filename", filePeakName);
mainNet->updControl("PeakViewSink/peSink/mrs_bool/done", true);
}
//cfile.close(); [TODO]
delete mainNet;
}
void
MarGrid::setupTrain(QString fname)
{
// Build network for feature extraction
MarSystem* extractNet = mng.create("Series", "extractNet");
extractNet->addMarSystem(mng.create("SoundFileSource", "src"));
extractNet->addMarSystem(mng.create("Stereo2Mono", "s2m"));
// extractNet->addMarSystem(mng.create("AudioSink", "dest"));
MarSystem* spectralNet = mng.create("Series", "spectralNet");
spectralNet->addMarSystem(mng.create("Windowing", "ham"));
spectralNet->addMarSystem(mng.create("Spectrum", "spk"));
spectralNet->addMarSystem(mng.create("PowerSpectrum", "pspk"));
MarSystem* featureFanout = mng.create("Fanout", "featureFanout");
featureFanout->addMarSystem(mng.create("Centroid", "centroid"));
featureFanout->addMarSystem(mng.create("Rolloff", "rolloff"));
featureFanout->addMarSystem(mng.create("Flux", "flux"));
featureFanout->addMarSystem(mng.create("MFCC", "mfcc"));
spectralNet->addMarSystem(featureFanout);
extractNet->addMarSystem(spectralNet);
extractNet->addMarSystem(mng.create("Memory", "mem"));
MarSystem* stats = mng.create("Fanout", "stats");
stats->addMarSystem(mng.create("Mean", "mn1"));
stats->addMarSystem(mng.create("StandardDeviation", "std1"));
extractNet->addMarSystem(stats);
MarSystem* acc = mng.create("Accumulator", "acc");
acc->updControl("mrs_natural/nTimes", 1200);
acc->addMarSystem(extractNet);
total_ = mng.create("Series", "total");
total_->addMarSystem(acc);
MarSystem* stats2 = mng.create("Fanout", "stats2");
stats2->addMarSystem(mng.create("Mean", "mn2"));
stats2->addMarSystem(mng.create("StandardDeviation", "std2"));
total_->addMarSystem(stats2);
total_->addMarSystem(mng.create("Annotator", "ann"));
// total_->updControl("Accumulator/acc/Series/extractNet/AudioSink/dest/mrs_bool/initAudio", true);
total_->linkControl("mrs_string/filename",
"Accumulator/acc/Series/extractNet/SoundFileSource/src/mrs_string/filename");
total_->linkControl("mrs_string/currentlyPlaying",
"Accumulator/acc/Series/extractNet/SoundFileSource/src/mrs_string/currentlyPlaying");
total_->linkControl("mrs_bool/shuffle",
"Accumulator/acc/Series/extractNet/SoundFileSource/src/mrs_bool/shuffle");
total_->linkControl("mrs_natural/pos",
"Accumulator/acc/Series/extractNet/SoundFileSource/src/mrs_natural/pos");
total_->linkControl("mrs_real/repetitions",
"Accumulator/acc/Series/extractNet/SoundFileSource/src/mrs_real/repetitions");
total_->linkControl("mrs_natural/cindex",
"Accumulator/acc/Series/extractNet/SoundFileSource/src/mrs_natural/cindex");
total_->linkControl("mrs_natural/numFiles",
"Accumulator/acc/Series/extractNet/SoundFileSource/src/mrs_natural/numFiles");
total_->linkControl("mrs_string/allfilenames",
"Accumulator/acc/Series/extractNet/SoundFileSource/src/mrs_string/allfilenames");
total_->linkControl("mrs_natural/numFiles",
"Accumulator/acc/Series/extractNet/SoundFileSource/src/mrs_natural/numFiles");
total_->linkControl("mrs_bool/hasData",
"Accumulator/acc/Series/extractNet/SoundFileSource/src/mrs_bool/hasData");
total_->linkControl("mrs_natural/advance",
"Accumulator/acc/Series/extractNet/SoundFileSource/src/mrs_natural/advance");
total_->linkControl("mrs_bool/memReset",
"Accumulator/acc/Series/extractNet/Memory/mem/mrs_bool/reset");
total_->linkControl("mrs_natural/label",
"Annotator/ann/mrs_natural/label");
total_->updControl("mrs_natural/inSamples", 512);
trainFname = fname;
predictFname = "margrid_train.mf";
total_->updControl("mrs_string/filename", trainFname.toStdString());
total_->updControl("mrs_real/repetitions", 1.0);
}
void extractBpm(string filename) {
cout << "BPM extractor" << endl;
MarSystemManager mng;
MarSystem* blackbox = mng.create("Series", "blackbox");
blackbox->addMarSystem(mng.create("SoundFileSource", "src"));
/**
* Linkaggio dei controlli: SoundSource
*/
blackbox->linkctrl("mrs_string/filename", "SoundFileSource/src/mrs_string/filename");
blackbox->linkctrl("mrs_string/labelNames", "SoundFileSource/src/mrs_string/labelNames");
blackbox->updctrl("mrs_string/filename", filename);
/*
* Creazione di un file di testo con alcune informazioni sul file:
* fname = name of the file courrently analyzed
* israte = input sample rate
* osrate = output sample rate
* duration = duration of the file in seconds
* size = number of audio samples contained into the file
* label = label for classification use
*/
ofstream finfo;
finfo.open("durata.txt");
mrs_string fname = blackbox->getctrl("mrs_string/filename")->to<mrs_string>();
finfo << "Input file name: " << fname << endl;
mrs_real israte = blackbox->getctrl("mrs_real/israte")->to<mrs_real>();
finfo << "Input samplerate: " << israte << " Hz" << endl;
mrs_real osrate = blackbox->getctrl("mrs_real/osrate")->to<mrs_real>();
finfo << "Output samplerate: " << osrate << " Hz" << endl;
mrs_real duration = blackbox->getctrl("SoundFileSource/src/mrs_real/duration")->to<mrs_real>();
finfo << "Duration: " << duration << " seconds" << endl;
mrs_natural size = blackbox->getctrl("SoundFileSource/src/mrs_natural/size")->to<mrs_natural>();
finfo << "Number of samples of courrent file: " << size << endl;
mrs_string label = blackbox->getctrl("mrs_string/labelNames")->to<mrs_string>();
finfo << "Label name: " << label << endl;
finfo.close();
ofstream wavelet;
wavelet.open("waveletbands.txt");
wavelet << "WAVELET BANDS VALUES" << endl;
/*
* Preparazione per l'estrazione dell'inviluppo del segnale audio
*/
//blackbox->addMarSystem(mng.create("WaveletBands", "wavelet"));
//blackbox->addMarSystem(mng.create("FullWaveRectifier","rectifier"));
blackbox->addMarSystem(mng.create("AutoCorrelation", "autocorrelation"));
blackbox->updctrl("AutoCorrelation/autocorrelation/mrs_bool/aliasedOutput", false);
blackbox->addMarSystem(mng.create("BeatHistogram", "histogram"));
mrs_real val = 0.0;
while (blackbox->getctrl("SoundFileSource/src/mrs_bool/hasData")->to<mrs_bool>()) {
blackbox->tick();
const mrs_realvec& src_data =
blackbox->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
val = src_data(0,0);
wavelet << val << endl;
}
wavelet.close();
delete blackbox;
cout << "done" << endl;
}
void centroidToTxt(string sfName1) {
cout << "Toy with centroid " << sfName1 << endl;
MarSystemManager mng;
MarSystem* net = mng.create("Series/net");
net->addMarSystem(mng.create("SoundFileSource/src"));
net->addMarSystem(mng.create("Windowing/ham"));
net->addMarSystem(mng.create("Spectrum/spk"));
net->addMarSystem(mng.create("PowerSpectrum/pspk"));
net->addMarSystem(mng.create("Centroid/cntrd"));
net->addMarSystem(mng.create("Memory/mem"));
net->addMarSystem(mng.create("Mean/mean"));
net->linkctrl("mrs_string/filename", "SoundFileSource/src/mrs_string/filename");
net->updctrl("mrs_string/filename", sfName1);
mrs_real val = 0.0;
ofstream ofs;
ofs.open("centroid.mpl");
ofs << *net << endl;
ofs.close();
ofstream text;
text.open("centroid.txt");
while (net->getctrl("SoundFileSource/src/mrs_bool/hasData")->to<mrs_bool>())
{
net->tick();
const mrs_realvec& src_data =
net->getctrl("mrs_realvec/processedData")->to<mrs_realvec>();
val = src_data(0,0);
text << val << endl;
//cout << val << endl;
}
text.close();
}