コード例 #1
0
ファイル: Talk.cpp プロジェクト: Amos-zq/marsyas
void
Talk::cmd_segment(mrs_string systemName, unsigned int memSize, unsigned int numPeaks, unsigned int peakSpacing, unsigned int start, unsigned int end, unsigned int winSize)
{
  // FIXME Unused parameters
  (void) memSize;
  (void) numPeaks;
  (void) peakSpacing;
  (void) start;
  (void) end;
  (void) winSize;

  TimeLine tline;

  mrs_natural hops = src_->getctrl("mrs_natural/size")->to<mrs_natural>() * src_->getctrl("mrs_natural/nChannels")->to<mrs_natural>() / src_->getctrl("mrs_natural/inSamples")->to<mrs_natural>() + 1;

  if(!strcmp(systemName.c_str(), "REG"))
    tline.regular(100, hops);

  realvec peaks(hops);


  tline.send(communicator_);
  peaks.send(communicator_);


//   tline.print(stdout);

//   cerr << "cmd_segment::systemName " << systemName << endl;
//   cerr << "cmd_segment::memSize " << memSize << endl;
//   cerr << "cmd_segment::numPeaks " << numPeaks << endl;
//   cerr << "cmd_segment::peakSpacing " << peakSpacing << endl;
//   cerr << "cmd_segment::start " << start << endl;
//   cerr << "cmd_segment::end " << end << endl;
//   cerr << "cmd_segment::winSize " << winSize << endl;






//   mrs_string extractorstr = systemName;
//   mrs_string rextractorstr = systemName;
//   if (!strcmp(rextractorstr.c_str(), "REG"))
//       extractorstr = "FFT_SEGM";

//   if (winSize != DEFAULT_WIN_SIZE)
//     {
//       start = (unsigned int)(start * ((float)winSize / DEFAULT_WIN_SIZE));
//       end = (unsigned int) (end * ((float)winSize/ DEFAULT_WIN_SIZE));
//       winSize = DEFAULT_WIN_SIZE;
//     }
//   src_->initWindow(winSize);
//   cerr << "Src winSize = " << src_->winSize() << endl;


//   Spectral spectral(src_);
//   SpectralSegm spectralsegm(src_,10);
//   MemMFCC mfcc(src_);

//   FeatExtractor mfccExtractor(src_, &mfcc);
//   FeatExtractor spectralExtractor(src_, &spectral);
//   FeatExtractor segmExtractor(src_, &spectralsegm);
//   SfxExtractor sfxExtractor(src_);

//   FeatMatrix mfccRes(src_->iterations(), mfcc.outSize());
//   FeatMatrix spectralRes(src_->iterations(), spectral.outSize());
//   FeatMatrix spectralSegmRes(src_->iterations(), spectralsegm.outSize());
//   FeatMatrix sfxRes(1, 2);


//   map<const char *, FeatMatrix *, ltstr> results;
//   results["FFT"] = &spectralRes;
//   results["FFT_SEGM"] = &spectralSegmRes;
//   results["MFCC"] = &mfccRes;
//   results["SFX"] = &sfxRes;


//   map<const char *, Extractor *, ltstr> extractors;
//   extractors["FFT"] = &spectralExtractor;
//   extractors["FFT_SEGM"] = &segmExtractor;
//   extractors["MFCC"] = &mfccExtractor;
//   extractors["SFX"] = &sfxExtractor;


//   map<const char *, Extractor *, ltstr>::iterator cur;
//   const char *ch = extractorstr.c_str();
//   cur = extractors.find(ch);

//   if (cur == extractors.end())
//     {
//       cerr << "Extractor " << extractorstr << " is not supported\n" << endl;
//       return;
//     }
//   else
//     {
//       extractors[extractorstr.c_str()]->extract(*(results[extractorstr.c_str()]));
//     }
//   TimeLine tline;
//   SegmentorSortedPeaks segmentor;
//   segmentor.init(numPeaks, peakSpacing);
//   fvec res((*(results[extractorstr.c_str()])).rows());
//   fvec peaks((*(results[extractorstr.c_str()])).rows());
//   segmentor.segment(*(results[extractorstr.c_str()]), res);
//   segmentor.peaks(*(results[extractorstr.c_str()]), peaks);


}
コード例 #2
0
void textract_trainAccumulator(string sfName, mrs_natural offset, mrs_natural duration, mrs_real start, mrs_real length, mrs_real gain, mrs_natural label, string pluginName, string wekafname, mrs_natural memSize, string extractorStr, TimeLine& tline)
{
	MarSystemManager mng;

	MRSDIAG("sfplay.cpp - sfplay");

	// default 
	if (extractorStr == EMPTYSTRING) 
		extractorStr = "STFT";

	// Find proper soundfile format and create SignalSource 
	MarSystem *src = mng.create("SoundFileSource", "src");

	src->updctrl("mrs_string/filename", sfName);
	src->updctrl("mrs_natural/inSamples", MRS_DEFAULT_SLICE_NSAMPLES);

	if (tlineName == EMPTYSTRING)
	{
		mrs_natural hops = src->getctrl("mrs_natural/size")->to<mrs_natural>() * src->getctrl("mrs_natural/nChannels")->to<mrs_natural>() / 2048 + 1;
		tline.regular(100, hops);
	}

	MarSystem *dest_;
	dest_ = mng.create("AudioSink", "dest");

	MarSystem *series = mng.create("Series", "playbacknet");
	series->addMarSystem(src);
	series->addMarSystem(dest_);

	series->updctrl("AudioSink/dest/mrs_natural/nChannels", 
		series->getctrl("SoundFileSource/src/mrs_natural/nChannels")->to<mrs_natural>());  

	// Calculate duration, offset parameters if necessary 
	if (start > 0.0f) 
		offset = (mrs_natural) (start 
		* src->getctrl("mrs_real/israte")->to<mrs_real>() 
		* src->getctrl("mrs_natural/nChannels")->to<mrs_natural>());
	if (length != 30.0f) 
		duration = (mrs_natural) (length 
		* src->getctrl("mrs_real/israte")->to<mrs_real>() 
		* src->getctrl("mrs_natural/nChannels")->to<mrs_natural>());

	// accumulate feature vectors over 30 seconds 
	MarSystem* acc = mng.create("Accumulator", "acc");

	acc->updctrl("mrs_natural/nTimes", 100);

	// Calculate windowed power spectrum and then 
	// calculate specific feature sets 
	MarSystem* spectralShape = mng.create("Series", "spectralShape");
	spectralShape->addMarSystem(mng.create("Windowing", "hamming"));
	spectralShape->addMarSystem(mng.create("Spectrum","spk"));
	spectralShape->addMarSystem(mng.create("PowerSpectrum", "pspk"));
	spectralShape->updctrl("PowerSpectrum/pspk/mrs_string/spectrumType","power");  

	// Spectrum Shape descriptors
	MarSystem* spectrumFeatures = mng.create("Fanout", "spectrumFeatures");

	if (extractorStr == "STFT") 
	{
		spectrumFeatures->addMarSystem(mng.create("Centroid", "cntrd"));
		spectrumFeatures->addMarSystem(mng.create("Rolloff", "rlf"));      
		spectrumFeatures->addMarSystem(mng.create("Flux", "flux"));
	}
	else if (extractorStr == "STFTMFCC")
	{
		spectrumFeatures->addMarSystem(mng.create("Centroid", "cntrd"));
		spectrumFeatures->addMarSystem(mng.create("Rolloff", "rlf"));      
		spectrumFeatures->addMarSystem(mng.create("Flux", "flux"));
		spectrumFeatures->addMarSystem(mng.create("MFCC", "mfcc"));
	}
	else if (extractorStr == "MFCC")
		spectrumFeatures->addMarSystem(mng.create("MFCC", "mfcc"));
	else if (extractorStr == "SCF")
		spectrumFeatures->addMarSystem(mng.create("SCF", "scf"));
	else if (extractorStr == "SFM") 
		spectrumFeatures->addMarSystem(mng.create("SFM", "sfm"));

	mng.registerPrototype("SpectrumFeatures", spectrumFeatures->clone());
	spectralShape->addMarSystem(mng.create("SpectrumFeatures", "spectrumFeatures"));
	mng.registerPrototype("SpectralShape", spectralShape->clone());

	//  add time-domain zerocrossings
	MarSystem* features = mng.create("Fanout", "features");
	features->addMarSystem(mng.create("SpectralShape", "SpectralShape"));
	if (extractorStr == "STFT")
		features->addMarSystem(mng.create("ZeroCrossings", "zcrs"));      
	mng.registerPrototype("Features", features->clone());

	// Means and standard deviation (statistics) for texture analysis 
	MarSystem* statistics = mng.create("Fanout","statistics");
	statistics->addMarSystem(mng.create("Mean", "mn"));
	statistics->addMarSystem(mng.create("StandardDeviation", "std"));
	mng.registerPrototype("Statistics", statistics->clone());

	// weka output 
	MarSystem *wsink = mng.create("WekaSink","wsink");

	// Build the overall feature calculation network 
	MarSystem* featureNetwork = mng.create("Series", "featureNetwork");

	featureNetwork->addMarSystem(src->clone());
	featureNetwork->addMarSystem(mng.create("Features", "features"));
	featureNetwork->addMarSystem(mng.create("Memory", "memory"));
	featureNetwork->updctrl("Memory/memory/mrs_natural/memSize", memSize);
	featureNetwork->addMarSystem(mng.create("Statistics", "statistics"));  

	// add network to accumulator
	acc->addMarSystem(featureNetwork->clone());

	// Final network compute 30-second statistics 
	MarSystem* total = mng.create("Series", "total");
	total->addMarSystem(acc->clone());
	total->addMarSystem(mng.create("Statistics", "statistics2"));
	// total->addMarSystem(mng.create("Mean", "mn2"));
	total->addMarSystem(wsink->clone());

	// update controls 
	total->updctrl("mrs_natural/inSamples", MRS_DEFAULT_SLICE_NSAMPLES);
	total->updctrl("Accumulator/acc/Series/featureNetwork/" + src->getType() + "/src/mrs_natural/pos", offset);      

	mrs_natural wc = 0;
	mrs_natural samplesPlayed =0;

	// main loop for extracting the features 
	string className = "";

	total->updctrl("Accumulator/acc/Series/featureNetwork/SoundFileSource/src/mrs_string/filename", sfName);
	wc = 0;  	  
	samplesPlayed = 0;

	total->updctrl("WekaSink/wsink/mrs_natural/nLabels", (mrs_natural)3);
	if (wekafname == EMPTYSTRING) 
		total->updctrl("WekaSink/wsink/mrs_string/filename", "weka2.arff");
	else 
		total->updctrl("WekaSink/wsink/mrs_string/filename", wekafname);  

	// total->tick();

	for (int r = 0; r < tline.numRegions(); r++)
	{
		cout << "start = " << tline.regionStart(r) << endl;
		cout << "end = " << tline.regionEnd(r) << endl;

		total->updctrl("Accumulator/acc/Series/featureNetwork/SoundFileSource/src/mrs_natural/pos", (mrs_natural)tline.regionStart(r) * tline.lineSize());
		total->updctrl("mrs_natural/inSamples", tline.lineSize());
		if (tlineName == EMPTYSTRING)
		{
			if ((tline.regionClass(r) > 0) && (tline.regionClass(r) != 4))//[?]
			{
				total->updctrl("WekaSink/wsink/mrs_natural/label", tline.regionClass(r)-1);
			}
		}
		else
			total->tick();
	}

	if (pluginName == EMPTYSTRING) // output to stdout 
		cout << (*total) << endl;      
	else 
	{
		ofstream oss(pluginName.c_str());
		oss << (*total) << endl;
	}
}