Tagged with #particles - Processing 2.x and 3.x Forum

Increasing maximum available memory testing. How to get better results?

bontempos — Fri, 08 Jun 2018 03:03:32 +0000

This is a i7-8700, 32Gb of RAM, NVIDIA GeForce GTX 1080, running Windows 10 and Java 8 (171) installed and heap memory set to max 32Gb(-Xmx32g) (?) on run parameters.

I think this is not a question about library. However, as experiment, I am running an example from box2D library for processing named Liquidy.pde where I changed the sketch sizeto (600,300) and tested 3 renderers (default, JAVA2D and P3D). P2D was way too slow to be considered at this point. I am printing the total memory, allocated memory, free memory, n of particles, fps in the title of the sketch. I am also declaring the sketch to run at 60 fps using frameRate(60); I have tried to increase maximum available memory, but when the option was disabled, I have got a slightly better performance in fps.

When running the sketch, a click of mouse will generate a particle system. 10 clicks would generate an environment with about 1000 particles, and 15 clicks will stay around 1700. See attached picture:

With 10 particle systems, each rendered kept sketch running around 60 fps:JAVA2D a little worse than default. P3D performed just a little better. for 15 particle systems, frame rate will decrease to 15 fps (P3D), 19fps (JAVA2D and default).

Disabling the "increase maximum available memory" in preferences (and restarting?) made default renderer and JAVA2D to perform a little better when running 15 particle systems. From ~20fps, they jumped to 25fps.

I am not running out of memory and I wonder if there is any way to improve the performance of my sketches. Thanks

Frame Rate keeps getting lower

dehyde — Mon, 07 May 2018 06:13:02 +0000

I working on a code running particles to represent refugee data The code limits the number of particles to keep the frameRate but even after using a steady number of particles, it keeps getting slower with lower frameRate.

I'm really not sure what I can do to make this run faster / smoother. Why does it keep getting slower?

Here's the data folder for the Sketch: https://www.dropbox.com/sh/z69phco3tahqklu/AAB8PLMpBQMoFUX5NGSie-5fa?dl=0

PImage texture;
PGraphics pg;
PShape worldMap;
import java.util.Map;  
int filterPSystemsNum;

PGraphics sumPG;

// ========== Table Data Stuff 

Table immigrationTable;
Table conflictTable;
Table countryLocations;

int k = 0;
String[] destCountryArray = new String[0];
String[] sourceCountryArray = new String[0];

String destCountry = "";
String prevDestCountry = "";

String sourceCountry;

float mapMultiplyX = 4;
float mapOffsetX = -100;
float mapMultiplyY = 4;
float mapOffsetY = 50;

// ========

int amountSum = 1;

String displayType = "Circular";

int maxParticles = 9000;

ParticleSystem ps;
ParticleSystem ps2;

int n = 0, n2=0;
int emmitMultiplyer = 1;
int emmitFreq = 1;
float particleSpeed = 1;

float locationX = 250;
float locationY = 450;

int[] sourceX = {10, 40, 200, 400, 700};
int[] destX = {300, 600, 300, 600, 600};
int[] amount = {10, 100, 500, 800, 1000};
int highestAmount;

float radius = 300;

float tempLong;
float tempLat;

int yearFilterMin = 1996;
int yearFilterMax = 2016;


ParticleSystem[] PSystems;

HashMap countries = new HashMap();

void setup() {
  size(1200, 800, P2D);
  ((PGraphicsOpenGL)g).textureSampling(3);

  texture = loadImage("paper_texture.jpg");
  //worldMap = loadShape("worldLow.svg");

  //=============== load immigrationTable and create an array of countries


  immigrationTable = loadTable("asylum_seekers_all.csv", "header");
  countryLocations = loadTable("LatLonCountries2.csv", "header");
  conflictTable = loadTable("ged171.csv", "header");

  destCountryArray = (String[]) append(destCountryArray, "Israel");

  sumPG = createGraphics(width, height);

  pg = createGraphics(width, height);
  pg.beginDraw();
  pg.background(177);

  pg.endDraw();
  image(pg, 0, 0);

  for (TableRow row : immigrationTable.rows()) {
    if (row.getInt("Year") <= yearFilterMax && row.getInt("Year") >= yearFilterMin) {

      String tempCountryHolder = row.getString("Country / territory of asylum/residence");

      boolean exists = countryExists(tempCountryHolder);
      if (exists==true) {

        continue;
      }

      destCountryArray = (String[]) append(destCountryArray, tempCountryHolder);
    }
  }

  for (TableRow row : immigrationTable.rows()) {
    if (row.getInt("Year") <= yearFilterMax && row.getInt("Year") >= yearFilterMin) {

      String tempCountryHolder = row.getString("Origin");

      boolean exists = countryExists(tempCountryHolder);
      if (exists==true) { //println("exists, skipping");
        continue;
      }
      destCountryArray = (String[]) append(destCountryArray, tempCountryHolder);
    }
  }
  destCountryArray = sort(destCountryArray);



  //============================ country hashmaps ======================================

  for (int i = 0; i < destCountryArray.length; i++) {
    String name = destCountryArray[i];




    for (TableRow row : countryLocations.rows()) {


      if (name.equals(row.getString("name"))) {

        tempLong = row.getFloat("longitude");
        tempLat = row.getFloat("latitude");
      }
    }

    countries.put(name, new Country(name, width/2+(tempLong*mapMultiplyX)+mapOffsetX, height/2-(tempLat*mapMultiplyY)+mapOffsetY));

  }

  for (String key : countries.keySet()) {
    Country c = countries.get(key);

  }

  //============================ PSystems =============

  PSystems = new ParticleSystem[immigrationTable.getRowCount()];
  int j = 0;

highestAmount = 291664;

  println(amountSum);
  for (TableRow row : immigrationTable.rows()) {
    if (row.getInt("Year") <= yearFilterMax && row.getInt("Year") >= yearFilterMin) {
      int tempAmount = row.getInt("decisions_recognized");
      String tempDestCountry = row.getString("Country / territory of asylum/residence");
      String tempSourceCountry = row.getString("Origin");
      int tempYear = row.getInt("Year");

      float sourceEmmiterX = countries.get(tempSourceCountry).x;
      float sourceEmmiterY = countries.get(tempSourceCountry).y;
      float destEmmiterX = countries.get(tempDestCountry).x;
      float destEmitterY = countries.get(tempDestCountry).y;

      PSystems[j] = new ParticleSystem(1, new Vector3D(sourceEmmiterX, sourceEmmiterY, 0), new Vector3D(destEmmiterX, destEmitterY, 0), tempAmount, tempYear);
      println("----");
      filterPSystemsNum++;

      println("tempAmount "+tempAmount);
      println("maxParticles "+maxParticles);
      println("amountSum "+amountSum);
      println("tempAmount*maxParticles "+tempAmount*maxParticles);
      println("tempAmount*(maxParticles/amountSum) "+tempAmount*maxParticles/amountSum); 
      //println("PSystems " + i + " is " +PSystems[i]);
      j++;
    }
  }

  smooth();
}
int currentYear = 2000;
void draw() {

  blendMode(MULTIPLY);
  background(247, 245, 246, 1);
  fill(1, 1, 1, 1);

  tint(255, 1);
  image(pg, 0, 0);

  for (int i = 0; i= 0; i--) {
      Particle p = (Particle) particles.get(i);
      p.run(onMouseOverPSystem);
      if (p.dead()) {
        particles.remove(i);
        //PCount--;
        //n--;
      }

    }
  }

  void addParticle() {
    particles.add(new Particle(origin, dest, PCount));
  }



  // A method to test if the particle system still has particles
  boolean dead() {
    if (particles.isEmpty()) {
      return true;
    } else {
      return false;
    }
  }
}

//=================================================== Class Country

class Country {
  String name;
  float x, y, lon, lat, migrationIndex, incoming, outgoing;
  // more things here?

  Country(String name, float x, float y) {
    this.name = name;
    this.x = x;
    this.y = y;
  }
}

// ================================================ Simple Vector3D Class


public class Vector3D {

  public float x;
  public float y;
  public float z;

  Vector3D(float x_, float y_, float z_) {
    x = x_; 
    y = y_; 
    z = z_;
  }

  Vector3D(float x_, float y_) {
    x = x_; 
    y = y_; 
    z = 0f;
  }

  Vector3D() {
    x = 0f; 
    y = 0f; 
    z = 0f;
  }

  void setX(float x_) {
    x = x_;
  }

  void setY(float y_) {
    y = y_;
  }

  void setZ(float z_) {
    z = z_;
  }

  void setXY(float x_, float y_) {
    x = x_;
    y = y_;
  }

  void setXYZ(float x_, float y_, float z_) {
    x = x_;
    y = y_;
    z = z_;
  }

  void setXYZ(Vector3D v) {
    x = v.x;
    y = v.y;
    z = v.z;
  }

  public float magnitude() {
    return (float) Math.sqrt(x*x + y*y + z*z);
  }

  public Vector3D copy() {
    return new Vector3D(x, y, z);
  }

  public Vector3D copy(Vector3D v) {
    return new Vector3D(v.x, v.y, v.z);
  }

  public void add(Vector3D v) {
    x += v.x;
    y += v.y;
    z += v.z;
  }

  public void sub(Vector3D v) {
    x -= v.x;
    y -= v.y;
    z -= v.z;
  }

  public void mult(float n) {
    x *= n;
    y *= n;
    z *= n;
  }

  public void div(float n) {
    x /= n;
    y /= n;
    z /= n;
  }

  public void normalize() {
    float m = magnitude();
    if (m > 0) {
      div(m);
    }
  }

  public void limit(float max) {
    if (magnitude() > max) {
      normalize();
      mult(max);
    }
  }

  public float heading2D() {
    float angle = (float) Math.atan2(-y, x);
    return -1*angle;
  }

  public Vector3D add(Vector3D v1, Vector3D v2) {
    Vector3D v = new Vector3D(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
    return v;
  }

  public Vector3D sub(Vector3D v1, Vector3D v2) {
    Vector3D v = new Vector3D(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
    return v;
  }

  public Vector3D div(Vector3D v1, float n) {
    Vector3D v = new Vector3D(v1.x/n, v1.y/n, v1.z/n);
    return v;
  }

  public Vector3D mult(Vector3D v1, float n) {
    Vector3D v = new Vector3D(v1.x*n, v1.y*n, v1.z*n);
    return v;
  }

  public float distance (Vector3D v1, Vector3D v2) {
    float dx = v1.x - v2.x;
    float dy = v1.y - v2.y;
    float dz = v1.z - v2.z;
    return (float) Math.sqrt(dx*dx + dy*dy + dz*dz);
  }
}

boolean countryExists(String tempCountryHolder) {

  for (int i = 0; i < destCountryArray.length; i++) {

    if (tempCountryHolder.equals(destCountryArray[i]) == true) {

      return true; // it exists
    } //if
  } //for
  return false ; // not found
}//func


//============================================= onMouseOver Bolean Class


boolean overParticle(int x, int y, int diameter) {
  float disX = x - mouseX;
  float disY = y - mouseY;
  if (sqrt(sq(disX) + sq(disY)) < diameter/2 ) {
    return true;
  } else {
    return false;
  }
}

boolean overCountry(int x, int y, int diameter) {
  float disX = x - mouseX;
  float disY = y - mouseY;
  if (sqrt(sq(disX) + sq(disY)) < diameter/2 ) {
    return true;
  } else {
    return false;
  }
}

Class scope Problem.

DDv2FF — Tue, 27 Mar 2018 18:07:51 +0000

Hi again.
I've been trying to make this creature with particles around it. I have 4 issues, that maybe someone can help me to solve.
1- After some time I figured out how to make the particles follow the creature. But the code doenst seem clean(? I would like to make it right.
2- The scope issue. In the Particle Class, the particle is showed using "this.xtotal" and "this.ytotal", and I know that those variables wherent declared in the constructor function. But if I do it, then I have no animation for my particles. This generate multiple messages in the console.
https://preview.ibb.co/k1wwpn/Captura.png
How can I fix it ?
3- I want to constrain the random position that the particles might have. I think that for this issue, I could simply do :

this.xtotal = constrain(this.xtotal, this.x - this.dist, this.x + this.dist);
this.ytotal = constrain(this.ytotal, this.y - this.dist, this.y + this.dist);

but that generate errors to.
4- The last issue is focused in the optimization of my code. Because I have lagg with more than 5 particles. That might be related to the first issue.

let particulas = [];
let criatura;

function setup() {
    createCanvas(1200, 600);
    criatura = new Criatura(600, 300);

    for(var i = 0; i < 5; i++){
        particulas.push(new Particula(criatura));
    }

}

function draw() {
    background(60);

    criatura.show();
    criatura.update();

    for(let partic of particulas){
        partic.show();
        partic.update();

        //the part that I dont like to have in the sketch file,
        //it just doesnt seem belong here.
        partic.x = criatura.x;
        partic.y = criatura.y;

    }

}

function keyPressed(){

    if(keyCode === 39){
        criatura.xvelocidad = 1;
    } else if(keyCode === 37){
        criatura.xvelocidad = -1;
    }

    if(keyCode === 38){
        criatura.yvelocidad = -1;
    } else if(keyCode === 40){
        criatura.yvelocidad = 1;
    }

}

function keyReleased(){
    criatura.xvelocidad = 0;
    criatura.yvelocidad = 0;
}

The classes

class Particula{
  constructor(object){
    this.x = object.x;
    this.y = object.y;
    this.dist = object.r;
    //give random positions araound the creature
    this.xm = random(-object.r, object.r);
    this.ym = random(-object.r, object.r);

    //for the particle efect
    this.history = [];

  }

  update(){
    //vibration effect
    this.xm+= random(-5, 5);
    this.ym+= random(-5, 5);

    //the problem with the scope
    this.xtotal = this.x + this.xm;
    this.ytotal = this.y + this.ym;
    //track of the particle
    let v = createVector(this.xtotal, this.ytotal);
    this.history.push(v);
    if(this.history.length > 20){
      this.history.splice(0, 1);
    }

  }

  show(){
    push();
    fill(50, 150);
    ellipse(this.xtotal, this.ytotal, 40);
    pop();

    for(var i = 0; i < this.history.length; i++){
      fill(random(200), random(200), random(200));
      let pos = this.history[i];
      ellipse(pos.x, pos.y, i);
    }

  }


}

The criature

class Criatura{
  constructor(x, y){

    this.x = x;
    this.y = y;
    this.r = 125;

    this.xvelocidad = 0;
    this.yvelocidad = 0;
  }

  update(){
    this.x+= this.xvelocidad * 5;
    this.y+=this.yvelocidad * 5;

    if(this.x > width - this.r){
      this.x = width - this.r;
    } else if(this.x < this.r){
      this.x = this.r;
    }
    if(this.y > height - this.r){
      this.y = height - this.r;
    } else if (this.y < this.r){
      this.y = this.r;
    }

  }

  show(){
    push();
    fill(250, 50, 100);
    ellipse(this.x, this.y, this.r * 2);
    pop();
  }

}

10x 4 reading

making particles attract to a specific point

dehyde — Wed, 07 Mar 2018 17:54:02 +0000

Hi, I'm want to use a simple particles code to visualize migration of refugees and asylum seekers. The code should run on processing.js as a web canvas.

Each source country is an emitter, and each destination country should be a concentration point.

right now I'm trying to make the particles move to a destination point, but I'm unsure why they don't (they just overshoot). Problem is probably in "update()" or in "Particle()"

// All Examples Written by Casey Reas and Ben Fry

// unless otherwise stated.

ParticleSystem ps;
ParticleSystem ps2;

int n = 0;
int emmitMultiplyer = 5;

float locationX = 250;
float locationY = 450;

void setup() {

  size(800,600);

  //frameRate(30);

  //colorMode(RGB,255,255,255,255);

  ps = new ParticleSystem(1,new Vector3D(width/2,height/2,0));
  ps2 = new ParticleSystem(1,new Vector3D(100,200,0));

  smooth();



}



void draw() {

  background(0);
  ellipse(locationX,locationY,5,5);
  ps.run();
  ps2.run();

  for (int i = 0; i= 0; i--) {

      Particle p = (Particle) particles.get(i);

      p.run();

      if (p.dead()) {
        n--;
        particles.remove(i);

      }

    }

  }



  void addParticle() {

    particles.add(new Particle(origin));

  }



  void addParticle(Particle p) {

    particles.add(p);

  }



  // A method to test if the particle system still has particles

  boolean dead() {

    if (particles.isEmpty()) {

      return true;

    } else {

      return false;

    }

  }



}







// Simple Vector3D Class 



public class Vector3D {

  public float x;

  public float y;

  public float z;



  Vector3D(float x_, float y_, float z_) {

    x = x_; y = y_; z = z_;

  }



  Vector3D(float x_, float y_) {

    x = x_; y = y_; z = 0f;

  }



  Vector3D() {

    x = 0f; y = 0f; z = 0f;

  }



  void setX(float x_) {

    x = x_;

  }



  void setY(float y_) {

    y = y_;

  }



  void setZ(float z_) {

    z = z_;

  }



  void setXY(float x_, float y_) {

    x = x_;

    y = y_;

  }



  void setXYZ(float x_, float y_, float z_) {

    x = x_;

    y = y_;

    z = z_;

  }



  void setXYZ(Vector3D v) {

    x = v.x;

    y = v.y;

    z = v.z;

  }

  public float magnitude() {

    return (float) Math.sqrt(x*x + y*y + z*z);

  }



  public Vector3D copy() {

    return new Vector3D(x,y,z);

  }



  public Vector3D copy(Vector3D v) {

    return new Vector3D(v.x, v.y,v.z);

  }



  public void add(Vector3D v) {

    x += v.x;

    y += v.y;

    z += v.z;

  }



  public void sub(Vector3D v) {

    x -= v.x;

    y -= v.y;

    z -= v.z;

  }



  public void mult(float n) {

    x *= n;

    y *= n;

    z *= n;

  }



  public void div(float n) {

    x /= n;

    y /= n;

    z /= n;

  }



  public void normalize() {

    float m = magnitude();

    if (m > 0) {

       div(m);

    }

  }



  public void limit(float max) {

    if (magnitude() > max) {

      normalize();

      mult(max);

    }

  }



  public float heading2D() {

    float angle = (float) Math.atan2(-y, x);

    return -1*angle;

  }



  public Vector3D add(Vector3D v1, Vector3D v2) {

    Vector3D v = new Vector3D(v1.x + v2.x,v1.y + v2.y, v1.z + v2.z);

    return v;

  }



  public Vector3D sub(Vector3D v1, Vector3D v2) {

    Vector3D v = new Vector3D(v1.x - v2.x,v1.y - v2.y,v1.z - v2.z);

    return v;

  }



  public Vector3D div(Vector3D v1, float n) {

    Vector3D v = new Vector3D(v1.x/n,v1.y/n,v1.z/n);

    return v;

  }



  public Vector3D mult(Vector3D v1, float n) {

    Vector3D v = new Vector3D(v1.x*n,v1.y*n,v1.z*n);

    return v;

  }



  public float distance (Vector3D v1, Vector3D v2) {

    float dx = v1.x - v2.x;

    float dy = v1.y - v2.y;

    float dz = v1.z - v2.z;

    return (float) Math.sqrt(dx*dx + dy*dy + dz*dz);

  }



}

how to delete particles from an array list?

CSoulo — Fri, 08 Dec 2017 00:31:12 +0000

I was wondering how to go about deleting particles from my array list particle trail. I want a stream of particles to be shown when the mouse cursor is moved and when the mouse cursor is moved away a certain distance I want the particles to be deleted. This is the code I have so far

`ArrayList particles = new ArrayList(); ArrayList gone = new ArrayList();

class particle { float X; float Y; float speed_X; float speed_Y;

void draw() { strokeWeight(1); stroke(255); fill(random(0, 255), random(0, 255), random(0, 255)); ellipse(X, Y, 8, 8); X = X + speed_X; Y = Y + speed_Y; } }

void P_Particles() {

for (particle Pa : particles) { Pa.draw(); if (Pa.X > mouseX + 50) { continue; } if (Pa.X < mouseX - 50) { continue; } if (Pa.Y > mouseY + 50) { continue; } if (Pa.Y < mouseY - 50) { continue; } gone.add(Pa); } particles = gone; }

particle Pa = new particle(); Pa.X = mouseX; Pa.Y = mouseY; Pa.speed_X = random(0.1, 0.3); Pa.speed_Y = random(0.1, 0.3); particles.add(Pa); } void draw() { //the rest of my game code to much to put it all in here P_Particles(); }`

Performance optimization for p5.js of particles system?

qniff — Tue, 28 Nov 2017 16:35:11 +0000

The idea of this program is to implement data visualization in form of "Tron" trails (like in the movie), with additional random color change functionality. Eventually it will visualize the way devices move in the building. I used particle system to implement the trail. The problem is that the sketch doesn't run at a constant FPS. I know that functions randomMovement() and changeColor() look a bit loaded, but profiling indicated that the addTrail() function takes the most of the time and provides the greatest load on the program. Right now the program uses some randomly generated coordinates to align and move devices, but eventually the real data will be involved and number of devices will increase up to 1000 and at the moment program is overwhelmed with only 100 of them. So I was wondering if there is a way to optimize this trail system. I am relatively new to Js and am hoping that someone could run through my code to see if it could be optimized. Any help will be greatly appreciated.

let x1 = [];
let y1 = [];
let Devices = [];

function setup() {

    createCanvas(displayWidth, displayHeight);
    getDummyDevices(100);
}

function draw() {

    background(100);
    for(let i = Devices.length - 1; i > 0; i--){
        Devices[i].goTo(x1[i], y1[i]);
        Devices[i].show();
    }

    showFps();
}

function showFps(){
    textSize(32);
    fill(70,250,5);
    text("FPS: " + frameRate().toFixed(2), 10, height - 10);
}

function getDummyDevices(number){

    for(let i = 0; i <= number; i++){

        let x = random(0, width);
        let y = random(0, height);

        let temp = new Device(x,y);
        Devices.push(temp);

        let x1p = random(0, width);
        let y1p = random(0, height);
        x1.push(x1p);
        y1.push(y1p);
    }

}


class Device {

    constructor(x0,y0) {
        this.x = x0;
        this.y = y0;

        this.diameter = 25;                           // diameter of the device
        this.speed = 2;                               // movement speed of the device

        if(random(-1,1) >= 0) {
            this.trailColor = color(255,0,0);         // trailColor: color variable
            this.trailColorString = "red";            // trailColorString: string indicator of color
        }
        else {
            this.trailColor = color(0,0,255); 
            this.trailColorString = "blue";
        }
        this.changeColorPeriod = random(100,200);     // How often device should change color
        this.lastChangedColorTime = 0;                // keeps track of last change of color
        this.colorChangeSpeed = 20;                   // speed of color change of the device (lower -> slower)

        this.deviceColor = color(8, 20, 33);          // color of the device

        this.particles = [];                          // stores particles representing trail of the device
        this.particleFrequency = 7;                   // per how many frames new particle appears
        this.particleCounter = 0;

        this.changeDirectionPeriod = random(50, 150); // How often device should change direction
        this.lastChangedDirectionTime = 0;            // keeps track of last change of direction
        this.currentDirection = random(-1, 1);        // signs direction of device
    }

    show() {
        fill(this.deviceColor);
        ellipse(this.x, this.y, this.diameter);
    }

    goTo(x1, y1) {

        this.randomMovement(x1, y1);
        this.addTrail();
        this.changeColor();
    }

    // simple 'random' movement to destination point, random means device randomly follows x or y first
    randomMovement(x1, y1){

        this.lastChangedDirectionTime += 1;

        if(this.lastChangedDirectionTime >= this.changeDirectionPeriod)
        {
            this.currentDirection *= -1;
            this.lastChangedDirectionTime = 0;
        }

        if(this.currentDirection < 0){

            // simple movement (first x, then y)
            if(!this.inDistanceOf("x", x1)){
                if(this.x < x1) this.x += this.speed;
                else if(this.x > x1) this.x -= this.speed;
            }
            else if(!this.inDistanceOf("y", y1)){
                if(this.y < y1) this.y += this.speed;
                else if(this.y > y1) this.y -= this.speed;
            }
        } else {

            // first y, then x
            if(!this.inDistanceOf("y", y1)){
                if(this.y < y1) this.y += this.speed;
                else if(this.y > y1) this.y -= this.speed;
            }
            else if(!this.inDistanceOf("x", x1)){
                if(this.x < x1) this.x += this.speed;
                else if(this.x > x1) this.x -= this.speed;
            }
        }
    }

    addTrail(){

        if(this.particleCounter >= this.particleFrequency){

            let p = new Particle(this.x, this.y, this.speed, this.trailColor);
            this.particles.push(p);
            this.particleCounter = 0;
        }
        this.particleCounter += 1;

        for(let i = this.particles.length - 1; i >= 0; i--){

            this.particles[i].show();

            if(this.particles[i].finished()){
                this.particles.splice(i, 1);
            }
        }
    }

    // function to periodically change color of the trail
    changeColor(){

        this.lastChangedColorTime += 1;

        if(this.lastChangedColorTime >= this.changeColorPeriod)
        {
            if(this.trailColorString == "red") this.trailColorString = "blue";
            else this.trailColorString = "red";
            this.lastChangedColorTime = 0;
        }

        let r = red(this.trailColor);
        let b = blue(this.trailColor);

        if(this.trailColorString == "blue")
        {
            if(r > 0){
                r -= this.colorChangeSpeed;
                if(r < 122) b += this.colorChangeSpeed;
            }
            else if(r >= 0 && b < 255)
            {
                b += this.colorChangeSpeed;
            }
        }
        else {
            if(b > 0){
                b -= this.colorChangeSpeed;
                if(b < 122) r += this.colorChangeSpeed;
            }
            else if(b >= 0 && r < 255)
            {
                r += this.colorChangeSpeed;
            }
        }

        this.trailColor = color(r, 0, b);
    }

    // due to the fact that destination point is not an integer, 
    // I use this function to determine if device is close enough to the destination and can stop moving
    inDistanceOf(axis, xy){
        let distance = 3;
        let toReturn = false;

        let check0, check1;

        if(axis == "x"){
            check0 = this.x - xy;
            check1 = xy - this.xy;

            if((check0 < distance) && ( check0 > -distance)) toReturn = true;

            if((check1 < distance) && ( check1 > -distance)) toReturn = true;
        }

        if(axis == "y"){
            check0 = this.y - xy;
            check1 = xy - this.y;

            if((check0 < distance) && ( check0 > -distance)) toReturn = true;

            if((check1 < distance) && ( check1 > -distance)) toReturn = true;
        }
        return toReturn;
    }

}


class Particle {

    constructor(x0, y0, speed, color) {
        this.x = x0;
        this.y = y0;
        this.diameter = 20;
        this.alpha = 255;
        this.speed = speed;

        this.r = red(color);
        this.b = blue(color);
    }

    show() {

        noStroke();
        fill(this.r, 0, this.b, this.alpha);
        ellipse(this.x, this.y, this.diameter);

        this.update();
    }

    // steadily decreases transparency of particles to make view of moving trail
    update() {
        if(this.alpha > 200){
            this.alpha -= 1.2*this.speed;
        }
        else if(this.alpha > 150){
            this.alpha -= 1*this.speed;
        }
        else if(this.alpha > 100){
            this.alpha -= 0.8*this.speed;
        }
        else if(this.alpha > 50){
            this.alpha -= 0.5*this.speed;
        }
        else{
            this.alpha -= 0.3*this.speed;
        }
    }

    finished() {
        return this.alpha <= 0;
    }

}

Why do my particles avoid the edge pixels

canalesbr1 — Fri, 17 Nov 2017 20:44:59 +0000

Hello Processing Community

I am new to the forum and I am also a complete rookie when it comes to coding but have been studying some processing books and tutorials in my spare time and am loving every second of it. That being said, I apologize for the confusing explanation/question that follows.

I am attempting to make a separation steering behavior that not only reacts to particles in the system but also reacts to trails left by the particles themselves. Even though I am not entirely satisfied with the behavior yet, I am working on improving it. Yet, my question is not regarding the behavior itself, but instead it is about how the particles are detecting the edges. It seems like the particles are detecting black pixels beyond the canvas and therefore are steering away from the edges which is not what I intend them to do. I would like the particles to ignore the edges entirely and go beyond the extents of the canvas. Any input on how to fix this or why this is happening would be greatly appreciated.

int num =50;

int d = 0;

ArrayList plist = new ArrayList();

void setup(){
  size(1400,900);
  background(240);
  strokeWeight(1);

  //fill(0);
  //ellipse(width/2,height/2,200,200);

  for (int i= 0; i10)){
          count++;


          PVector diff = PVector.sub(location,black);
          diff.normalize();
          diff.div(d);
          sum.add(diff);
        }
      } 
    }

    println(count);
    if (count > 0){
      sum.setMag(maxspeed);
      PVector steer = PVector.sub(sum,velocity);
      steer.limit(maxforce);
      applyForce(steer);
    }

   }




  void applyForce(PVector steer){
    acceleration.add(steer);
  }

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

  void display(){
    line(location.x,location.y,pastloc.x,pastloc.y);
    pastloc.x = location.x;
    pastloc.y = location.y;
  }

  void update(){
    velocity.add(acceleration);
    location.add(velocity);
    acceleration.mult(0);
  }
}

making particle system more efficient (in particular when they are deleted)

secondsky — Thu, 29 Jun 2017 13:37:40 +0000

Hi all, i'm trying to do a particle system where basically i have a matrix of drops that is gonna fall down. Kind o the simulation of a 3d water courtain.

As in the Shiffman examples, i'm using a OOP approach, where each particle is an object in an arraylist and when they go too fare are deleted to free memory.

The only difference is that the particle system is executed in a parallel thread and the main one just get a copy of the particles to represent them, when is needed.

What i don't understand, is why the sketch slow down so much when the drops approach the distance where they are deleted. After all, the check happen to every loop anyway. Is there some technique to make this more efficient?

import peasy.*;

PeasyCam cam;

ParticleSystem ps;

void setup() {

  size(600, 600, P3D);

  cam = new PeasyCam(this, 15, 30, 15, 100);
  cam.setMinimumDistance(50);
  cam.setMaximumDistance(500);
  ps = new ParticleSystem();
}

void draw() {

  background(255);
  noFill();
  strokeWeight(1);

  pushMatrix();
  translate(15, -5, 15);
  box(30, 10, 30);
  popMatrix();

  pushMatrix();
  translate(15, 50, 15);
  box(30, 30, 30);
  popMatrix();

  pushMatrix();
  strokeWeight(0.1);

  ArrayList particles = ps.particles();
  for (int i = 0; i< particles.size(); i++ ) {

    point(
      particles.get(i).position.x, 
      particles.get(i).position.y, 
      particles.get(i).position.z
      );
  }

  popMatrix();
}

public  class ParticleSystem implements Runnable {

  boolean loop = true;
  ArrayList particles;

  long lastUpdate;
  int updateInterval = 10;

  float maxTravelDistance = 35 ;
  float pRF = 0.005;  // particlesRandomFactor


  public ParticleSystem() {


    particles = new ArrayList();

    for (int x = 0; x < 15; x++) {
      for (int z = 0; z < 15; z++) {
        for (int i = 0; i < 1000; i++)
        {
          particles.add(new Particle(new PVector(x*2, 0, z*2), new PVector(random(-pRF, pRF), random(-pRF, pRF), random(-pRF, pRF))));
        }
      }
    }
    new Thread(this).start();
    println(particles.size());
  }

  @ Override
  public void run() {

    while (loop) {
      if (millis()-lastUpdate > updateInterval && millis() > 3000) {
        if (particles.size() >0) {
          for (int i = particles.size()-1; i>0; i--) {
            if (particles.get(i).position.y > maxTravelDistance) particles.remove(i);
            else  particles.get(i).update();
          }
        }
        lastUpdate = millis();
      }
    }
  }


  ///////////particles
  public synchronized ArrayList particles() {
    return particles;
  }




  public synchronized PVector[] getPositions() {

    //ArrayListparticlesToExport = particles().toArray(new Particle[particles.size()]);

    ArrayListparticlesToExport = particles;
    PVector[] output = new PVector[particlesToExport.size()];

    for (int i = 0; i < output.length; i++)
    {
      output[i] = particlesToExport.get(i).position();
    }

    return output;
  }
}


public  class  Particle {

  float mass;
  boolean isDead = false;
  float airDrag = 0.95;


  PVector position;
  PVector oldPosition;

  PVector speed;
  PVector acceleration;

  public Particle(PVector p, PVector s) {
    mass = random(0.9, 1.1);
    position = p;
    speed = s;
    acceleration = new PVector(0, 0.02*mass, 0);
  }

  void update() {
    //oldPosition = position;
    if (abs(speed.x) >=0.05 || abs(speed.z) >= 0.05) speed.mult(airDrag);
    if (!(speed.y > 10)) speed.add(acceleration);
    position.add(speed);
  }

  ///////////position
  public synchronized void position(PVector input) {
    position = input;
  }
  public synchronized PVector position() {
    return position;
  }
}

Wind map with Processing

thalesrm — Wed, 25 Jan 2017 10:48:19 +0000

Hi there, I'm trying to create some visuals based on a Wind Map. I got the visuals to work with the parameters setting the thickness and turbulence of the particles but I would like to be able to control those parameters through sliders on an interface so I have more control of it.

I added the sliders to control these parameters but It's not changing the visuals live for some reason. I think it might be because of the positioning of the elements in my code, so I will past it here a section of my code and hopefully someone with experience can point me where i'm getting this wrong?

int sParticles = 5000;
int sNoiseScale = 5000;
int sLength = 5;

float sRandomA = .5;
float sRandomB = 2;



int num = sParticles;
Particle[] particles = new Particle[num];
float noiseScale=sNoiseScale, noiseStrength=5; // Turbulence

void setup() {

  cp5 = new ControlP5(this);
  cp5.addSlider("sParticles").setPosition(0,0).setRange(0,10000);
  cp5.addSlider("sNoiseScale").setPosition(160,0).setRange(0,10000);
  cp5.addSlider("sLength").setPosition(330,0).setRange(0,20);

  cp5.addSlider("sRandomA").setPosition(490,0).setRange(0,5);
  cp5.addSlider("sRandomB").setPosition(650,0).setRange(0,5);

  size(1920, 1080);
  noStroke();
  for (int i=0; i



Project problems (ParticleSystem / Video)
JamesHewitt — Tue, 29 Nov 2016 10:24:45 +0000
Hello all I am new to processing and have a question with regards to how I would fix my code.

import processing.video.*;

Capture video;

PImage prevFrame;

float threshold = 50;

void setup() {
  size(600,400);
  video = new Capture(this, 640, 480,30);
  video.start();
  ps = new ParticleSystem(new PVector(width/2, 50));
  prevFrame = createImage(video.width, video.height, RGB);
}

void captureEvent(Capture video) {
  prevFrame.copy(video, 0, 0, video.width, video.height, 0, 0, video.width, video.height);
  prevFrame.updatePixels();
  video.read();
}

void draw() {
  background(0);
  image(video, 0, 0);
  ps.addParticle();
  ps.run();
  loadPixels();
  video.loadPixels();
  prevFrame.loadPixels();

  float sumX = 0;
  float sumY = 0;
  int motionCount = 0;

  for (int x = 0; x < video.width; x++ ) {
    for (int y = 0; y < video.height; y++ ) {
      color current = video.pixels[x+y*video.width];

      color previous = prevFrame.pixels[x+y*video.width];

      float r1 = red(current);
      float g1 = green(current);
      float b1 = blue(current);
      float r2 = red(previous); 
      float g2 = green(previous);
      float b2 = blue(previous);

      float diff = dist(r1, g1, b1, r2, g2, b2);

      if (diff > threshold){
        sumX += x;
        sumY += y;
        motionCount ++;
      }
    }
  }

  float avgX = sumX / motionCount;
  float avgY = sumY / motionCount;


  smooth();
  noStroke();
  fill(0);
  ellipse(avgX, avgY, 16, 16);
}

  ParticleSystem ps;


class ParticleSystem {
  ArrayList particles;
  PVector origin;

  ParticleSystem(PVector position) {
    origin = position.copy();
    particles = new ArrayList();
  }

  void addParticle() {
    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);
      }
    }
  }
}

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

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

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

  void update() {
    velocity.add(acceleration);
    position.add(velocity);
    lifespan -= 1.0;
  }

  void display() {
    stroke(255, lifespan);
    fill(255, lifespan);
    ellipse(avgX, avgY, 8, 8);
  }

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


I have two pieces of code with one being able to detect motion and place a dot where it is detected and the other is a particle system and I am trying to place the particle system where movement is detected but I am unsure as to why it is not working, any help is appreciated!



Particles appear in the same place (Video / Particles)
JamesHewitt — Wed, 30 Nov 2016 07:43:42 +0000
Hello all I have working piece of motion detection that is supposed to place my particles where it is detected but I am having an error on line 67 ish with the argX and argY saying that they do not exist? Any help is appreciated!

__    import processing.video.*;

Capture video;

PImage prevFrame;

float threshold = 50;

float avgX; 
float avgY;

void setup() {
  size(600,400);
  video = new Capture(this, 640, 480,30);
  video.start();
  ps = new ParticleSystem(new PVector(width/2, 50));
  prevFrame = createImage(video.width, video.height, RGB);
  minim = new Minim(this);
  player = minim.loadFile("sandstorm.mp3", 2048);
  player.play();
}

void captureEvent(Capture video) {
  prevFrame.copy(video, 0, 0, video.width, video.height, 0, 0, video.width, video.height);
  prevFrame.updatePixels();
  video.read();
}

void draw() {
  background(0);
  image(video, 0, 0);
  loadPixels();
  video.loadPixels();
  prevFrame.loadPixels();

  float sumX = 0;
  float sumY = 0;
  int motionCount = 0;

  for (int x = 0; x < video.width; x++ ) {
    for (int y = 0; y < video.height; y++ ) {
      color current = video.pixels[x+y*video.width];

      color previous = prevFrame.pixels[x+y*video.width];

      float r1 = red(current);
      float g1 = green(current);
      float b1 = blue(current);
      float r2 = red(previous); 
      float g2 = green(previous);
      float b2 = blue(previous);

      float diff = dist(r1, g1, b1, r2, g2, b2);

      if (diff > threshold){
        sumX += x;
        sumY += y;
        motionCount ++;
      }
    }
  }

  avgX = sumX / motionCount;
  avgY = sumY / motionCount;


  ps.addParticle(new PVector(argX, argY));
  ps.run();


  smooth();
  noStroke();
}

  ParticleSystem ps;


class ParticleSystem {
  ArrayList particles;
  PVector origin;

  ParticleSystem(PVector position) {
    origin = position.copy();
    particles = new ArrayList();
  }

  void addParticle(PVector pos) {
   particles.add(new Particle(pos));
  }

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

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

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

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

  void update() {
    velocity.add(acceleration);
    position.add(velocity);
    lifespan -= 1.0;
  }

  void display() {
    stroke(255, lifespan);
    fill(255, lifespan);
    ellipse(position.x, position.y, 8, 8);
  }

  boolean isDead() {
    if (lifespan < 0.0) {
      return true;
    } else {
      return false;
    }
  }
}_




pass a global variable to a class
digitalmartyn — Mon, 21 Nov 2016 11:30:28 +0000
I have a particle system over a live video feed with an implementation of OpenCV OpticalFlow.

I need the particles to be affected by opticalflow values - i.e. move left and a right with the person in the video.

I can get the variable aveFlow.x each frame but can't run it through to each particle and change the vector x

full code:

import gab.opencv.*;
import processing.video.*;
import java.awt.*;

//Movie video;
Capture video;
OpenCV opencv;

// DECLARE
ArrayList ballCollection;

float numBalls = 2;

void setup() {
  size(640, 480);
  video = new Capture(this, width/4, height/4);
  opencv = new OpenCV(this, width/4, height/4);
  opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE);  

  //INITIALIZE
  ballCollection = new ArrayList();

  video.start();
}

void draw() {
  //background(0);
  //scale(2);
  opencv.loadImage(video);
  opencv.calculateOpticalFlow();

  image(video, 0, 0, width, height);

  //translate(video.width, 0);
  stroke(255, 0, 0);
  //opencv.drawOpticalFlow();

  PVector aveFlow = opencv.getAverageFlow();
  int flowScale = 100;
  //float optX = aveFlow.x;

  stroke(255);
  strokeWeight(2);
  //line(video.width/2, video.height/2, video.width/2 + aveFlow.x*flowScale, video.height/2 + aveFlow.y*flowScale);
  line(width/2, height/2, width/2 + aveFlow.x*flowScale, height/2 + aveFlow.y*flowScale);

  //numberofballs
  if (ballCollection.size() width ) {
      speedX *= -1;
    }
    if (x < 0 ) {
      speedX *= -1;
    }
    if (y > height ) {
      speedY *= -1;
    }
    if (y < 0 ) {
      speedY *= -1;
    }
  }

  void move() {
    x += speedX;
    y += speedY;
  }

  void display() {
    ellipse (x, y, 20, 20);
  }
}




Zooming in and out using the direction keys? / Changing color of text
drewk94 — Wed, 16 Nov 2016 19:23:20 +0000
Hello! Really new to processing.. new to programming in general so bear with me. All I want to do is:

1) Change the color of the text


2) Zoom in and out using the directional keys (Up, down, left, right)

I can't manage to figure it out.. some help would be great. 
Thank you.

TextGraphics tg;
PVector root = new PVector(random(1234), random(1234), random(1234)), //noise root
nSpeed = new PVector(random(-.02, .02), random(-.02, .02), random(-.02, .02));//noise speed;
ArrayList particles = new ArrayList();
int nbParticle = 6000;
int[] pgpx;//PGraphics' pixels array
float zoom = 100;//noise zoom level
Boolean noiseOn = true, hitMode = true;
import peasy.*;
PeasyCam cam;


void setup()
{
  size(1300, 800, P3D);
  cam = new PeasyCam(this, 800);
  cam.setMinimumDistance(50);
  cam.setMaximumDistance(1300);
  tg = new TextGraphics();
  strokeWeight(10);
  smooth();

}

void draw()
{ 
  background(0);
  lights();
  box(0);
  pushMatrix();
  box(0);
  popMatrix();


  for (int i = 0; i < nbParticle; i++)
  {
    Particle p = particles.get(i);
    p.update();
  }
  root.add(nSpeed);//update noise


}


void createParticles()
{
  particles = new ArrayList();
  //random particle disposition 
  while (particles.size () < nbParticle)
  {
    Particle p = new Particle(particles.size ());
    particles.add(p);
  }
}

void mousePressed()
{
  root = new PVector(random(1234), random(1234));//reset noise root
  nSpeed = new PVector(random(-.02, .02), random(-.02, .02));//reset noise speed
}

void keyPressed()

  {
    switch(key)
    {
    case 'n'://noise toggle
      noiseOn = !noiseOn;
      break;
    case 'h'://hit toggle
      hitMode = !hitMode;
      if (!hitMode)
        for (Particle p : particles)
        {
          p.speed.mult(-1);
        }
      break;
    case ' '://ignore SPACE
    case ESC://ignore ESCAPE
    case ENTER://ignore ENTER
    case BACKSPACE://ignore BACKSPACE
      break;
    default://char input
      //tg.process("" + key);//RUN IN JAVA

      break;
    }
  }


class Particle
{
  final float SPEED_MIN = .12, SPEED_MAX = .25, h = 40;
  PVector pos, origin, speed;
  int rank, col = color(random(128, 255), random(128, 205), 90, 120);
  float n, nz;//noise
  Boolean stuck = false;//against a wall

  Particle(int p_rank)
  {
    rank = p_rank;
    init();
  }

  void init()
  {
    stuck = false;
    float theta = random(TWO_PI);
    speed = new PVector(cos(theta), sin(theta), -cos(theta));
    speed.mult(random(SPEED_MIN, SPEED_MAX) * (random(1)<0?1:-1));
    Boolean done = false;
    while (!done)
    {
      pos = new PVector(random(width), random(height));
      if (green(pgpx[(int)pos.y * width + (int)pos.x]) > 100)
      {
        pos.z = random(-h/2, h/2);
        origin = pos.get();
        done = true;
      }
    }
  }

  void update()
  {
    if (noiseOn && !stuck)
    {
      n = noise(root.x + pos.x/zoom, root.y + pos.y/zoom, root.z + pos.z/zoom)*2*TWO_PI;
      nz = noise(root.x/10 + pos.x/zoom, root.y + pos.y/zoom, root.z + pos.z/zoom)*2*TWO_PI;
      speed.set(cos(n), sin(n), -cos(nz));
      speed.mult(SPEED_MAX);
    }

    if (!(stuck && hitMode))
      pos.add(speed);

    if (green(pgpx[(int)pos.y * width + (int)pos.x]) < 80)//particle outside the letter
    {
      stuck = hitMode;
      pos.sub(speed);
      if (!hitMode)
      {
        if (noiseOn)
        { 
          pos = origin.get();
        } else
        {      
          speed.x *= -1;
          speed.y *= -1;
        }
      }
    }
    if (pos.z > h/2 || pos.z < -h/2)
    {
      stuck = hitMode;
      pos.z = constrain(pos.z, -h/2, h/2);
      if (!hitMode)
      {
        if (noiseOn)
        {
          pos = origin.get();
        } else
        {
          speed.z *= -1;
        }
      }
    }

    stroke(map(pos.z, -h/2, h/2, 128, 255), map(pos.z, -h/2, h/2, 128, 205), 90, 120);
    point(pos.x-width/2, pos.y-height/2, pos.z);
  }
}

class TextGraphics
{  
  PGraphics pg;//buffer PG used to write the input char

  TextGraphics()
  {
    pg = createGraphics(width, height, P2D);
    process(new String("Nothing is ever complete."));//"Ï�")//initialize with a String
  }

  void process(String c)
  {
    pg.beginDraw();
    pg.translate(-width/2, -height/1.7);
    pg.background(0);
    pg.textSize(70);//500
    pg.fill(color(255, 255, 255));
    pg.textAlign(CENTER, CENTER);
    pg.text(c, width, height);
    pg.translate(width/2, height/1.7);
    pg.endDraw();

    pgpx = new int[width * height];
    pg.loadPixels();
    arrayCopy(pg.pixels, pgpx);
    pg.updatePixels();

    createParticles();
  }
}




How to run Particles example in fullScreen();
greentrancer — Fri, 11 Nov 2016 10:18:56 +0000
Hello. So I was looking at the Particles (Demos > Graphics) example from Processing 3.2.3 and I removed size(); and added fullScreen(); - after doing so, I cannot see anything on the screen anymore, only black background and no particles. Does anyone have any idea? Thanks.



how to improve performance for particle systems
flowen — Sat, 15 Oct 2016 19:43:04 +0000
dear creatives,

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



any tips to speed up sketch with 'high' number of particles?
Xeronimo74 — Wed, 06 Jul 2016 14:24:03 +0000
I've got around 2800 particles (just calculating a couple of simple values and drawing them) but the sketch becomes quite slow (in Chrome and Firefox) ... I supposed that's to be expected? Or are there general tricks to speed something like this up?



How to make particles go around an object instead of going through
PoYo — Mon, 30 May 2016 07:59:16 +0000
I've been trying to do something with this project I have but failed always so far :) so decided to ask here :)

I want the particles to go around the ellipse from Rock class, not through it but around it, like a rock inside a river that water flows around it. Any suggestions ?

int NUM_PARTICLES = 1000;
ParticleSystem p;
Rock r;
void setup()
{
  smooth();
  fullScreen(P2D);
  //size(700,700,P2D);
  //background(0);
  p = new ParticleSystem();
  r = new Rock();
}

void draw()
{
  background(0);
  p.update();
  p.render();
  r.rock();

}

float speed = 1;
class Particle
{
  PVector position, velocity;

  Particle()
  {
    position = new PVector(random(width),random(height));
    velocity = new PVector();
  }

  void update()
  {
    velocity.x = speed*(noise(position.y));
    velocity.y = speed*(noise(position.x));
    position.add(velocity);

    if(position.x<0)position.x+=width;
    if(position.x>width)position.x-=width;
    if(position.y<0)position.y+=height;
    if(position.y>height)position.y-=height;
  }

  void render()
  {
    stroke(0, 0, 255, 80);
    line(position.x,position.y,position.x-velocity.x,position.y-velocity.y);
  }
}

class ParticleSystem
{
  Particle[] particles;

  ParticleSystem()
  {
    particles = new Particle[NUM_PARTICLES];
    for(int i = 0; i < NUM_PARTICLES; i++)
    {
      particles[i]= new Particle();
    }
  }

  void update()
  {
    for(int i = 0; i < NUM_PARTICLES; i++)
    {
      particles[i].update();
    }
  }

  void render()
  {
    for(int i = 0; i < NUM_PARTICLES; i++)
    {
      particles[i].render();
    }
  }
}
class Rock{

  void rock()
  {
  noFill();
  stroke(255);
  strokeWeight(4);
  ellipse(mouseX,mouseY,50,50);

}



}




ArrayList of PVectors Setup and Display
schehe — Wed, 25 May 2016 21:15:15 +0000
Hi, 
I was wondering if anyone here can help me getting my head around PVectors. I am creating a visualization of points on Earth. For this I am creating an arrayList of PVectors, which get their data from a csv (Longitude, Latitute). My problem is the csv has over 88 000 lines and slows down the program when drawn in void draw() Therefore I wanted to initialize the PVectors in void createLocationPoints()) and only display them in draw with another funciton... For instance with giving the points a stroke weight. Can someone explain how I can display the function LocationVectors.add(new PVector(x, y, z)); in this example? I was thinking of something similar like Daniel Schiffmans simple particle example from the documentation but I can't quite get my head around it. Please be gentle, I am quite new to processing. Thanks a lot!

import peasy.*;

PeasyCam cam;

//Radius Earth
float radius = 6371000/50000; //global scale

//Tables
Table dataTable;
Table locationTable;

//Data lists
FloatList AffordabilityIndex;
FloatList LongituteAI;
FloatList LatituteAI;
FloatList AltituteAI;

//Locations Lists
FloatList settlementPoint;
FloatList Longitute;
FloatList Latitute;
FloatList Altitute;

float x;
float y;
float z;

PVector LocationVector;
//PShape points;

ArrayList LocationVectors;

void setup() {
  size(800, 800, P3D);
  smooth();
  dataTable = loadTable("dataTable.csv", "header");
  locationTable = loadTable("locationTable.csv", "header");

  LocationVectors = new ArrayList();

  cam = new PeasyCam(this, 4000);
  cam.setMinimumDistance(250); //0
  cam.setMaximumDistance(500); //8000

  ////LOCATIONS
  ////create location lists
  Longitute = new FloatList();
  Latitute = new FloatList();
  Altitute = new FloatList();
  //Read and store CSV
  for (int i = 0; i < locationTable.getRowCount(); i++) {
      TableRow rowLocationTable = locationTable.getRow(i);  
      Longitute.append(rowLocationTable.getFloat("Longitute")); 
      Latitute.append(rowLocationTable.getFloat("Latitute"));
      Altitute.append(rowLocationTable.getFloat("Altitute"));
    }


  //DATA
  //create data lists
  AffordabilityIndex = new FloatList();
  LongituteAI = new FloatList();
  LatituteAI = new FloatList();
  //Read and store CSV
  for (int i = 0; i < dataTable.getRowCount(); i++) {
    TableRow rowDataTable = dataTable.getRow(i);
    AffordabilityIndex.append(rowDataTable.getFloat("Affordability Index")*1);
    LongituteAI.append(rowDataTable.getFloat("Longitute"));
    LatituteAI.append(rowDataTable.getFloat("Latitute"));
    //println(Longitute, Latitute, AffordabilityIndex);
  }

  createLocationPoints();

}

void draw() {

  background(255);
  shape(points);
  displayLocationPoints();

  //DRAW DATA

  AltituteAI = AffordabilityIndex;

  strokeWeight(4);
  stroke(0);
  beginShape(POINTS);

  for (int i = 0; i < LongituteAI.size(); i++) {
    //Convert to Cartesian Coordinates
    //float a = pow( 1, 3);  // Sets 'a' to 1*1*1 = 1
    float f = 0; // flatening
    float lambda = atan(pow((1 - f), 2) * tan(radians(LatituteAI.get(i))));    // lambda

    float y = radius * cos(lambda) * cos(radians(LongituteAI.get(i))) + AltituteAI.get(i) * cos(radians(LatituteAI.get(i))) * cos(radians(LongituteAI.get(i))); //swaped x&y
    float x = radius * cos(lambda) * sin(radians(LongituteAI.get(i))) + AltituteAI.get(i) * cos(radians(LatituteAI.get(i))) * sin(radians(LongituteAI.get(i)));
    float z = radius * sin(lambda) + AltituteAI.get(i) * sin(radians(LatituteAI.get(i)));

    vertex(x, y, z);
  }
  endShape();

  noStroke();
  sphere(radius*0.98);

}

void createLocationPoints(){
    //DRAW ALL LOCATIONS
  //strokeWeight(1);
  //stroke(0);
  //beginShape(POINTS);
   //points = createShape();
   //points.beginShape();

  for (int i = 0; i < Longitute.size(); i++) {
    //Convert to Cartesian Coordinates
    //float a = pow( 1, 3);  // Sets 'a' to 1*1*1 = 1
    float f = 0; // flatening
    float lambda = atan(pow((1 - f), 2) * tan(radians(Latitute.get(i))));    // lambda

    float y = radius * cos(lambda) * cos(radians(Longitute.get(i))) + Altitute.get(i) * cos(radians(Latitute.get(i))) * cos(radians(Longitute.get(i))); //swaped x&y
    float x = radius * cos(lambda) * sin(radians(Longitute.get(i))) + Altitute.get(i) * cos(radians(Latitute.get(i))) * sin(radians(Longitute.get(i)));
    float z = radius * sin(lambda) + Altitute.get(i) * sin(radians(Latitute.get(i)));

    vertex(x, y, z);

    LocationVector = new PVector(x, y, z);
    LocationVectors.add(new PVector(x, y, z));

  }

  //endShape();
  //points.endShape();
  println(LocationVectors);
} 

void displayLocationPoints(){
  strokeWeight(10);
  stroke(0);

}




Code particles
Pathy — Mon, 18 Apr 2016 23:27:50 +0000
Hello . Does anyone have the particle code, which leave too many balls at the same time a certain point ?



Particles moving (creating a word and expanding) using the position of the mouse
derienkun — Tue, 01 Mar 2016 18:28:07 +0000
Hi guys. Im quite new at this. I found this code that creates a number of particles which automatically expand and contracts forming a word, in this case the word is “real”. Now, what I would love it to do is to expand and contract not automatically and randomly, but using the position of the mouse. So, if the mouseY is down the screen all the particles are spread all over the canvas, but if the mouseY is up in the screen, all the particles contract and form the word “real”. If you could help me I would be eternally grateful.

Thanks!



color c = color(1);//the secret colour
String word = "real";
String allwords ="real";
PVector start  =new PVector(10, 60);
int tSize =500; //Textsize
ArrayList Points = new ArrayList();
int index=0;
float restZ=0;
int F = 0;
float CTime=150;//number of frames between words
int PNum =6000;//number of particles
void setup() {
  size(1450, 850);
  frameRate(100);
  background(0);
  textSize(tSize);
  fill(0);
  text(word, start.x, start.y+tSize); //writing invisible text
  loadPixels(); //saving all pixels of the sketch
  for (int i = 0; i < PNum; i++) {//creating the particles
    Points.add(new particle(random(width), random(height)));
  }
}

void draw() {
  background(0);
  int Len = word.length();
  PVector RealPix;
  if (restZ==0) {//when the timer for the word runs out
    restZ=CTime;
    for (particle P : Points) {//resetting particles and slowing them down
      P.target=false;
      P.velocity.mult(1);
    }
    String[] Arr = allwords.split(" ");
    word=Arr[F];//getting the next word
    start.x = int(random(0, width-word.length()*tSize/1.45));
    start.y = int(random(0, height-tSize*1.3));//positioning text inside the window
    fill(c);
    text(word, start.x, start.y+tSize);
    loadPixels();
    F++;
    if (F>=Arr.length) {
      F=0;
    };
  } else if (restZ<=1) {//slowing down on the last 4 frames
    for (particle P : Points) {
      P.velocity.mult(1.5);
    }
  }
  restZ-=1;
  for (int i = 0; i < 13*PNum/(CTime-30); i++) {//checking random points in the area of the text
    RealPix=  new PVector(int(random(start.x, start.x+Len*tSize/1.45)), int(random(start.y, start.y+tSize*1.3)));
    int pixNr =int(RealPix.y*width + RealPix.x);
    color b= pixels[pixNr];
    if ((c == b)&&(restZ=10)) {//if the point is on text
      particle Aktuell = Points.get(index);
      if (Aktuell.target==false) {
        Aktuell.target=true;
        PVector desired = PVector.sub(RealPix, Aktuell.location);
        desired.div(restZ);
        Aktuell.velocity= desired;//kicking the particle in the direction of the point
      }
      index++;
      index=index%PNum;
    }
  }
  runP();//simulating and drawing the particles
}

void runP() {
  for (particle P : Points) {
    stroke(255, 255, 255, 128/sqrt(P.velocity.mag()+1));
    P.location.add(P.velocity);
    line(P.location.x, P.location.y, P.location.x+P.velocity.x, P.location.y+P.velocity.y);
  }//drawig particles as lines for a smoother look
}

class particle {
  PVector location;
  PVector velocity;
  boolean target=false;
  particle(float x, float y) {
    location = new PVector(x, y);
    velocity = new PVector(0.0, 0.0);
  }
}







Create a particle explosion of an image
CantSayIHave — Thu, 26 Nov 2015 22:08:56 +0000
Hey, I'd like to make an explosion effect for a game I'm making. The image is about 20 pixels w/h so I'm not looking for anything huge.

I'd like to make it radiate outwards and fade from a central point, but I can't think of how to.

Any help is appreciated.

Thanks



Gifs made up of Particles + Flock Behavior
amaier — Fri, 18 Sep 2015 18:08:49 +0000
Hello! I've been creeping around the forums for about a month trying to see if I could answer this on my own... but I can't.

I want to create a gif that is made up of tiny particles. Like these wizards did: http://www.iamnop.com/particles/  ^:)^  (I know this isn't processing, but you get the idea)

But then I want each gif to interact with each other using Flocking behaviors, including having the mouse be a Predator.

Is this ridiculous?

I have been able to do bits and pieces of what I want... but I can't for the life of me figure out how to bring it together.  Creating gifs from particles seems impossible. :(

Any advice would be so greatly appreciated.

Thank you!
Allison



Flying Particles 2D & 3D (made with Processing, HD 720p)
atoro — Sun, 03 May 2015 16:41:13 +0000
(1) Flying Particles 2D (made with Processing)


(2) Flying Particles 2D (made with Processing)


(3) Flying Particles 3D (made with Processing)




Adding Particle Background
Shaker — Wed, 06 May 2015 18:30:10 +0000
I am really new at processing but I am working on a code with a current particle system and want to add another system of particles as a background. How do I go about adding a second particle to an existing code without it effecting the current particle.

Any help at all would be greatly appreciated. I am trying to teach myself coding and just need to know the right direction to look.

Thanks,



Flying Particles / Music Player (HD 720p)
atoro — Tue, 12 May 2015 19:22:22 +0000
Made with Processing 
Flying Particles / Music Player (HD 720p) // gp 001 01 svsa




click on particle - loop over each?
argdev173 — Tue, 28 Apr 2015 01:16:30 +0000
Hi! I've a canvas with 400 aprox. elements (objects), each has a boolean state and i want to change that state by clicking on that object, i can achieve it by doing a dist from object x and y to mouse position. But looping over all the objects each time i click is a good choice? i think thats a perfomance flaw, i didnt try yet, but maybe in the future i want 1000 particles. The elements dont move, sorry for the english.

Thanks



How to use particles
RifleGirl — Mon, 13 Apr 2015 23:31:18 +0000
So for a visualization of data I want a specific number of particles to move in a constrained area and then when the space bar is pressed move to another specific area and have the particles move in a different constrained space.

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



How to avoid particle teletransportation when deleting elements from a particles ArrayList
cifre — Thu, 26 Feb 2015 02:24:31 +0000
import peasy.*;
import processing.opengl.*;
import java.util.Iterator;

PeasyCam cam;

vectorField vectorfield;

ArrayList particles;
ArrayList arrays = new ArrayList();

void setup()
{
  size(800, 600, OPENGL);
  smooth();

  cam = new PeasyCam(this, 600/2, 600/2, 600/2, 700);

  vectorfield = new vectorField();
  particles = new ArrayList();

  for (int i = 0; i < 5; i++) 
  {
    particles.add(new Particle(new PVector(random(0, 600), random(0, 600), random(0, 600)), random(2, 5), random(0.1f, 0.5f)));
    ArrayList lines = new ArrayList();
    arrays.add(lines);
  }
}

void draw()
{
  background(255);
  vectorfield.display();

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

    ArrayList lines = (ArrayList) arrays.get(i);
    lines.add(new PVector(p.loc.x, p.loc.y, p.loc.z));

    p.follow(vectorfield);
    p.run();
  }

  for (int i = 0; i < arrays.size (); i++)
  {
    ArrayList lines = (ArrayList) arrays.get(i);


    if (lines.size() > 0)
    {
      for (int j=1; j < lines.size (); j++) 
      {
        PVector a = (PVector) lines.get(j-1);
        PVector b = (PVector) lines.get(j);

        stroke(255, 0, 0);
        strokeWeight(1);
        line(a.x, a.y, a.z, b.x, b.y, b.z);
      }
    }
  }

  Iterator it = particles.iterator();
  while (it.hasNext ()) 
  {
    Particle p = it.next();
    if (p.isDead()) 
    {
      it.remove();
    }
  }
}


class Particle 
{
  PVector loc;
  PVector vel;
  PVector acc;
  float r;
  float maxforce;    // Maximum steering force
  float maxspeed;    // Maximum speed

  Particle(PVector l, float ms, float mf) 
  {
    loc = l.get();
    r = 3.0f;
    maxspeed = ms;
    maxforce = mf;
    acc = new PVector(0, 0, 0);
    vel = new PVector(0, 0, 0);
  }

  public void run() 
  {
    render();
    update();
  }

  void follow(vectorField f) 
  {

    // Look ahead
    PVector ahead = vel.get();
    ahead.normalize(); 
    PVector lookup = PVector.add(loc, ahead);

    // What is the vector at that spot in the vector field?
    PVector desired = f.lookup(lookup);
    // Scale it up by maxspeed
    desired.mult(maxspeed);
    // Steering is desired minus velocity
    PVector steer = PVector.sub(desired, vel);
    steer.limit(maxforce);  // Limit to maximum steering force
    acc.add(steer);
  }

  void update() 
  {
    // Update velocity
    vel.add(acc);
    // Limit speed
    vel.limit(maxspeed);
    loc.add(vel);
    // Reset accelertion to 0 each cycle
    acc.mult(0);
  }

  void render() 
  {
    stroke(0);
    strokeWeight(1);

    stroke(255, 0, 0);
    strokeWeight(5);
    pushMatrix();
    point(loc.x, loc.y, loc.z);
    popMatrix();
  }

  boolean isDead() 
  {
    if (loc.x < -r) return true;
    if (loc.y < -r) return true;
    if (loc.z < -r) return true;
    if (loc.x > 600+r) return true;
    if (loc.y > 600+r) return true;
    if (loc.z > 600+r) return true;
    else return false;
  }
}


class vectorField
{
  PVector[][][] field;
  int cols, rows, surf;

  int resolution;

  vectorField()
  {
    resolution = 50;

    cols = 600/resolution;
    rows = 600/resolution;
    surf = 600/resolution;

    field = new PVector[cols][rows][surf];
    init();
  }
  void init()
  {
    for (int i = 0; i < cols; i++)
    {
      for (int j = 0; j < rows; j++)
      {
        for (int k = 0; k < surf; k++)
        {
         field[i][j][k] = new PVector(random(-100, 100), random(-100, 100), random(-100, 100));
        }
      }
    }
  }

  void display()
  {
    for (int i = 0; i < cols; i++)
    {
      for (int j = 0; j < rows; j++)
      {
        for (int k = 0; k < surf; k++)
        {
          drawVector(field[i][j][k], i*resolution, j*resolution, k*resolution);
        }
      }
    }
  }

  void drawVector (PVector v, float x, float y, float z)
  {
    pushMatrix();
    translate(x, y, z);
    stroke(0,10);
    strokeWeight(1);
    line(0, 0, 0, v.x, v.y, v.z);
    popMatrix();
  }

  PVector lookup(PVector lookup) 
  {
    int i = (int) constrain(lookup.x/resolution, 0, cols-1);
    int j = (int) constrain(lookup.y/resolution, 0, rows-1);
    int k = (int) constrain(lookup.z/resolution, 0, surf-1);
    return field[i][j][k].get();
  }
}


Hello world! This is my first post in processing forum and I hope it won't be the last :)
My problem is that I have an ArrayList of particles and an ArrayList of each particles position, which I use to draw a line along the trajectory of the particles. When the particles leave the VectorField I kill them, and here comes the headache... I have particle_0, particle_1, particle_2, and particle_3, when I kill particle_2 particle_3 becomes particle_2, the last know position of particle_2 was before leaving the VectorField and beeing removed, but the new position of the new particle_2 is a completely different one so it just draws a straight line between the last know position and the new one... I can't get to figure this out, I hope someone out there has a solution for this! :)
Thanks in advanced



PDF Export - Generative Typography - particles
dachsdennis — Sun, 10 Aug 2014 20:50:00 +0000
Hey everybody, i am totally new to processing and i was playing around with this generative Typography Tutorial. My Problem is that the pdf export that i tried to add to it won't work. Well, it just shows the regular Text in de PDF File but i want to have the particles. I guess that i am overlocking the class of particles somehow. Can anybody please help me out?

This is the Code which consists of two tabs.

FIRST TAB

import processing.pdf.*;

boolean dosave=false;
int maxParticles = 1000; 
ArrayList  particles = new ArrayList  (); 
color BACKGROUND_COLOR = color(255);
color PGRAPHICS_COLOR = color(0);
float globalRotation;
PGraphics pg;

void setup() {
  size(1280, 700, P2D);
  smooth(16);
  pg = createGraphics(width, height, JAVA2D);
  pg.beginDraw();
  pg.textSize(200);
  pg.textAlign(CENTER, CENTER);
  pg.fill(PGRAPHICS_COLOR);
  pg.text("Test", pg.width/2, pg.height/2); 
  pg.endDraw();
  background(BACKGROUND_COLOR);
}

void draw() {

  if(dosave) {

   PGraphicsPDF pdf = (PGraphicsPDF)beginRaw(PDF, "pdf_complex_out.pdf"); 


    pdf.beginDraw();
    pdf.textSize(200);
    pdf.textAlign(CENTER, CENTER);
    pdf.fill(PGRAPHICS_COLOR);

    pdf.endDraw();
  }

  addRemoveParticles();
  // update and display each particle in the list
  for (Particle p : particles) {
    p.update();
    p.display();
  }

 if(dosave) {
    endRaw();
    }

}



void mousePressed() {
  particles.clear(); // remove all particles
  globalRotation = random(TWO_PI); // randomly set the global rotation/direction of the Particles
  }

void keyPressed() {
  if (key == 'd') {
    dosave=false;
  }
}

void addRemoveParticles() {
  // remove particles with no life left
  for (int i=particles.size()-1; i>=0; i--) {
    Particle p = particles.get(i);
    if (p.life <= 0) {
      particles.remove(i);
    }
  }
  // add particles until the maximum
  while (particles.size () < maxParticles) {
    particles.add(new Particle());
  }

}


SECOND TAB

class Particle {
  PVector loc;
  float life, lifeRate;

  Particle() {
    getPosition();
    life = random(0.9, 1.25);
    lifeRate = random(0.07, 0.08);
  }

  void update() {
    float angle = noise(loc.x * 0.01, loc.y * 0.01) * TWO_PI;
    PVector vel = PVector.fromAngle(angle + globalRotation);
    loc.add(vel);
    life -= lifeRate;
  }

  void display() {
    boolean special = random(1) < 0.001;
    strokeWeight(special ? random(0.75, 3) : 0.75);
    stroke(0, special ? random(175, 255) : 65);
    point(loc.x, loc.y);
  }

  // get a random position inside the text
  void getPosition() {
    while (loc == null || !isInText (loc)) loc = new PVector(random(width), random(height));
  }

  // return if point is inside the text
  boolean isInText(PVector v) {
    return pg.get(int(v.x), int(v.y)) == PGRAPHICS_COLOR;
  }
}