Marsyas: /home/marsyas/marsyas/src/marsyas/NormMaxMin.cpp Source File

00001 /*
00002 ** Copyright (C) 1998-2006 George Tzanetakis <gtzan@cs.uvic.ca>
00003 **  
00004 ** This program is free software; you can redistribute it and/or modify
00005 ** it under the terms of the GNU General Public License as published by
00006 ** the Free Software Foundation; either version 2 of the License, or
00007 ** (at your option) any later version.
00008 ** 
00009 ** This program is distributed in the hope that it will be useful,
00010 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
00011 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012 ** GNU General Public License for more details.
00013 ** 
00014 ** You should have received a copy of the GNU General Public License
00015 ** along with this program; if not, write to the Free Software 
00016 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00017 */
00018 
00019 #include "NormMaxMin.h"
00020 
00021 using std::ostringstream;
00022 using namespace Marsyas;
00023 
00024 NormMaxMin::NormMaxMin(mrs_string name):MarSystem("NormMaxMin",name)
00025 {
00026 
00027   init_ = false;
00028 
00029   addControls();            
00030   prev_mode_ = "predict";
00031 }
00032 
00033 NormMaxMin::NormMaxMin(const NormMaxMin& a): MarSystem(a) 
00034 {
00035   prev_mode_ = "predict";
00036   
00037   lowerPtr_ = getctrl("mrs_real/lower");
00038   upperPtr_ = getctrl("mrs_real/upper");
00039   initPtr_ = getctrl("mrs_bool/init");
00040   maximumsPtr_ = getctrl("mrs_realvec/maximums");
00041   minimumsPtr_ = getctrl("mrs_realvec/minimums");
00042 }
00043 
00044 NormMaxMin::~NormMaxMin()
00045 {
00046 }
00047 
00048 MarSystem* 
00049 NormMaxMin::clone() const 
00050 {
00051   return new NormMaxMin(*this);
00052 }
00053 
00054 void 
00055 NormMaxMin::addControls()
00056 {
00057   addctrl("mrs_real/lower", 0.0, lowerPtr_);
00058   addctrl("mrs_real/upper", 1.0, upperPtr_);
00059   maximums_.create(1);
00060   minimums_.create(1);
00061   addctrl("mrs_realvec/maximums", maximums_, maximumsPtr_);
00062   addctrl("mrs_realvec/minimums", minimums_, minimumsPtr_);
00063   setctrlState("mrs_realvec/maximums", true);
00064   setctrlState("mrs_realvec/minimums", true);
00065   addctrl("mrs_string/mode", "train");
00066   addctrl("mrs_string/domain", "observations");
00067     
00068   addctrl("mrs_natural/ignoreLast", 0);
00069   addctrl("mrs_bool/init", false, initPtr_);
00070   setctrlState("mrs_bool/init", true);
00071 }
00072 
00073 void
00074 NormMaxMin::myUpdate(MarControlPtr sender)
00075 {
00076   MRSDIAG("NormMaxMin.cpp - NormMaxMin:myUpdate");
00077 
00078   MarSystem::myUpdate(sender);
00079   
00080   inObservations_ = ctrl_inObservations_->to<mrs_natural>();
00081   
00082   init_ = initPtr_->to<mrs_bool>();
00083   
00084   mrs_natural msize = maximumsPtr_->to<mrs_realvec>().getSize();
00085   mrs_natural nsize = maximums_.getSize();
00086   
00087   if (msize != nsize) 
00088     {
00089       maximums_.stretch(msize);
00090       minimums_.stretch(msize);
00091     }
00092   
00093   if (!init_)
00094     {
00095       maximums_.stretch(inObservations_);
00096       minimums_.stretch(inObservations_);
00097       
00098       maximums_.setval(-MAXREAL);
00099       minimums_.setval(MAXREAL);
00100       maximumsPtr_->setValue(maximums_, NOUPDATE);
00101       minimumsPtr_->setValue(minimums_, NOUPDATE);  
00102     }
00103 
00104   mrs_string mode = getctrl("mrs_string/mode")->to<mrs_string>();
00105   if (mode == "predict")
00106     {
00107       minimums_ = minimumsPtr_->to<mrs_realvec>();
00108       maximums_ = maximumsPtr_->to<mrs_realvec>();
00109     }
00110 
00111 }
00112 
00113 void 
00114 NormMaxMin::myProcess(realvec& in, realvec& out)
00115 {
00116   init_ = true;
00117   setctrl(initPtr_, init_);
00118   
00119   lower_ = lowerPtr_->to<mrs_real>();
00120   upper_ = upperPtr_->to<mrs_real>();
00121   
00122   if (lower_ > upper_) 
00123     {
00124       MRSWARN("Lower is greater than upper");
00125       return;
00126     }
00127   
00128   range_ = upper_ - lower_;
00129 
00130   domain_ = getctrl("mrs_string/domain")->to<mrs_string>();
00131 
00132   if (domain_ == "slices") 
00133     do_slices(in, out);
00134   else if (domain_ == "samples") 
00135     do_samples(in, out);
00136   else 
00137     do_observations(in, out);
00138   
00139   prev_mode_ = mode_;
00140 }
00141 
00142 
00143 void 
00144 NormMaxMin::do_observations(realvec& in, realvec& out) {
00145   mrs_natural t,o;
00146   init_ = true;
00147   setctrl(initPtr_, init_);
00148   
00149   lower_ = lowerPtr_->to<mrs_real>();
00150   upper_ = upperPtr_->to<mrs_real>();
00151   
00152   mode_ = getctrl("mrs_string/mode")->to<mrs_string>();
00153   mrs_natural ignoreLast = getctrl("mrs_natural/ignoreLast")->to<mrs_natural>();
00154 
00155   // sness
00156   domain_ = getctrl("mrs_string/domain")->to<mrs_string>();
00157   
00158   range_ = upper_ - lower_;
00159 
00160   if (mode_ == "twopass") 
00161     {
00162 
00163 
00164 
00165       // first pass calculate min/max limits
00166       for (o=0; o < inObservations_; o++)
00167         for (t = 0; t < inSamples_; t++)
00168           {
00169             if (in(o,t) > maximums_(o))
00170               maximums_(o) = in(o,t);
00171             if (in(o,t) < minimums_(o)) 
00172               minimums_(o) = in(o,t);
00173             out(o,t) = in(o,t);
00174 
00175 
00176           }
00177 
00178 
00179 
00180       // second pass for normalization 
00181       for (o=0; o < inObservations_-ignoreLast; o++)
00182           for (t = 0; t < inSamples_; t++)
00183               out(o,t) = lower_ + range_ * ((in(o,t) - minimums_(o)) / (maximums_(o) - minimums_(o)));
00184       
00185     }
00186   
00187   
00188   if ((prev_mode_ == "predict") && (mode_ == "train"))
00189   {
00190       maximums_.setval(-MAXREAL);
00191       minimums_.setval(MAXREAL);
00192       maximumsPtr_->setValue(maximums_, NOUPDATE);
00193       minimumsPtr_->setValue(minimums_, NOUPDATE);  
00194   }
00195   
00196   if (mode_ == "train")
00197   {
00198       // first pass calculate min/max limits
00199       for (o=0; o < inObservations_; o++)
00200           for (t = 0; t < inSamples_; t++)
00201           {
00202               if (in(o,t) > maximums_(o))
00203                   maximums_(o) = in(o,t);
00204               if (in(o,t) < minimums_(o))   
00205                   minimums_(o) = in(o,t);
00206               out(o,t) = in(o,t);
00207           }
00208       
00209       setctrl(maximumsPtr_, maximums_);
00210       setctrl(minimumsPtr_, minimums_);  
00211 
00212   }
00213   
00214   
00215   if ((prev_mode_ == "train")&&(mode_ == "predict"))    
00216   {
00217       maximums_ = maximumsPtr_->to<mrs_realvec>();
00218       minimums_ = minimumsPtr_->to<mrs_realvec>();
00219   }
00220   
00221   
00222   if (mode_ == "predict")
00223   {
00224       // second pass for normalization 
00225       for (o=0; o < inObservations_-ignoreLast; o++)
00226           for (t = 0; t < inSamples_; t++)
00227               out(o,t) = lower_ + range_ * ((in(o,t) - minimums_(o)) / (maximums_(o) - minimums_(o)));
00228   }
00229   
00230 }
00231 
00232 
00233 void 
00234 NormMaxMin::do_samples(realvec& in, realvec& out) 
00235 {
00236     mrs_natural o,t;
00237   init_ = true;
00238   setctrl(initPtr_, init_);
00239   
00240   lower_ = lowerPtr_->to<mrs_real>();
00241   upper_ = upperPtr_->to<mrs_real>();
00242   
00243   mode_ = getctrl("mrs_string/mode")->to<mrs_string>();
00244   mrs_natural ignoreLast = getctrl("mrs_natural/ignoreLast")->to<mrs_natural>();
00245 
00246   domain_ = getctrl("mrs_string/domain")->to<mrs_string>();
00247   
00248   range_ = upper_ - lower_;
00249 
00250   if (mode_ == "twopass") 
00251     {
00252       // first pass calculate min/max limits
00253       for (t=0; t < inSamples_; t++)
00254         for (o = 0; o < inObservations_; o++)
00255           {
00256             if (in(o,t) > maximums_(t))
00257               maximums_(t) = in(o,t);
00258             if (in(o,t) < minimums_(t)) 
00259               minimums_(t) = in(o,t);
00260             out(o,t) = in(o,t);
00261           }
00262       // second pass for normalization 
00263       for (t=0; t < inSamples_-ignoreLast; t++)
00264           for (o = 0; o < inObservations_; o++)
00265           {
00266               out(o,t) = lower_ + range_ * ((in(o,t) - minimums_(t)) / (maximums_(t) - minimums_(t)));
00267           }
00268     }
00269 
00270   if ((prev_mode_ == "predict") && (mode_ == "train"))
00271     {
00272       maximums_.setval(-MAXREAL);
00273       minimums_.setval(MAXREAL);
00274       maximumsPtr_->setValue(maximums_, NOUPDATE);
00275       minimumsPtr_->setValue(minimums_, NOUPDATE);  
00276     }
00277   
00278   if (mode_ == "train")
00279     {
00280       // first pass calculate min/max limits
00281       for (t = 0; t < inSamples_; t++)
00282         for (o=0; o < inObservations_; o++)
00283           {
00284             if (in(o,t) > maximums_(t))
00285               maximums_(t) = in(o,t);
00286             if (in(o,t) < minimums_(t)) 
00287               minimums_(t) = in(o,t);
00288             out(o,t) = in(o,t);
00289         
00290           }
00291       
00292       setctrl(maximumsPtr_, maximums_);
00293       setctrl(minimumsPtr_, minimums_);  
00294     }
00295 
00296 
00297   if ((prev_mode_ == "train")&&(mode_ == "predict"))    
00298     {
00299       maximums_ = maximumsPtr_->to<mrs_realvec>();
00300       minimums_ = minimumsPtr_->to<mrs_realvec>();
00301     }
00302   
00303 
00304   if (mode_ == "predict")
00305     {
00306       // second pass for normalization 
00307       for (t = 0; t < inSamples_-ignoreLast; t++)
00308         for (o=0; o < inObservations_; o++)
00309           {
00310               out(o,t) = lower_ + range_ * ((in(o,t) - minimums_(t)) / (maximums_(t) - minimums_(t)));
00311           }
00312     }
00313 
00314 }
00315 
00316 void 
00317 NormMaxMin::do_slices(realvec& in, realvec& out) 
00318 {
00319 
00320     mrs_natural o,t;
00321   maximums_(0) = -MAXREAL;
00322   minimums_(0) = MAXREAL;
00323 
00324   init_ = true;
00325   setctrl(initPtr_, init_);
00326   
00327   lower_ = lowerPtr_->to<mrs_real>();
00328   upper_ = upperPtr_->to<mrs_real>();
00329   
00330   mode_ = getctrl("mrs_string/mode")->to<mrs_string>();
00331   mrs_natural ignoreLast = getctrl("mrs_natural/ignoreLast")->to<mrs_natural>();
00332 
00333   domain_ = getctrl("mrs_string/domain")->to<mrs_string>();
00334   
00335   range_ = upper_ - lower_;
00336 
00337   if (mode_ == "twopass") {
00338     // first pass calculate min/max limits
00339     for (o=0; o < inObservations_; o++) 
00340       for (t = 0; t < inSamples_; t++) 
00341         {
00342           if (in(o,t) > maximums_(0))
00343             maximums_(0) = in(o,t);
00344           if (in(o,t) < minimums_(0))   
00345             minimums_(0) = in(o,t);
00346           out(o,t) = in(o,t);
00347         }
00348     // second pass for normalization 
00349     for (o=0; o < inObservations_-ignoreLast; o++) 
00350       for (t = 0; t < inSamples_; t++) 
00351         {
00352             out(o,t) = lower_ + range_ * ((in(o,t) - minimums_(0)) / (maximums_(0) - minimums_(0)));
00353         }
00354   }
00355 
00356   if ((prev_mode_ == "predict") && (mode_ == "train"))
00357     {
00358       maximums_.setval(-MAXREAL);
00359       minimums_.setval(MAXREAL);
00360       maximumsPtr_->setValue(maximums_, NOUPDATE);
00361       minimumsPtr_->setValue(minimums_, NOUPDATE);  
00362     }
00363   
00364   if (mode_ == "train")
00365     {
00366       // first pass calculate min/max limits
00367       for (o=0; o < inObservations_; o++)
00368         for (t = 0; t < inSamples_; t++)
00369           {
00370             if (in(o,t) > maximums_(0))
00371               maximums_(0) = in(o,t);
00372             if (in(o,t) < minimums_(0)) 
00373               minimums_(0) = in(o,t);
00374             out(o,t) = in(o,t);
00375         
00376           }
00377       
00378       setctrl(maximumsPtr_, maximums_);
00379       setctrl(minimumsPtr_, minimums_);  
00380     }
00381 
00382 
00383   if ((prev_mode_ == "train")&&(mode_ == "predict"))    
00384     {
00385       maximums_ = maximumsPtr_->to<mrs_realvec>();
00386       minimums_ = minimumsPtr_->to<mrs_realvec>();
00387     }
00388   
00389 
00390   if (mode_ == "predict")
00391     {
00392       // second pass for normalization 
00393       for (o=0; o < inObservations_-ignoreLast; o++)
00394         for (t = 0; t < inSamples_; t++)
00395           {
00396               out(o,t) = lower_ + range_ * ((in(o,t) - minimums_(0)) / (maximums_(0) - minimums_(0)));
00397           }
00398     }
00399 
00400 }