We want to draw some particle. at this moment, the particle should be drawn on the color that we tracking.

the particle that we want to draw is as in the following.

the main tap is ↓

/**
 * Simple Particle System
 * by Daniel Shiffman.  
 * 
 * Particles are generated each cycle through draw(),
 * fall with gravity and fade out over time
 * A ParticleSystem object manages a variable size (ArrayList) 
 * list of particles. 
 */

ParticleSystem ps;

void setup() {
  size(640,360);
  ps = new ParticleSystem(new PVector(width/2,50));
}

void draw() {
  background(0);
  if(mousePressed)
  {  ps.updateOrigin(new PVector(mouseX, mouseY)); }

  ps.addParticle();
  ps.run();
}

and the second tap is ↓

// A simple Particle class

class Particle {
  PVector location;
  PVector velocity;
  PVector acceleration;
  float lifespan;

  Particle(PVector l) {
    acceleration = new PVector(0,0.05);
    velocity = new PVector(random(-1,1),random(-2,0));
    location = l.copy();
    lifespan = 255.0;
  }

  void run() {
    update();
    display();
  }

  // Method to update location
  void update() {
    velocity.add(acceleration);
    location.add(velocity);
    lifespan -= 1.0;
  }

  // Method to display
  void display() {
    stroke(255,lifespan);
    fill(255,lifespan);
    ellipse(location.x,location.y,8,8);
  }

  // Is the particle still useful?
  boolean isDead() {
    if (lifespan < 0.0) {
      return true;
    } else {
      return false;
    }
  }
}

and the third tap is ↓

// A class to describe a group of Particles
// An ArrayList is used to manage the list of Particles 

class ParticleSystem {
  ArrayList<Particle> particles;
  PVector origin;

  ParticleSystem(PVector location) {
    origin = location.copy();
    particles = new ArrayList<Particle>();
  }

  void addParticle() {
    //particles.add(new Particle(new PVector(mouseX, mouseY)));
    particles.add(new Particle(origin));
  }

  void run() {
    for (int i = particles.size()-1; i >= 0; i--) {
      Particle p = particles.get(i);
      p.run();
      if (p.isDead()) {
        particles.remove(i);
      }
    }   
  }

  void updateOrigin(PVector newOrigin)
  { origin = newOrigin.copy(); }

}

I'm building a particle system, based on Daniel Shiffman's code from nature of code. Drawing triangle vertices when distance is within the defined range. Quite fast I get massive fps drops, which i sort of expected as it's 3 loops within each other.

I've been briefly told about binned particle system, for which I could only find some old thread containing dead links. https://forum.libcinder.org/topic/kyle-mcdonald-s-binned-particle-system

I wonder if there are other known techniques like this and if you know some resources or perhaps even a tutorial ;)

Thx in advance

here is the code:

import java.util.Iterator;
ParticleSystem ps;
PVector location;
PVector acceleration;
PVector velocity;
float lifesp = 255;
float _lifesp = 2.0;

void setup(){
 size(640,360,P2D);
PImage image = loadImage("texture.png");
ps = new ParticleSystem(image);


}

void draw(){
 background(0);
 //ps.applyForce();
 acceleration = new PVector(0, 0.05);
    velocity = new PVector(random(-1, 1), random(-2, 0));
 PVector location = new PVector (mouseX,mouseY);
 lifesp -= _lifesp;
ps.run(location, acceleration, velocity,lifesp );
ps.addParticle();


}

the particle class:

class Particle {


  PVector loc;
  PVector location;

  float lifespan;
PImage image;




  Particle(PImage img) {



    image = img;
  }

  void run(PVector location ,PVector _acceleration, PVector _velocity,float _lifespan) {

    update(location,_acceleration,_velocity);
    display(location,_lifespan);
  }

  void update(PVector _location, PVector _acceleration, PVector _velocity) {

    velocity.add(_acceleration);
    _location.add(_velocity); 

  }


  void display(PVector _location, float _lifespan) {

    stroke(0, lifespan);
    imageMode(CENTER);
    tint(255,lifespan);
    image(image,_location.x,_location.y);
    //fill(175, lifespan);
    //ellipse(location.x, location.y, 8, 8);
  }

  boolean isDead(float _lifespan) {
    lifespan = _lifespan;
    if (_lifespan < 0.0) { 
      return true;
    } else {
      return false;
    }
  }
}

and the particle system class:

class ParticleSystem{

 ArrayList<Particle> particles;
PVector origin;

//PVector _loc;

PImage image;

ParticleSystem(PImage _img){

  particles = new ArrayList<Particle>();
  image = _img;

} 

  void addParticle(){
   particles.add(new Particle(image)); 


  }

  void run(PVector location, PVector acceleration, PVector velocity,float _lifespan){
   Iterator<Particle> it = particles.iterator();
  while (it.hasNext()){

   Particle p = it.next();
   p.run(location,acceleration,velocity, _lifespan);
   if(p.isDead(_lifespan)){
     println("khgkhk");
    it.remove(); 
   }
  } 

  }


}`

Is there any way to draw the background branch particles behind the fluid and to keep them from being erased every frame without effecting the fluid fade?

I'm fairly new to processing and coding all together but am trying to teach myself as fast as possible. I'm working on a interactive project in my collective using a kinect and processing. I already have a particle and particle system that interacts with the kinect in my sketch but I want to add a second particle as the background specifically a plexus. My question is how do I go about adding a second separate set of particles that don't interact with the current particle system.

As I said I am really new and sure this is a super newbie question but any help would be greatly appreciated. Thanks,

How would you do this and also change the number of particles in these constrained areas (go from 60 to 50).

import ddf.minim.*;

AudioPlayer player;
AudioInput input;
Minim minim;
AudioInput in;
float volume = 0;
float volumeF = 0;

int maxParticles=300; // max number of particles. real particles count depends on ppf and its lifetime
int addPPF=2;         // number of particles per frame added
ArrayList particles;

void setup(){
  size(1000,1000);
  frameRate(30);
  smooth();
  background(255);
  noStroke();
      minim = new Minim(this);
  player = minim.loadFile("aventry-fire.mp3", 2048);
  player.play();

  // get a line in from Minim, default bit depth is 16
  in = minim.getLineIn(Minim.MONO, 512);


  particles = new ArrayList();
}

void draw(){
  background(0); // overpaint circles the frame before
  //  for(int i = 0; i < 1; i++)
  //{
     volumeF = in.right.level()*1000;
  volume = 0.7*volume + 0.1*volumeF;
  if(particles.size()<maxParticles){
    /** add particle(s) */
    for(int k=1; k<= volume; k++){
      particles.add(new Particles());
    }
  }
  //}

  /** run trought all Balls and make some action */
  for(int j=0; j<particles.size(); j++){
    Particles particle = (Particles)particles.get(j);
    /** if particle still alive */
    if( particle.alive() ){
      /** update x/y positions */
      particle.position();
      /** now draw as cirle */
      //fill(255,0,0, particle.lt);

     if(key == '1'){
        fill(0,255,0, particle.lt);
        text("verander kleur",10,50);

     }
     if(key == '2'){
        fill(0,255,255, particle.lt);
         text("verander kleur",10,50);
     }
     if(key == '3'){
        fill(255,255,0, particle.lt);
         text("verander kleur",10,50);
     }
     if(key == '4'){
        fill(0,0,255, particle.lt);
         text("verander kleur",10,50);
     }
     if(key == '5'){
        fill(random(255),random(255),random(255), particle.lt);
        text("verander kleur",10,50);
     }
      if(key == '6'){
        fill(random(255),random(255),random(255));
        text("verander kleur",10,50);
     }

     if(key== 'q'){
       text("Reageer op geluid",10,50);
      if(volume>0){
         fill(0,0,255, particle.lt);

       } 
      if(volume>3){
         fill(255,255,255, particle.lt);
       } 
       if(volume>6){
         fill(0,255,255, particle.lt);
       }
       if(volume>9){
         fill(255,0,255, particle.lt);
       }
       if(volume>12){
         fill(255,255,0, particle.lt);
       }
       if(volume>15){
         fill(255,100,100, particle.lt);
       }

      }


     if(key == 'a'){
       text("Vierkantjes",10,50);
       rect(particle.x, particle.y, particle.r, particle.r);}
    else{
     ellipse(particle.x, particle.y, particle.r, particle.r);  
   }


  }else{
      /** if lifetime is running out, delete */
      particles.remove(j);
    }
  }
}


  void stop()
{
  // always close Minim audio classes when you are done with them
  in.close();
  minim.stop();

  super.stop();
}

public class Particles {
  float r, x, y, _x, _y, dx=0, dy=0, lt;

  /** init start-values */
  public Particles() {
    /** start position center */
    x=width/2;
    y=height/2;
    /** now random values to make it non-linear */
    lt=random(50,100);       // lifetime in frames
    r=random(20, 50);        // circle Radius
    _x=random(-0.5, 0.5);    // stepwidth in x-pos (left, right)
    _y=random(-0.5, 0.5);    // stepwidth in y-pos (up, down)

    if(key == 'w'){
    text("Volg muis",10,50);
    x=mouseX;
    y=mouseY;
    }

  if(key == 's'){
    _x=random(-4,-0);    // stepwidth in x-pos (left, right)
    _y=random(-2, 2); 

  }

   if(key == 'd'){
    _x=random(0,4);    // stepwidth in x-pos (left, right)
    _y=random(-4, 4); 

  }
  if(key == 'z'){
    text("verander Snelheid",10,50);
     _x=random(-2.5,4);    // stepwidth in x-pos (left, right)
    _y=random(-2.5,4 ); 
  }
 if(key == 'x'){
   text("verander grootte",10,50);
   r=random(50, 120); 

 }
    }

    void stop(){
  player.close();
  minim.stop();

}

  public void position() {
    /** stepwidth increases, circlespeed is exponential */
    dx+=_x;
    dy+=_y;
    x+=dx;
    y+=dy;
  }

  public boolean alive(){
     if(lt<=0){ return false; }else{ lt--; return true; }
  }


}

        Constructor(){
        //blabla
        ..
            Particle first=particles.get(0);
            first.lock(); 
        //blabla
        ..
        }

            void display() {
            //blabla
            ..
 //for (Particle p : particles) {  //rejected

                   for (int i = particles.size();i>=1; i++) {//we start from i>=1 so 1st particle remains fixed  ??   
                      Particle p= particles.get(i); 
                //blabla
             ellipse(p.x, p.y, 2, 2);
    ..

                }

look at this screenshot with the same particle system at three different rotation, with the same blend mode

after that i also tried to change the 2d particle with a 3d, but all i've obtained is 3 spheres turning around with no trails.

I'm building off the SimpleParticleSystem example.

Things likevoid mouseDragged() can't be carried out in classes. So one must call them from the main sketch, which is simple enough... except that I'm working with a particle system (array list) composed of 2 classes (1 describes the particle group, 1 describes the particle itself), which is creating lots of problems for me.

I found this thread describing how to implement void mousePressed in classes, but the example answer that apparently worked for the asker did not work with my particles.

I'm able to freeze and capture the exact coordinates of a moving particle on hover, and even identify it's sequence in the array, but when it comes to using variables from one class in the other, I just end up getting static vs non-static field errors or null pointer exceptions.

It'd take me probably an hour to sort out my code to present my specific problems (and I can't really think anymore today :P), so I'd just like to know:

Is it even possible to have such interaction with a particle system; to be able to single a particle out (i.e. on click) and manipulate it independently (i.e. drag it around)?

Has anyone here done this before?

Does it require "hacking" around the particle system somehow (i.e. creating a new object on top of the particle and manipulating that instead of the particle itself)?

Thanks in advance for any feedback, hopefully this will help me move forward so I can come up with a more sensible question.

I am playing with particle system and am trying to create a group of particles within which each particle is connected to the particle that's closest in distance with a line. However, when I use the for loop and the dist() function to find the shortest distance, the returned result is for some reason always zero.

Could someone help me understand why this is happening? I have pasted my code below.

Thank you for your time in advance.

-Frank

ArrayList particles = new ArrayList();
int closest_i = 0;
float d = 400;

void setup() {
  size(400, 200);
  background(50);
  smooth();

  fill(255);
  textSize(90);
  text("NEON", 30, 130);

  for (int x = 0; x < width; x++) {
    for (int y = 0; y < height; y++) {
      if (get(x, y) == color(255)) {
        // number to control the number of particles generated
        if(random(1) < 0.05) {
          particles.add(new Particle(x, y));
        }
      }
    }
  }
}

void draw() {
  background(50);

  for (int i = 0; i < particles.size(); i++) {
    Particle p1 = (Particle) particles.get(i);
    p1.display();
    p1.update();

    for(int j = 0; j < particles.size(); j++) {
      if(i != j) {
        Particle p2 = (Particle) particles.get(j);
        float dt = dist(p1.x, p1.y, p2.x, p2.y);
        if(dt < d) {
          d = dt;
          closest_i = j;
          println("d: " + d);
          println("closest index: " + closest_i);
          println("-------------------------");
        }
      }
    }

    //println("index: " + i + ", " + "closest: " + closest_i);
    Particle pc = (Particle) particles.get(closest_i);
    stroke(28, 152, 232, 20);
    line(p1.x, p1.y, pc.x, pc.y);
  }
}

class Particle {
  float x, y;

  Particle(float x0, float y0) {
    x = x0;
    y = y0;
  }

  void display() {
    stroke(28, 152, 232);
    point(x, y);
  }

  void update() {
    x += floor(random(-1, 2));
    y += floor(random(-1, 2));
  }
}

I am trying to create a charge particle system where when you click left mouse it creates negative charge and right click creates positive charge. You can add as many as positive and negative charges.

The problem in my code is when I try to calculate the ditance between the two charges it returns NaN and when I check for NaN as in line number 63 it returns some float values so I figured out that when I try calculating the force and accl it returns NaN but when float.NaN(d) is ture the d returns some value.

ArrayList<Charge> poop = new ArrayList();
void setup() {
  size(300, 200);
}

float k =  1; // 8.98E+9; //  8.9875517873681764×10^9
void draw() {
  background(0);
  for (int i=0;i<poop.size();i++) {
    Charge q = (Charge)poop.get(i);
    q.show();
    q.update();
    q.applyForce(q);
  }
}

void mousePressed() {
  int t=1;
  if (mouseButton == RIGHT) t = 1;
  if (mouseButton == LEFT) t = -1;
  Charge C = new Charge(t, mouseX, mouseY);
  poop.add(C);
}

class Charge {
  PVector loc;
  PVector vel;
  PVector acc;
  float k =  1;
  float state = 1;//1.60E-19; //  1.602176487×10−19
  color c;

  Charge(int t, int x, int y) {
    loc = new PVector(x, y);
    vel = new PVector(0, 0);
    acc = new PVector(0, 0);
    //acc = new PVector(random(-0.05, 0.05), random(-0.05, 0.05));
    state*=t;
    c = (color) random(#000000);
  }

  void show() {
    noFill();
    strokeWeight(2);
    stroke(c);
    ellipse(loc.x, loc.y, 20, 20);
    setCharge();
  }

  void update() {
    vel.add(acc);
    vel.limit(1);
    loc.add(vel);
  }

  void applyForce(Charge C) {

    for (int i=0;i<poop.size();i++) {
      Charge Q = (Charge)poop.get(i);
      PVector dir = PVector.sub(Q.loc, C.loc);
      float d = dir.mag();
      println(" d: " + d);
      if (!Float.isNaN(d)) {
        float force = (k*Q.state*C.state)/d*d;
        dir.mult(force);
        acc.add(dir);
      }
    }

  }

  void setCharge() {
    pushMatrix();
    translate(loc.x, loc.y);
    if (state<0)line(-5, 0, 5, 0);
    else {
      line(0, -5, 0, 5); 
      line(-5, 0, 5, 0);
    }
    popMatrix();
  }
}

boolean flag=false;
void keyPressed() {
  flag = !flag;
}

We have just release our last interactive project, Stimula, and want to share it with you.

It’s a real time interpretation of information generated by a plant while reacting to human and environmental stimuli. The piece which combines generative, sound and interactive design brings to the light the fact that the plant is a living organism. In this setup, the plant is no longer considered as a simple decoration object.

I hope you will enjoy it.