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;
}
Esempio n. 3
0
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;
}
Esempio n. 5
0
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;
}
Esempio n. 7
0
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!

}
Esempio n. 8
0
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_;
}
Esempio n. 9
0
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;
}
Esempio n. 11
0
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;
}
Esempio n. 16
0
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]
}
Esempio n. 18
0
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;
}
Esempio n. 19
0
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;
}
Esempio n. 20
0
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;
}
Esempio n. 21
0
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;





}
Esempio n. 22
0
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;


}
Esempio n. 23
0
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;

}
Esempio n. 24
0
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;
   }





}
Esempio n. 25
0
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;
}
Esempio n. 26
0
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;
}
Esempio n. 28
0
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);


}
Esempio n. 29
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;
	}
Esempio n. 30
0
	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();
	}