I used Perlin noises to draw complex wave shapes and colors.

/**
 * Don't Count the Waves
 * Poisonous, flashy color. It charms me.
 * 
 * @author @deconbatch
 * @version 0.2
 * Processing 3.5.3
 * updated 2021.02.23 rewrite almost whole code and make it simple.
 * created 2017.09.17
 */

ArrayList<Wave> waves = new ArrayList<Wave>();
float hueBase;

void setup() {

  size(720, 720, P2D);
  colorMode(HSB, 360.0, 100.0, 100.0, 100.0);
  rectMode(CENTER);
  smooth();
  noStroke();

 hueBase = random(360.0);
  int waveMax = 5;
  for (int i = 0; i < waveMax; i++) {
    waves.add(new Wave((hueBase + i * 90.0 / waveMax) % 360.0));
  }

}

void draw() {

  int   frmMax   = 24 * 6;
  float frmRatio = map(frameCount, 0, frmMax, 0.0, 1.0);
  
  translate(width / 2, height / 2);
  blendMode(BLEND);
  drawBackground();

  blendMode(SCREEN);
  for (Wave ps : waves) {
    ps.drawWave(frmRatio);
  }
  
  blendMode(BLEND);
  casing();
  saveFrame("frames/####.png");
  if (frameCount >= frmMax) {
    exit();
  }
  
}

/**
 * drawBackground : draws center bright background
 */
void drawBackground() {
  int eMax = 50;
  float sizBase = max(width, height) * 1.5;
  background(0.0, 0.0, 0.0, 100.0);
  noStroke();
  for (int i = 0; i < eMax; i++) {
    float iRatio = map(i, 0, eMax, 0.0, 1.0);
    float eSiz = sizBase * (1.0 - iRatio);
    fill((hueBase + 90.0) % 360.0, 30.0 + 70.0 * iRatio, 30.0 * iRatio, 100.0);
    ellipse(0.0, 0.0, eSiz, eSiz);
  }
}

/**
 * casing : draws a fancy casing
 */
private void casing() {
  fill(0.0, 0.0, 0.0, 0.0);
  strokeWeight(34.0);
  stroke(0.0, 0.0, 0.0, 100.0);
  rect(0.0, 0.0, width, height);
  strokeWeight(30.0);
  stroke(0.0, 0.0, 100.0, 100.0);
  rect(0.0, 0.0, width, height);
  noStroke();
  noFill();
  noStroke();
}

/**
 * Wave : holds the wave data and draws a wave
 */
class Wave {

  float hueVal;
  float phase;
  float thetaMax;
  float thetaDiv;
  float thetaMult;
  float noiseBase;
  float speed;
  
  Wave(float _hue) {
    // base color
    hueVal = _hue;

    // wave shape
    phase     = random(TWO_PI);
    thetaMax  = PI * random(5.0, 20.0);
    thetaDiv  = PI * random(0.0005, 0.002);
    thetaMult = random(1.0);
    noiseBase = random(thetaMax);

    // wave shape moving speed
    speed = random(0.01, 0.5);
  }

  /**
   * drawWave : draws a wave
   */
  void drawWave(float _ratio) {

    float radiusBase = min(width, height) * 0.5;
    float shapeRatio = noise(phase, 10.0 + cos(TWO_PI * _ratio), 10.0 + sin(TWO_PI * _ratio));

    // holds the data to draw
    ArrayList<WavePoint> wps = new ArrayList<WavePoint>();
    for (float theta = phase; theta < thetaMax; theta += thetaDiv) {
      float thetaRatio = map(theta, phase, thetaMax, 0.0, 1.0);

      // shape calculation
      float nParam = noiseBase + theta * thetaMult;
      float waveShape = map(customNoise(shapeRatio * speed, nParam), 0.0, 1.0, 0.85, 1.15);
      float heave = sin(TWO_PI * (5.0 * thetaRatio + shapeRatio)) * 0.02;
      float radius = radiusBase * thetaRatio * (waveShape + heave);
      float eX = radius * cos(theta);
      float eY = radius * sin(theta);

      // color
      float eHue = (360.0 + hueVal + noise(phase, thetaRatio) * 180.0 - map(radius, 0.0, width * 0.5, 0.0, 90.0)) % 360.0;
      float eSat = noise(phase, nParam) * map(radius, 0.0, width * 0.5, 60.0, 100.0);
      float eBri = noise(noiseBase, phase, nParam) * map(radius, 0.0, width * 0.5, 0.0, 2.0);
      float eSiz = noise(noiseBase, nParam) * sin(PI * theta * thetaRatio) * 20.0;

      wps.add(new WavePoint(eX, eY, eHue, eSat, eBri, eSiz));
    }

    // draws and glow the line
    pushMatrix();
    noFill();
    for (int i = 1; i < 5; i++) {
      beginShape();
      for (WavePoint wp : wps) {
        strokeWeight(wp.siz / (i * i));
        stroke(wp.hueVal, wp.satVal, wp.briVal * i * i, 100.0);
        curveVertex(wp.x, wp.y);
      }
      endShape();
    }
    popMatrix();
  }

  /**
   * WavePoint : holds the vertex points data of the wave
   */
  class WavePoint {
    float x, y;
    float hueVal, satVal, briVal;
    float siz;
    WavePoint(float _x, float _y, float _hue, float _sat, float _bri, float _siz) {
      x      = _x;
      y      = _y;
      hueVal = _hue;
      satVal = _sat;
      briVal = _bri;
      siz    = _siz;
    }
  }

  /**
   * customNoise : returns custom noise value
   */
  private float customNoise(float _p01, float _p02) {
    return noise(pow(sin(TWO_PI * _p01), 3), cos(TWO_PI * pow(_p02, 2))) * 2.0;
  }
  
}


/*
Copyright (C) 2021- deconbatch

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>
*/