Marsyas  0.6.0-alpha
/usr/src/RPM/BUILD/marsyas-0.6.0/src/marsyas/marsystems/AveragingPattern.cpp
Go to the documentation of this file.
00001 #include "AveragingPattern.h"
00002 
00003 using std::ostringstream;
00004 using namespace Marsyas;
00005 
00006 AveragingPattern::AveragingPattern(mrs_string name):MarSystem("AveragingPattern", name)
00007 {
00008   addControls();
00009 }
00010 
00011 AveragingPattern::AveragingPattern(const AveragingPattern& a):MarSystem(a)
00012 {
00013   ctrl_sizes_ = getctrl("mrs_realvec/sizes");
00014   ctrl_alignment_ = getctrl("mrs_realvec/alignment");
00015   ctrl_counts_ = getctrl("mrs_realvec/counts");
00016   ctrl_input_ = getctrl("mrs_bool/input");
00017   ctrl_countVector_ = getctrl("mrs_realvec/countVector");
00018   ctrl_setCountVector_ = getctrl("mrs_bool/setCountVector");
00019 }
00020 
00021 AveragingPattern::~AveragingPattern()
00022 {
00023 }
00024 
00025 MarSystem*
00026 AveragingPattern::clone() const
00027 {
00028   return new AveragingPattern(*this);
00029 }
00030 
00031 void
00032 AveragingPattern::addControls()
00033 {
00034   addControl("mrs_realvec/sizes", realvec(), ctrl_sizes_);
00035   addControl("mrs_realvec/alignment", realvec(), ctrl_alignment_);
00036   addControl("mrs_realvec/counts", realvec(), ctrl_counts_);
00037   addControl("mrs_bool/input", true, ctrl_input_);
00038   addControl("mrs_realvec/countVector", realvec(), ctrl_countVector_);
00039   addControl("mrs_bool/setCountVector", false, ctrl_setCountVector_);
00040 }
00041 
00042 void
00043 AveragingPattern::myUpdate(MarControlPtr sender)
00044 {
00045   (void) sender;  //suppress warning of unused parameter(s)
00046   // The output is a same size matrix with the input
00047 
00048   // forward flow propagation
00049   if(ctrl_input_->to<mrs_bool>()) {
00050     ctrl_onObservations_->setValue(ctrl_inObservations_, NOUPDATE);
00051     ctrl_onSamples_->setValue(ctrl_inSamples_, NOUPDATE);
00052   } else {
00053     realvec formaxsize = ctrl_sizes_->to<mrs_realvec>();
00054     formaxsize(0) = 0;
00055     mrs_natural tmpNTL = ctrl_inObservations_->to<mrs_natural>()/formaxsize.getSize();
00056     ctrl_onObservations_->setValue(tmpNTL*(formaxsize.getSize()-1), NOUPDATE);
00057     ctrl_onSamples_->setValue(formaxsize.maxval(),NOUPDATE);
00058   }
00059   ctrl_osrate_->setValue(ctrl_osrate_, NOUPDATE);
00060   ostringstream oss;
00061   for(mrs_natural o=0; o<ctrl_onObservations_->to<mrs_natural>(); ++o)
00062     oss << "AveragingPattern_" << o << ",";
00063   ctrl_onObsNames_->setValue(oss.str(), NOUPDATE);
00064 
00065   const realvec& tmpvec = ctrl_sizes_->to<mrs_realvec>();
00066   mrs_natural insize = ctrl_inSamples_->to<mrs_natural>();
00067   if(tmpvec.getRows() == 1 && tmpvec.getCols() >= 2)
00068   {
00069     sizes_.create(tmpvec.getCols());
00070     for(mrs_natural i=0; i<tmpvec.getCols(); ++i)
00071     {
00072       sizes_(i) = (mrs_natural)tmpvec(0,i);
00073     }
00074     for(mrs_natural i=0; i<tmpvec.getCols(); ++i)
00075     {
00076       if(sizes_(i) > insize)
00077         sizes_(i) = insize;
00078     }
00079   }
00080   else if(tmpvec.getRows() >= 2 && tmpvec.getCols() == 1)
00081   {
00082     sizes_.create(tmpvec.getRows());
00083     for(mrs_natural i=0; i<tmpvec.getRows(); ++i)
00084     {
00085       sizes_(i) = (mrs_natural)tmpvec(i,0);
00086     }
00087     for(mrs_natural i=0; i<tmpvec.getRows(); ++i)
00088     {
00089       if(sizes_(i) > insize)
00090         sizes_(i) = insize;
00091     }
00092   }
00093 
00094   mrs_natural numVec = sizes_.getSize();
00095   mrs_natural dimVec = ctrl_inObservations_->to<mrs_natural>()/numVec;
00096   mrs_natural templateSize = 0;
00097   for(mrs_natural i=1; i<numVec; ++i)
00098   {
00099     templateSize += (mrs_natural)sizes_(i);
00100   }
00101   const realvec& tmpvec2 = ctrl_countVector_->to<mrs_realvec>();
00102   if(tmpvec2.getSize() > 0 && ctrl_setCountVector_->to<mrs_bool>())
00103     countvector_ = tmpvec2;
00104   else
00105     countvector_.create(templateSize);
00106 
00107   average_.create(dimVec,templateSize);
00108   counts_.create(numVec);
00109   beginPos_.create(numVec-1);
00110   endPos_.create(numVec-1);
00111   beginPos_(0) = 0;
00112 
00113   for(mrs_natural l=1; l<numVec-1; l++)
00114   {
00115     beginPos_(l) = sizes_(l) + beginPos_(l-1);
00116   }
00117   for(mrs_natural l=0; l<numVec-1; l++)
00118   {
00119     endPos_(l) = beginPos_(l) + sizes_(l+1);
00120   }
00121 }
00122 
00123 void
00124 AveragingPattern::myProcess(realvec& in, realvec& out)
00125 {
00126 
00127   mrs_natural j, k, l;
00128   if(inSamples_>0)
00129   {
00130     const realvec& alignment = ctrl_alignment_->to<mrs_realvec>();
00131 
00132     if(sizes_.getSize() > 0 && alignment.getSize() > 0)
00133     {
00134       mrs_natural numVec = sizes_.getSize();
00135       mrs_natural dimVec = ctrl_inObservations_->to<mrs_natural>()/numVec;
00136       mrs_natural templateSize = 0;
00137       mrs_natural tmpNatural = 0;
00138       for(mrs_natural i=1; i<numVec; ++i)
00139       {
00140         templateSize += (mrs_natural)sizes_(i);
00141       }
00142 
00143       if(!ctrl_setCountVector_->to<mrs_bool>())
00144       {
00145         for(mrs_natural i=0; i<countvector_.getSize(); ++i)
00146         {
00147           countvector_(i) = 0;
00148         }
00149       }
00150       for(mrs_natural i=0; i<counts_.getSize(); ++i) {
00151         counts_(i) = 0;
00152       }
00153       // initialize according to countVector
00154       if(ctrl_setCountVector_->to<mrs_bool>())
00155       {
00156         for(k=0; k<numVec-1; k++)
00157         {
00158           for(mrs_natural i=0; i<sizes_(k+1); ++i)
00159           {
00160             for(j=0; j<dimVec; j++)
00161             {
00162               average_(j,i+tmpNatural) = countvector_(i+tmpNatural)*out(j+dimVec*k,i);
00163             }
00164           }
00165           tmpNatural += (mrs_natural)sizes_(k+1);
00166         }
00167         tmpNatural = 0;
00168       }
00169       else
00170       {
00171         for(mrs_natural i=0; i<average_.getCols(); ++i)
00172         {
00173           for(j=0; j<dimVec; j++)
00174           {
00175             average_(j,i) = 0;
00176           }
00177         }
00178       }
00179 
00180       mrs_bool b_begin = false;
00181 
00182       // averaging
00183       for(k=0; k<alignment.getRows(); k++)
00184       {
00185         if(alignment(k,0)>=0 && alignment(k,1)>=0)
00186         {
00187           for(l=0; l<numVec-1; l++)
00188           {
00189             if(beginPos_(l) == alignment(k,1))
00190             {
00191               b_begin = true;
00192               break;
00193             }
00194             else if(endPos_(l)-1 == alignment(k,1))
00195             {
00196               if(b_begin)
00197                 counts_(l+1) ++;
00198               b_begin = false;
00199               break;
00200             }
00201           }
00202           for(j=0; j<dimVec; j++)
00203           {
00204             average_(j,(mrs_natural)alignment(k,1)) += in(j,(mrs_natural)alignment(k,0));
00205           }
00206           countvector_((mrs_natural)alignment(k,1))++;
00207         }
00208       }
00209       for(mrs_natural n=0; n<templateSize; ++n)
00210       {
00211         if(countvector_(n)>0)
00212         {
00213           for(j=0; j<dimVec; j++)
00214           {
00215             average_(j,n) /= countvector_(n);
00216           }
00217         }
00218       }
00219       if(ctrl_input_->to<mrs_bool>())
00220       {
00221         for(mrs_natural i=0; i<sizes_(0); ++i)
00222         {
00223           for(j=0; j<dimVec; j++)
00224           {
00225             out(j,i) = in(j,i);
00226           }
00227         }
00228         l=0;
00229       }
00230       else
00231         l=1;
00232       for(k=1; k<numVec; k++)
00233       {
00234         for(mrs_natural n=0; n<sizes_(k); ++n)
00235         {
00236           if(countvector_(n+tmpNatural)>0)
00237           {
00238             for(j=0; j<dimVec; j++)
00239             {
00240               out(j+(k-l)*dimVec,n) = average_(j,n+tmpNatural);
00241             }
00242           }
00243           else
00244           {
00245             for(j=0; j<dimVec; j++)
00246             {
00247               out(j+(k-l)*dimVec,n) = in(j+k*dimVec,n);
00248             }
00249           }
00250         }
00251         tmpNatural += (mrs_natural)sizes_(k);
00252       }
00253       for(l=1; l<numVec; l++)
00254       {
00255         counts_(0) += counts_(l);
00256       }
00257       ctrl_counts_->setValue(counts_);
00258       ctrl_countVector_->setValue(countvector_);
00259     }
00260     else
00261     {
00262       MRSWARN("AveragingPattern:myProcess - invalid sizes and alignment vectors (does not output a real value)!");
00263     }
00264   }
00265 }
00266