示例#1
0
Cloth::Cloth(FXMVECTOR topLeftPostition, float height, float width, int numRows, int numColumns, float totalMass, float structuralStiffness, float structuralDamping, float shearStiffness, float shearDamping, float flexionStiffness, float flexionDamping) :
 timeSpentCalculatingInternalForce(0.0), timeSpentCalculatingExternalForce(0.0) {
  createParticles(topLeftPostition, height, width, totalMass);
  createStructuralLinks(structuralStiffness, structuralDamping);
  createShearLinks(shearStiffness, shearDamping);
  createFlexionLinks(flexionStiffness, flexionDamping);
}
void Filtro_Particulas::spin()
{
	ros::Rate loopRate(freq_);
	while(n_.ok())
	{
		ros::spinOnce();
		loopRate.sleep();
		//cout<<free_ok_<<occ_ok_<<odom_ok_<<laser_ok_<<endl;
		if (free_ok_ == true && occ_ok_ == true){
			createParticles();
			if(create_particle_ok_ == 0  && odom_ok_ == true && laser_ok_ == true && zerar_deltas_ == false){
				pose_anterior_.x = pose_x_;
				pose_anterior_.y = pose_y_;
				pose_anterior_.theta = pose_theta_;

				zerar_deltas_ = true;

				moveParticles();
				//cout<<"moveParticles()"<<endl;
			}else if(create_particle_ok_ == 0  && odom_ok_ == true && laser_ok_ == true && zerar_deltas_ == true){
				moveParticles();

			}
		}
	}
}
示例#3
0
/**
 * Create Water Generic Emiter
 */
void createWaterEmiter(vec2 pos)
{
	Emiter temp = createGenericEmiter(2, pos);	
	temp.ttlMax =  ((float)rand()/(float)(RAND_MAX)) * (MAX_TTL_WATER - MIN_TTL_WATER) + MIN_TTL_WATER;
	temp.nbParticle = rand() % (MAX_PARTICLE_WATER - MIN_PARTICLE_WATER) + MIN_PARTICLE_WATER;
	createParticles(temp);
	temp.ttlCurr = temp.ttlMax;
	temp.ttlPrev = temp.ttlMax;
	ParticleEmiters.push_back(temp);
}
示例#4
0
/**
 * Create FireWork Emiter
 */
void createFireWorkEmiter(vec2 pos)
{
	Emiter temp = createGenericEmiter(1, pos);
	temp.ttlMax =  ((float)rand()/(float)(RAND_MAX)) * (MAX_TTL_FW - MIN_TTL_FW) + MIN_TTL_FW;
	temp.nbParticle = rand() % (MAX_PARTICLE_FW - MIN_PARTICLE_FW) + MIN_PARTICLE_FW;
	createParticles(temp);
	temp.ttlCurr = temp.ttlMax;
	temp.ttlPrev = temp.ttlMax;
	ParticleEmiters.push_back(temp);
}
示例#5
0
void GvParticle::update(float dt) 
{

	updateParticles(dt);
 	createParticles(dt*rate);
	if (getNumParticles() > maxCount) 
	{
		deleteParticles(getNumParticles() - maxCount);
	}

}
示例#6
0
//--------------------------------------------------------------
void AnimationParticlesMega2::VM_draw(float w, float h)
{
	drawBackground(0);

    m_resolution.set(w,h);
    createParticles();

    if (!m_isParticlesInit) return;
    
    particleSystem.setTimeStep(timeStep);
 
	m_particlesVbo.updateVertexData(m_particlesPos, kParticles*1024);
	m_particlesVbo.updateColorData(m_particlesColor, kParticles*1024);
    
	ofEnableAlphaBlending();
//	ofSetColor(255, 255, 255, lineOpacity);
	particleSystem.setupForces();
    
	// apply per-particle forces
//	glBegin(GL_LINES);
	for(int i = 0; i < particleSystem.size(); i++)
    {
		Particle& cur = particleSystem[i];

		// global force on other particles
		//particleSystem.addRepulsionForce(cur, particleNeighborhood, particleRepulsion/100);
		
        // forces on this particle
		cur.bounceOffWalls(0, 0, w, h);
		cur.addDampingForce();
	}
//	glEnd();
    
	// single global forces
	map<string,ParticleForce*>::iterator it = m_mapParticleForce.begin();
	ParticleForce* pParticleForce=0;
	for ( ; it != m_mapParticleForce.end() ; ++it)
	{
		pParticleForce = it->second;
	
		particleSystem.m_color = m_isColorFromDevice ? pParticleForce->m_color : ofColor(255);
		particleSystem.addAttractionForce(pParticleForce->m_anchor.x, pParticleForce->m_anchor.y, w, centerAttraction*m_ampAttraction);
    	particleSystem.addRepulsionForce(pParticleForce->m_anchor.x, pParticleForce->m_anchor.y, pParticleForce->m_volume*m_repulsionRadius, pParticleForce->m_volume*m_ampRepulsion, false);
    	particleSystem.addRepulsionForce(pParticleForce->m_anchor.x, pParticleForce->m_anchor.y, pParticleForce->m_volume*m_repulsionRadius*m_colorRadiusFactor, 0, true);
	}

        
    particleSystem.update();
	ofSetColor(255, 255, 255, pointOpacity);
	glPointSize(particleSystem.getParticleSize());
	m_particlesVbo.draw(GL_POINTS,0,kParticles*1024);
//	ofDisableAlphaBlending();
 }
示例#7
0
void ParticleGenerator::getFileInput(char* fileName, ParticleContainer* pc, Simulation *sim) {
	double m = 1;
	int num_cuboids = 0;

	std::ifstream input_file(fileName);
	string tmp_string;

	if (input_file.is_open()) {
		getline(input_file, tmp_string);
		LOG4CXX_DEBUG(iolog, "Read line: " << tmp_string);

		while (tmp_string.size() == 0 || tmp_string[0] == '#') {
			getline(input_file, tmp_string);
			LOG4CXX_DEBUG(iolog, "Read line: " << tmp_string);
		}

		istringstream numstream(tmp_string);
		numstream >> num_cuboids;
		LOG4CXX_DEBUG(iolog, "Reading " << num_cuboids << ".");
		getline(input_file, tmp_string);
		LOG4CXX_DEBUG(iolog, "Read line: " << tmp_string);

		for (int i = 0; i < num_cuboids; i++) {
			istringstream datastream(tmp_string);

			for (int j = 0; j < 3; j++) {
				datastream >> X[j];
			}
			for (int j = 0; j < 3; j++) {
				datastream >> V[j];
			}

			for (int j = 0; j < 3; j++) {
				datastream >> num[j];
			}
			if (datastream.eof()) {
				LOG4CXX_ERROR(iolog, "Error reading file: eof reached unexpectedly reading from line " << i);
				exit(-1);
			}

			datastream >> meanV;
			datastream >> M;
			datastream >> H;

			// create particles from cuboid data
			LOG4CXX_ERROR(particlelog, "Generating Cuboid...");
			createParticles(pc);

			getline(input_file, tmp_string);
		}
	} else {
示例#8
0
cloth::cloth(float width, float height, int num_particles_x, int num_particles_y) : num_particles_width(num_particles_x), num_particles_height(num_particles_y)
{
	faces.clear();
	fixedParticles.clear();
	particles.clear();
	constraints.clear();

	createParticles( width, height, num_particles_x, num_particles_y);
	createSprings();
	
	collisionFlag = false;
	draw_wire = false;
	clothThick = 0.1;
	collisionChecker = new collisionDetector();
	intersectQ=vec3(0,0,0);
	iterativeTimes = 15;
}
//! read particles matching a specific PDG name and run id from supplied
//  file. Must supply particle mass ourselves...
EventArray* readParticles(const std::string& file, 
                          const std::string& particle, 
                          const double mass, const std::string& runId) {
  
  int resultCode(0);
  size_t numberOf(0); 
  resultCode = countParticles(file, particle, runId, numberOf);
  if (resultCode) {
    std::cerr << "[pp6day3_muonanalysis:error] Failed to count particles in file "
              << file
              << std::endl;
    return 0;
  }

  // With number of particles known, create the appropriately sized
  // EventArray and fill it
  return createParticles(file, numberOf, particle, mass, runId);
}
示例#10
0
bool init(int argc, char *argv[]){

    setDataDir(argc, argv);
    initGLFW();
    ogle::initGLEW();
    bool found_extensions = checkExtensions();
    if (!found_extensions)
        return false;
    
    ogle::Debug::init();

    initGLSettings();

    createParticles();

    createBufferObject();

    return true;
}
示例#11
0
Cloth::Cloth(xml_node<>* clothParams) : timeSpentCalculatingInternalForce(0.0), timeSpentCalculatingExternalForce(0.0) {
  float x, y, z, height, width, mass, stiffness, damping;

  height = convertStringToNumber<float>(clothParams->first_attribute("height")->value());
  width = convertStringToNumber<float>(clothParams->first_attribute("width")->value());
  mass = convertStringToNumber<float>(clothParams->first_attribute("mass")->value());
  windConstant = convertStringToNumber<float>(clothParams->first_attribute("wind_constant")->value());

  xml_node<>* currentNode = clothParams->first_node("top_left_position");
  x = convertStringToNumber<float>(currentNode->first_attribute("x")->value());
  y = convertStringToNumber<float>(currentNode->first_attribute("y")->value());
  z = convertStringToNumber<float>(currentNode->first_attribute("z")->value());

  currentNode = clothParams->first_node("mesh_size");
  rows = convertStringToNumber<int>(currentNode->first_attribute("rows")->value());
  columns = convertStringToNumber<int>(currentNode->first_attribute("columns")->value());

  XMVECTOR topLeft = XMVectorSet(x, y, z, 0.0f);
  createParticles(topLeft, height, width, mass);

  currentNode = clothParams->first_node("structural");
  stiffness = convertStringToNumber<float>(currentNode->first_attribute("spring_coefficient")->value());
  damping = convertStringToNumber<float>(currentNode->first_attribute("damping_coefficient")->value());
  createStructuralLinks(stiffness, damping);

  currentNode = clothParams->first_node("shear");
  stiffness = convertStringToNumber<float>(currentNode->first_attribute("spring_coefficient")->value());
  damping = convertStringToNumber<float>(currentNode->first_attribute("damping_coefficient")->value());
  createShearLinks(stiffness, damping);

  currentNode = clothParams->first_node("flexion");
  stiffness = convertStringToNumber<float>(currentNode->first_attribute("spring_coefficient")->value());
  damping = convertStringToNumber<float>(currentNode->first_attribute("damping_coefficient")->value());
  createFlexionLinks(stiffness, damping);

  currentNode = clothParams->first_node("wind_direction");
  x = convertStringToNumber<float>(currentNode->first_attribute("x")->value());
  y = convertStringToNumber<float>(currentNode->first_attribute("y")->value());
  z = convertStringToNumber<float>(currentNode->first_attribute("z")->value());
  windDirection = XMVectorSet(x, y, z, 0.0f);
}
示例#12
0
int main(int argc, char** argv){
	
	int i,j,k,l;
	
	int timeStep=0;
	int worldRank;
	int worldSize;
	
	double elapseTime;
	clock_t start;
	clock_t end;
	float seconds1=0.00;
	float seconds3=0.00;
	
	int numParticle;
	int dispParticle;
	double distance;
	double initialEnergy;
	double energy;
	double totalEnergy=0.00;
	double localEnergy=0.00;
	double globalEnergy;
	double previousEnergy=0.00;
	double fabGlobal;
	double fabPrev;
	particle p[N];
	particle oldP[N];
	int newX,newY,newZ;
	
	//496 is derived from 32P2/2
	int index1Pair[496];
	int index2Pair[496];
	
	MPI_Datatype particleType;
	MPI_Datatype type[3]={MPI_DOUBLE,MPI_DOUBLE,MPI_DOUBLE};
	int blocklen[3]={1,1,1};
	MPI_Aint disp[3];
	MPI_Aint extent;
	//Initialize MPI
	MPI_Init(&argc,&argv);
	MPI_Comm_rank(MPI_COMM_WORLD,&worldRank);
	MPI_Comm_size(MPI_COMM_WORLD,&worldSize);
	MPI_Type_extent(MPI_DOUBLE,&extent);
	disp[0]=0;
	disp[1]=1*extent;
	disp[2]=2*extent;
	MPI_Type_struct(3,blocklen,disp,type,&particleType);
	MPI_Type_commit(&particleType);
    
	if(worldRank==0){
		createParticles(p);
		for(i=0;i<N;i++)
		{
			printf("Particle %d: X:%f,Y:%f,Z:%f\n",i,p[i].x,p[i].y,p[i].z);
		}
	}
	
	while(1){
		totalEnergy=0.00;
		localEnergy=0.00;
		globalEnergy=0.00;
		//broadcast particle coordinates to all processors
		MPI_Bcast(p,N,particleType, 0, MPI_COMM_WORLD);
        
		/*assign  number of particle to compute
         particle decomposition technique is used
         */
		numParticle =31;
		dispParticle = worldRank*(numParticle);
        
		//calculate total energy
        
		//form array 1 that contains the index of first particle of a pair
		l=0;
		k=N-1;//-1 to exclude same index pair
        
		for(i=0;i<N-1;i++){
			for(j=0;j<k;j++){
				index1Pair[l]=(N-1)-k+1;
				l++;
			}
			k--;
		}
        
		
        //form array 2 that contains the index of second particle of a pair
		l=0;
		k=N-1;
		for(i=0;i<N-1;i++){
			for(j=0;j<k;j++){
				index2Pair[l]=(N-1)-k+2+j;
				l++;
			}
			k--;
		}
   
		for(i=0;i<numParticle;i++){
			k=i+dispParticle;
			distance = sqrt(pow(p[index1Pair[k]].x-p[index2Pair[k]].x,2.0)+pow(p[index1Pair[k]].y-p[index2Pair[k]].y,2.0)+pow(p[index1Pair[k]].z-p[index2Pair[k]].z,2.0));
			if(distance == 0){
				energy=0.00;
			}
			else
				energy = 1/pow(distance,12.0)-1/pow(distance,6.0);
			totalEnergy = totalEnergy + energy;
		}
		localEnergy = totalEnergy;
        
		//sum of all energy
		MPI_Allreduce(&localEnergy,&globalEnergy, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
        
        
        
		if(timeStep ==0){
			initialEnergy=globalEnergy;
		}
		if(timeStep ==0 && worldRank==0)
			printf("Initial Energy= %f\n",initialEnergy);
        
		if(timeStep ==0){
            initialEnergy=fabs(globalEnergy);
        }
	
		
		//accept new coordinate if new state energy less than previous state
		fabGlobal = fabs(globalEnergy);
		fabPrev = fabs(previousEnergy);
        
		if( fabGlobal < fabPrev || timeStep==50000){
			if(fabGlobal <= (initialEnergy/4.00) && timeStep!=0 || timeStep ==50000){
				if(worldRank==0){
                    printf("Solution is found after %d\n",timeStep);
                    printf("New Energy = %f\n",globalEnergy);
				}
				break;
			}
		}
		
		else if(timeStep!=0){
			//if(worldRank==0)
            //printf("greater");
            for(i=0;i<N;i++){
                p[i].x=oldP[i].x;
                p[i].y=oldP[i].y;
                p[i].z=oldP[i].z;
                
            }
		}
        
		previousEnergy = globalEnergy;
        
		//save old coordinates before moving particles
		for(i=0;i<N;i++){
			oldP[i].x=p[i].x;
			oldP[i].y=p[i].y;
			oldP[i].z=p[i].z;
            
		}
        
		/*
         MOVING PARTICLES
         */
		if(worldRank==0){
			srand (time(NULL));
			for(i=0;i<N;i++){
				int randX=rand() % 19 + (-9);
				int randY=rand() % 19 + (-9);
				int randZ=rand() % 19 + (-9);
				newX = p[i].x*100 + randX*1;
				newY = p[i].y*100 + randY*1;
				newZ = p[i].z*100 + randZ*1;
				
				if(newX<=900 && newX>=100)
					p[i].x = (double)newX/100;
				if(newY<=900 && newY>=100)
					p[i].y = (double)newY/100;
				if(newZ<=900 && newZ>=100)
					p[i].z = (double)newZ/100;
			}
            
         
		}
		timeStep++;		
        
	}
    
	MPI_Finalize();
	return 0;
}
示例#13
0
void GvParticle::init() 
{

	clearParticles();
	createParticles(startCount);
}
示例#14
0
//--------------------------------------------------------------
void ofApp::update(){
    
    //openCV update/////////////////////////////////////////////////////////////////////////////////////////////////////////
    grabber.update();   //pull our next frame of video
    
    image.setFromPixels(grabber.getPixelsRef());    //set our CV Color Image to have the same data as the current frame
    
    greyImage = image;  //convert our color image to grayscale

    greyDiff.absDiff(greyBackground, greyImage);//compare the difference of the background to a greyed version
    
    greyProcessed = greyDiff;//set our greyProcessed to the greyDiff
    
    greyProcessed.threshold(250);//threshold for finding light this is set high so that it can find fine light points
    
    contourFinder.findContours(greyProcessed, 40, (grabber.width*grabber.height)/2, maxBlobs, true);//using the graber find the contours of the blob
    if(contourFinder.nBlobs == 1) // if the number of detected blobs is 1
    {
        drawPoint = true;//set draw point to be true to allow drawing
        
        createAlphaTrail();
        
        if(particles.size()<maxParticles)//if the size of the vector of particles is less than the max allowed particles
        {
            createParticles();//create particles
            checkParticles();//check the size of the vector
        }
    }
    else
    {
        drawPoint = false;//if none of the above is true then remain false to avoid drawing when nothing is detected
    }
    
    for(int i = 0; i < contourFinder.nBlobs; i++)//go throught the blobs and send the information to a location point
    {
        blobCenters[i] = contourFinder.blobs[i].centroid;
    }
    //openCV end////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    //audio update//////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    scaledVol = ofMap(smoothedVol, 0.0, 0.17, 0.0, 1.0, true);//map the smoothed volume to a sensible set of integers
    
    volHistory.push_back( scaledVol );//push the oldest volume recording in the vector
    
    if( volHistory.size() >= 400 )//if the volume history hits the cap of 400 erase the oldest volume recording
    {
		checkFreq();//check the recorded amount of frequencies
	}
    
    //audio end////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    //visuals update///////////////////////////////////////////////////////////////////////////////////////////////////////
    
    for(int i = 0; i < particles.size(); i++)
    {
        particles[i].applyForce(wind);//apply the wind force to the big circle particles
        particles[i].applyForce(gravity);//apply the gravity force to the big circle particles
        particles[i].changeAlpha();//change the particle alpha
        particles[i].particleFlow();//run the particle flow function on every particle
        particles[i].particleMass = scaledVolInt;//set the current particles mass to be the current volume for variation
        particles[i].update();//update particles
    }
    
    particleLoc = blobLocation;//particle location is equal to the location of the blob found using the camera (must update)
    
    if(drawPoint)
        {
            screenFbo.begin();//start the FBO
            if(fboTimer == 0)//if the timer is 0 clear the FBO to give it a delayed alpha trail effect
            {
                ofClear(255, 255, 255);//clear the screen of the old particles
                fboTimer = 4;//after clearing reset the timer
            }
            screenFbo.end();//end the fbo
    
            screenFbo.begin();
            ofEnableAlphaBlending();
            for(int i = 0; i < particles.size(); i++)//loop through and draw the particles
            {
                particles[i].draw();//draw the particles
                particles[i].particleFlow();//call the flow function on the particles
            }
            screenFbo.end();
        }
    //VISUALS end/////////////////////////////////////////////////////////////////////////////////////////////////////////
}