testing branch merge

README.md

@@ -1,8 +1,8 @@
 # Music Visualiser Project
 
-Name:
-
-Student Number: 
+Student Number and Student Name: Alex Mackey - C22739165	
+								 Aaron Connolly - C22410766
+								 Sergei Larionov - C22483302
 
 ## Instructions
 - Fork this repository and use it a starter project for your assignment
@@ -11,10 +11,19 @@ Student Number:
 - There is an example visualiser called MyVisual in the example package
 - Check out the WaveForm and AudioBandsVisual for examples of how to call the Processing functions from other classes that are not subclasses of PApplet
 
+# IDEAS
+0:00 - 0:16 
+0:16 - 1:57
+1:57 - 3:04
+3:04 - 4:09
+4:09 - 5:59
+
+
 # Description of the assignment
+visuals of Bohemian Rhapsody 
 
 # Instructions
-
+merge practice
 # How it works
 
 # What I am most proud of in the assignment

java/.project

@@ -16,12 +16,12 @@
 	</natures>
 	<filteredResources>
 		<filter>
-			<id>1616413840733</id>
+			<id>1710348951264</id>
 			<name></name>
 			<type>30</type>
 			<matcher>
 				<id>org.eclipse.core.resources.regexFilterMatcher</id>
-				<arguments>node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
 			</matcher>
 		</filter>
 	</filteredResources>

java/src/C22410766/AaronVisual.java

@@ -0,0 +1,156 @@
+package C22410766;
+
+import java.util.ArrayList;
+
+import ie.tudublin.Visual;
+import ie.tudublin.VisualException;
+import processing.core.PApplet;
+
+
+public class AaronVisual {
+    Visual visual;
+    ArrayList<Particle> particles = new ArrayList<>();
+    ArrayList<ArrayList<Lines>> lineSets = new ArrayList<>();
+
+
+    int len, linesPerBand = 20;
+    float amplitude, centerX, centerY;
+    float[] bands;
+    int radius = 200;
+
+    public AaronVisual(Visual visual) {
+        this.visual = visual;
+        visual.startMinim();
+
+        this.centerX = visual.width / 2;
+        this.centerY = visual.height / 2;
+
+
+
+        visual.calculateFrequencyBands(); // Calculate frequency bands
+        visual.calculateAverageAmplitude(); // Calculate amplitude
+        this.bands = visual.getSmoothedBands(); // max 667
+        this.len = bands.length;
+        this.amplitude = visual.getSmoothedAmplitude(); // max value is 0.233
+
+        float[] bandLengthsstart = {radius, 1200, 1400, 1600, 1800, 2000, 2200, 2400, 2600}; // Example specific lengths for each band
+        float[] bandLengthsend = {100, 1200, 1400, 1600, 1800, 2000, 2200, 2400, 2600}; // Example specific lengths for each band
+        int[] bandColors = {visual.color(255, 255, 125),   // Red
+                            visual.color(20, 165, 120), // Orange
+                            visual.color(40, 255, 125), // Yellow
+                            visual.color(100, 255, 125),   // Green
+                            visual.color(150, 55, 125),   // Blue
+                            visual.color(195, 255, 120),  // Indigo
+                            visual.color(218, 230, 128),// Violet
+                            visual.color(225, 230, 125), // Magenta
+                            visual.color(255, 192, 123) // Pink
+    };
+
+        for (int i = 0; i < len; i++) {
+            ArrayList<Lines> lines = new ArrayList<>();
+            for (int j = 0; j < linesPerBand; j++) {
+                float angle = visual.TWO_PI / linesPerBand * j + visual.TWO_PI / len * i;
+                float strokeWeight = visual.random(1, 3);
+                lines.add(new Lines(visual, 0, 0, bandLengthsstart[0], angle, bandLengthsend[i], bandColors[i], strokeWeight));
+            }
+            lineSets.add(lines);
+        }
+
+    }
+
+    float b = 0;                 // Angle of rotation
+    float offset = (float) (visual.PI/24.0);  // Angle offset between boxes
+    int num = 60;
+
+
+
+    public void draw() {
+        visual.background(0);
+
+        //float bgHue = visual.map(amplitude, 0, 0.3f, 0, 360);  // Use full color wheel
+        //visual.background(bgHue, 100, 100, 1);  // Set background with HSB color mode
+
+
+        try {
+            visual.calculateFFT(); // Perform FFT analysis
+        } catch (VisualException e) {
+            e.printStackTrace();
+        }
+
+        visual.calculateFrequencyBands(); // Calculate frequency bands
+        visual.calculateAverageAmplitude(); // Calculate amplitude
+        bands = visual.getSmoothedBands(); // max 667
+
+        amplitude = visual.getSmoothedAmplitude(); // max value is 0.233
+        float radius = visual.map(amplitude, 0, 0.3f, 200, 400);
+
+
+        float hue = visual.map(amplitude, 0.15f, 0.3f, 100, 255);
+        //visual.strokeWeight(10);
+
+        visual.noFill();
+
+        visual.lights();
+        visual.translate(centerX, centerY); // Center translate to middle of window
+        float rotateVelocity = visual.map(amplitude, 0.1f, 0.24f, 0.4f, 1.1f) * offset;
+
+
+        for (int i = 0; i < num; i++) {
+            float gray = visual.map(i, 0, num - 1, 0, 255);
+            visual.pushMatrix();
+            //visual.fill(gray);
+            visual.stroke(hue, 255, 255);
+            visual.rotateY(b + rotateVelocity * i);    // Rotate around Y axis
+            visual.rotateX(b / 2 + rotateVelocity * i); // Rotate around X axis
+            visual.ellipse(0, 0, radius, radius);
+            visual.popMatrix();
+        }
+
+        b += 0.01;  // Increment angle
+        if (b > visual.TWO_PI) {  // Reset 'b' to avoid overflow
+            b = 0;
+                }
+        // Draw each circle
+
+
+        for (int i = particles.size() - 1; i >= 0; i--) {
+            Particle p = particles.get(i);
+            p.run();  // Update and display the particle
+
+            if (p.isDead()) {
+                particles.remove(i);  // Remove dead particles
+            }
+        }
+
+        // Add new particles based on some condition (e.g., on beats)
+        int numParticlesToSpawn = (int) (amplitude * 350);  // Scale number of particles with amplitude
+        for (int i = 0; i < numParticlesToSpawn; i++) {
+            float angle = visual.random(visual.TWO_PI);
+            float velocityFactor = visual.map(amplitude, 0.1f, 0.24f, 1, 7);  // Map the band amplitude to a useful velocity range
+            particles.add(new Particle(visual, 0, 0, radius/2, angle, velocityFactor));
+        }
+
+
+        int maxBandIndex = 0;
+        float maxBandValue = 0;
+        for (int i = 0; i < len; i++) {
+            if (bands[i] > maxBandValue) {
+                maxBandValue = bands[i];
+                maxBandIndex = i;
+            }
+        }
+
+
+        // Draw only the lines of the band with the highest current value
+        for (int i = 0; i < len; i++) {
+            for (Lines line : lineSets.get(i)) {
+                if (i == maxBandIndex) {
+                    line.display();
+                }
+            }
+        }
+
+
+    }
+
+}

java/src/C22410766/Lines.java

@@ -0,0 +1,31 @@
+package C22410766;
+
+import ie.tudublin.Visual;
+
+public class Lines {
+    float x, y, endX, endY;
+    Visual parent;
+    float angle, length;
+    int strokeColor;
+    float strokeWeight;
+
+    public Lines(Visual parent, float centerX, float centerY, float radius, float angle, float length, int strokeColor, float strokeWeight) {
+        this.parent = parent;
+        this.angle = angle;
+        this.length = length;
+        this.strokeColor = strokeColor;
+        this.strokeWeight = strokeWeight;
+
+        this.x = centerX + radius * parent.cos(angle);
+        this.y = centerY + radius * parent.sin(angle);
+        this.endX = x + length * parent.cos(angle);
+        this.endY = y + length * parent.sin(angle);
+    }
+
+    public void display() {
+        parent.stroke(strokeColor);
+        parent.strokeWeight(strokeWeight);
+        parent.line(x, y, endX, endY);
+    }
+}
+

java/src/C22410766/Particle.java

@@ -0,0 +1,45 @@
+package C22410766;
+
+import processing.core.PApplet;
+import ie.tudublin.Visual;
+
+
+public class Particle {
+    float x, y, vx, vy, life; // Properties for particle position, velocity, and life
+    Visual parent;            // Reference to the Visual class which should be a subclass of PApplet
+
+    // Constructor with correctly named parameters
+    public Particle(Visual parent, float centerX, float centerY, float radius, float angle, float velocityFactor) {
+        this.parent = parent;
+
+        // Calculate initial position on the circle edge
+        this.x = centerX + radius * PApplet.cos(angle);
+        this.y = centerY + radius * PApplet.sin(angle);
+
+        // Initial velocities, possibly away from the center or tangential
+        this.vx = PApplet.cos(angle) * velocityFactor;  // This could be adjusted
+        this.vy = PApplet.sin(angle) * velocityFactor;  // This could be adjusted
+        this.life = 255;  // Starting life value
+    }
+
+    public void run() {
+        update();
+        display();
+    }
+
+    private void update() {
+        x += vx;
+        y += vy;
+        life -= 2;  // Decrease life
+    }
+
+    private void display() {
+        parent.stroke(255, life);
+        parent.strokeWeight(2);
+        parent.point(x, y);
+    }
+
+    public boolean isDead() {
+        return life <= 0;
+    }
+}

java/src/C22410766/start.java

@@ -0,0 +1,32 @@
+package C22410766;
+
+import ie.tudublin.Visual;
+
+public class start {
+    Visual visual;
+
+    public start(Visual visual) {
+        this.visual = visual;
+
+
+    }
+    public void draw(){
+        visual.background(0);
+
+        float centerX = visual.width / 2;
+        float centerY = visual.height / 2;
+        float angle = 0;5
+
+        angle += 0.01;
+
+        // Set the rotation angle
+        visual.rotate(angle);
+
+        visual.textSize(50);
+        visual.text("OOP Visual assignment", centerX-200, centerY);
+        visual.textSize(30);
+        visual.text("by Aaron, Alex, Sergei", centerX-200, centerY+50);
+
+
+    }
+}