Datasets:

webxos
/

audioform_dataset

	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>AUDIOFORM: by webXOS</title>
	<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
	<script src="https://cdn.jsdelivr.net/npm/jszip@3.7.1/dist/jszip.min.js"></script>
	<script src="https://cdnjs.cloudflare.com/ajax/libs/FileSaver.js/2.0.5/FileSaver.min.js"></script>
	<style>
	* {
	margin: 0;
	padding: 0;
	box-sizing: border-box;
	font-family: 'Courier New', monospace;
	}

	body {
	background: #0a0a12;
	color: #00ff9d;
	overflow: hidden;
	height: 100vh;
	position: relative;
	}

	/* Loading Screen */
	#loading-screen {
	position: fixed;
	top: 0;
	left: 0;
	width: 100%;
	height: 100%;
	background: #000000;
	display: flex;
	flex-direction: column;
	justify-content: center;
	align-items: center;
	z-index: 1000;
	transition: opacity 1s;
	}

	.loading-title {
	font-size: 3rem;
	color: #00ff9d;
	text-shadow: 0 0 10px #00ff9d;
	margin-bottom: 2rem;
	letter-spacing: 5px;
	}

	.loading-bar {
	width: 300px;
	height: 4px;
	background: #111;
	border-radius: 2px;
	overflow: hidden;
	margin-top: 20px;
	}

	.loading-progress {
	height: 100%;
	background: #00ff9d;
	width: 0%;
	transition: width 0.3s;
	}

	/* Main UI */
	#ui-container {
	position: absolute;
	top: 0;
	left: 0;
	width: 100%;
	height: 100%;
	pointer-events: none;
	z-index: 10;
	}

	.ui-section {
	position: absolute;
	background: rgba(5, 5, 15, 0.85);
	border: 1px solid #00ff9d;
	border-radius: 5px;
	padding: 15px;
	box-shadow: 0 0 15px rgba(0, 255, 157, 0.3);
	pointer-events: all;
	}

	/* Control Panel */
	#control-panel {
	top: 20px;
	left: 20px;
	width: 320px;
	}

	/* Visualization Panel */
	#viz-panel {
	bottom: 20px;
	left: 20px;
	width: 320px;
	}

	/* Export Panel */
	#export-panel {
	top: 20px;
	right: 20px;
	width: 320px;
	}

	/* Title */
	#title {
	position: absolute;
	top: 20px;
	left: 50%;
	transform: translateX(-50%);
	font-size: 2.2rem;
	color: #00ff9d;
	text-shadow: 0 0 10px #00ff9d;
	letter-spacing: 3px;
	text-align: center;
	background: rgba(5, 5, 15, 0.7);
	padding: 10px 30px;
	border-radius: 5px;
	border: 1px solid #00ff9d;
	box-shadow: 0 0 15px rgba(0, 255, 157, 0.3);
	z-index: 11;
	}

	/* Fullscreen Button */
	#fullscreen-btn {
	position: absolute;
	bottom: 20px;
	right: 20px;
	width: 50px;
	height: 50px;
	background: rgba(5, 5, 15, 0.85);
	border: 1px solid #00ff9d;
	border-radius: 50%;
	color: #00ff9d;
	font-size: 24px;
	cursor: pointer;
	display: flex;
	justify-content: center;
	align-items: center;
	z-index: 11;
	pointer-events: all;
	transition: all 0.3s;
	}

	#fullscreen-btn:hover {
	background: rgba(0, 255, 157, 0.2);
	box-shadow: 0 0 15px #00ff9d;
	}

	/* UI Elements */
	h2 {
	color: #00ff9d;
	margin-bottom: 15px;
	border-bottom: 1px solid #00ff9d;
	padding-bottom: 5px;
	font-size: 1.3rem;
	}

	.btn {
	background: #001a0f;
	color: #00ff9d;
	border: 1px solid #00ff9d;
	padding: 10px 15px;
	border-radius: 3px;
	cursor: pointer;
	margin: 5px 0;
	width: 100%;
	font-weight: bold;
	transition: all 0.3s;
	}

	.btn:hover {
	background: #003320;
	box-shadow: 0 0 10px #00ff9d;
	}

	.btn:active {
	background: #00ff9d;
	color: #000;
	}

	.btn-red {
	background: #1a0000;
	border-color: #ff0033;
	color: #ff0033;
	}

	.btn-red:hover {
	background: #330000;
	box-shadow: 0 0 10px #ff0033;
	}

	.file-input {
	width: 100%;
	margin: 10px 0;
	padding: 8px;
	background: #000;
	color: #00ff9d;
	border: 1px solid #00ff9d;
	border-radius: 3px;
	}

	.slider-container {
	margin: 15px 0;
	}

	.slider-label {
	display: flex;
	justify-content: space-between;
	margin-bottom: 5px;
	}

	.slider {
	width: 100%;
	-webkit-appearance: none;
	height: 6px;
	background: #001a0f;
	border-radius: 3px;
	outline: none;
	}

	.slider::-webkit-slider-thumb {
	-webkit-appearance: none;
	width: 18px;
	height: 18px;
	background: #00ff9d;
	border-radius: 50%;
	cursor: pointer;
	}

	.toggle {
	display: flex;
	align-items: center;
	margin: 10px 0;
	}

	.toggle input {
	display: none;
	}

	.toggle-slider {
	width: 50px;
	height: 24px;
	background: #001a0f;
	border-radius: 12px;
	margin-right: 10px;
	position: relative;
	cursor: pointer;
	border: 1px solid #00ff9d;
	}

	.toggle-slider:after {
	content: '';
	position: absolute;
	width: 20px;
	height: 20px;
	background: #00ff9d;
	border-radius: 50%;
	top: 1px;
	left: 1px;
	transition: 0.3s;
	}

	.toggle input:checked + .toggle-slider:after {
	transform: translateX(26px);
	}

	.info-text {
	font-size: 0.85rem;
	color: #00cc7a;
	margin-top: 10px;
	line-height: 1.4;
	}

	/* Canvas */
	#canvas-container {
	width: 100%;
	height: 100%;
	}

	canvas {
	display: block;
	}

	/* Metrics Display */
	.metrics {
	background: rgba(0, 0, 0, 0.7);
	padding: 10px;
	border-radius: 3px;
	margin-top: 15px;
	border: 1px solid #ff0033;
	}

	.metric-row {
	display: flex;
	justify-content: space-between;
	margin: 5px 0;
	font-size: 0.9rem;
	}

	.metric-value {
	color: #ff0033;
	}
	</style>
	</head>
	<body>
	<!-- Loading Screen -->
	<div id="loading-screen">
	<div class="loading-title">AUDIOFORM</div>
	<div>Initializing 3D Audio Visualization System...</div>
	<div class="loading-bar">
	<div class="loading-progress" id="loading-progress"></div>
	</div>
	</div>

	<!-- Main UI -->
	<div id="ui-container">
	<div id="title">AUDIOFORM by webXOS</div>

	<div class="ui-section" id="control-panel">
	<h2>Audio Input</h2>
	<input type="file" id="audio-upload" accept=".wav" class="file-input">
	<button id="load-sample" class="btn">Load Sample Audio</button>

	<h2>Synthetic Noise Generator</h2>
	<div class="toggle">
	<input type="checkbox" id="noise-toggle">
	<label for="noise-toggle" class="toggle-slider"></label>
	<label for="noise-toggle">Enable 8-bit Tone Generation</label>
	</div>

	<div class="slider-container">
	<div class="slider-label">
	<span>Tone Frequency</span>
	<span id="freq-value">440 Hz</span>
	</div>
	<input type="range" min="50" max="2000" value="440" class="slider" id="freq-slider">
	</div>

	<div class="slider-container">
	<div class="slider-label">
	<span>Time Scaling</span>
	<span id="time-value">1.0x</span>
	</div>
	<input type="range" min="0.1" max="5" step="0.1" value="1" class="slider" id="time-slider">
	</div>

	<button id="generate-noise" class="btn">Generate Synthetic Audio</button>

	<div class="info-text">
	Synthetic mode generates 8-bit tones with timelapse time-scaling for dataset creation.
	</div>
	</div>

	<div class="ui-section" id="viz-panel">
	<h2>Visualization Controls</h2>

	<div class="slider-container">
	<div class="slider-label">
	<span>Waveform Scale</span>
	<span id="scale-value">1.0</span>
	</div>
	<input type="range" min="0.1" max="3" step="0.1" value="1" class="slider" id="scale-slider">
	</div>

	<div class="slider-container">
	<div class="slider-label">
	<span>Rotation Speed</span>
	<span id="rotation-value">0.5</span>
	</div>
	<input type="range" min="0" max="2" step="0.1" value="0.5" class="slider" id="rotation-slider">
	</div>

	<div class="toggle">
	<input type="checkbox" id="auto-rotate" checked>
	<label for="auto-rotate" class="toggle-slider"></label>
	<label for="auto-rotate">Auto-Rotate Visualization</label>
	</div>

	<button id="capture-frame" class="btn">Capture Current Frame</button>

	<div class="metrics">
	<div class="metric-row">
	<span>Frames Captured:</span>
	<span class="metric-value" id="frame-count">0</span>
	</div>
	<div class="metric-row">
	<span>Audio Duration:</span>
	<span class="metric-value" id="audio-duration">0.0s</span>
	</div>
	<div class="metric-row">
	<span>Current Time:</span>
	<span class="metric-value" id="current-time">0.0s</span>
	</div>
	</div>
	</div>

	<div class="ui-section" id="export-panel">
	<h2>Dataset Export</h2>

	<input type="text" id="dataset-name" placeholder="Dataset Name" class="file-input" value="audioform_dataset">

	<div class="slider-container">
	<div class="slider-label">
	<span>Frames to Capture</span>
	<span id="capture-count-value">10</span>
	</div>
	<input type="range" min="5" max="100" value="10" class="slider" id="capture-count-slider">
	</div>

	<button id="start-capture" class="btn">Start Timelapse Capture</button>
	<button id="export-dataset" class="btn">Export Dataset (.zip)</button>
	<button id="reset-captures" class="btn btn-red">Reset All Captures</button>

	<div class="info-text">
	Exports Hugging Face formatted .zip with README.md, images, and classification CSV.
	</div>
	</div>

	<div id="fullscreen-btn">⛶</div>
	</div>

	<!-- Three.js Canvas Container -->
	<div id="canvas-container"></div>

	<script>
	// Main Application
	document.addEventListener('DOMContentLoaded', function() {
	// Simulate loading progress
	let progress = 0;
	const progressInterval = setInterval(() => {
	progress += Math.random() * 15;
	if (progress >= 100) {
	progress = 100;
	clearInterval(progressInterval);
	setTimeout(() => {
	document.getElementById('loading-screen').style.opacity = '0';
	setTimeout(() => {
	document.getElementById('loading-screen').style.display = 'none';
	}, 1000);
	}, 500);
	}
	document.getElementById('loading-progress').style.width = `${progress}%`;
	}, 150);

	// Global variables
	let scene, camera, renderer, audioContext, audioSource, analyser;
	let waveformGeometry, waveformMaterial, waveformMesh;
	let capturedFrames = [];
	let isPlaying = false;
	let isNoiseMode = false;
	let currentAudioBuffer = null;
	let startTime = 0;
	let rotationSpeed = 0.5;
	let autoRotate = true;
	let timeScale = 1.0;
	let noiseFrequency = 440;
	let frameCaptureCount = 0;

	// Initialize Three.js scene
	function initThreeJS() {
	// Create scene
	scene = new THREE.Scene();
	scene.background = new THREE.Color(0x000000);

	// Create camera
	camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
	camera.position.z = 15;
	camera.position.y = 5;

	// Create renderer
	renderer = new THREE.WebGLRenderer({ antialias: true });
	renderer.setSize(window.innerWidth, window.innerHeight);
	renderer.setPixelRatio(window.devicePixelRatio);
	document.getElementById('canvas-container').appendChild(renderer.domElement);

	// Add lights
	const ambientLight = new THREE.AmbientLight(0x222222);
	scene.add(ambientLight);

	const directionalLight = new THREE.DirectionalLight(0x00ff9d, 1);
	directionalLight.position.set(10, 10, 5);
	scene.add(directionalLight);

	const redLight = new THREE.DirectionalLight(0xff0033, 0.5);
	redLight.position.set(-10, 5, -5);
	scene.add(redLight);

	// Create initial waveform visualization
	createWaveformVisualization();

	// Add grid helper
	const gridHelper = new THREE.GridHelper(30, 30, 0x00aa00, 0x003300);
	gridHelper.position.y = -5;
	scene.add(gridHelper);

	// Add axes helper
	const axesHelper = new THREE.AxesHelper(10);
	scene.add(axesHelper);

	// Handle window resize
	window.addEventListener('resize', onWindowResize);
	}

	// Create waveform visualization
	function createWaveformVisualization() {
	// Create geometry for waveform visualization
	const geometry = new THREE.BufferGeometry();
	const pointCount = 512;
	const positions = new Float32Array(pointCount * 3);

	// Initialize with flat line
	for (let i = 0; i < pointCount; i++) {
	positions[i * 3] = (i - pointCount / 2) * 0.05;
	positions[i * 3 + 1] = 0;
	positions[i * 3 + 2] = 0;
	}

	geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));

	// Create material with neon green color
	const material = new THREE.LineBasicMaterial({
	color: 0x00ff9d,
	linewidth: 2
	});

	// Create mesh and add to scene
	waveformMesh = new THREE.Line(geometry, material);
	scene.add(waveformMesh);

	// Also create a particle system for additional visualization
	const particleGeometry = new THREE.BufferGeometry();
	const particlePositions = new Float32Array(pointCount * 3);
	const particleColors = new Float32Array(pointCount * 3);

	for (let i = 0; i < pointCount; i++) {
	particlePositions[i * 3] = (i - pointCount / 2) * 0.05;
	particlePositions[i * 3 + 1] = 0;
	particlePositions[i * 3 + 2] = 0;

	// Green color for particles
	particleColors[i * 3] = 0.0; // R
	particleColors[i * 3 + 1] = 1.0; // G
	particleColors[i * 3 + 2] = 0.0; // B
	}

	particleGeometry.setAttribute('position', new THREE.BufferAttribute(particlePositions, 3));
	particleGeometry.setAttribute('color', new THREE.BufferAttribute(particleColors, 3));

	const particleMaterial = new THREE.PointsMaterial({
	size: 0.05,
	vertexColors: true,
	transparent: true
	});

	const particles = new THREE.Points(particleGeometry, particleMaterial);
	waveformMesh.add(particles);

	waveformGeometry = geometry;
	}

	// Update waveform visualization based on audio data
	function updateWaveform(dataArray) {
	if (!waveformGeometry) return;

	const positions = waveformGeometry.attributes.position.array;
	const pointCount = positions.length / 3;

	for (let i = 0; i < pointCount; i++) {
	// Get audio data value (normalized)
	const value = dataArray[i] / 128.0;

	// Update Y position based on audio data
	positions[i * 3 + 1] = value * 5;

	// Add some Z variation for 3D effect
	positions[i * 3 + 2] = Math.sin(i * 0.05 + Date.now() * 0.001) * value;
	}

	waveformGeometry.attributes.position.needsUpdate = true;
	}

	// Initialize audio context
	function initAudio() {
	audioContext = new (window.AudioContext \|\| window.webkitAudioContext)();
	analyser = audioContext.createAnalyser();
	analyser.fftSize = 512;
	analyser.smoothingTimeConstant = 0.8;
	}

	// Load and play audio file
	function loadAudioFile(file) {
	if (!audioContext) initAudio();

	const reader = new FileReader();
	reader.onload = function(e) {
	audioContext.decodeAudioData(e.target.result, function(buffer) {
	playAudioBuffer(buffer);
	}, function(e) {
	console.error("Error decoding audio data", e);
	});
	};
	reader.readAsArrayBuffer(file);
	}

	// Play audio buffer
	function playAudioBuffer(buffer) {
	stopAudio();

	currentAudioBuffer = buffer;
	audioSource = audioContext.createBufferSource();
	audioSource.buffer = buffer;
	audioSource.connect(analyser);
	analyser.connect(audioContext.destination);

	// Set playback rate based on time scaling
	audioSource.playbackRate.value = timeScale;

	audioSource.start(0);
	isPlaying = true;
	startTime = audioContext.currentTime;

	// Update duration display
	document.getElementById('audio-duration').textContent = `${buffer.duration.toFixed(2)}s`;

	// Start animation loop
	animate();
	}

	// Generate synthetic 8-bit tone
	function generateSyntheticNoise() {
	if (!audioContext) initAudio();

	stopAudio();

	// Create oscillator for 8-bit tone
	const oscillator = audioContext.createOscillator();
	oscillator.type = 'square'; // Square wave for 8-bit sound
	oscillator.frequency.setValueAtTime(noiseFrequency, audioContext.currentTime);

	// Create gain node for volume control
	const gainNode = audioContext.createGain();
	gainNode.gain.setValueAtTime(0.1, audioContext.currentTime);

	// Connect nodes
	oscillator.connect(gainNode);
	gainNode.connect(analyser);
	analyser.connect(audioContext.destination);

	// Create buffer source for continuous playback
	const bufferLength = 2; // 2 seconds buffer
	const buffer = audioContext.createBuffer(1, audioContext.sampleRate * bufferLength, audioContext.sampleRate);
	const channelData = buffer.getChannelData(0);

	// Fill buffer with 8-bit style square wave
	for (let i = 0; i < channelData.length; i++) {
	const time = i / audioContext.sampleRate;
	const frequency = noiseFrequency;
	// Square wave calculation
	channelData[i] = Math.sign(Math.sin(2 * Math.PI * frequency * time));
	// Add some noise for "8-bit" character
	channelData[i] += (Math.random() - 0.5) * 0.1;
	// Clamp to prevent distortion
	channelData[i] = Math.max(-0.8, Math.min(0.8, channelData[i]));
	}

	// Play the buffer
	audioSource = audioContext.createBufferSource();
	audioSource.buffer = buffer;
	audioSource.loop = true;
	audioSource.playbackRate.value = timeScale;
	audioSource.connect(analyser);
	analyser.connect(audioContext.destination);

	audioSource.start(0);
	isPlaying = true;
	startTime = audioContext.currentTime;

	// Update duration display for synthetic audio
	document.getElementById('audio-duration').textContent = `∞ (synthetic)`;

	// Start animation loop
	animate();
	}

	// Stop audio playback
	function stopAudio() {
	if (audioSource) {
	audioSource.stop();
	audioSource.disconnect();
	isPlaying = false;
	}
	}

	// Capture current frame as image
	function captureFrame() {
	// Render the current frame to a data URL
	renderer.render(scene, camera);
	const dataURL = renderer.domElement.toDataURL('image/png');

	// Create frame object
	const frame = {
	id: frameCaptureCount,
	timestamp: audioContext ? (audioContext.currentTime - startTime).toFixed(3) : '0.000',
	dataURL: dataURL,
	frequency: isNoiseMode ? noiseFrequency : 0,
	timeScale: timeScale,
	date: new Date().toISOString()
	};

	capturedFrames.push(frame);
	frameCaptureCount++;

	// Update UI
	document.getElementById('frame-count').textContent = frameCaptureCount;

	// Add visual feedback
	waveformMesh.material.color.setHex(0xff0033);
	setTimeout(() => {
	waveformMesh.material.color.setHex(0x00ff9d);
	}, 100);

	return frame;
	}

	// Start timelapse capture
	function startTimelapseCapture() {
	const totalFrames = parseInt(document.getElementById('capture-count-slider').value);
	const interval = 0.5; // Capture every 0.5 seconds

	let framesCaptured = 0;

	const captureInterval = setInterval(() => {
	if (framesCaptured >= totalFrames) {
	clearInterval(captureInterval);
	alert(`Timelapse capture complete! Captured ${totalFrames} frames.`);
	return;
	}

	captureFrame();
	framesCaptured++;
	}, interval * 1000);
	}

	// Export dataset as Hugging Face formatted zip
	async function exportDataset() {
	if (capturedFrames.length === 0) {
	alert('No frames captured yet! Capture some frames before exporting.');
	return;
	}

	const datasetName = document.getElementById('dataset-name').value \|\| 'audioform_dataset';
	const zip = new JSZip();

	// Create dataset folder structure
	const datasetFolder = zip.folder(datasetName);
	const imagesFolder = datasetFolder.folder('images');

	// Create metadata CSV with REQUIRED file_name column for Hugging Face compatibility
	let csvContent = 'file_name,frame_id,timestamp,frequency,time_scale,capture_date\n';

	// Add images to zip and build CSV simultaneously
	capturedFrames.forEach((frame, index) => {
	// Convert dataURL to blob
	const data = frame.dataURL.split(',')[1];
	const blob = b64toBlob(data, 'image/png');

	// Add image to zip
	const imageName = `frame_${String(index).padStart(4, '0')}.png`;
	imagesFolder.file(imageName, blob);

	// Add to CSV with file_name column (required by Hugging Face ImageFolder)
	csvContent += `images/${imageName},${frame.id},${frame.timestamp},${frame.frequency},${frame.timeScale},${frame.date}\n`;
	});

	datasetFolder.file('metadata.csv', csvContent);

	// Create README.md
	const readmeContent = `# ${datasetName}

	## Dataset Description

	This dataset was generated using AUDIOFORM, a 3D audio visualization system.

	- Total Frames: ${capturedFrames.length}
	- Generation Date: ${new Date().toISOString().split('T')[0]}
	- Audio Type: ${isNoiseMode ? 'Synthetic 8-bit Tone' : 'Uploaded WAV File'}
	- Time Scaling: ${timeScale}x

	## Dataset Structure

	- \`images/\`: Contains all captured frames in PNG format
	- \`metadata.csv\`: Contains classification data for each frame

	## Metadata Columns

	- \`file_name\`: Relative path to the image file (e.g., images/frame_0001.png) - REQUIRED for Hugging Face
	- \`frame_id\`: Unique identifier for each frame
	- \`timestamp\`: Time in seconds when frame was captured
	- \`frequency\`: Audio frequency at capture time (Hz)
	- \`time_scale\`: Playback speed multiplier
	- \`capture_date\`: ISO date string of capture

	## Intended Use

	This dataset is intended for training machine learning models on audio visualization patterns, waveform classification, or generative AI tasks.

	## Generation Details

	Generated with AUDIOFORM v1.0 - A Three.js based audio visualization dataset generator.
	`;

	datasetFolder.file('README.md', readmeContent);

	// Generate and download zip file
	const zipBlob = await zip.generateAsync({type: 'blob'});
	saveAs(zipBlob, `${datasetName}.zip`);

	alert(`Dataset exported successfully as ${datasetName}.zip\n\nThe dataset includes the required 'file_name' column for Hugging Face compatibility.`);
	}

	// Helper function to convert base64 to blob
	function b64toBlob(b64Data, contentType = '', sliceSize = 512) {
	const byteCharacters = atob(b64Data);
	const byteArrays = [];

	for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {
	const slice = byteCharacters.slice(offset, offset + sliceSize);

	const byteNumbers = new Array(slice.length);
	for (let i = 0; i < slice.length; i++) {
	byteNumbers[i] = slice.charCodeAt(i);
	}

	const byteArray = new Uint8Array(byteNumbers);
	byteArrays.push(byteArray);
	}

	const blob = new Blob(byteArrays, {type: contentType});
	return blob;
	}

	// Reset all captured frames
	function resetCaptures() {
	if (capturedFrames.length > 0 && !confirm('Are you sure you want to reset all captured frames?')) {
	return;
	}

	capturedFrames = [];
	frameCaptureCount = 0;
	document.getElementById('frame-count').textContent = '0';
	}

	// Animation loop
	function animate() {
	requestAnimationFrame(animate);

	// Update audio visualization if playing
	if (isPlaying && analyser) {
	const dataArray = new Uint8Array(analyser.frequencyBinCount);
	analyser.getByteFrequencyData(dataArray);
	updateWaveform(dataArray);

	// Update current time display
	if (audioContext) {
	const currentTime = audioContext.currentTime - startTime;
	document.getElementById('current-time').textContent = `${currentTime.toFixed(2)}s`;
	}
	}

	// Auto-rotate visualization
	if (autoRotate && waveformMesh) {
	waveformMesh.rotation.y += 0.005 * rotationSpeed;
	waveformMesh.rotation.x += 0.002 * rotationSpeed;
	}

	// Render scene
	renderer.render(scene, camera);
	}

	// Handle window resize
	function onWindowResize() {
	camera.aspect = window.innerWidth / window.innerHeight;
	camera.updateProjectionMatrix();
	renderer.setSize(window.innerWidth, window.innerHeight);
	}

	// Toggle fullscreen mode
	function toggleFullscreen() {
	if (!document.fullscreenElement) {
	document.documentElement.requestFullscreen().catch(err => {
	console.error(`Error attempting to enable fullscreen: ${err.message}`);
	});
	} else {
	if (document.exitFullscreen) {
	document.exitFullscreen();
	}
	}
	}

	// Load sample audio
	function loadSampleAudio() {
	// Create a simple 8-bit style sample audio
	if (!audioContext) initAudio();

	// Create a buffer with multiple frequencies
	const buffer = audioContext.createBuffer(1, audioContext.sampleRate * 3, audioContext.sampleRate);
	const channelData = buffer.getChannelData(0);

	// Generate a sample with varying frequencies
	for (let i = 0; i < channelData.length; i++) {
	const time = i / audioContext.sampleRate;

	// Vary frequency over time
	const freq = 200 + Math.sin(time * 2) * 100;

	// Square wave
	channelData[i] = Math.sign(Math.sin(2 * Math.PI * freq * time));

	// Add some noise
	channelData[i] += (Math.random() - 0.5) * 0.05;

	// Clamp
	channelData[i] = Math.max(-0.8, Math.min(0.8, channelData[i]));
	}

	playAudioBuffer(buffer);
	}

	// Setup event listeners
	function setupEventListeners() {
	// File upload
	document.getElementById('audio-upload').addEventListener('change', function(e) {
	if (e.target.files.length > 0) {
	loadAudioFile(e.target.files[0]);
	isNoiseMode = false;
	}
	});

	// Sample audio button
	document.getElementById('load-sample').addEventListener('click', loadSampleAudio);

	// Noise generator toggle
	document.getElementById('noise-toggle').addEventListener('change', function(e) {
	isNoiseMode = e.target.checked;
	});

	// Generate synthetic noise
	document.getElementById('generate-noise').addEventListener('click', generateSyntheticNoise);

	// Frequency slider
	const freqSlider = document.getElementById('freq-slider');
	const freqValue = document.getElementById('freq-value');
	freqSlider.addEventListener('input', function() {
	noiseFrequency = parseInt(this.value);
	freqValue.textContent = `${noiseFrequency} Hz`;

	// Regenerate noise if currently playing in noise mode
	if (isPlaying && isNoiseMode) {
	generateSyntheticNoise();
	}
	});

	// Time scaling slider
	const timeSlider = document.getElementById('time-slider');
	const timeValue = document.getElementById('time-value');
	timeSlider.addEventListener('input', function() {
	timeScale = parseFloat(this.value);
	timeValue.textContent = `${timeScale.toFixed(1)}x`;

	// Update playback rate if audio is playing
	if (audioSource && isPlaying) {
	audioSource.playbackRate.value = timeScale;
	}
	});

	// Waveform scale slider
	const scaleSlider = document.getElementById('scale-slider');
	const scaleValue = document.getElementById('scale-value');
	scaleSlider.addEventListener('input', function() {
	const scale = parseFloat(this.value);
	scaleValue.textContent = scale.toFixed(1);

	if (waveformMesh) {
	waveformMesh.scale.y = scale;
	}
	});

	// Rotation speed slider
	const rotationSlider = document.getElementById('rotation-slider');
	const rotationValue = document.getElementById('rotation-value');
	rotationSlider.addEventListener('input', function() {
	rotationSpeed = parseFloat(this.value);
	rotationValue.textContent = rotationSpeed.toFixed(1);
	});

	// Auto-rotate toggle
	document.getElementById('auto-rotate').addEventListener('change', function(e) {
	autoRotate = e.target.checked;
	});

	// Capture frame button
	document.getElementById('capture-frame').addEventListener('click', captureFrame);

	// Capture count slider
	const captureCountSlider = document.getElementById('capture-count-slider');
	const captureCountValue = document.getElementById('capture-count-value');
	captureCountSlider.addEventListener('input', function() {
	captureCountValue.textContent = this.value;
	});

	// Start timelapse capture
	document.getElementById('start-capture').addEventListener('click', startTimelapseCapture);

	// Export dataset
	document.getElementById('export-dataset').addEventListener('click', exportDataset);

	// Reset captures
	document.getElementById('reset-captures').addEventListener('click', resetCaptures);

	// Fullscreen button
	document.getElementById('fullscreen-btn').addEventListener('click', toggleFullscreen);

	// Handle fullscreen change
	document.addEventListener('fullscreenchange', function() {
	const fullscreenBtn = document.getElementById('fullscreen-btn');
	if (document.fullscreenElement) {
	fullscreenBtn.textContent = '⛶';
	} else {
	fullscreenBtn.textContent = '⛶';
	}
	});
	}

	// Initialize everything
	initThreeJS();
	initAudio();
	setupEventListeners();

	// Start animation loop
	animate();

	// Show a welcome message
	setTimeout(() => {
	console.log('AUDIOFORM initialized. Ready to generate audio visualization datasets.');
	}, 1000);
	});
	</script>
	</body>
	</html>