WeightedFace(shared_ptr<Face> face_,
              const milliseconds& delay = milliseconds(0))
   : face(face_)
   , lastDelay(delay)
 {
   calculateWeight();
 }
Esempio n. 2
0
uint32_t GraphData::getOutgoingBandwidth( const uint32_t & ip, std::stringstream &connections )
{
	uint32_t outgoing = 0;
	std::map< uint32_t, GraphInfo* >::iterator itr;
	graphMapMutex_.lock( );
   connections << "<Outgoing>" << std::endl;
	for( itr = graphMap_[ip].begin(); itr != graphMap_[ip].end(); ++itr )
	{
		outgoing += calculateWeight( itr->second->weights, itr->second->lastAccess );
		std::vector< Connections >::iterator citr;
      for( citr = itr->second->connections.begin(); citr != itr->second->connections.end(); ++citr )
		{
			connections << "<Connection>" << std::endl;
			connections << "<Protocol>" << citr->protocol << "</Protocol>" << std::endl;
         connections << "<Source>" << std::endl;
         connections << "<IP>" << inet_ntoa( *((struct in_addr*)&ip)) << "</IP>" << std::endl;
         connections << "<Port>" << citr->sport << "</Port>" << std::endl;
         connections << "</Source>" << std::endl;
         connections << "<Destination>" << std::endl;
         connections << "<IP>" << inet_ntoa( *((struct in_addr*)&(itr->first))) << "</IP>" << std::endl;
         connections << "<Port>" << citr->dport << "</Port>" << std::endl;
         connections << "</Destination>" << std::endl;
			connections << "</Connection>" << std::endl;
		}
	}
   connections << "</Outgoing>" << std::endl;
	graphMapMutex_.unlock( );
	return outgoing;
}
Esempio n. 3
0
bool UInventoryComponent::removeItem(UItemBase* Item, int32 ammount)
{
	if (!Item) return false;
	if (ammount > 0)
	{
		UItemBase* place = items[Item->type].map[Item];
		if (place)
		{

			if (ammount > place->ammount) ammount = place->ammount;
			currentWeight -= place->weight * ammount;
			place->ammount -= ammount;
			if (place->ammount > 0) return false;
			//fallthrough to past if nothing is left of the thing
		}
		else
		{
			return false;
		}
	}
	items[Item->type].map.Remove(Item);
	equipment->unequipItemByPointer(Item);//used only when character needs to be equipped while looting
	refresh();
	calculateWeight();
	return true;

}
Esempio n. 4
0
	void Inventory::updateStats()
	{
		calculateWeight(getAllItems());
		calculateRsAndBe();
		// flag setzen: Werte sind up to Date
		mValuesUpToDate = true;
	}
Esempio n. 5
0
void UInventoryComponent::dropItem(UItemBase* Item)
{
	if (!Item) return;
	items[Item->type].map.Remove(Item);
	if(Item->ammount > 0) GetWorld()->SpawnActor<AItemBaseActor>(itemBaseTemplate, GetOwner()->GetActorLocation(), GetOwner()->GetActorRotation())->spawn(Item);
	if (requiresUI)
		Item->widget->RemoveFromParent();
	calculateWeight();
}
Esempio n. 6
0
bool UInventoryComponent::addItem(UItemBase* Item,bool forceNew)
{
	if (!Item) return true;
	
	if (items.Find(Item->type) == NULL) return false;
	if (items[Item->type].map.Find(Item) != NULL)
	{
		return true;
	}
	if (forceNew)
	{
		addItemCreate(Item);
	}
	else
	{
		
		
			for (auto& x : items[Item->type].map)
			{
				if (x.Key->name == Item->name)
				{
					int32 ammountPossibleToAdd = x.Key->maxAmmount - x.Key->ammount;
					if (ammountPossibleToAdd  < Item->ammount )
					{
						x.Key->ammount += ammountPossibleToAdd;
						Item->ammount -= ammountPossibleToAdd;
					}
					else
					{
						x.Key->ammount += Item->ammount;
						Item->ammount = 0;
					}
					if (requiresUI)
						if(x.Key->widget) x.Key->widget->loadVisuals();
				}
				
			}
			if (Item->ammount > 0)
			{
				addItemCreate(Item);
			}
		
	}
	if (requiresUI)
		if (Item->widget) Item->widget->loadVisuals();
	calculateWeight();
	refresh();
	return true;
}
Esempio n. 7
0
T* UInventoryComponent::createItem(FString ID)
{
	
	static const FString ContextString(TEXT("GENERAL"));
	FItemTable* row = standardItemTable->FindRow<FItemTable>(FName(*ID), ContextString);
	if (!row)
	{
		UE_LOG(LogTemp, Warning, TEXT("ItemRowNotFound"));
		return NULL;
	}
	calculateWeight();
	T* x = Cast<T>(NewObject<UItemBase>(this, row->base));
	Cast<UItemBase>(x)->initialize(GetOwner()->GetWorld());
	return x;
}
ClassifyDocum::ClassifyDocum(string nameclass ,string namedirclass) // конструктор , сразу нормализует документы
{
	countAllWords = 0;
	nameClass=nameclass;
	nameDirClass = namedirclass;
	normalize = new NormalizeDocum(nameDirClass);
	normalize->scanListFiles();
	normalize->normalizeFiles();
	listFiles = normalize->getListFiles();
	countAllFiles = listFiles.size();
	calculateWords();
	calculateWeight();
	cout<<listFiles.size()<<endl;

}
Esempio n. 9
0
std::string GraphData::makeGraphPacket()
{
	std::string data;
	std::string datastream;
	graphMapMutex_.lock( );
	std::cerr << "mutex locked" << std::endl;

	std::map< uint32_t, std::map< uint32_t, GraphInfo*> >::iterator ritr;
	std::map< uint32_t, GraphInfo* >::iterator citr;
	std::map< uint32_t, GraphInfo* >::iterator tmp;
	uint32_t edges = 0;
	edgeLifeMutex_.lock( );
	for( ritr = graphMap_.begin(); ritr != graphMap_.end(); ++ritr )
	{
		for( citr = ritr->second.begin(); citr != ritr->second.end();  )
		{
			tmp = citr; //Needed to be able to delete the current element in all cases.
			++citr;
			//edge exist
			//recalculate weight
			time_t currentTime = time( NULL );
			if( (currentTime - tmp->second->lastAccess)  >= edgeLife_ )
			{
				//edge past life expectancy - time to die
				Edge edge;
				edge.ipA = ritr->first;
				edge.ipB = tmp->first;
				deadNodesMutex_.lock( );
				deadNodes_.push_back( edge );
				deadNodesMutex_.unlock();
				delete tmp->second;
				(ritr->second).erase( tmp->first );
				continue;
			}
			++edges;
			data += numToString( ritr->first );
			data += numToString( tmp->first );
			data += numToString( htonl(calculateWeight((tmp->second)->weights, tmp->second->lastAccess)) );
		}
	}
	edgeLifeMutex_.unlock( );
	graphMapMutex_.unlock( );
	std::cout << "Number of Edges: " << edges << std::endl;
	datastream += numToString( htonl(edges) );
	datastream += data;
	return datastream;
}
Esempio n. 10
0
void MultiColvarBase::performTask( const unsigned& task_index, const unsigned& current, MultiValue& myvals ) const {

  AtomValuePack myatoms( myvals, this );
  // Retrieve the atom list
  if( !setupCurrentAtomList( current, myatoms ) ) return;

  // Do a quick check on the size of this contribution  
  calculateWeight( myatoms ); 
  if( myatoms.getValue(0)<getTolerance() ){
     updateActiveAtoms( myatoms );
     return;   
  }

  // Compute everything
  double vv=doCalculation( task_index, myatoms ); 
  myatoms.setValue( 1, vv );
  return;
}
Esempio n. 11
0
void ActiveGroup::finish() 
{
	const int nsel = vertices->size();
	if(nsel < 1) return;

	average(vertices);
	
	if(nsel > 1) {
		meanPosition *= 1.f / (float)nsel;
		
		meanPosition = incidentRay.closetPointOnRay(meanPosition);
		
		meanNormal.normalize();
	}
	//std::cout<<"\n n sel "<<nsel
	//<<"\n mean p "<<meanPosition<<" depth "<<depthMin;
	
	calculateWeight(vertices);
}
Esempio n. 12
0
STImage *FieldMorph(STImage *image,
                    const std::vector<Feature> &sourceFeatures,
                    const std::vector<Feature> &targetFeatures,
                    float t, float a, float b, float p)
{
    int width = image->GetWidth();
    int height = image->GetHeight();
    STImage *result = new STImage(width, height, STColor4ub(255,255,255,255));
    
    std::vector<Feature> interpolatedFeatures = interpolateFeatures(sourceFeatures, targetFeatures, t);
    
    for (int x = 0; x < width; x++) {
        for (int y = 0; y < height; y++) {
            STVector2 dispSum = STVector2(0, 0);
            float weightsum = 0;
            STPoint2 X = STPoint2(x, y);
            
            int numFeatures = sourceFeatures.size();
            for (int i = 0; i < numFeatures; i++) {
                STPoint2 Pp = sourceFeatures[i].P;
                STPoint2 Qp = sourceFeatures[i].Q;
                STPoint2 P = interpolatedFeatures[i].P;
                STPoint2 Q = interpolatedFeatures[i].Q;
                
                float u = calculateU(X, P, Q);
                float v = calculateV(X, P, Q);
                STPoint2 Xp = calculateXp(Pp, Qp, u, v);
                
                STVector2 displacement = STVector2(Xp) - STVector2(X);
                float dist = calculateDistance(X, P, Q, u, v);
                float weight = calculateWeight(Q, P, a, b, p, dist);
                dispSum += displacement * weight;
                weightsum += weight;
            }
            STPoint2 Xprime = X + dispSum/weightsum;
            
            result->SetPixel(x, y, interpolatedColor(Xprime, image));
        }
    }
    
    return result;
}
Esempio n. 13
0
uint32_t GraphData::getIncommingBandwidth( const uint32_t & ip, std::stringstream &connections )
{
	uint32_t incomming = 0;
	std::map< uint32_t, std::map< uint32_t, GraphInfo* > >::iterator ritr;
	std::map< uint32_t, GraphInfo* >::iterator citr;
	graphMapMutex_.lock( );
   connections << "<Incoming>"  << std::endl;
	for( ritr = graphMap_.begin( ); ritr != graphMap_.end(); ++ritr )
	{
		for( citr = ritr->second.begin(); citr != ritr->second.end(); ++citr )
		{
			if( citr->first == ip )
			{
				//incomming
				incomming += calculateWeight( citr->second->weights, citr->second->lastAccess );
				std::vector< Connections >::iterator itr;
            for( itr = citr->second->connections.begin(); itr != citr->second->connections.end(); ++itr )
				{
					connections << "<Connection>" << std::endl;
               connections << "<Protocol>" << itr->protocol << "</Protocol>" << std::endl;
               connections << "<Source>" << std::endl;
               connections << "<IP>" << inet_ntoa( *((struct in_addr*)&(citr->first)) ) << "</IP>" << std::endl;
               connections << "<Port>" << itr->dport << "</Port>" << std::endl;
               connections << "</Source>" << std::endl;
               connections << "<Destination>" << std::endl;
               connections << "<IP>" << inet_ntoa( *((struct in_addr*)&(ritr->first)) ) << "</IP>" << std::endl;
               connections << "<Port>" << itr->sport << "</Port>" << std::endl;
               connections << "</Destination>" << std::endl;
               connections << "</Connection>" << std::endl;
				}
			}
			else
			{
				//next
				continue;
			}
		}
	}
   connections << "</Incoming>" << std::endl;
	graphMapMutex_.unlock( );
	return incomming;
}
Esempio n. 14
0
void MultiColvarBase::performTask(){
  // Currently no atoms have derivatives so deactivate those that are active
  atoms_with_derivatives.deactivateAll();
  // Currently no central atoms have derivatives so deactive them all
  atomsWithCatomDer.deactivateAll();
  // Retrieve the atom list
  if( !setupCurrentAtomList( getCurrentTask() ) ) return;

  // Do a quick check on the size of this contribution  
  calculateWeight(); // printf("HELLO WEIGHT %f \n",getElementValue(1) );
  if( getElementValue(1)<getTolerance() ){
     updateActiveAtoms();
     return;   
  }

  // Compute everything
  double vv=doCalculation();
  // Set the value of this element in ActionWithVessel
  setElementValue( 0, vv );
  return;
}
Esempio n. 15
0
MStatus BCIViz::compute( const MPlug& plug, MDataBlock& block )
{
	if( plug == outValue ) {
		MStatus status;
		
		MDagPath path;
		MDagPath::getAPathTo(thisMObject(), path);
		
		MMatrix worldInverseSpace = path.inclusiveMatrixInverse();
		
		MDataHandle inputdata = block.inputValue(ainput, &status);
        if(status) {
			const MMatrix drvSpace = inputdata.asMatrix();
			fDriverPos.x = drvSpace(3, 0);
			fDriverPos.y = drvSpace(3, 1);
			fDriverPos.z = drvSpace(3, 2);
			
			fDriverPos *= worldInverseSpace;
		}
		
		fTargetPositions.clear();
		
		MArrayDataHandle htarget = block.inputArrayValue( atargets );
		unsigned numTarget = htarget.elementCount();
		
		fTargetPositions.setLength(numTarget);
		
		for(unsigned i = 0; i<numTarget; i++) {
			MDataHandle tgtdata = htarget.inputValue(&status);
			if(status) {
				const MMatrix tgtSpace = tgtdata.asMatrix();
				MPoint tgtPos(tgtSpace(3,0), tgtSpace(3,1), tgtSpace(3,2));
				tgtPos *= worldInverseSpace;
				MVector disp = tgtPos;
				disp.normalize();
				tgtPos = disp;
				fTargetPositions[i] = tgtPos;
			}
			htarget.next();
		}
		
		m_hitTriangle = 0;
		neighbourId[0] = 0;
		neighbourId[1] = 1;
		neighbourId[2] = 2;
		
		if(!checkTarget())
		{
			MGlobal::displayWarning("convex hull must have no less than 4 targes.");
			return MS::kSuccess;
		}
		
		if(!checkFirstFour(fTargetPositions))
		{
			MGlobal::displayWarning("first 4 targes cannot sit on the same plane.");
			return MS::kSuccess;
		}
		
		if(!constructHull())
		{
			MGlobal::displayWarning("convex hull failed on construction.");
			return MS::kSuccess;
		}

		findNeighbours();
		
		calculateWeight();

        MArrayDataHandle outputHandle = block.outputArrayValue( outValue );
		
		int numWeight = fTargetPositions.length();

		m_resultWeights.setLength(numWeight);
		
		for(int i=0; i < numWeight; i++) 
			m_resultWeights[i] = 0.0;
			
		m_resultWeights[neighbourId[0]] = fAlpha;
		m_resultWeights[neighbourId[1]] = fBeta;
		m_resultWeights[neighbourId[2]] = fGamma;
		
		MArrayDataBuilder builder(outValue, numWeight, &status);
		
		for(int i=0; i < numWeight; i++) {
			MDataHandle outWeightHandle = builder.addElement(i);
			outWeightHandle.set( m_resultWeights[i] );
			//MGlobal::displayInfo(MString("wei ") + i + " " + weights[i]);
		}
		
		outputHandle.set(builder);
		outputHandle.setAllClean();
    }

	return MS::kSuccess;
}
Esempio n. 16
0
float UInventoryComponent::getWeight()
{
	calculateWeight();
	return currentWeight;
}
Esempio n. 17
0
/*任务类要执行的任务
 */
void Task::process()
{
	map<string,double> query;		//存储查询词权重
	calculateWeight(query);			//计算查询词权重
	if(query.size()==0)
	{
		cout<<"查询词为空"<<endl;
		return;
	}
	map<string,double>::iterator it = query.begin();
	map<int,double> ret;
	ret = index_.search(it->first);	//调用InvertIndex中的search()函数,返回对应单词的倒排列表
	map<int,double>::iterator pos = ret.begin();	//用于遍历ret的迭代器
	map<int,map<string,double> > common;			//存储交集容器
	while(pos!=ret.end())							//遍历map<int,double> ret 生成第一个交集
	{
		pair<int,map<string,double> > pr1;	//element of common
		pr1.first = pos->first;				//docid
		pair<string,double> pr2;			//element of pr1.second
		pr2.first = it->first;				//string
		pr2.second = pos->second;			//weight
		pr1.second.insert(pr2);	
		common.insert(pr1);
		++pos;
	}
	it++;
	//取交集值
	while(it!=query.end())
	{
		string word(it->first);
		ret = index_.search(word);//查找下一个查询词
		map<int,double>::iterator invalid = ret.begin();
		if(-1==(invalid->first))
		{

			query.erase(it);
			it++;
			continue;
		}
		if(0==(invalid->first))
			ret.erase(invalid);
		map<int,map<string,double> >::iterator beg1 = common.begin();
		map<int,map<string,double> >::iterator last1 = common.end();
		map<int,double>::iterator beg2 = ret.begin();
		map<int,double>::iterator last2 = ret.end();
		common = intersection(&beg1,&last1,&beg2,&last2,word);//交集
		it++;
	}
	//求余弦值
	if(common.size()==0)
	{
		cout<<"交集为空"<<endl;
		return;
	}
	map<int,map<string,double> >::iterator iter = common.begin();
	map<string,double>::iterator iter1 = query.begin();
	Document doc;
	while(iter!=common.end())
	{
		double fenzi=0,fenmu=0,part1=0,part2=0;
		double cos;
		while(iter1!=query.end())
		{
			fenzi = fenzi +(iter1->second)*(query[iter1->first]);//分子 = 分子 +
			part1 = part1 +(iter1->second)*(iter1->second);
			part2 = part2 +(query[iter1->first])*(query[iter1->first]);
			++iter1;
		}
		fenmu = sqrt(part1)*sqrt(part2);
		cos = fenzi/fenmu;
		memset(&doc,0,sizeof(doc));
		if(iter->first==0)
		{
			++iter;
			continue;
		}
		doc.docid = iter->first;
		doc.cosValue = cos;
		pq_.push(doc);
		++iter;
	}
}