Quantum-CRISPR Epigenome-Targeted Theranostic System (Q-CETS): A Next-Generation Platform for Alzheimer’s Prevention and Diagnosis

Step 1: 📥 Load brain wave data (like opening a music file, but for brain signals!)
Step 2: 📈 Create a plot showing 10 seconds of "raw" brain activity (all the noise included)

Step 3: 🔧 Apply a "filter" to clean up the signal (like noise-canceling headphones for data!)

Step 4: 📊 Make a side-by-side comparison (before vs after cleaning)
Step 5: 🌈 Create colorful "power spectrum" plots (shows which brain wave frequencies are strongest)

Visualizing Frequency Changes Over Time (Spectrogram)

Assignment 2 - Brainimation Art October 20, 2025
Tori and Bani
Original Code
// 🧠 BrainImation: Live EEG + P5.js
// Access real-time brain data through the 'eegData' object:
// eegData.alpha, eegData.beta, eegData.theta, eegData.delta
// eegData.attention, eegData.meditation, eegData.raw[]
let particles = [];
let time = 0 ;
function setup() {
// Canvas is already created by the system
// Just set up the drawing mode and initialize
colorMode( HSB , 360 , 100 , 100 , 1 );
// Initialize particles
for ( let i = 0 ; i < 50 ; i++) {
particles.push({
x: random(width),
y: random(height),
vx: random(- 1 , 1 ),
vy: random(- 1 , 1 ),
hue: random( 360 )
});
}
}
function draw() {
// Background responds to meditation
let bgAlpha = map(eegData.meditation, 0 , 1 , 0.05 , 0.2 );
background( 220 , 30 , 10 , bgAlpha);
time += 0.01 ;
// Draw neural network
stroke( 180 , 80 , 90 , 0.3 );
strokeWeight( 1 );
for ( let i = 0 ; i < particles.length; i++) {
let p = particles[i];
// Movement influenced by alpha waves
let alphaForce = eegData.alpha * 2 ;
p.vx += random(-alphaForce, alphaForce) * 0.01 ;

p.vy += random(-alphaForce, alphaForce) * 0.01 ;
// Damping
p.vx *= 0.99 ;
p.vy *= 0.99 ;
// Update position
p.x += p.vx;
p.y += p.vy;
// Wrap around edges
if (p.x < 0 ) p.x = width;
if (p.x > width) p.x = 0 ;
if (p.y < 0 ) p.y = height;
if (p.y > height) p.y = 0 ;
// Color influenced by attention
let hue = (p.hue + eegData.attention * 50 + time * 10 ) % 360 ;
let brightness = map(eegData.beta, 0 , 1 , 30 , 90 );
fill(hue, 70 , brightness, 0.8 );
noStroke();
// Size influenced by theta waves
let size = 5 + eegData.theta * 15 ;
ellipse(p.x, p.y, size);
// Connect nearby particles
for ( let j = i + 1 ; j < particles.length; j++) {
let p2 = particles[j];
let d = dist(p.x, p.y, p2.x, p2.y);
if (d < 80 ) {
let alpha = map(d, 0 , 80 , 0.5 , 0 ) * eegData.alpha;
stroke(hue, 50 , 70 , alpha);
strokeWeight( 1 );
line(p.x, p.y, p2.x, p2.y);
}
}
}
// Display connection status
if (!eegData.connected) {

fill( 0 , 0 , 100 , 0.8 );
textAlign( CENTER , CENTER );
textSize( 20 );
text( "Connect your Muse headset or use 'Simulate Data'" , width/ 2 , height/ 2 - 10 );
textSize( 16 );
fill( 0 , 0 , 70 , 0.6 );
text( "to see brain-controlled animation" , width/ 2 , height/ 2 + 20 );
}
}
Steps
1. Converted the original code into a kaleidoscope shape using ChatGPT
2. Colors and movement respond to brain wavesIncreased pulse size depending on which type of
brain wave is coming in
3. Gave each brain wave its own corresponding colour; Alpha/Theta = Blue, Beta = Orange/Red,
Delta = White
4. Then the code only showed one colour and did not change depending on wave type, so the code
was edited to only include the simulated data as it was trying to incorporate the MUSE data at the
same time (which was not present). Then at the end of the code “ text("to see brain-controlled
kaleidoscope", 0, 20)” was added to specify the action.
5. We then asked the code to pulse when brain waves of the same type meet/collide, to create a wave
specific connection system.
Purpose of this Code
We created a code that would reflect a kaleidoscope based on the real-time brain data. We wanted the
alpha and theta waves to reflect calm colours like blue and cyan (brain waves that are more evident during
meditation and focus), the beta waves to reflect more chaotic colours like red and orange (brain waves
that are more evident during anxiety-inducing situations), and the delta waves to reflect the colour white
(brain waves that are more evident during deep sleep).
Final Code:
// EEG-Responsive Kaleidoscope with Wave-Specific Pulsing Connections and Size Growth
let particles = [];
let time = 0 ;
let symmetry = 6 ;
let angle = TWO_PI / symmetry;
function setup() {
colorMode( HSB , 360 , 100 , 100 , 1 );

// Initialize particles with wave group (0=Alpha, 1=Theta, 2=Beta, 3=Delta)
for ( let i = 0 ; i < 50 ; i++) {
particles.push({
x: random(width),
y: random(height),
vx: random(- 1 , 1 ),
vy: random(- 1 , 1 ),
hue: random( 360 ),
saturation: 80 ,
size: 5 ,
waveGroup: i % 4
});
}
}
function draw() {
// Background responds to meditation
background( 220 , 30 , 10 , map(eegData.meditation, 0 , 1 , 0.05 , 0.2 ));
translate(width / 2 , height / 2 );
time += 0.01 ;
for ( let i = 0 ; i < particles.length; i++) {
let p = particles[i];
// Wave amplitudes
let alpha = eegData.alpha;
let theta = eegData.theta;
let beta = eegData.beta;
let delta = eegData.delta;
// Particle movement influenced by waves
let moveForce = (alpha + theta)* 2 + beta* 2 + delta;
p.vx += random(-moveForce, moveForce) * 0.01 ;
p.vy += random(-moveForce, moveForce) * 0.01 ;
p.vx *= 0.99 ;
p.vy *= 0.99 ;
p.x += p.vx;
p.y += p.vy;
// Wrap around edges
if (p.x < 0 ) p.x = width;

if (p.x > width) p.x = 0 ;
if (p.y < 0 ) p.y = height;
if (p.y > height) p.y = 0 ;
let cx = p.x - width / 2 ;
let cy = p.y - height / 2 ;
// --- Assign wave-specific color ---
let targetHue, targetSaturation, targetBrightness;
if (p.waveGroup === 0 ) {
targetHue = map(alpha, 0 , 1 , 180 , 220 ); // Alpha - Blue
targetSaturation = 80 ;
targetBrightness = 80 ;
} else if (p.waveGroup === 1 ) {
targetHue = map(theta, 0 , 1 , 200 , 240 ); // Theta - Cyan
targetSaturation = 80 ;
targetBrightness = 80 ;
} else if (p.waveGroup === 2 ) {
targetHue = map(beta, 0 , 1 , 0 , 30 ); // Beta - Red/Orange
targetSaturation = 100 ;
targetBrightness = 80 ;
} else {
targetHue = 0 ; // Delta - White
targetSaturation = 0 ;
targetBrightness = map(delta, 0 , 1 , 50 , 100 );
}
// Smooth color transitions
p.hue = lerp(p.hue, targetHue, 0.05 );
p.saturation = lerp(p.saturation, targetSaturation, 0.05 );
let brightness = targetBrightness;
// --- Particle size based on wave ---
let targetSize;
if (p.waveGroup === 0 ) targetSize = 5 + alpha * 15 ;
else if (p.waveGroup === 1 ) targetSize = 5 + theta * 15 ;
else if (p.waveGroup === 2 ) targetSize = 5 + beta * 15 ;
else targetSize = 5 + delta * 15 ;
p.size = lerp(p.size, targetSize, 0.1 );

// --- Draw particle in kaleidoscope symmetry ---
for ( let s = 0 ; s < symmetry; s++) {
rotate(angle);
fill(p.hue, p.saturation, brightness, 0.8 );
noStroke();
ellipse(cx, cy, p.size);
push();
scale( 1 , - 1 );
ellipse(cx, cy, p.size);
pop();
}
// --- Wave-specific connections with pulsing and size growth ---
for ( let j = i + 1 ; j < particles.length; j++) {
let p2 = particles[j];
// Connect only particles of the same wave group
if (p.waveGroup !== p2.waveGroup) continue ;
let dx = p2.x - width / 2 ;
let dy = p2.y - height / 2 ;
let d = dist(cx, cy, dx, dy);
if (d < 80 ) {
// Wave amplitude
let waveAmp;
if (p.waveGroup === 0 ) waveAmp = alpha;
else if (p.waveGroup === 1 ) waveAmp = theta;
else if (p.waveGroup === 2 ) waveAmp = beta;
else waveAmp = delta;
// Pulsing effect
let pulse = map(sin(time * 5 ), - 1 , 1 , 0.3 , 1 );
let alphaLine = map(d, 0 , 80 , 0.5 , 0 ) * waveAmp * pulse;
// Increase particle size on connection
let sizeBoost = map(d, 0 , 80 , waveAmp * 5 , 0 );
p.size = lerp(p.size, p.size + sizeBoost, 0.2 );
p2.size = lerp(p2.size, p2.size + sizeBoost, 0.2 );
// Optional subtle hue shift for pulse

let pulseHue = p.hue + pulse * 10 ;
stroke(pulseHue, p.saturation * 0.7 , brightness * 0.7 , alphaLine);
strokeWeight( 1 + waveAmp * 2 );
// Kaleidoscope rotation
for ( let s = 0 ; s < symmetry; s++) {
rotate(angle);
line(cx, cy, dx, dy);
push();
scale( 1 , - 1 );
line(cx, cy, dx, dy);
pop();
}
}
}
}
// --- Message for simulated EEG data ---
if (!eegData.connected) {
fill( 0 , 0 , 100 , 0.8 );
textAlign( CENTER , CENTER );
textSize( 20 );
text( "Using simulated EEG data" , 0 , - 10 );
textSize( 16 );
fill( 0 , 0 , 70 , 0.6 );
text( "Colors and movement respond to brain waves" , 0 , 20 );
}
}
Challenges Faced:
We were unable to connect our muse headband, so simulated data was used
We could not get the kaleidoscope P5.js code to work in the brainanimation system. After repeated attempts
we figured out it was due to the code being meant for a mouse and would not work for what we wanted. We
created our own kaleidoscope design using ChatGTP, that would respond to the EEG brainwave data.
Changing the colours within the code was also challenging as it kept combining the colours together. This was
solved through increased specificity and lots of trial and error.

Screenshots

(Part 1) Extend your Assignment 2 BrainImation project with novel BCI concepts
Description :
For this project, I implemented a novel Brain-Computer Interface (BCI) concept that dynamically visualizes a user’s
mental state through a kaleidoscope display. The system translates real-time brainwave activity into changes in both
color and intensity, creating a visually intuitive representation of the user’s cognitive and emotional state. Unlike
traditional BCI applications that focus on basic parameter control (such as moving a cursor or adjusting a single
variable), this implementation provides a multi-dimensional, immersive feedback loop, combining visual aesthetics
with cognitive monitoring.
The logic of the system operates on a continuous loop. Brainwave data is collected and analyzed to determine the
relative power of alpha, theta, and beta frequencies. When alpha and theta waves dominate, frequencies commonly
associated with relaxation and calmness, the kaleidoscope shifts toward cool tones, such as blues and cyans.
Conversely, when beta waves are predominant, indicating stress or heightened cognitive load, warmer colors like
reds and oranges become more prominent. The display also includes a textual indicator at the top, stating whether
the user is “Relaxed,” “Focused,” or “Stressed,” based on the detected brainwave pattern. This real-time mapping of
mental state to visual output allows the user to immediately perceive their cognitive and emotional status in an
intuitive and engaging way.
What sets this BCI apart from basic parameter control is its emphasis on continuous, multi-sensory feedback rather
than simple binary outputs or single-variable adjustments. The system does not merely respond to one input; it
interprets a combination of brainwave frequencies and translates them into both color gradients and text, creating a
rich, interactive visualization. This approach highlights the potential of BCIs for more expressive and artistic
applications, rather than purely functional ones.
Implementing this system taught me the importance of real-time signal processing, the subtlety of mapping abstract
neural signals to intuitive visual feedback, and the challenge of designing an interface that is both responsive and
aesthetically meaningful. It reinforced the idea that BCIs can serve as tools not just for control, but for enhancing
self-awareness and engagement with one’s own cognitive and emotional states.
Screen Recording:

(2) Create an Event-Related Potential (ERP) experiment using BrainImation.
Description :
The ERP component measured in this experiment is the P300 (or P3b), a positive deflection in EEG that typically
occurs 300–600 milliseconds after a rare or meaningful stimulus. The P300 reflects attentional resource allocation
and stimulus evaluation, rather than the physical features of the stimulus, and is one of the most widely studied
cognitive ERP components. Its amplitude and latency vary with factors such as stimulus probability, task relevance,
and participant age (as shown in studies summarized in P300 Development Across the Lifespan: A Systematic
Review and Meta-Analysis ).
This project implements a visual oddball paradigm using simulated EEG data. Two stimulus categories are
presented: a frequent standard stimulus (blue circle; 80% probability) and a rare target stimulus (red circle; 20%
probability). Each trial triggers an EEG epoch representing a –200 ms baseline period and an 800 ms post-stimulus
window. The simulation adds a positive-going deflection around 300–600 ms for rare trials to mimic the real P300

response observed in human EEG data. The system separately averages epochs for standard and rare stimuli,
displaying both on the same ERP plot (blue vs. red) with labeled axes, timing markers, and trial counters for each
condition.
Two versions of the experiment were implemented.
The first version provides the core functionality with a 1-second epoch and straightforward averaging—ideal for
clear visualization and demonstration.
The second version extends the epoch length to approximately 1.5 seconds (–200 to +800 ms) and introduces
baseline correction, in which the mean of the pre-stimulus samples (–200 to 0 ms) is subtracted from the entire
epoch. This adjustment ensures that the averaged waveform reflects relative changes following stimulus onset rather
than absolute voltage shifts.
If conducted with real EEG, consistent with classic findings by Sutton et al. (1965), we would expect the rare targets
to elicit a larger and delayed positive peak around 300–600 ms over parietal electrodes, while frequent standards
would show minimal or no such positivity.
Screen Recording Version 1:

Screen Recording Version 2: