C++ deque::at方法代码示例

void RegApp::featuresCurrentHandler(const lcm::ReceiveBuffer* rbuf, const std::string& channel, const  reg::features_t* msg){
  if (registeration_mode_!= 2){
    return;
  }
  //cout << "\n\ngot current features @ "<< msg->utime<<"\n";
  
  // now find the corresponding image and pair it
  bool feat_image_matched_ = false;
  for(int i=0; i < image_queue_->size(); i++){
    //cout << image_queue_->at(i).utime << " " << i << "\n";
    if (msg->utime == image_queue_->at(i).utime){
      cur_features_ = getFeaturesFromLCM(msg,cur_pose_);
      cur_image_ = image_queue_->at(i);
      //cout << "image and features matched: " << i << " " << image_queue_->at(i).utime << " ("<< cur_features_.size()<<"f)\n"; 
      feat_image_matched_ = true;

      break;
    }
  }
  
  // If the registartation have been activated, do it live:
  if (feat_image_matched_ ){
    doReg();
  }else{
   cout << "didn't find a matching current image - make image deque bigger\n";  // not fatal... just continue
  }
}

void GridDisplay::setGridVec(deque<deque<double> > gridVec) {
	this->setGridSize(Size(gridVec.at(0).size(),gridVec.size()));
	for(int i=0; i<this->gridSize.height; i++) {
		for(int j=0; j<this->gridSize.width; j++) {
			this->gridMat.at<float>(i,j) = gridVec.at(i).at(j);
		}
	}
}

void printDeque(deque< pair<String, int> > d)
{
	cout << "PRINT DEQUE" << endl;
	for (int i=0; i < d.size(); i++)
	{
		cout << d.at(i).first << " " << d.at(i).second << endl;
	}
	cout << "----" << endl;
}

void RegApp::featuresReferenceHandler(const lcm::ReceiveBuffer* rbuf, const std::string& channel, const  reg::features_t* msg){
  
  if (registeration_mode_ != 1){ // ignore features if we havent just been asked to track to them
    return;
  }

  cout << "\n\ngot reference features @ "<< msg->utime<<"\n";

  // now find the corresponding image and pair it
  bool feat_image_matched_ = false;
  for(int i=0; i < image_queue_->size(); i++){
    //cout << image_queue_->at(i).utime << " " << i << "\n";
    if (msg->utime == image_queue_->at(i).utime){
      cur_features_ = getFeaturesFromLCM(msg,cur_pose_);
      cur_image_ = image_queue_->at(i);
      cout << "image and features matched: " << i << " " << image_queue_->at(i).utime << " ("<< cur_features_.size()<<"f)\n"; 
      feat_image_matched_ = true;

      break;
    }
  }
  
  if (!feat_image_matched_){
     cout <<"didn't find a matching reference image - make image deque bigger\n";
     exit(-1);
  } 

  ref_features_ = cur_features_;
  ref_image_ = cur_image_;
  ref_pose_ = cur_pose_;

  // set the reference image
  cout << "Will now register to " << ref_features_.size() << " features\n";
  
  // Send the pose we will try to register back to:
  Isometry3dTime ref_poseT = Isometry3dTime(ref_image_.utime, ref_pose_);
  pc_vis_->pose_to_lcm_from_list(70000, ref_poseT);

  deque_to_cloud(laser_queue_, botframes_, accum_cloud);

  Isometry3dTime null_poseT = Isometry3dTime(ref_image_.utime, Eigen::Isometry3d::Identity()  );
  pc_vis_->pose_to_lcm_from_list(70001, null_poseT);
  pc_vis_->ptcld_to_lcm_from_list(70002, *accum_cloud, ref_image_.utime, ref_image_.utime);

  std::stringstream ss2;
  print_Isometry3d(ref_pose_, ss2);
  std::cout << "Received refpose: " << ss2.str() << "\n";

  Eigen::Isometry3f pose_f = ref_pose_.inverse().cast<float>();
  Eigen::Quaternionf pose_quat(pose_f.rotation());
  pcl::transformPointCloud (*accum_cloud, *accum_cloud,
      pose_f.translation(), pose_quat); // !! modifies accum_cloud
  pc_vis_->ptcld_to_lcm_from_list(70003, *accum_cloud, ref_image_.utime, ref_image_.utime);

  registeration_mode_ = 2;
}

void clean_fit_all() {
  deque<int> idx;
  for (int i =0; i<rem.size(); ++i) {
    if (!clean_fit(words[rem.at(i)])) {
      idx.push_back(rem.at(i));
    }
  }
  rem.clear();
  rem = idx;
}

void fill_grid() {
  string w;
  int size;
  deque<int> idx, leftover, backup = rem;
  vector<Entry> fitted; //successfully fitted words
  bool done = false;
  char optimal[SIZE][SIZE];  
  int prev = WORD_LIST;      
  
  int limit = SIZE - words[rem.at(0)].length();
  
  for (int i=0; i<SIZE && !done; ++i) {
    for (int j=0; j<limit && !done; ++j) {                  
      if (!fit_word(words[rem.at(0)], i, j, true)) continue;
            
      rem.pop_front();
      clean_fit_all();
      size = rem.size();

      for (int k=0; k<size; ++k) {
        w = words[rem.at(k)];
        if (clean_fit(w) || force_fit(w)) continue;
        else {          
          idx.push_back(rem.at(k));
        }
      }               
      size = idx.size();
      
      if (size < prev) {
        prev = size;
        leftover = idx;
        fitted = placed;
        //TODO: must optimize using pointers if grid is large. 
        //optimization: point optimal to grid and allocate a new space for grid
        for(int i=0; i < SIZE; ++i) for(int j=0; j<SIZE; ++j) optimal[i][j] = grid[i][j];
        done = prev == 0;
      }
      
      if (!done) {
        rem = backup;
        idx.clear();
        clear_grid();
        placed.clear();        
      }
    }
  }
  rem = leftover;
  placed = fitted;
  for(int i=0; i < SIZE; ++i) for(int j=0; j<SIZE; ++j) grid[i][j] = optimal[i][j];  
}

void calculateLastLikelyPerson()
{
	for(int i=0; i < lastTenSeen.size(); i++)
	{
		int answer = dequeContains(lastTenSeenOutput, lastTenSeen.at(i).first);
		if (answer >= 0)
		{
			lastTenSeenOutput[answer].second += lastTenSeen.at(i).second;
		}
		else
		{
			lastTenSeenOutput.push_back(lastTenSeen.at(i));
		}
	}
}

//路径
deque<Situation> Situation::showWay(deque<Situation> &closed){
    //cout << closed.size() << endl;
    deque<Situation> dequeList;
    Situation temp = closed.back();
    dequeList.push_back(temp);
    
    //closed表从后往前，根据father值找到路径
    for (int i = closed.size()-1; i >= 0;i--){
        if (temp.father==closed.at(i).code){
            dequeList.push_back(closed.at(i));
            temp = closed.at(i);
        }
    }
    //cout << dequeList.size() << endl;
    return dequeList;
}

pair <Float_t,Float_t> TPedestalCalculation::calculateFirstPedestalDia(int ch,deque<Int_t> adcQueue, float meanChannel, float sigmaChannel,int iterations,float maxSigma){
	diaSUM[ch]=0;
	diaSUM2[ch]=0;
	diaEventsInSum[ch]=0;
	this->diaEventUsed[ch].clear();
	for(UInt_t nEvent=0;nEvent<adcQueue.size();nEvent++){
		Float_t adc = (Float_t) adcQueue.at(nEvent);
		if(   (adc >= getLowLimitPedestal(meanChannel,sigmaChannel,maxSigma)  )
				&& (adc <= getHighLimitPedestal(meanChannel,sigmaChannel,maxSigma) ) ){
			diaEventUsed[ch].push_back(true);
			diaSUM[ch]+=adc;
			diaSUM2[ch]+=adc*adc;
			diaEventsInSum[ch]++;
		}//end if
		else
			diaEventUsed[ch].push_back(false);
	}//end for nEvent
	if(diaEventsInSum[ch]<0.1*adcQueue.size())
		cout<<"For the calculation of first pedestals in diamond and ch "<<ch<<"there were only "<<diaEventsInSum[ch]<<" Events used..."<<endl;
	Float_t mean=diaSUM[ch]/(Float_t)diaEventsInSum[ch];
	Float_t sigma=TMath::Sqrt( diaSUM2[ch]/(Float_t)diaEventsInSum[ch]-mean*mean);

	diaPedestalMean[ch]=RoundFloat(mean);
	diaPedestalSigma[ch]=RoundFloat(sigma);
	pair<Float_t,Float_t> output = make_pair(mean,sigma);
	//	if(verbosity>4&& ch ==103)
	//		cout<<"diamond ch "<<ch<<", it "<<iterations<<", usedEvents " <<diaEventsInSum[ch]<<"\t"<<mean<<"+/-"<<sigma<<endl;
	if(iterations==0)return output;
	else return this->calculateFirstPedestalDia(ch,adcQueue,mean,sigma,iterations-1,maxSigma);
}

/* called from layer 3, when a packet arrives for layer 4
 * If the ack packet is for a packet inside the window, then that particular packet
 * is marked as acknowledged. If it is the base packet then the window gets shifted
 * by number of consecutive acked packets.
 * For correctly received ack packets(for non retransmitted packets), an RTT is
 * calculated and sent to estimateRTT for timeout estimation.
 *
 * */
void A_input(struct pkt packet)
{
	cout<<"*************************Inside A_input start*************************"<<endl;

	int indexOfPacketsAck=0;
	timerPacket* tempTimerPacket;
	if(!isCorrupt(&packet)){
			if((senderBuffer.size()>=(a_base+1))&&senderBuffer.at(a_base)->packet->seqnum<=packet.acknum){

			//		cout<<"A->Ack recevied for packet "<<packet.acknum<<endl;//<<" a_nextseqnum:"<<(senderBuffer.size()>=0 ? senderBuffer.at(a_nextseqnum)->seqnum:0)<<endl;
			indexOfPacketsAck=packet.acknum - senderBuffer.at(a_base)->packet->seqnum;
			//senderBuffer.erase(senderBuffer.begin(),senderBuffer.begin()+numOfPacketsAck);
			//	cout<<"indexOfPacketsAck:"<<indexOfPacketsAck<<" size:"<<senderBuffer.size()<<endl;
			cout<<"A->Packet with Seq num:"<<senderBuffer.at(indexOfPacketsAck)->packet->seqnum<<" is Ackowledged. Sender Buffer size:"<<senderBuffer.size()<<endl;
			senderBuffer.at(indexOfPacketsAck)->ackedFlag=true;
			/*Added for timeout Estimation*/
			cout<<"Before estimate call"<<endl;
			if(!senderBuffer.at(indexOfPacketsAck)->retransmitFlag){
				//This is not for a retransmission
				estimateTimeout(time_local-senderBuffer.at(indexOfPacketsAck)->start_time);
			}else{
				cout<<" Packet received is a retransmission"<<endl;
			}


			int i=a_base;
			int count=0;
			timerPacket * tempTimerPacket;
			while((count<a_windowSize)&&(senderBuffer.size()>=(a_base+1)&&senderBuffer.at(a_base)->ackedFlag==true)){
				tempTimerPacket=senderBuffer.at(i);
				cout<<"A->Remove Packet Seq:"<<tempTimerPacket->packet->seqnum<<endl;
				fflush(stdout);
				senderBuffer.pop_front();
				count++;
				a_nextseqnum--;
			}
			//	a_nextseqnum-=count;
			//Added as an Optimization.Possible a better approach for SR
			if(count!=0){
				cout<<"A->Window Shifted by "<<count<<" packets. Sending more packets now"<<endl;
				sendPacketsinBulk();
			}else{
				cout<<"A->Since base packet was not Acknowledged, Window was not shifted."<<endl;
			}
		}else{
			//acknum is less than base. So this is a delayed, duplicate Ack packet.
			//Ignore it
			cout<<"A->Base sequence:"/*<<senderBuffer.at(a_base)->seqnum*/<<" Ack Received:"<<packet.acknum<<". Received a delayed, duplicate Ack. Ignoring it"<<endl;
			return;
		}
	}else{
		cout<<"A-> Corrupt Ack Received. Ignoring this"<<endl;
	}
	cout<<"*************************Inside A_input end*************************"<<endl;

}

//customize calcuation of hue avg
double Hsl::calcHueAvg(deque<int> &vec) {
	double hue=0;
	double total=0;
	for(unsigned int i=0; i<vec.size(); i++) {
		hue = (vec.at(i)+180)%360;
		total += hue;
	}
	total /= vec.size();
	total /= 360;
	return total;
}

/*
 * Check that what gets written is what we expected
 */
void MockLogDestination::Write(log_level level, const string &log_line) {
  vector<string> tokens;
  ola::StringSplit(log_line, tokens, ":");
  vector<string>::iterator iter;
  OLA_ASSERT_EQ(tokens.size() , (size_t) 3);
  OLA_ASSERT_GT(m_log_lines.size(), 0);
  std::pair<log_level, string> expected_result = m_log_lines.at(0);
  m_log_lines.pop_front();
  OLA_ASSERT_EQ(expected_result.first, level);
  OLA_ASSERT_EQ(expected_result.second, tokens.at(2));
}

void Situation::show_deque(deque<Situation> &m_deque) const{
    /*deque<Situation>::iterator it = m_deque.begin();
     while (it!=m_deque.end())
     {
     (*it).show();
     it++;
     }*/
    for (int i = 0; i < m_deque.size();i++){
        m_deque.at(i).show();
    }
}

int dequeContains(deque< pair<String, int> > d, String s)
{
	for (int i=0; i < d.size(); i++)
	{
		if (d.at(i).first == s)
		{
			return i;
		}
	}
	return -1;
}

/**
 * Compare the given query spectrum to all library spectra.  Create a
 * match for each and add to matches.
 */
void SearchLibrary::scoreMatches(Spectrum& s, deque<RefSpectrum*>& spectra,
                                 vector<Match>& matches ){
    Verbosity::debug("Scoring %d matches.", spectra.size());
    // get the charge states we will search
    const vector<int>& charges = s.getPossibleCharges();
    
    // compare all ref spec to query, create match for each
    for(size_t i=0; i< spectra.size(); i++) {
        // is there a better place to check this?
        if(spectra.at(i)->getNumProcessedPeaks() == 0 ){ 
            Verbosity::debug("Skipping library spectrum %d.  No peaks.", 
                             spectra.at(i)->getLibSpecID());
            continue;
        }
        
        if( ! checkCharge(charges, spectra.at(i)->getCharge()) ){
            continue;
        }
        
        Match thisMatch(&s, spectra.at(i));  
        
        thisMatch.setMatchLibID(spectra.at(i)->getLibID());
        
        Verbosity::comment(V_ALL, "Comparing query spec %d and library spec %d",
                           s.getScanNumber(), spectra.at(i)->getLibSpecID());
        
        DotProduct::compare(thisMatch); //static method
        
        // save match for reporting
        matches.push_back(thisMatch);
    }  
}