Example #1
0
static double
score2(const boost::unordered_map<int, double> &m0,
       const boost::unordered_map<int, double> &m1)
{
  int tmp = 0;
  auto i0 = m0.begin();
  auto i1 = m1.begin();
  while (i0 != m0.end() && i1 != m1.end()) {
    if (i0->first < i1->first) ++i0;
    else if (i0->first > i1->first) ++i1;
    else ++tmp, ++i0, ++i1;
  }
  return m0.size() + m1.size() - tmp;
}
Example #2
0
void IfcTreeWidget::slotObjectsSelected( boost::unordered_map<int, shared_ptr<IfcPPEntity> >& map )
{
	if( m_block_selection_signals )
	{
		return;
	}

	if( map.size() < 1 )
	{
		return;
	}

	// take the first object from map and highlight it
	shared_ptr<IfcPPEntity> object = (*(map.begin())).second;
	int selected_id = object->m_id;

	for( int i=0; i<topLevelItemCount(); ++i )
	{
		QTreeWidgetItem* toplevel_item = topLevelItem( i );
		QTreeWidgetItem* selected_item = ViewerUtil::findItemByIfcId( toplevel_item, selected_id );
		if( selected_item != 0 )
		{
			blockSignals(true);
			m_block_selection_signals = true;
			setCurrentItem( selected_item, 1, QItemSelectionModel::SelectCurrent );
			blockSignals(false);
			m_block_selection_signals = false;
			break;
		}
	}
}
void IndexingVariables::set(
    boost::unordered_map<std::string, boost::shared_ptr<ArrayStorage> > as,
    int offset) {
  hm.clear();
  hm.insert(as.begin(), as.end());
  this->offset = offset;
}
//! Dump Legendre polynomial cache data to stream (table and history).
void dumpLegendrePolynomialCacheData( std::ostream& outputStream,
                                      boost::unordered_map< Point, double > cacheTable,
                                      boost::circular_buffer< Point > cacheHistory )
{
    outputStream << "Table:\n";

    for ( boost::unordered_map< Point, double >::iterator iteratorCacheTable = cacheTable.begin( );
          iteratorCacheTable != cacheTable.end( ); iteratorCacheTable++ )
    {
        outputStream << "\t" << writeLegendrePolynomialStructureToString(
                            iteratorCacheTable->first ).c_str( ) << " => "
                     << iteratorCacheTable->second << std::endl;
    }

    outputStream << "History:\n";

    for ( boost::circular_buffer< Point >::iterator iteratorCacheHistory = cacheHistory.begin( );
          iteratorCacheHistory != cacheHistory.end( ); iteratorCacheHistory++ )
    {
        outputStream << "\t"
                     << writeLegendrePolynomialStructureToString( *iteratorCacheHistory ).c_str( )
                     << ", ";
    }

    outputStream << std::endl;
}
Example #5
0
TKmerMapSimple
kmerify_graph_simple(String<TVertexDescriptor const> const & order,
                     TGraph const & graph,
                     std::vector<VertexLabels> & vertex_vector,
                     boost::unordered_set<TVertexDescriptor> const & free_nodes,
                     boost::unordered_map< std::pair<TVertexDescriptor, TVertexDescriptor>, boost::dynamic_bitset<> > & edge_ids,
                     int const & kmer_size
                    )
{
  TKmerMapSimple kmer_map;

  for (Iterator<String<TVertexDescriptor const> const>::Type it = begin(order) ; it != end(order) ; ++it)
  {
    TVertexDescriptor const & source_vertex = *it;

    if (free_nodes.count(source_vertex) == 0)
    {
      boost::dynamic_bitset<> id_bits(edge_ids.begin()->second.size());
      id_bits.flip();
      check_kmers_simple(vertex_vector[source_vertex].dna, graph, source_vertex, vertex_vector, free_nodes, edge_ids, id_bits, kmer_map, static_cast<std::size_t>(kmer_size));
    }
  }

  return kmer_map;
}
Example #6
0
TKmerMap
kmerifyGraph(String<TVertexDescriptor const> const & order,
             TGraph const & graph,
             std::vector<VertexLabels> & vertex_vector,
             boost::unordered_set<TVertexDescriptor> const & free_nodes,
             boost::unordered_map< std::pair<TVertexDescriptor, TVertexDescriptor>, boost::dynamic_bitset<> > & edge_ids,
             int const & kmer_size
            )
{
  TKmerMap kmer_map;

  for (Iterator<String<TVertexDescriptor const> const>::Type it = begin(order) ; it != end(order) ; ++it)
  {
    TVertexDescriptor const & source_vertex = *it;

    if (free_nodes.count(source_vertex) == 0)
    {
      boost::dynamic_bitset<> id_bits(edge_ids.begin()->second.size());
      id_bits.flip();
      checkKmers(vertex_vector[source_vertex].dna, source_vertex, source_vertex, graph, vertex_vector, free_nodes, edge_ids, id_bits, kmer_map, static_cast<std::size_t>(kmer_size));
      // std::cout << "source_vertex = " << source_vertex << " kmer_map.size() = " << kmer_map.size() << " kmer_size = " << kmer_size;
      // std::cout << " vertex_vector[source_vertex].level = " << vertex_vector[source_vertex].level << std::endl;
    }
  }

  return kmer_map;
}
void Streamer::processPickups(Player &player, const std::vector<SharedCell> &cells)
{
	static boost::unordered_map<int, Item::SharedPickup> discoveredPickups;
	for (std::vector<SharedCell>::const_iterator c = cells.begin(); c != cells.end(); ++c)
	{
		for (boost::unordered_map<int, Item::SharedPickup>::const_iterator p = (*c)->pickups.begin(); p != (*c)->pickups.end(); ++p)
		{
			boost::unordered_map<int, Item::SharedPickup>::iterator d = discoveredPickups.find(p->first);
			if (d == discoveredPickups.end())
			{
				if (checkPlayer(p->second->players, player.playerID, p->second->interiors, player.interiorID, p->second->worlds, player.worldID))
				{
					if (boost::geometry::comparable_distance(player.position, p->second->position) <= p->second->streamDistance)
					{
						boost::unordered_map<int, int>::iterator i = internalPickups.find(p->first);
						if (i == internalPickups.end())
						{
							p->second->worldID = !p->second->worlds.empty() ? player.worldID : -1;
						}
						discoveredPickups.insert(*p);
					}
				}
			}
		}
	}
	if (processingFinalPlayer)
	{
		boost::unordered_map<int, int>::iterator i = internalPickups.begin();
		while (i != internalPickups.end())
		{
			boost::unordered_map<int, Item::SharedPickup>::iterator d = discoveredPickups.find(i->first);
			if (d == discoveredPickups.end())
			{
				DestroyPickup(i->second);
				i = internalPickups.erase(i);
			}
			else
			{
				discoveredPickups.erase(d);
				++i;
			}
		}
		for (boost::unordered_map<int, Item::SharedPickup>::iterator d = discoveredPickups.begin(); d != discoveredPickups.end(); ++d)
		{
			if (internalPickups.size() == visiblePickups)
			{
				break;
			}
			int internalID = CreatePickup(d->second->modelID, d->second->type, d->second->position[0], d->second->position[1], d->second->position[2], d->second->worldID);
			if (internalID == INVALID_ALTERNATE_ID)
			{
				break;
			}
			internalPickups.insert(std::make_pair(d->second->pickupID, internalID));
		}
		discoveredPickups.clear();
	}
}
Example #8
0
///Calculates the Gini impurity of a node. The impurity is defined as
///1-sum_j p(j|t)^2
///i.e the 1 minus the sum of the squared probability of observing class j in node t
double CARTTrainer::gini(boost::unordered_map<std::size_t, std::size_t>& countMatrix, std::size_t n){
	double res = 0;
	boost::unordered_map<std::size_t, std::size_t>::iterator it;
	double denominator = n;
	for ( it=countMatrix.begin() ; it != countMatrix.end(); it++ ){
		res += sqr(it->second/denominator);
	}
	return 1-res;
}
Example #9
0
bool buildNameLookupTable(Kompex::SQLiteStatement * stmt,
                          boost::unordered_map<std::string,int32_t> &table_names)
{
    std::string stmt_insert = "INSERT INTO name_lookup";
    stmt_insert += "(name_id,name_lookup) VALUES(@name_id,@name_lookup);";

    try   {
        stmt->BeginTransaction();
        stmt->Sql(stmt_insert);
    }
    catch(Kompex::SQLiteException &exception)   {
        qDebug() << "ERROR: SQLite exception with insert statement:"
                 << QString::fromStdString(exception.GetString());
        return false;
    }

    // keep track of the number of transactions and
    // commit after a certain limit
    size_t transaction_limit=5000;
    size_t transaction_count=0;

    // write name lookup info the database
    boost::unordered_map<std::string,int32_t>::iterator it;
    for(it  = table_names.begin(); it != table_names.end(); ++it)   {
        // prepare sql
        try   {
            //[name_id, name_lookup]
            stmt->BindInt(1,it->second);
            stmt->BindString(2,it->first);
            stmt->Execute();
            stmt->Reset();

            if(transaction_count > transaction_limit)   {
                stmt->FreeQuery();
                stmt->CommitTransaction();

                stmt->BeginTransaction();
                stmt->Sql(stmt_insert);
                transaction_count=0;
            }
            transaction_count++;
        }
        catch(Kompex::SQLiteException &exception)   {
            qDebug() << "ERROR: SQLite exception writing tile data:"
                     << QString::fromStdString(exception.GetString());
            qDebug() << "ERROR: name_id:" << it->second;
            qDebug() << "ERROR: name_lookup:" << QString::fromStdString(it->first);
            return false;
        }
    }

    stmt->FreeQuery();
    stmt->CommitTransaction();

    return true;
}
Example #10
0
void read_db_users()
{
	m_read_db_users_time = srv_time();
	if (!m_use_sql)
		return;
	try
	{
		Csql_query q(m_database, "select @uid");
		if (m_read_users_can_leech)
			q += ", can_leech";
		if (m_read_users_peers_limit)
			q += ", peers_limit";
		if (m_read_users_torrent_pass)
			q += ", torrent_pass";
		q += ", torrent_pass_version";
		if (m_read_users_wait_time)
			q += ", wait_time";
		q += " from @users";
		Csql_result result = q.execute();
		// m_users.reserve(result.size());
		for (auto& i : m_users)
			i.second.marked = true;
		m_users_torrent_passes.clear();
		while (Csql_row row = result.fetch_row())
		{
			t_user& user = m_users[row[0].i()];
			user.marked = false;
			int c = 0;
			user.uid = row[c++].i();
			if (m_read_users_can_leech)
				user.can_leech = row[c++].i();
			if (m_read_users_peers_limit)
				user.peers_limit = row[c++].i();
			if (m_read_users_torrent_pass)
			{
				if (row[c].size() == 32)
					m_users_torrent_passes[to_array<char, 32>(row[c])] = &user;
				c++;
			}
			user.torrent_pass_version = row[c++].i();
			if (m_read_users_wait_time)
				user.wait_time = row[c++].i();
		}
		for (auto i = m_users.begin(); i != m_users.end(); )
		{
			if (i->second.marked)
				m_users.erase(i++);
			else
				i++;
		}
	}
	catch (bad_query&)
	{
	}
}
		static void serialize(storage_type& s, const boost::unordered_map<T1, T2>& o)
			{
			uint32_t sz = o.size();
			s.serialize(sz);

			for (typename boost::unordered_map<T1,T2>::const_iterator it = o.begin(), it_end = o.end(); it != it_end; ++it)
				{
				s.serialize(it->first);
				s.serialize(it->second);
				}
			}
Example #12
0
///Calculates the Gini impurity of a node. The impurity is defined as
///1-sum_j p(j|t)^2
///i.e the 1 minus the sum of the squared probability of observing class j in node t
double RFTrainer::gini(boost::unordered_map<std::size_t, std::size_t> & countMatrix, std::size_t n){
	double res = 0;
	boost::unordered_map<std::size_t, std::size_t>::iterator it;
	if(n){
		n = n*n;
		for ( it=countMatrix.begin() ; it != countMatrix.end(); it++ ){
			res += sqr(it->second)/(double)n;
		}
	}
	return 1-res;
}
Example #13
0
int TwoSum::find_range(int lower, int upper) {
    int count = 0;
    numbers_to_check.resize(upper-lower);
    for (int i=lower; i<= upper; i++ ) {
	numbers_to_check.push_back(i);
    };
    for( auto it = numbers.begin(); it != numbers.end(); ++it ) {
	if( find_sum(it->first) ) { 
	    ++count; 
	};
    };	
    return count;
};
Example #14
0
RealVector CARTTrainer::hist(boost::unordered_map<std::size_t, std::size_t> countMatrix){

	//create a normed histogram
	std::size_t totalElements = 0;
	RealVector normedHistogram(m_maxLabel+1);
	normedHistogram.clear();
	boost::unordered_map<std::size_t, std::size_t>::iterator it;
	for ( it=countMatrix.begin() ; it != countMatrix.end(); it++ ){
		normedHistogram(it->first) = it->second;
		totalElements += it->second;
	}
	normedHistogram /= totalElements;
	return normedHistogram;
}
void Task::drawKeypoints(const base::samples::frame::Frame &frame2,
                const std::vector<cv::KeyPoint> &keypoints1,
                const std::vector<cv::KeyPoint> &keypoints2,
                const std::vector<cv::DMatch> &matches,
                const boost::unordered_map<boost::uuids::uuid, StereoFeature> &hash)

{
    /** Convert Images to opencv **/
    cv::Mat img2 = frameHelperLeft.convertToCvMat(frame2);

    ::cv::Mat img_out(img2);
    cv::drawKeypoints (img2, keypoints1, img_out, cv::Scalar(0, 255, 0));//green previous
    for (std::vector<cv::DMatch>::const_iterator it= matches.begin(); it!= matches.end(); ++it)
    {
        cv::Point point1 = keypoints1[it->queryIdx].pt;
        cv::Point point2 = keypoints2[it->trainIdx].pt;

        //cv::circle(img_out, point1, 3, cv::Scalar(0, 255, 0), 1);// green previous
        cv::circle(img_out, point2, 3, cv::Scalar(255, 0, 0), 1);// blue current
        cv::line (img_out, point1, point2, cv::Scalar(0, 0, 255)); // red line

    }

    if (_draw_hash_uuid_features.value())
    {
        /** Draw hash features **/
        for (boost::unordered_map<boost::uuids::uuid, StereoFeature>::const_iterator
                        it = hash.begin(); it != hash.end(); ++it)
        {
            /** Only current features but with the hash id and the image frame index in the label **/
            if (it->second.img_idx == this->fcurrent_left.img_idx)
            {
                float red = 255.0 - (255.0/(this->frame_window_hash_size)*(this->ffinal_left.img_idx-it->second.img_idx));
                cv::circle(img_out, it->second.keypoint_left.pt, 5, cv::Scalar(0, 0, red), 2);
                std::vector<std::string> uuid_tokens = this->split(boost::lexical_cast<std::string>(it->first), '-');
                cv::putText(img_out, uuid_tokens[uuid_tokens.size()-1]+"["+boost::lexical_cast<std::string>(it->second.img_idx)+"]",
                        it->second.keypoint_left.pt, cv::FONT_HERSHEY_COMPLEX_SMALL, 1.0, cv::Scalar(0,0,0), 2.5);
            }
        }
    }

    ::base::samples::frame::Frame *frame_ptr = this->inter_frame_out.write_access();
    frameHelperLeft.copyMatToFrame(img_out, *frame_ptr);

    frame_ptr->time = this->frame_pair.time;
    this->inter_frame_out.reset(frame_ptr);
    _inter_frame_samples_out.write(this->inter_frame_out);

    return;
}
void save(Archive & ar, const boost::unordered_map<T,U> & t, unsigned int version)
{
    // write the size
    // TODO: should we handle bucket size as well?
    typedef typename boost::unordered_map<T, U>::size_type size_type;
    typedef typename boost::unordered_map<T,U>::const_iterator const_iterator;
    size_type size = t.size();
    ar & BOOST_SERIALIZATION_NVP(size);
    unsigned int count = 0;
    for (const_iterator it = t.begin(); it != t.end(); it++) {
        ar & boost::serialization::make_nvp("pair" + count, *it);
        count++;
    }
}
Example #17
0
RealVector RFTrainer::hist(boost::unordered_map<std::size_t, std::size_t> countMatrix){

	RealVector histogram(m_maxLabel+1,0.0);

	std::size_t totalElements = 0;

	boost::unordered_map<std::size_t, std::size_t>::iterator it;
	for ( it=countMatrix.begin() ; it != countMatrix.end(); it++ ){
		histogram(it->first) = (double)it->second;
		totalElements += it->second;
	}
	histogram /= totalElements;

	return histogram;
}
Example #18
0
bool TwoSum::find_sum(long int target) {
    long int bucket;
    for( auto it = numbers_to_check.begin(); it != numbers_to_check.end(); it++ ) {
	if( numbers.find((*it) - target) == numbers.end() ) { continue; };
	bucket = numbers.bucket( (*it) - target );
	for(auto it_local = numbers.begin(bucket); it_local != numbers.end(bucket); ++it_local) {
	    if ( ( it_local->first + target ) != (*it) ) { continue; }; 
	    if ( it_local->first != target || (it_local->first == target && multi_numbers.find(target) != multi_numbers.end()) ) {
		std::cout << target << " + " << it_local->first << " = " << (*it) << " ( " << target + it_local->first << std::endl;
		numbers_to_check.erase(it);
		return true; 
	    };
	};
    };
    return false;
};
Example #19
0
void printIdMap(boost::unordered_map<std::string, long> &my_id_map)
{
  // std::cout << my_id_map.size() << std::endl;
  std::string max_id;
  long max_count = 0;

  for (boost::unordered_map<std::string, long>::iterator it = my_id_map.begin() ; it != my_id_map.end() ; ++it)
  {
    printf("%8s: %4ld\n", it->first.c_str(), it->second);
    if (it->second > max_count)
    {
      max_count = it->second;
      max_id = it->first.c_str();
    }
  }
  std::cout << max_id << " wins!" << std::endl;
}
Example #20
0
inline void operator<< (object::with_zone& o, const boost::unordered_map<K,V>& v)
{
    o.type = type::MAP;
    if(v.empty()) {
        o.via.map.ptr  = NULL;
        o.via.map.size = 0;
    } else {
        object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
        object_kv* const pend = p + v.size();
        o.via.map.ptr  = p;
        o.via.map.size = v.size();
        typename boost::unordered_map<K,V>::const_iterator it(v.begin());
        do {
            p->key = object(it->first, o.zone);
            p->val = object(it->second, o.zone);
            ++p;
            ++it;
        } while(p < pend);
    }
}
Example #21
0
void dump_call_profile()
{
#ifdef TORRENT_PROFILE_CALLS
	FILE* out = fopen("blocking_calls.txt", "w+");

	std::map<int, std::string> profile;

	mutex::scoped_lock l(g_calls_mutex);
	for (boost::unordered_map<std::string, int>::const_iterator i = g_blocking_calls.begin()
		, end(g_blocking_calls.end()); i != end; ++i)
	{
		profile[i->second] = i->first;
	}
	for (std::map<int, std::string>::const_reverse_iterator i = profile.rbegin()
		, end(profile.rend()); i != end; ++i)
	{
		fprintf(out, "\n\n%d\n%s\n", i->first, i->second.c_str());
	}
	fclose(out);
#endif
}
Example #22
0
static std::pair<double, double>
score(const boost::unordered_map<int, double> &real,
      const boost::unordered_map<int, double> &fake,
      double threshold = 0.0)
{
  double res = 0.0;
  int cnt = 0;
  double e = std::numeric_limits<double>::epsilon();
  for (auto i = fake.begin(); i != fake.end(); ++i)
    if (i->second >= threshold &&
        real.find(i->first) != real.end()) {
      ++cnt;

      double p = real.at(i->first);
      double q = fake.at(i->first);

      if (p <= e)
        res += (1-p) * log((1-p)/(1-q));
      else if (1-p <= e || 1-q <= e)
        res += p * log(p/q);
      else res += p * log(p/q) + (1-p) * log((1-p)/(1-q));
    }
  return {res, cnt ? res / cnt : 0.0};
}
void Task::cleanHashFeatures (const int current_image_idx,
                        const int max_number_img,
                        boost::unordered_map<boost::uuids::uuid, StereoFeature> &hash)
{
    if (current_image_idx > max_number_img)
    {
        const int border_image_idx = (current_image_idx - max_number_img);

        /** All the images with idx <= border_image_idx should be eliminated **/
        for (boost::unordered_map<boost::uuids::uuid, StereoFeature>::const_iterator
                it = hash.begin(); it != hash.end(); ++it)
        {
            if (it->second.img_idx <= border_image_idx)
            {
                #ifdef DEBUG_PRINTS
                std::cout<<"[CLEAN_HASH_FEATURES] Remove from hash "<<boost::lexical_cast<std::string>(it->first)<<"\n";
                #endif
                hash.erase(it);
            }
        }
    }

    return;
}
Example #24
0
void read_db_torrents()
{
	m_read_db_torrents_time = srv_time();
	if (m_use_sql)
		read_db_torrents_sql();
	else if (!m_config.m_auto_register)
	{
		std::set<t_torrent*> new_torrents;
		std::ifstream is("xbt_torrents.txt");
		for (std::string s; getline(is, s); )
		{
			s = hex_decode(s);
			if (s.size() == 20)
				new_torrents.insert(&m_torrents[to_array<char, 20>(s)]);
		}
		for (auto i = m_torrents.begin(); i != m_torrents.end(); )
		{
			if (new_torrents.count(&i->second))
				i++;
			else
				m_torrents.erase(i++);
		}
	}
}
Example #25
0
	iterator begin() {
		return iterator(xmls.begin());
	}
Example #26
0
void Voxelize::generateUmap(pcl::PointCloud<pcl::PointXYZ> &cloud,double resolution,boost::unordered_map<unordered_map_voxel,un_key> &m)//遍历每个点,生成栅格。然后计算每个栅格的参数
{
    double t0 = ros::Time::now().toSec();

    un_key tempp;  //key键不允许修改,全存在value中

    for(int i=0;i<cloud.size();i++)
    {
        unordered_map_voxel tempv(cloud[i].x,cloud[i].y,cloud[i].z,resolution);

        pair<umap::iterator,bool> pair_insert = m.insert(umap::value_type(tempv,tempp));//这个pair就是用来存储插入返回值的,看是否这个栅格已经存在

        pair_insert.first->second.vec_index_point.push_back(i);
        /*
           if(!pair_insert.second)//如果栅格已经存在,那么把value++
           {
           (pair_insert.first)->second.cout++;
           pair_insert.first->second.vec_index_point.push_back(i);
           }
           else{
           pair_insert.first->second.vec_index_point.push_back(i);
           }
           */
    }

    double t2 = ros::Time::now().toSec();
    //cout <<"划栅格的时间为"<<(t2-t0)<<endl;
    Matrix3d tempmat;
    tempmat.setZero();

    pcl::PointXYZ temppoint(0,0,0);
    for(umap::iterator iter=m.begin();iter!=m.end();)
    {
        temppoint.x=temppoint.y=temppoint.z=0;
        if(iter->second.vec_index_point.size()<10)
        {
            m.erase(iter++);
            continue;
        }

        for(int j = 0;j<iter->second.vec_index_point.size();j++)
        {
            double x_ = cloud[iter->second.vec_index_point[j]].x;
            double y_ = cloud[iter->second.vec_index_point[j]].y;
            double z_ = cloud[iter->second.vec_index_point[j]].z;

            tempmat += (Vector3d(x_,y_,z_) * RowVector3d(x_,y_,z_));//存储pipiT的和
            temppoint.x += x_;
            temppoint.y += y_;
            temppoint.z += z_;
        }

        int n = iter->second.vec_index_point.size();
        //cout <<"栅格大小为"<<n<<endl;
        Vector3d v(temppoint.x/n,temppoint.y/n,temppoint.z/n);//存储栅格重心
        RowVector3d vT(temppoint.x/n,temppoint.y/n,temppoint.z/n);

        tempmat /= n;
        tempmat -= v*vT;//S
        iter->second.matS = tempmat;
        //cout <<"S 矩阵= "<< tempmat <<endl;

        vector<eigen_sort> vector1(3);//用于排序

        //cout <<"tempmat="<<endl<<tempmat<<endl;
        EigenSolver<MatrixXd> es(tempmat);
        VectorXcd eivals = es.eigenvalues();
        MatrixXcd eigenvectors = es.eigenvectors();
        //cout << "特征值="<<eivals<<endl;
        vector1[0]=eigen_sort(eivals(0).real(),es.eigenvectors().col(0));
        vector1[1]=eigen_sort(eivals(1).real(),es.eigenvectors().col(1));
        vector1[2]=eigen_sort(eivals(2).real(),es.eigenvectors().col(2));
        sort(vector1.begin(),vector1.end());
        double lamada1 = vector1[0].eigen_value;
        double lamada2 = vector1[1].eigen_value;
        double lamada3 = vector1[2].eigen_value;
        //cout <<"lamada="<<lamada1<<" "<<lamada2<<" "<<lamada3<<endl;
        //
        if(vector1[0].eigen_vector(2).real()<0)
        {
            vector1[0].eigen_vector(2).real() = -vector1[0].eigen_vector(2).real();
        }
        if(vector1[2].eigen_vector(2).real()<0)
        {
            vector1[2].eigen_vector(2).real() = -vector1[2].eigen_vector(2).real();
        }


        iter->second.c = (lamada3-lamada2)/(lamada1+lamada2+lamada3);
        iter->second.p = 2*(lamada2-lamada1)/(lamada1+lamada2+lamada3);
        iter->second.u = v;
        iter->second.v1 = vector1[0].eigen_vector;
        iter->second.v3 = vector1[2].eigen_vector;

        double c = iter->second.c;
        double p = iter->second.p;


        iter->second.vector_9D << v(0),v(1),v(2),p*vector1[0].eigen_vector(0).real(),p*vector1[0].eigen_vector(1).real(),
            p*vector1[0].eigen_vector(2).real(),c*vector1[2].eigen_vector(0).real(),c*vector1[2].eigen_vector(1).real(),
            p*vector1[2].eigen_vector(2).real();

        //cout << "9D向量="<<iter->second.vector_9D<<endl;
        //ArrayXd ad = iter->second.vector_9D;
        //cout <<"ad = "<<ad<<endl;
        //cout <<"ad square="<<ad.square()<<endl;
        tempmat.setZero();

        iter++;

    }

    double tn = ros::Time::now().toSec();
    //cout << "对栅格计算处理的时间"<<(tn - t2)<<endl;
    //cout <<"栅格数量为" <<m.size()<<endl;

}
Example #27
0
//------------------------------------------------------------------------------
bool MzIDIO::insertMZIDValues(boost::unordered_map<PercolatorOutFeatures, string, PercolatorOutFeatures> &pout_values,
                              vector <string> &filenames, bool multiplemzidfiles) {
  ifstream fpr;
  ofstream fpw;
  ostream *wout;
  string mzidname,s1,psmid;
  int i1,vi1,n,xmlindent;

  n=0;
  psmid="";
  try {
    for (vi1=0; vi1<filenames.size(); vi1++) {
      mzidname=boost::lexical_cast<boost::filesystem::path>(filenames[vi1]).stem().string();
      if (!multiplemzidfiles)
        mzidname="";
      fpr.open(filenames[vi1].c_str());
      if (outputfileending.length()>0) {
        fpw.open(setOutputFileName(filenames[vi1]).c_str());
        wout=&fpw;
        }
      else
        wout=&cout;
      while (getline(fpr,s1)) {
        if (s1.find(MZID_PARAM::END_INSERT_TAG)!=string::npos) {
          if (psmid.length()==0)
            THROW_ERROR_VALUE(PRINT_TEXT::BAD_XML,filenames[vi1]);
          for (i1=0; i1<ARRAYSIZE(MZID_PARAM::ELEMENT_DATA::ELEMENTS); i1++) {
            if (pout_values.find(PercolatorOutFeatures(mzidname,psmid,i1))==pout_values.end())
              continue;
            n++;
            switch (MZID_PARAM::ELEMENT_DATA::ELEMENTS[i1]) {
              case MZID_PARAM::CVPARAM: {
                *wout << boost::format(MZID_PARAM::CVPARAM_TAG) % string(xmlindent,' ')
                        % MZID_PARAM::ELEMENT_DATA::ACCESSIONS[i1]
                        % MZID_PARAM::ELEMENT_DATA::CVREFS[i1]
                        % MZID_PARAM::ELEMENT_DATA::NAMES[i1]
                        % pout_values[PercolatorOutFeatures(mzidname,psmid,i1)];
                break;
                }
              case MZID_PARAM::USERPARAM: {
                *wout << boost::format(MZID_PARAM::USERPARAM_TAG) % string(xmlindent,' ')
                        % MZID_PARAM::ELEMENT_DATA::NAMES[i1]
                        % pout_values[PercolatorOutFeatures(mzidname,psmid,i1)];
                break;
                }
              }
            pout_values.erase(PercolatorOutFeatures(mzidname,psmid,i1));
            }
          psmid="";
          }
        xmlindent=s1.find_first_not_of(" ");
        *wout << s1 << endl;
        if (s1.find(MZID_PARAM::PSMID_TAG)!=string::npos && s1.find(MZID_PARAM::START_INSERT_TAG)!=string::npos) {
          i1=s1.find(MZID_PARAM::PSMID_TAG)+strlen(MZID_PARAM::PSMID_TAG);
          psmid=s1.substr(i1,s1.find("\"",i1)-i1);
          }
        }
      fpr.close();
      fpw.close();
      }
    clog << boost::format(PRINT_TEXT::INSERTED) % n << endl;
    for (boost::unordered_map<PercolatorOutFeatures, string, PercolatorOutFeatures>::iterator
        it=pout_values.begin(); it!=pout_values.end(); it++)
      cerr << boost::format(PRINT_TEXT::PSM_NOT_ENTERED) % it->first.filename % it->first.psmid << endl;
    return true;
    }
  catch (exception &e) {
    cerr << e.what() << endl;
    fpr.close();
    fpw.close();
    return false;
    }
  }
Example #28
0
//-----------------------------------------------------------------------------
std::size_t DofMapBuilder::build_constrained_vertex_indices(
  const Mesh& mesh,
  const std::map<unsigned int,
  std::pair<unsigned int, unsigned int> >& slave_to_master_vertices,
  std::vector<std::size_t>& modified_global_indices)
{
  // MPI communicator
  const MPI_Comm mpi_comm = mesh.mpi_comm();

  // Get vertex sharing information (local index, [(sharing process p,
  // local index on p)])
  const boost::unordered_map<unsigned int, std::
                             vector<std::pair<unsigned int, unsigned int> > >
    shared_vertices = DistributedMeshTools::compute_shared_entities(mesh, 0);

   // Mark shared vertices
  std::vector<bool> vertex_shared(mesh.num_vertices(), false);
  boost::unordered_map<unsigned int, std::vector<std::pair<unsigned int,
      unsigned int> > >::const_iterator shared_vertex;
  for (shared_vertex = shared_vertices.begin();
       shared_vertex != shared_vertices.end(); ++shared_vertex)
  {
    dolfin_assert(shared_vertex->first < vertex_shared.size());
    vertex_shared[shared_vertex->first] = true;
  }

  // Mark slave vertices
  std::vector<bool> slave_vertex(mesh.num_vertices(), false);
  std::map<unsigned int, std::pair<unsigned int,
                                   unsigned int> >::const_iterator slave;
  for (slave = slave_to_master_vertices.begin();
       slave != slave_to_master_vertices.end(); ++slave)
  {
    dolfin_assert(slave->first < slave_vertex.size());
    slave_vertex[slave->first] = true;
  }

  // MPI process number
  const std::size_t proc_num = MPI::rank(mesh.mpi_comm());

  // Communication data structures
  std::vector<std::vector<std::size_t> >
    new_shared_vertex_indices(MPI::size(mesh.mpi_comm()));

  // Compute modified global vertex indices
  std::size_t new_index = 0;
  modified_global_indices
    = std::vector<std::size_t>(mesh.num_vertices(),
                               std::numeric_limits<std::size_t>::max());
  for (VertexIterator vertex(mesh); !vertex.end(); ++vertex)
  {
    const std::size_t local_index = vertex->index();
    if (slave_vertex[local_index])
    {
      // Do nothing, will get new master index later
    }
    else if (vertex_shared[local_index])
    {
      // If shared, let lowest rank process number the vertex
      boost::unordered_map<unsigned int, std::vector<std::pair<unsigned int, unsigned int> > >::const_iterator
        it = shared_vertices.find(local_index);
      dolfin_assert(it != shared_vertices.end());
      const std::vector<std::pair<unsigned int, unsigned int> >& sharing_procs
        = it->second;

      // Figure out if this is the lowest rank process sharing the vertex
      std::vector<std::pair<unsigned int, unsigned int> >::const_iterator
       min_sharing_rank = std::min_element(sharing_procs.begin(),
                                           sharing_procs.end());
      std::size_t _min_sharing_rank = proc_num + 1;
      if (min_sharing_rank != sharing_procs.end())
        _min_sharing_rank = min_sharing_rank->first;

      if (proc_num <= _min_sharing_rank)
      {
        // Re-number vertex
        modified_global_indices[vertex->index()] = new_index;

        // Add to list to communicate
        std::vector<std::pair<unsigned int, unsigned int> >::const_iterator p;
        for (p = sharing_procs.begin(); p != sharing_procs.end(); ++p)
        {
          dolfin_assert(p->first < new_shared_vertex_indices.size());

          // Local index on remote process
          new_shared_vertex_indices[p->first].push_back(p->second);

          // Modified global index
          new_shared_vertex_indices[p->first].push_back(new_index);
        }

        new_index++;
      }
    }
    else
      modified_global_indices[vertex->index()] = new_index++;
  }

  // Send number of owned entities to compute offeset
  std::size_t offset = MPI::global_offset(mpi_comm, new_index, true);

  // Add process offset to modified indices
  for (std::size_t i = 0; i < modified_global_indices.size(); ++i)
    modified_global_indices[i] += offset;

  // Add process offset to shared vertex indices before sending
  for (std::size_t p = 0; p < new_shared_vertex_indices.size(); ++p)
    for (std::size_t i = 1; i < new_shared_vertex_indices[p].size(); i += 2)
      new_shared_vertex_indices[p][i] += offset;

  // Send/receive new indices for shared vertices
  std::vector<std::vector<std::size_t> > received_vertex_data;
  MPI::all_to_all(mesh.mpi_comm(), new_shared_vertex_indices,
                  received_vertex_data);

  // Set index for shared vertices that have been numbered by another
  // process
  for (std::size_t p = 0; p < received_vertex_data.size(); ++p)
  {
    const std::vector<std::size_t>& received_vertex_data_p
      = received_vertex_data[p];
    for (std::size_t i = 0; i < received_vertex_data_p.size(); i += 2)
    {
      const unsigned int local_index = received_vertex_data_p[i];
      const std::size_t recv_new_index = received_vertex_data_p[i + 1];

      dolfin_assert(local_index < modified_global_indices.size());
      modified_global_indices[local_index] = recv_new_index;
    }
  }

  // Request master vertex index from master owner
  std::vector<std::vector<std::size_t> >
    master_send_buffer(MPI::size(mpi_comm));
  std::vector<std::vector<std::size_t> >
    local_slave_index(MPI::size(mpi_comm));
  std::map<unsigned int,
           std::pair<unsigned int, unsigned int> >::const_iterator master;
  for (master = slave_to_master_vertices.begin();
       master != slave_to_master_vertices.end(); ++master)
  {
    const unsigned int local_index = master->first;
    const unsigned int master_proc = master->second.first;
    const unsigned int remote_master_local_index = master->second.second;
    dolfin_assert(master_proc < local_slave_index.size());
    dolfin_assert(master_proc < master_send_buffer.size());
    local_slave_index[master_proc].push_back(local_index);
    master_send_buffer[master_proc].push_back(remote_master_local_index);
  }

  // Send/receive master local indices for slave vertices
  std::vector<std::vector<std::size_t> > received_slave_vertex_indices;
  MPI::all_to_all(mpi_comm, master_send_buffer,
                  received_slave_vertex_indices);

  // Send back new master vertex index
  std::vector<std::vector<std::size_t> >
    master_vertex_indices(MPI::size(mpi_comm));
  for (std::size_t p = 0; p < received_slave_vertex_indices.size(); ++p)
  {
    const std::vector<std::size_t>& local_master_indices
      = received_slave_vertex_indices[p];
    for (std::size_t i = 0; i < local_master_indices.size(); ++i)
    {
      std::size_t master_local_index = local_master_indices[i];
      dolfin_assert(master_local_index < modified_global_indices.size());
      master_vertex_indices[p].push_back(modified_global_indices[master_local_index]);
    }
  }

  // Send/receive new global master indices for slave vertices
  std::vector<std::vector<std::size_t> > received_new_slave_vertex_indices;
  MPI::all_to_all(mpi_comm, master_vertex_indices,
                  received_new_slave_vertex_indices);

  // Set index for slave vertices
  for (std::size_t p = 0; p < received_new_slave_vertex_indices.size(); ++p)
  {
    const std::vector<std::size_t>& new_indices
      = received_new_slave_vertex_indices[p];
    const std::vector<std::size_t>& local_indices = local_slave_index[p];
    for (std::size_t i = 0; i < new_indices.size(); ++i)
    {
      const std::size_t local_index = local_indices[i];
      const std::size_t new_global_index   = new_indices[i];

      dolfin_assert(local_index < modified_global_indices.size());
      modified_global_indices[local_index] = new_global_index;
    }
  }

  // Send new indices to process that share a vertex but were not
  // responsible for re-numbering
  return MPI::sum(mpi_comm, new_index);
}
Example #29
0
void HDBScan::get_clusters(vector<CondensedTree*>& tree,
                           boost::unordered_map<int, double>& stability,
                           vector<int>& out_labels,
                           vector<double>& out_probs,
                           vector<double>& out_stabilities,
                           int cluster_selection_method,
                           bool allow_single_cluster,
                           bool match_reference_implementation)
{
    vector<int> node_list;
    boost::unordered_map<int, double>::iterator sit;
    for (sit = stability.begin(); sit!=stability.end(); sit++) {
        node_list.push_back(sit->first);
    }
    std::sort(node_list.begin(), node_list.end(), std::greater<int>());
    if (!allow_single_cluster) {
        // exclude root
        node_list.pop_back();
    }
    
    vector<CondensedTree*> cluster_tree;
    for (int i=0; i<tree.size(); i++) {
        if (tree[i]->child_size > 1) {
            cluster_tree.push_back(tree[i]);
        }
    }
    
    boost::unordered_map<int, bool> is_cluster;
    for (int i=0; i<node_list.size(); i++) {
        is_cluster[node_list[i]] = true;
    }
    
    int num_points = DBL_MIN;
    for (int i=0; i<tree.size(); i++) {
        if (tree[i]->child_size == 1) {
            if (tree[i]->child > num_points) {
                num_points = tree[i]->child;
            }
        }
    }
    num_points += 1;
    
    double max_lambda = tree[0]->lambda_val;
    for (int i=1; i<tree.size(); i++) {
        if (tree[i]->lambda_val  > max_lambda) {
            max_lambda = tree[i]->lambda_val;
        }
    }
    
    if (cluster_selection_method == 0) {
        // eom
        for (int i=0; i<node_list.size(); i++) {
            int node = node_list[i];
            
            double subtree_stability = 0;
            
            for (int j=0; j<cluster_tree.size(); j++) {
                if (cluster_tree[j]->parent == node) {
                    //child_selection.push_back(node);
                    int child = cluster_tree[j]->child;
                    subtree_stability += stability[child];
                }
            }
            
            if (subtree_stability > stability[node]) {
                is_cluster[node] = false;
                stability[node] = subtree_stability;
            } else {
                vector<int> sub_nodes = bfs_from_cluster_tree(cluster_tree, node);
                for (int j=0; j<sub_nodes.size(); j++) {
                    int sub_node = sub_nodes[j];
                    if (sub_node != node) {
                        is_cluster[sub_node] = false;
                    }
                }
            }
        }
    } else if (cluster_selection_method == 1) {
        // leaf
        int parent_min = tree[0]->parent;
        for (int i=1; i<tree.size(); i++) {
            if (tree[i]->parent < parent_min) {
                parent_min = tree[i]->parent;
            }
        }
        boost::unordered_map<int, bool>::iterator it;
        
        vector<int> leaves_ = get_cluster_tree_leaves(cluster_tree);
        set<int> leaves;
        for (int i=0; i<leaves_.size(); i++) {
            leaves.insert(leaves_[i]);
        }
        if ( leaves.empty()) {
            for (it=is_cluster.begin(); it!=is_cluster.end(); it++) {
                is_cluster[it->first] = false;
            }
            is_cluster[parent_min] = true;
        }
        for (it=is_cluster.begin(); it!=is_cluster.end(); it++) {
            int c = it->first;
            if (leaves.find(c) != leaves.end()) {
                is_cluster[c] = true;
            } else {
                is_cluster[c] = false;
            }
        }
    }
    
    set<int> clusters;
    boost::unordered_map<int, bool>::iterator it;
    for (it = is_cluster.begin(); it!= is_cluster.end(); it++) {
        int c = it->first;
        if (it->second) {
            clusters.insert(c);
        }
    }
    vector<int> _clusters;
    set<int>::iterator _it;
    for (_it =clusters.begin(); _it != clusters.end(); _it++) {
        _clusters.push_back(*_it);
    }
    
    std::sort(_clusters.begin(), _clusters.end());
    
    boost::unordered_map<int, int> cluster_map, reverse_cluster_map;
    for (int i=0; i<_clusters.size(); i++) {
        cluster_map[_clusters[i]] = i;
        reverse_cluster_map[i] = _clusters[i];
    }
    
    // do labeling (tree, clusters, cluster_map, False, False
    out_labels = do_labelling(tree, clusters, cluster_map, allow_single_cluster, match_reference_implementation);
    
    //  probs = get_probabilities(tree, reverse_cluster_map, labels)
    out_probs = get_probabilities(tree, reverse_cluster_map, out_labels);
    
    // stabilities = get_stability_scores(labels, clusters, stability, max_lambda)
    out_stabilities = get_stability_scores(out_labels, clusters, stability, max_lambda);
}
void Task::featuresOut(const int current_image_idx, const boost::unordered_map<boost::uuids::uuid, StereoFeature> &hash)
{
    ExteroFeatures features_samples;
    base::samples::Pointcloud features_points;
    double const &baseline(cameracalib.extrinsic.tx);
    cv::Mat cv_image1;

    /** Uncertainty in the images (left and right) planes **/
    Eigen::Matrix4d px_var;
    px_var << this->pxleftVar, Eigen::Matrix2d::Zero(),
        Eigen::Matrix2d::Zero(), this->pxrightVar;


    #ifdef DEBUG_PRINTS
    std::cout<<"[FEATURES_OUT] Current hash.size(): "<<hash.size()<<"\n";
    #endif

    /** Parse the hash table of features **/
    for (boost::unordered_map<boost::uuids::uuid, StereoFeature>::const_iterator
                    it = hash.begin(); it != hash.end(); ++it)
    {
        //std::cout<<"[FEATURES_OUT] img_idx: "<<it->second.img_idx<<" current_idx: "<<current_image_idx<<"\n";
        if (it->second.img_idx == current_image_idx)
        {
            Feature feature;

            /** Get the uuid **/
            feature.index = it->first;

            /** Take the "Stereo" 2d point **/
            cv::Point const &left_pt(it->second.keypoint_left.pt);
            cv::Point const &right_pt(it->second.keypoint_right.pt);
            feature.stereo_point = base::Vector3d(left_pt.x, right_pt.x, left_pt.y);

            /** Compute the 3d point **/
            double disparity = std::min(right_pt.x - left_pt.x, -1);
            base::Vector4d image_point (left_pt.x, left_pt.y, disparity, 1);
            base::Vector4d homogeneous_point = Q * image_point;

            feature.point_3d = base::Vector3d (homogeneous_point(0)/homogeneous_point(3),
                                homogeneous_point(1)/homogeneous_point(3),
                                homogeneous_point(2)/homogeneous_point(3));
            #ifdef DEBUG_PRINTS
            std::cout<<"[FEATURES_OUT] Image point[left]: "<<left_pt.x<<" "<<left_pt.y<<"\n";
            std::cout<<"[FEATURES_OUT] Image point[right]: "<<right_pt.x<<" "<<right_pt.y<<"\n";
            std::cout<<"[FEATURES_OUT] 3D point:\n"<<feature.point_3d<<"\n";
            #endif

            if (_output_debug.value())
            {
                /** 3D point coordinates in base point cloud structure **/
                features_points.points.push_back(base::Vector3d (
                                homogeneous_point(0)/homogeneous_point(3),
                                homogeneous_point(1)/homogeneous_point(3),
                                homogeneous_point(2)/homogeneous_point(3)));

                /** Color **/
                cv_image1 = frame_helper::FrameHelper::convertToCvMat(this->left_color_frame);
                cv::Vec3b color = cv_image1.at<cv::Vec3b>(left_pt.y, left_pt.x);
                base::Vector4d color4d;
                color4d[0] = color[0]/255.0;//R
                color4d[1] = color[1]/255.0;//G
                color4d[2] = color[2]/255.0;//B
                color4d[3] = 1.0;//Alpha
                features_points.colors.push_back(color4d);
            }

            /** Compute the covariance **/
            Eigen::Matrix<double, 3, 4> noise_jacobian; /** Jacobian Matrix for the triangulation noise model */
            double disparity_power = pow(disparity,2);

            noise_jacobian <<  -(baseline*right_pt.x)/disparity_power, 0.00, (baseline*left_pt.x)/disparity_power, 0.00,
                -(baseline*left_pt.y)/disparity_power, baseline/disparity, (baseline*left_pt.y)/disparity_power, 0.00,
                -(baseline*cameracalib.camLeft.fx)/disparity_power, 0.00,  (baseline*cameracalib.camLeft.fx)/disparity_power, 0.00;

            feature.cov_3d = noise_jacobian * px_var * noise_jacobian.transpose();

            /** Store the feature in the vector **/
            features_samples.features.push_back(feature);
        }
    }

    #ifdef DEBUG_PRINTS
    std::cout<<"[FEATURES_OUT] Sent "<<features_samples.features.size()<<" vector of uuids\n";
    #endif

    features_samples.time = this->frame_pair.time;
    features_samples.img_idx = current_image_idx;
    _features_samples_out.write(features_samples);

    if (_output_debug.value())
    {
        features_points.time =  this->frame_pair.time;
        _features_point_samples_out.write(features_points);
    }

    return;
}