C++ RawData类代码示例

SP_RESULT load_calc(const char *load_file_name,
               const char *file_name,
               EPAnalysis& ep,
               bool playback) {
    RawData data;
    Capture c;
    char fn_buffer [128]="";
    
    data.loadWav(stringFile(load_file_name,".wav",fn_buffer));
    ep.Initial(&data);
    ep.reCalcAllData();
    ep.saveMatlab(stringFile(file_name,".dat",fn_buffer));
    
    if(playback)c.play(&data);
    
    ep.smooth();
    ep.saveMatlab(stringFile(file_name,"_smooth.dat",fn_buffer));
    ep.cut();
    ep.saveMatlab(stringFile(file_name,"_cut.dat",fn_buffer));
    
    //ep.smooth();
    //ep.cut();
    //ep.saveMatlab(stringFile(file_name,"_cut_2.m",fn_buffer));

    if(playback)c.play(&data);

    return SP_SUCCESS;
}

void capture(const char *save_file_name, RawData &data, bool playback) {
    DAEPAnalysis ep;
    AutoCapture c(&ep);
    
    Tip("Press any key to capture:");
    getch();
    puts("");
    Tip("Preparing...");
    sleep(1);
    
    char fn_buffer [128]="";
    
    Tip("Start talking");

    if(c.capture(&data)) {
        data.saveWav(stringFile(save_file_name,".wav",fn_buffer));
        
        //if(playback)c.play(&data);
        
        ep.smooth();
        ep.cut();
        
        if(playback) c.play(&data);
        
        data.saveWav(stringFile(save_file_name,"_cut.wav",fn_buffer));
    }
    else{
        ErrorLog("Capture error");
    }
}

int test_main(int argc, char *argv[])
{
	if (argc == 1) {
		// no argument, lets run like we are in "check"
		const char * srcdir = getenv("srcdir");

		BOOST_ASSERT(srcdir != NULL);
		g_testfile = std::string(srcdir);
		g_testfile += "/ljpegtest1.jpg";
	}
	else {
		g_testfile = argv[1];
	}

	RawData *decompData;
	File::Ptr s(new File(g_testfile.c_str()));
	RawContainer *container = new JfifContainer(s, 0);

	LJpegDecompressor decompressor(s.get(), container);

	decompData = decompressor.decompress();

	boost::crc_optimal<16, 0x1021, 0xFFFF, 0, false, false>  crc_ccitt2;
	const uint8_t * data = static_cast<uint8_t *>(decompData->data());
	size_t data_len = decompData->size();
	crc_ccitt2 = std::for_each( data, data + data_len, crc_ccitt2 );

	BOOST_CHECK(crc_ccitt2() == 0x20cc);

	delete decompData;
	delete container;

	return 0;
}

    bool AnimationLoader::isLoadable(const std::string& filename) {
        bfs::path animPath(filename);

        std::string animationFilename = animPath.string();

        try {
            RawData* data = m_vfs->open(animationFilename);

            if (data) {
                if (data->getDataLength() != 0) {
                    // TODO - this could be expanded to do more checks
                    TiXmlDocument doc;
                    doc.Parse(data->readString(data->getDataLength()).c_str());

                    if (doc.Error()) {
                        return false;
                    }
                }

                // done with data delete resource
                delete data;
                data = 0;
            }
        }
        catch (NotFound&) {
            return false;
        }

        return true;
    }

TEST(CryptingTest, EncryptString)
{
	RawData expression(StringToRawData("1234567890"));
	AesEncryptor encryptor(keyNormal, ivNormal);
	RawData encrypted;
	ASSERT_NO_THROW(encryptor.Encrypt(expression, encrypted));
	EXPECT_EQ(encrypted.size(), expression.size());
	EXPECT_NE(encrypted, expression);
}

void createNoise(const char * file_name){
    RawData data;
    int size =SAMPLES_IN_EACH_FRAME * FRAME_PER_SECOND * 60;
    data.setFrameNum(size);
    
    for(int i = 0;i<size;i++){
        int d = rand()%500+10000;
        data.setData(i,d);
    }
    data.saveWav(file_name);
}

void CommandManager::onResponse(CCHttpClient* client, CCHttpResponse* response)
{
    const string commandName = m_currentCommand->getName();
    if (response->isSucceed())
    {
        
        
        m_currentCommand->setCommandState(CommandStateResonsedProcessed);
        if (m_currentCommand->getMessageHandler())
        {
            int responseCode = response->getResponseCode();
            
            RawData* responseData = response->getResponseData();
            int responseDataSize = responseData->size();
            
            const char* data = &((*responseData)[0]);
            
            CCLOG("command %s response code %d length %d", commandName.c_str(), responseCode, responseDataSize);
            
            ResponseMessage message;
            bool decoded = message.ParseFromArray(data, responseDataSize);
            
            CCAssert(decoded, FORMAT("command %s decode fail data length=%d", commandName.c_str(), responseDataSize));
            
            m_currentCommand->getMessageHandler()->setMessage(&message);
            m_currentCommand->getMessageHandler()->execute();
            
        }
    }
    else
    {
        CCLOG("command %s fail errorcode=%d error message=%s", commandName.c_str(), response->getResponseCode(), response->getErrorBuffer());
        
        int resendCount = m_currentCommand->getResendCount();
        if (resendCount < MAX_RESEND_COUNT)
        {
            client->send(response->getHttpRequest());
            
            m_currentCommand->setResendCount(resendCount + 1);
            
            CCLOG("resend command %s for the %d time(s)", commandName.c_str(), resendCount);
        }
        else
        {
            CCMessageBox(FORMAT("Command fail %s", commandName.c_str()), "Error");
        }
        
    }
    
}

RawData KontrolerWejsciowy::porcjaDanych()
{
    RawData wynik;
    while(!mojaKolejka->empty())
    {
        wynik += mojaKolejka->front();
        mojaKolejka->pop();
        if(wynik.get_data_size() >= suggestedRawDataMaxSize)
        {
            break;
        }
    }
    return wynik;
}

SP_RESULT load_wav_file(const char *file_name, RawData &data) {
    DAEPAnalysis da_ep;
    Capture c;
    char fn_buffer[128] = "";
    data.loadWav(stringFile(file_name, ".wav", fn_buffer));
    da_ep.Initial(&data);
    da_ep.reCalcAllData();
//    da_ep.smooth();
//    da_ep.cut();

    return SP_SUCCESS;
}

void FillStream(std::iostream& strm, RawData& expression)
{
	static const std::string s_smallExpression("0123456789abcdefghijklmnopqrstuvwxyz");
	static const int iterationsCount = 10;

	for (int i = 0; i < iterationsCount; ++i)
	{
		strm << s_smallExpression;
	}
	size_t expressionSize = iterationsCount * s_smallExpression.size();
	expression.resize(expressionSize);
	strm.read(reinterpret_cast<char*>(&expression[0]), expressionSize);
	strm.seekg(0);
}

RawData *RawDataDump(float *ADC_import, int *ADCchan_import,  int ntdc, int *TDC_channel_import, float *TDC_value_import, float *QDC_import)
{
  RawData *raw = new RawData();
  raw->Init(raw);
  for(int i=0;i<ADCsize;i++)
  {
    raw->SetADCValue(i,ADC_import[i]);
    raw->SetADCChannel(i,ADCchan_import[i]);
    raw->SetADCCalibratedValue(i,ADCOffsets[i] + ADCGains[i] * ADC_import[i]);
  }
  //for(int i=0;i<ADCsize;i++)raw->SetADCCalibratedValue(i,ADCOffsets[i] + ADCGains[i] * ADC_import[i]);
  
  for(int n=0;n<ntdc;n++)
  {
    raw->SetTDCChannel(n,TDC_channel_import[n]);
    raw->SetTDCValue(n,TDC_value_import[n]);
  }
  
  for(int i=0;i<QDCsize;i++)raw->SetQDCValue(i,QDC_import[i]);
  return raw;
}

void Net::process()
{
   sockaddr sa;
   sa.sa_family = AF_UNSPEC;
   NetAddress srcAddress;
   RawData tmpBuffer;
   tmpBuffer.alloc(MaxPacketDataSize);

   for(;;)
   {
      socklen_t addrLen = sizeof(sa);
      S32 bytesRead = -1;

      if(udpSocket != InvalidSocket)
         bytesRead = recvfrom(udpSocket, (char *) tmpBuffer.data, MaxPacketDataSize, 0, &sa, &addrLen);

      if(bytesRead == -1)
         break;

      if(sa.sa_family == AF_INET)
         IPSocketToNetAddress((sockaddr_in *) &sa,  &srcAddress);
      else
         continue;

      if(bytesRead <= 0)
         continue;

      if(srcAddress.type == NetAddress::IPAddress &&
         srcAddress.netNum[0] == 127 &&
         srcAddress.netNum[1] == 0 &&
         srcAddress.netNum[2] == 0 &&
         srcAddress.netNum[3] == 1 &&
         srcAddress.port == netPort)
         continue;

      tmpBuffer.size = bytesRead;

      Net::smPacketReceive.trigger(srcAddress, tmpBuffer);
   }

   // process the polled sockets.  This blob of code performs functions
   // similar to WinsockProc in winNet.cc

   if (gPolledSockets.size() == 0)
      return;

   S32 optval;
   socklen_t optlen = sizeof(S32);
   S32 bytesRead;
   Net::Error err;
   bool removeSock = false;
   Socket *currentSock = NULL;
   sockaddr_in ipAddr;
   NetSocket incoming = InvalidSocket;
   char out_h_addr[1024];
   int out_h_length = 0;
   RawData readBuff;

   for (S32 i = 0; i < gPolledSockets.size();
      /* no increment, this is done at end of loop body */)
   {
      removeSock = false;
      currentSock = gPolledSockets[i];
      switch (currentSock->state)
      {
      case ::InvalidState:
         Con::errorf("Error, InvalidState socket in polled sockets  list");
         break;
      case ::ConnectionPending:
         // see if it is now connected
#ifdef TORQUE_OS_XENON
         // WSASetLastError has no return value, however part of the SO_ERROR behavior
         // is to clear the last error, so this needs to be done here.
         if( ( optval = _getLastErrorAndClear() ) == -1 ) 
#else
         if (getsockopt(currentSock->fd, SOL_SOCKET, SO_ERROR,
            (char*)&optval, &optlen) == -1)
#endif
         {
            Con::errorf("Error getting socket options: %s",  strerror(errno));

            Net::smConnectionNotify.trigger(currentSock->fd, Net::ConnectFailed);
            removeSock = true;
         }
         else
         {
            if (optval == EINPROGRESS)
               // still connecting...
               break;

            if (optval == 0)
            {
               // poll for writable status to be sure we're connected.
               bool ready = netSocketWaitForWritable(currentSock->fd,0);
               if(!ready)
                  break;

               currentSock->state = ::Connected;
               Net::smConnectionNotify.trigger(currentSock->fd, Net::Connected);
            }
//.........这里部分代码省略.........

int main(int argc, char* argv[]) {
	options opts;
	uint i = 0;
	uint j = 0;
	uint newFeatureIndex = 0;
	uint lastFeatureIndex = 0;
	double mrmr = 0;
	double acum = 0;
	vector<double> relevances;
	vector<double> redundances;
	vector<int> selectedFeatures;

	Timer tm;
	opts = parseOptions(argc, argv);
	RawData rawData = RawData(opts.file);
	tm.start();
	ProbTable prob = ProbTable(rawData);
	MutualInfo mutualInfo = MutualInfo(rawData, prob);
	


	//Get relevances between all features and class.
	for (i = 0; i < rawData.getFeaturesSize(); ++i) {
		relevances.push_back(mutualInfo.get(opts.classIndex, i));
		redundances.push_back(0);
	}

	// Max relevance feature is added because no redundancy is possible.
	newFeatureIndex = getMaxRelevance(relevances, opts.classIndex);
	selectedFeatures.push_back(newFeatureIndex);
	lastFeatureIndex = newFeatureIndex;

	cout << newFeatureIndex << ",";
	//MRMR
	while (selectedFeatures.size() < rawData.getFeaturesSize() - 1 //-1 because class is discarded
	and selectedFeatures.size() < opts.selectedFeatures) {
		acum = -std::numeric_limits<double>::infinity();
		for (j = 0; j < rawData.getFeaturesSize(); ++j) {
			//If feature not in selected selectedFeatures
			if (find(selectedFeatures.begin(), selectedFeatures.end(), j)
					== selectedFeatures.end() && j != opts.classIndex) {
				redundances[j] += mutualInfo.get(lastFeatureIndex, j);
				mrmr = relevances[j]
						- (redundances[j] / selectedFeatures.size());
				if (mrmr > acum) {
					acum = mrmr;
					newFeatureIndex = j;
				}
			}
		}
		//Last feature doesn't prints comma.
		if ( (selectedFeatures.size() == (opts.selectedFeatures - 1)) or (selectedFeatures.size() == (rawData.getFeaturesSize() -2)) ){
			cout << newFeatureIndex;
		}else{
			cout << newFeatureIndex << ",";
		}
		selectedFeatures.push_back(newFeatureIndex);
		lastFeatureIndex = newFeatureIndex;
	}

	rawData.destroy();
	prob.destroy();
	printf("\n");
	return (0);
}

// Calculates centroides of peaks from raw data
void CentroidData::calcCentroids(	RawData &pRawData ) // Profile data object
// Calculates centroide data from profile data
{
  
  int i,hw,j;
  double cm,toti,min_dh;
  vector<double> masses,intens;
  
  pRawData.get(masses,intens);
  fCentroidPeaks.clear();
  
  ////////////////////////////////////////////
  
  if( CENTROID_DATA_MODUS ) { // if data alread centroided in mzXML file
    for (i=0;i<(int)masses.size();i++) { 
      
      double inte = intens[i];
      double mz = masses[i];
      
      if( inte >= pRawData.LOW_INTENSITY_MS_SIGNAL_THRESHOLD ){
        CentroidPeak peak(mz,inte, fScanRetentionTime);
        
        /*
        if( CentroidData::MonoIsoDebugging ){
          if( ( CentroidData::DebugMonoIsoMassMin <= mz) && ( CentroidData::DebugMonoIsoMassMax >= mz) ){
            peak.show_info();
          }
        }
        */
        
        fCentroidPeaks.push_back(peak);
      }
      
    }
  } 
  else {
    
    ////////////////////////////////////////////
    // centroid raw data
    min_dh = pRawData.LOW_INTENSITY_MS_SIGNAL_THRESHOLD; // min height
    hw = fWindowWidth/2;
    
    for (i=2;i<(int)masses.size()-2;i++) { 
      
      // Peak must be concave in the interval [i-2 .. i+2]
      if (intens[i]>min_dh && intens[i]>intens[i-1]+min_dh && intens[i]>=intens[i+1] && intens[i-1]>intens[i-2]+min_dh && intens[i+1]>=intens[i+2]) {
        
        // centroid mass:
        cm = 0.0;
        // total intensity:
        toti = 0.0;
        
        // double Tinte = intens[i];
        double Tmz = masses[i];
        
        /*
        if( MonoIsoDebugging ){
          if( ( DebugMonoIsoMassMin <= Tmz) && ( DebugMonoIsoMassMax >= Tmz) ){
            cout<<endl<<"*Centroid: "<<Tmz<<": "<<Tinte<<endl;
          }
        }
        */
        
        for (j= -hw;j<=hw;j++) {
          double inte = intens[i-j];
          double mz = masses[i-j];

          /*
          if( MonoIsoDebugging ){
            if( ( DebugMonoIsoMassMin <= Tmz) && ( DebugMonoIsoMassMax >= Tmz) ){
              cout<<"** add: "<<mz<<": "<<inte<<endl;
            }
          }
           */
          
          cm += inte*mz;
          toti += (double) intens[i-j];
        }
        cm = cm/toti;  // Centre of gravity = centroid
        
        // take the intensity at the apex of the profile peak:
        CentroidPeak peak(cm,intens[i],fScanRetentionTime);
       
        // Lukas: take summed intensity over all peaks:
        // CentroidPeak peak( cm, toti);
        
        if( MonoIsoDebugging ){
          if( ( DebugMonoIsoMassMin <= Tmz) && ( DebugMonoIsoMassMax >= Tmz) ){
            cout<<"*final: ";
            peak.show_info();
          }
        }
        
        
        fCentroidPeaks.push_back(peak);
      }
    }
  }
}

void DataStore::Insert(const RawData& data)
{
	Insert(data.GetSessionId(), data.GetWebsiteId(), data.GetAction());
}