float speedx=-0.5,speedy=-0.1,x,y=-70,g;
void setup() {
fullScreen();
rectMode(CENTER);
}
void draw() {
  background(200);
  translate(width/2,height/2);
  ellipse(0,0,50,50);
  rect(x,y,20,20);
  if (x<0) {g=1/sq(dist(0,0,x,y));}
  if (x>=0) {g=-1/sq(dist(0,0,x,y));}
  speedx=speedx+30*g*cos(atan(y/x));
  speedy=speedy+30*g*sin(atan(y/x));
   x=x+speedx;y=y+speedy;
  if (mousePressed) {y=50;x=0;speedx=0;speedy=0;}
}

ArrayList<Car> car;
int timer = 1000;
int _timer = 100;

void setup(){
  size(800,800);
  car = new ArrayList();
}

void draw(){
  background(0);

  text("millis="+millis(), 20, 20);

  for (int i = 0; i < car.size(); i++)
  {

    car.get(i).drawCar();
    car.get(i).move(car.get(i).getDx(), car.get(i).getDy());

    for (int j = i+1; j < car.size(); j++){  
      car.get(i).collideCircle(car.get(j));
    }


  }

  if(itstime()){
    car.add(new Car(-20, 360, 50, 30, random_color(255), 1, 2, 0, 1)); //x, y, w, h, c, d, dx, dy, t
    int ran = int(random(1000,1500));
    timer = timer + ran;
  }

  if(_itstime()){
    car.add(new Car(820, 360, 50, 30, random_color(255), -1, -2, 0, 1));
    int ran = int(random(1000,1500));
    _timer = _timer + ran;
  }

}

boolean itstime(){
  return millis() >= timer;
}

boolean _itstime(){
  return millis() >= _timer;
}

color random_color(float v) {
  return color(random(v), random(v), random(v));
}

//CAR CLASS
class Car {
  int x, y; //x position, y position
  int w, h; //weight, height/lenght
  color c; //color
  int direction; // 1 = left-to-right, 2 = right-to-left
  int dx, dy; //dx = x velocity, dy = y velocity
  int turn; //turn=> 1 = Straight, 2 = right, 3 = left
  int radius;

  Car(int x, int y, int w, int h, color c,int direction, int dx, int dy, int turn) {
    this.x = x;
    this.y = y;
    this.w = w;
    this.h = h;
    this.c = c;;
    this.direction = direction;
    this.dx = dx;
    this.dy = dy;
    this.turn = turn;
    this.radius = 20;
  }

  void drawCar() {
    fill(c);
    ellipse(x, y, radius, radius); 
  }

  int getDx(){
    return dx;
  }

  void setDx(int vx){
    this.dx = dx + vx;
  }

  int getDy(){
    return dy;
  }

  void setDy(int vy){
    this.dy = dy + vy;
  }

  void setDx_zero(){
    this.dx = 0;
  }

  int getDir(){
    return direction;
  }

  void move() {
    this.x = this.x + this.dx;
    this.y = this.y + this.dy;  
  }

  //with parameter
  void move(int dx, int dy) {
    this.dx = dx;
    this.dy = dy;

    this.x = this.x + this.dx;
    this.y = this.y + this.dy;
  }

  void collideCircle(Car other){

    println(direction+"  "+other.getDir()); 
    if(direction != other.getDir()){
      if (radius + other.radius > dist(x, y, other.x, other.y)){
        println("r1="+radius+" r2="+other.radius+ " x1="+x+ " x2="+other.x);
        setDx_zero();
        if(getDy() < 4){
          setDy(1);
        }else{
          setDy(0);
        }

        other.setDx_zero();
        if(other.getDy() < -4){
          other.setDy(0);
        }else{
          other.setDy(-1);
        }
      }else{
        println("No collision");
      }
    }
  } //collideCircle
}  

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;
    }

}

I have been working with P5 for a while now, but in my current project I'm working with large data sets for the first time. The FPS I'm getting when animating over 2000+ data points is not good, is there a way to improve upon this?

Thanks!

float r=0,a=0,t=0,x0=0,y0=0,x=0,y=0;
int c=80;

void setup(){
  size(1024,768);
  background(0);
  strokeWeight(1);
  stroke(c,100,150);
}

void draw(){

  translate(width/2,height/2);

   if(t<=30*PI)
    {
      x0=r*cos(a);
      y0=r*sin(a);

      a=t;//360*(sin(t/20)+0.5*sin(t/40));
      r=a;//200*(sin(t/40)+0.5*sin(t/80));

      x=r*cos(a);
      y=r*sin(a);

      line(x0,-y0,x,-y);

      t+=0.1;
   }
}

How can I make this faster? Code here: https://codepen.io/jmean/pen/pdwXgO

Thanks

void setup() {
  size(1024,896,P2D);
  frameRate(500);
  noStroke();
  smooth(0);
}

void draw() {
  background(0);
  ellipse(mouseX,mouseY,100,100);
  if(mousePressed){
    drawPixels(256,224);
  }
  println(frameRate);
}

void drawPixels(int retroResX, int retroResY) {
  int pixelScale = width/retroResX;
  loadPixels();
  for(int y=0;y<retroResY;y++){
    for(int x=0;x<retroResX;x++){
      for(int py=0;py<pixelScale;py++){
        for(int px=0;px<pixelScale;px++) {
          pixels[((py+(y*pixelScale))*width)+(px+(x*pixelScale))] = pixels[(y*width*pixelScale)+(x*pixelScale)];
        }
      }
    }
  }
  updatePixels();
}

The top loops are drawing the whole shape and the enhanced loops are drawing the shape sections. The reason for separating them into individual loops was that having them in one loop meant that things were not drawing when the tweet came in and instead everything was drawn simultaneously.

If there is a way to improve this, i'm all ears.

I haven't included the entire program due to size and that this is the only part i'm looking to optimize.

Thankyou.

    if (state == S_PLAY) { 
    shapeMode(CORNER);
    noStroke();
    fill(shapeColor);
    for (int i = 0; i < numLollipops; i++) {
      lollipopFull.disableStyle();
      shape(lollipopFull, i*SIZE, SIZE, SIZE, SIZE);
      numLollipops = check(i*SIZE, numLollipops);
    }
    for (int i = 0; i < numCircles; i++) {
      circleFull.disableStyle();
      shape(circleFull, (width-SIZE)-i*SIZE, SIZE*3, SIZE, SIZE);
      numCircles = check(i*SIZE, numCircles);
    }
    for (int i = 0; i < numLines; i++) {
      lineFull.disableStyle();
      shape(lineFull, i*SIZE, SIZE*5, SIZE, SIZE);
      numLines = check(i*SIZE, numLines);
    }
    for (int i = 0; i < numSeptagons; i++) {
      septagonFull.disableStyle();
      shape(septagonFull, (width-SIZE)-i*SIZE, SIZE*7, SIZE, SIZE);
      numSeptagons = check(i*SIZE, numSeptagons);
    }
    for (int i = 0; i < numSq; i++) {
      squareFull.disableStyle();
      shape(squareFull, i*SIZE, SIZE*9, SIZE, SIZE);
      numSq = check(i*SIZE, numSq);
    }
    for (int i = 0; i < numTriStars; i++) {
      starFull.disableStyle();
      shape(starFull, (width-SIZE)-i*SIZE, SIZE*11, SIZE, SIZE);
      numTriStars = check(i*SIZE, numTriStars);
    }
    for (int i = 0; i < numSeptagrams; i++) {
      septagramFull.disableStyle();
      shape(septagramFull, i*SIZE, SIZE*13, SIZE, SIZE);
      numSeptagrams = check(i*SIZE, numSeptagrams);
    }
    shapeMode(CENTER);
    for (Lollipop l : lollipops) l. draw();
    for (Septagon s : septagons) s. draw();
    for (Line li : lines) li.draw();
    for (Circle c : circles) c. draw();
    for (Square sq : squares) sq.draw();
    for (TriStar t : triStars) t. draw();
    for (Septagram sg : septagrams) sg.draw();
    words.clear();

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

I run a sketch that makes 180 ellipses rotating around a point. each of those ellipses are instances of a Satellite Class that render the ellipse using pushMatrix(), translate(...), rotate(...) and ellipse(...)

Running this sketch on my pc , the FPS is stuck at 60, but running it on my Nvidia Shield K1, I get around 30 FPS

-1- is it that demanding to run 180 objects using primitive shapes ?

I tried with a little more complicated shapes, using 4 primitives, it gets to 22 FPS

I tried using PShape to build Shapes of 4 primitives and it gets to 18 FPS

-2- Am I facing a weakness in Processing for android ?

-3- Is there a way to solve that ?

(I tried using P2D and it crashes with "A/libc: Fatal signal 11 (SIGSEGV), code 1, fault addr 0x9e5ad000 in tid 17144 (GLThread 46915)" message)

cheers

update: using a 50x50 PGraphics instead of PShape gets me 11 FPS

update 2: I finally got it to run on P2D (I don't know why, I just copied my whole code, classes and all, to a blank app that was running P2D just fine) and here is the result:

with my 180 satellites being mere ellipses my FPS is 25 :( (with them being points(), I'm back over 60 FPS)

is anybody here ?

I would appreciate if someone could help me to optimize this code. This code takes reads from arduino code which is an array separated by , and then splits and use each number to color a rectangle. The screen has 32 rectangles. This code runs too slow on android phones\tablets and I don't know the problem. I've tried HTC One/Samsung S4/Tegra Note 7.

Here is the code:

    import android.content.Intent;
    import android.os.Bundle;
    import ketai.net.bluetooth.*;
    import ketai.ui.*;
    import ketai.net.*;

    PFont fontMy;
    boolean bReleased = true; //no permament sending when finger is tap
    KetaiBluetooth bt;
    boolean isConfiguring = true;
    String info = "";
    float num[] = new float[32];
    int i = 0;
    int x = 0;
    int y = 0;
    int Height = 0;
    int Width = 0;
    KetaiList klist;
    ArrayList devicesDiscovered = new ArrayList();

    //********************************************************************
    // The following code is required to enable bluetooth at startup.
    //********************************************************************

    void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      bt = new KetaiBluetooth(this);
    }

    void onActivityResult(int requestCode, int resultCode, Intent data) {
      bt.onActivityResult(requestCode, resultCode, data);
    }

    void setup() {
      size(displayWidth, displayHeight, JAVA2D);
      frameRate(30);
      orientation(LANDSCAPE);
      background(0);

      //start listening for BT connections
      bt.start();
      //at app start select device…
      isConfiguring = true;
      //font size
      fontMy = createFont("SansSerif", 40);
      textFont(fontMy);
      Height = (displayHeight - (displayHeight % 4));
      Width = (displayWidth - (displayWidth % 8));
    }

    void draw() {
      //at app start select device
      if (isConfiguring)
      {
        ArrayList names;
        background(0, 0, 0);
        klist = new KetaiList(this, bt.getPairedDeviceNames());
        isConfiguring = false;
      }
      else
      {
        //    background(0, 50, 0);
        //  if((mousePressed) && (bReleased == true))
        //  {
        // //send with BT
        //  byte[] data = {'s','w','i','t','c','h','\r'};
        //  bt.broadcast(data);
        // //first tap off to send next message
        //  bReleased = false;
        //  }
        //  if(mousePressed == false)
        //  {
        //  bReleased = true; //finger is up
        //  }
        //print received data
        //    fill(255);
        //      textAlign(LEFT);
        //     text(info.length(), 20, 104);
        //       text(w,20,104);
        //       text(h,20,130);
        num = float(split(info, ','));
        if (num.length == 32) {
          //      info = "";
          fill(255);
          noStroke();
          i = 0;
          for (int y=0; y<Height; y+=Height/4) {
            for (int x=0; x<Width; x+=Width/8) {
              fill(num[i]);
              rect(x, y, Width/8, Height/4);
              i++;
            }
          }
          num = new float [32];
        }
      }
    }

    void onKetaiListSelection(KetaiList klist) {
      String selection = klist.getSelection();
      bt.connectToDeviceByName(selection);
      //dispose of list for now
      klist = null;
    }

    //Call back method to manage data received
    void onBluetoothDataEvent(String who, byte[] data) {
      if (isConfiguring)
        return;
      //received

      if (info.length() >= 62)
        info = "";

      info += new String(data);
    }

    // Arduino+Bluetooth+Processing 
    // Arduino-Android Bluetooth communication

Thank you in advance :)