C++ realvec::create方法代码示例

void
TranscriberExtract::getAllFromAudio(const std::string audioFilename, realvec&
                                    pitchList, realvec& ampList,
                                    realvec& boundaries)
{
	MarSystem* pitchSink = mng.create("RealvecSink", "pitchSink");
	MarSystem* ampSink = mng.create("RealvecSink", "ampSink");

	MarSystem* pnet = mng.create("Series", "pnet");
	mrs_real srate = addFileSource(pnet, audioFilename);
// TODO: double the number of observations?
//	pnet->updControl("SoundFileSource/src/mrs_natural/inSamples",256);
//	pnet->addMarSystem(mng.create("ShiftInput", "shift"));
//	pnet->updControl("ShiftInput/shift/mrs_natural/winSize",512);

	MarSystem* fanout = mng.create("Fanout", "fanout");
	fanout->addMarSystem(makePitchNet(srate, 100.0, pitchSink));
	fanout->addMarSystem(makeAmplitudeNet(ampSink));
	pnet->addMarSystem(fanout);

	while ( pnet->getctrl("mrs_bool/hasData")->to<mrs_bool>() )
		pnet->tick();

	pitchList = getPitchesFromRealvecSink(pitchSink, srate);
	ampList = getAmpsFromRealvecSink(ampSink);
	boundaries.create(2);
	boundaries(0) = 0;
	boundaries(1) = pitchList.getSize();
	delete pnet;
}

void
HWPS::discretize(const realvec& peakSetWrapFreqs, const realvec& peakAmps,
                 const mrs_natural& histSize, realvec& resultHistogram)
{
  mrs_natural index;

  resultHistogram.create(histSize);

  for (mrs_natural i=0 ; i<peakSetWrapFreqs.getSize() ; ++i)
  {
    index = (mrs_natural) fmod(floor(peakSetWrapFreqs(i)*histSize+.5), histSize);
    resultHistogram(index) += peakAmps(i);
  }
}

/**
 * Function: recvUDP
 * Description: Receive a vector from a peer on a UDP socket connection.
 */
int NetworkSocket::recvUDP ( realvec& out )  {

  int status = 0;

  // assume a size 512 vector
  mrs_natural inSamples = getctrl("mrs_natural/inSamples")->to<mrs_natural>();
  mrs_natural inObservations = getctrl("mrs_natural/inObservations")->to<mrs_natural>();


  mrs_real* buffer = new mrs_real[(inSamples*inObservations)+3];
  int cliLen = sizeof(cliAddr);
#ifndef MARSYAS_CYGWIN
  status = ::recvfrom(s_sock, buffer, sizeof(mrs_real) *
                      ((inSamples*inObservations)+3), MSG_WAITALL,
                      (struct sockaddr *) &cliAddr, (socklen_t *)&cliLen);
#else
  status = ::recvfrom(s_sock, buffer, sizeof(mrs_real) *
                      ((inSamples*inObservations)+3), MSG_NOSIGNAL,
                      (struct sockaddr *) &cliAddr, (socklen_t *)&cliLen);

#endif

  if ( status <= 0 ) {
    MRSERR("Could not receive UDP data...");
    return 0;
  } else {
    updctrl("mrs_natural/inSamples", (mrs_natural) buffer[0]);
    updctrl("mrs_natural/inObservations",(mrs_natural) buffer[1]);
    updctrl("mrs_real/israte", buffer[2]);
  }

  // process the data to an output vector...
  out.create( inObservations, inSamples );
  mrs_real* data = out.getData();

  int i;
  for ( i = 0; i < 512; i++ ) {
    // *( data + i ) = buffer[i+3];
  }

  // delete [] buffer;
  return status;
}

/**
 * Function: recvTCP
 * Description: Receive a vector from a peer on a TCP socket connection.
 */
int NetworkSocket::recvTCP ( realvec& out )
{

  // create our slice with updated controls
  mrs_natural inSamples = getctrl("mrs_natural/inSamples")->to<mrs_natural>();
  mrs_natural inObservations = getctrl("mrs_natural/inObservations")->to<mrs_natural>();

  out.create(inObservations, inSamples);
  mrs_real* data = out.getData();


#ifndef MARSYAS_CYGWIN
  return ::recv ( client_d, data, sizeof(mrs_real)*(inObservations*inSamples),
                  MSG_WAITALL );
#else
  return ::recv ( client_d, data, sizeof(mrs_real)*(inObservations*inSamples),
                  MSG_NOSIGNAL);
#endif

}

void
peakView::toTable(realvec& vecTable)
{
  //resize and initialize the table (assuming the largest possible number of peaks + the header for now...)
  vecTable.create(frameMaxNumPeaks_*numFrames_+1, nbPkParameters);


  //In Table format, the 1st row is a "header row"
  vecTable(0, 0) = -1;
  vecTable(0, 1) =  fs_;
  vecTable(0, 2) =  frameSize_;
  vecTable(0, 3) =  frameMaxNumPeaks_;
  vecTable(0, 4) =  numFrames_;
  vecTable(0, 5) = -1;
  vecTable(0, pkGroup) = -2;
  for (mrs_natural i = pkGroup+1 ; i < nbPkParameters ; ++i) //i = pkGroup or i = pkGroup+1 [?]
    vecTable(0, i)=0;


  //fill the table with peak data
  mrs_natural l = 1; //l = peak index for table format (i.e. row index)
  for (mrs_natural j=0 ; j < vec_.getCols(); ++j) //j = frame index
    for (mrs_natural i=0 ; i < frameMaxNumPeaks_; ++i) //i = peak index
    {
      //just output existing peaks at each frame (i.e. freq != 0)
      if(vec_(i, j) != 0.0)
      {
        for(mrs_natural k = 0; k < nbPkParameters; k++)// k = parameter index
          vecTable(l, k) = (*this)(i, pkParameter(k), j);
        l++;
      }
    }

  //resize the table to the correct (i.e. possibly smaller)
  //number of peaks (i.e. nr of rows)

  vecTable.stretch(l, nbPkParameters);
}

int
MATLABengine::getVariable(std::string MATLABname, realvec& value)
{
  mxArray* mxVector = engGetVariable(engine_, MATLABname.c_str());

  if (mxVector == NULL)
  {
    MRSERR("MATLABengine::getVariable(\"" << MATLABname << "\", realvec&) error: variable does not exist in MATLAB!");
    return -1;
  }
  else {
    if (mxGetNumberOfDimensions(mxVector) > 2)
    {
      MRSERR("MATLABengine::getVariable(\"" << MATLABname << "\", realvecl&): MATLAB array with more than 2 dimensions!");
      return -1;
    }

    if(mxIsComplex(mxVector))
    {
      MRSWARN("MATLABengine::getVariable(\"" << MATLABname << "\", realvec&): MATLAB complex array => getting real part only!");
    }

    //number of rows and cols for the 2D MATLAB array
    //resize realvec accordingly
    value.create(mxGetDimensions(mxVector)[0],mxGetDimensions(mxVector)[1]);
    for(unsigned int i= 0; i < mxGetNumberOfElements(mxVector); ++i)
    {
      //both Marsyas realvec and MATLAB arrays are column-wise,
      //so they can be copied as linear vectors
      value(i) = (mrs_real)(*(mxGetPr(mxVector)+i));
    }

    mxDestroyArray(mxVector);
    return 0;
  }
}

mrs_natural
realvec::invert(realvec& res)
{
  if (rows_ != cols_)
  {
    MRSERR("realvec::invert() - matrix should be square!");
    res.create(0);
    return -1;
  }
  if (this != &res)
  {
    mrs_natural rank;
    mrs_natural r,c,i;
    mrs_real temp;

    res.create(rows_, cols_);

    rank = 0;
    for (r = 0; r < rows_; ++r)
      for (c=0; c < cols_; ++c)
      {
        if (r == c)
          res(r,c) = 1.0;
        else
          res(r,c) = 0.0;
      }
    for (i = 0; i < rows_; ++i)
    {
      if ((*this)(i,i) == 0)
      {
        for (r = i; r < rows_; ++r)
          for (c = 0; c < cols_; ++c)
          {
            (*this)(i,c) += (*this)(r,c);
            res(i,c) += res(r,c);
          }
      }
      for (r = i; r < rows_; ++r)
      {
        temp = (*this)(r,i);
        if (temp != 0)
          for (c =0; c < cols_; ++c)
          {
            (*this)(r,c) /= temp;
            res(r,c) /= temp;
          }
      }
      if (i != rows_-1)
      {
        for (r = i+1; r < rows_; ++r)
        {
          temp = (*this)(r,i);
          if (temp != 0.0)
            for (c=0; c < cols_; ++c)
            {
              (*this)(r,c) -= (*this)(i,c);
              res(r,c) -= res(i,c);
            }
        }
      }
    }
    for (i=1; i < rows_; ++i)
      for (r=0; r < i; ++r)
      {
        temp = (*this)(r,i);
        for (c=0; c < cols_; ++c)
        {
          (*this)(r,c) -= (temp * (*this)(i,c));
          res(r,c) -= (temp * res(i,c));
        }
      }
    for (r =0; r < rows_; ++r)
      for (c=0; c < cols_; ++c)
        (*this)(r,c) = res(r,c);
    return rank;
  }
  else
  {
    res.create(0);
    MRSERR("realvec::invert() - inPlace operation not supported - returning empty result vector!");
    return -1;
  }
}