| | <!DOCTYPE html> |
| | <html lang="en"> |
| | <head> |
| | <meta charset="UTF-8"> |
| | <meta name="viewport" content="width=device-width, initial-scale=1.0"> |
| | <title>IONICSPHERE v7.0 - Real-Time Quantum Simulator</title> |
| | |
| | |
| | <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script> |
| | <script src="https://cdn.jsdelivr.net/npm/three@0.128.0/examples/js/controls/OrbitControls.min.js"></script> |
| | <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@latest/dist/tf.min.js"></script> |
| | <script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script> |
| | <script src="https://cdnjs.cloudflare.com/ajax/libs/FileSaver.js/2.0.5/FileSaver.min.js"></script> |
| | <script src="https://cdn.jsdelivr.net/npm/gpu.js@latest/dist/gpu-browser.min.js"></script> |
| | |
| | <style> |
| | * { |
| | margin: 0; |
| | padding: 0; |
| | box-sizing: border-box; |
| | } |
| | |
| | body { |
| | font-family: 'Courier New', monospace; |
| | background: #000000; |
| | color: #00ff00; |
| | overflow: hidden; |
| | height: 100vh; |
| | display: flex; |
| | flex-direction: column; |
| | } |
| | |
| | |
| | #header { |
| | background: rgba(0, 20, 0, 0.95); |
| | border-bottom: 2px solid #00ff00; |
| | padding: 10px 20px; |
| | display: flex; |
| | justify-content: space-between; |
| | align-items: center; |
| | z-index: 100; |
| | height: 60px; |
| | box-shadow: 0 0 20px rgba(0, 255, 0, 0.3); |
| | } |
| | |
| | .logo { |
| | font-size: 24px; |
| | font-weight: bold; |
| | color: #00ff00; |
| | text-shadow: 0 0 10px #00ff00; |
| | letter-spacing: 2px; |
| | } |
| | |
| | .status-indicator { |
| | display: flex; |
| | align-items: center; |
| | gap: 10px; |
| | } |
| | |
| | .live-dot { |
| | width: 12px; |
| | height: 12px; |
| | border-radius: 50%; |
| | background: #ff0000; |
| | box-shadow: 0 0 10px #ff0000; |
| | animation: pulse 1s infinite; |
| | } |
| | |
| | .live-dot.active { |
| | background: #00ff00; |
| | box-shadow: 0 0 15px #00ff00; |
| | } |
| | |
| | .header-buttons { |
| | display: flex; |
| | gap: 10px; |
| | } |
| | |
| | .header-btn { |
| | background: transparent; |
| | border: 1px solid #00ff00; |
| | color: #00ff00; |
| | padding: 8px 15px; |
| | font-family: 'Courier New', monospace; |
| | cursor: pointer; |
| | font-size: 14px; |
| | transition: all 0.3s; |
| | } |
| | |
| | .header-btn:hover { |
| | background: rgba(0, 255, 0, 0.1); |
| | box-shadow: 0 0 10px #00ff00; |
| | } |
| | |
| | .header-btn.active { |
| | background: rgba(0, 255, 0, 0.2); |
| | box-shadow: 0 0 15px #00ff00; |
| | animation: neonPulse 1.5s infinite alternate; |
| | } |
| | |
| | |
| | #main-content { |
| | display: flex; |
| | flex: 1; |
| | overflow: hidden; |
| | } |
| | |
| | |
| | #terminal-container { |
| | flex: 0 0 500px; |
| | background: rgba(0, 10, 0, 0.95); |
| | border-right: 2px solid #00ff00; |
| | display: flex; |
| | flex-direction: column; |
| | z-index: 10; |
| | box-shadow: 5px 0 15px rgba(0, 255, 0, 0.2); |
| | } |
| | |
| | #terminal { |
| | flex: 1; |
| | padding: 20px; |
| | overflow-y: auto; |
| | font-size: 14px; |
| | line-height: 1.4; |
| | } |
| | |
| | .terminal-line { |
| | margin-bottom: 5px; |
| | white-space: pre-wrap; |
| | word-break: break-word; |
| | } |
| | |
| | .terminal-line.prompt { |
| | color: #00ff00; |
| | } |
| | |
| | .terminal-line.output { |
| | color: #00cc00; |
| | } |
| | |
| | .terminal-line.system { |
| | color: #00ffff; |
| | } |
| | |
| | .terminal-line.error { |
| | color: #ff0000; |
| | } |
| | |
| | .terminal-line.warning { |
| | color: #ffff00; |
| | } |
| | |
| | .terminal-line.success { |
| | color: #00ff00; |
| | text-shadow: 0 0 5px #00ff00; |
| | } |
| | |
| | .terminal-input { |
| | background: rgba(0, 20, 0, 0.8); |
| | border: 1px solid #00ff00; |
| | border-left: none; |
| | border-right: none; |
| | border-bottom: none; |
| | padding: 15px 20px; |
| | color: #00ff00; |
| | font-family: 'Courier New', monospace; |
| | font-size: 14px; |
| | width: 100%; |
| | outline: none; |
| | } |
| | |
| | .terminal-input:focus { |
| | background: rgba(0, 30, 0, 0.9); |
| | box-shadow: inset 0 0 10px rgba(0, 255, 0, 0.3); |
| | } |
| | |
| | |
| | #visualization { |
| | flex: 1; |
| | position: relative; |
| | background: #000; |
| | } |
| | |
| | #threeCanvas { |
| | position: absolute; |
| | top: 0; |
| | left: 0; |
| | width: 100%; |
| | height: 100%; |
| | display: block; |
| | } |
| | |
| | |
| | #stats-panel { |
| | position: absolute; |
| | bottom: 20px; |
| | right: 20px; |
| | background: rgba(0, 20, 0, 0.9); |
| | border: 2px solid #00ff00; |
| | padding: 15px; |
| | font-size: 12px; |
| | width: 300px; |
| | z-index: 5; |
| | backdrop-filter: blur(5px); |
| | } |
| | |
| | .stat-row { |
| | display: flex; |
| | justify-content: space-between; |
| | margin: 6px 0; |
| | padding: 3px 0; |
| | border-bottom: 1px solid rgba(0, 255, 0, 0.1); |
| | } |
| | |
| | .stat-label { |
| | color: #00cc00; |
| | } |
| | |
| | .stat-value { |
| | color: #00ff00; |
| | font-weight: bold; |
| | } |
| | |
| | |
| | #training-panel { |
| | position: absolute; |
| | top: 20px; |
| | right: 20px; |
| | background: rgba(0, 20, 0, 0.9); |
| | border: 2px solid #00ff00; |
| | padding: 15px; |
| | font-size: 12px; |
| | width: 350px; |
| | z-index: 5; |
| | backdrop-filter: blur(5px); |
| | } |
| | |
| | .training-progress { |
| | width: 100%; |
| | height: 10px; |
| | background: rgba(0, 0, 0, 0.5); |
| | border: 1px solid #00ff00; |
| | margin: 10px 0; |
| | overflow: hidden; |
| | } |
| | |
| | .training-progress-fill { |
| | height: 100%; |
| | background: linear-gradient(90deg, #00ff00, #00cc00); |
| | width: 0%; |
| | transition: width 0.5s ease-out; |
| | } |
| | |
| | |
| | @keyframes pulse { |
| | 0%, 100% { opacity: 1; } |
| | 50% { opacity: 0.5; } |
| | } |
| | |
| | @keyframes neonPulse { |
| | 0% { box-shadow: 0 0 10px #00ff00; } |
| | 100% { box-shadow: 0 0 20px #00ff00, 0 0 30px #00ff00; } |
| | } |
| | |
| | @keyframes blink { |
| | 0%, 100% { opacity: 1; } |
| | 50% { opacity: 0; } |
| | } |
| | |
| | .cursor { |
| | animation: blink 1s infinite; |
| | } |
| | |
| | |
| | #terminal::-webkit-scrollbar { |
| | width: 10px; |
| | } |
| | |
| | #terminal::-webkit-scrollbar-track { |
| | background: rgba(0, 20, 0, 0.5); |
| | } |
| | |
| | #terminal::-webkit-scrollbar-thumb { |
| | background: #00ff00; |
| | border-radius: 5px; |
| | } |
| | |
| | |
| | .model-status { |
| | display: inline-block; |
| | padding: 2px 8px; |
| | border-radius: 3px; |
| | font-size: 11px; |
| | margin-left: 5px; |
| | } |
| | |
| | .status-training { |
| | background: rgba(255, 255, 0, 0.2); |
| | color: #ffff00; |
| | } |
| | |
| | .status-ready { |
| | background: rgba(0, 255, 0, 0.2); |
| | color: #00ff00; |
| | } |
| | </style> |
| | </head> |
| | <body> |
| | |
| | <div id="header"> |
| | <div class="logo">IONICSPHERE v7.0</div> |
| | |
| | <div class="status-indicator"> |
| | <div class="live-dot" id="liveDot"></div> |
| | <span id="statusText">INITIALIZING</span> |
| | </div> |
| | |
| | <div class="header-buttons"> |
| | <button class="header-btn" onclick="runSimulation()" id="runBtn">▶ RUN SIM</button> |
| | <button class="header-btn" onclick="toggleTraining()" id="trainBtn">🧠 TRAIN</button> |
| | <button class="header-btn" onclick="exportEverything()">📦 EXPORT ALL</button> |
| | </div> |
| | </div> |
| | |
| | |
| | <div id="main-content"> |
| | |
| | <div id="terminal-container"> |
| | <div id="terminal"> |
| | <div class="terminal-line system">========================================</div> |
| | <div class="terminal-line system"> REAL-TIME IONIC SIMULATOR v7.0</div> |
| | <div class="terminal-line system"> TensorFlow.js + Three.js Integration</div> |
| | <div class="terminal-line system">========================================</div> |
| | <div class="terminal-line output">Initializing quantum simulation matrix...</div> |
| | <div class="terminal-line output">Loading TensorFlow.js neural kernel...</div> |
| | <div class="terminal-line output">Generating 10,240 synthetic ions...</div> |
| | <div class="terminal-line output">Type 'help' for available commands</div> |
| | <div class="terminal-line prompt">$ <span id="currentLine"></span><span class="cursor">█</span></div> |
| | </div> |
| | <input type="text" id="commandInput" class="terminal-input" placeholder="Type command (help, train, export, clear, status, reset)..."> |
| | </div> |
| | |
| | |
| | <div id="visualization"> |
| | <canvas id="threeCanvas"></canvas> |
| | |
| | |
| | <div id="training-panel"> |
| | <div class="stat-row"> |
| | <span class="stat-label">NEURAL TRAINING:</span> |
| | <span class="stat-value" id="trainingStatus">IDLE</span> |
| | </div> |
| | <div class="stat-row"> |
| | <span class="stat-label">EPOCH:</span> |
| | <span class="stat-value" id="epochDisplay">0</span> |
| | </div> |
| | <div class="stat-row"> |
| | <span class="stat-label">LOSS:</span> |
| | <span class="stat-value" id="lossDisplay">0.0000</span> |
| | </div> |
| | <div class="stat-row"> |
| | <span class="stat-label">ACCURACY:</span> |
| | <span class="stat-value" id="accuracyDisplay">0.0%</span> |
| | </div> |
| | <div class="training-progress"> |
| | <div id="trainingProgress" class="training-progress-fill"></div> |
| | </div> |
| | <div class="stat-row"> |
| | <span class="stat-label">BATCH SIZE:</span> |
| | <span class="stat-value" id="batchDisplay">32</span> |
| | </div> |
| | </div> |
| | |
| | |
| | <div id="stats-panel"> |
| | <div class="stat-row"> |
| | <span class="stat-label">SIMULATION:</span> |
| | <span class="stat-value" id="simStatus">PAUSED</span> |
| | </div> |
| | <div class="stat-row"> |
| | <span class="stat-label">FPS:</span> |
| | <span class="stat-value" id="fpsCounter">0</span> |
| | </div> |
| | <div class="stat-row"> |
| | <span class="stat-label">IONS:</span> |
| | <span class="stat-value" id="ionCount">10,240</span> |
| | </div> |
| | <div class="stat-row"> |
| | <span class="stat-label">SIM TIME:</span> |
| | <span class="stat-value" id="simTime">0.0s</span> |
| | </div> |
| | <div class="stat-row"> |
| | <span class="stat-label">CAPTURED DATA:</span> |
| | <span class="stat-value" id="dataCount">0</span> |
| | </div> |
| | <div class="stat-row"> |
| | <span class="stat-label">GPU ACCEL:</span> |
| | <span class="stat-value" id="gpuStatus">ACTIVE</span> |
| | </div> |
| | </div> |
| | </div> |
| | </div> |
| |
|
| | <script> |
| | |
| | let simulationRunning = false; |
| | let trainingActive = false; |
| | let animationId = null; |
| | let trainingAnimationId = null; |
| | let simulationTime = 0; |
| | let lastFrameTime = performance.now(); |
| | let frameCount = 0; |
| | let fps = 0; |
| | let epochCount = 0; |
| | let trainingLoss = 0; |
| | let trainingAccuracy = 0; |
| | let currentBatch = 0; |
| | |
| | |
| | let capturedData = { |
| | positions: [], |
| | velocities: [], |
| | trainingLog: [], |
| | frames: [], |
| | modelStates: [], |
| | timestamps: [] |
| | }; |
| | |
| | |
| | let tfModel = null; |
| | let trainingData = []; |
| | let validationData = []; |
| | |
| | |
| | let scene, camera, renderer, controls, particles, ocean; |
| | let particleCount = 10240; |
| | |
| | |
| | let commandHistory = []; |
| | let historyIndex = -1; |
| | |
| | |
| | let gpu = new GPU(); |
| | let physicsKernel = null; |
| | |
| | |
| | async function createNeuralModel() { |
| | printLine('[TENSORFLOW] Creating neural network...', 'system'); |
| | |
| | try { |
| | |
| | tfModel = tf.sequential(); |
| | |
| | |
| | tfModel.add(tf.layers.dense({ |
| | units: 32, |
| | inputShape: [5], |
| | activation: 'relu', |
| | kernelInitializer: 'heNormal' |
| | })); |
| | |
| | tfModel.add(tf.layers.dropout({rate: 0.2})); |
| | |
| | tfModel.add(tf.layers.dense({ |
| | units: 16, |
| | activation: 'relu' |
| | })); |
| | |
| | tfModel.add(tf.layers.dense({ |
| | units: 8, |
| | activation: 'relu' |
| | })); |
| | |
| | |
| | tfModel.add(tf.layers.dense({ |
| | units: 1, |
| | activation: 'sigmoid' |
| | })); |
| | |
| | |
| | tfModel.compile({ |
| | optimizer: tf.train.adam(0.001), |
| | loss: 'binaryCrossentropy', |
| | metrics: ['accuracy'] |
| | }); |
| | |
| | printLine('[TENSORFLOW] Model created successfully', 'success'); |
| | printLine('[TENSORFLOW] Architecture: 5→32→16→8→1', 'output'); |
| | printLine('[TENSORFLOW] Optimizer: Adam (0.001)', 'output'); |
| | |
| | return true; |
| | } catch (error) { |
| | printLine(`[TENSORFLOW] Error: ${error.message}`, 'error'); |
| | return false; |
| | } |
| | } |
| | |
| | async function generateTrainingData() { |
| | printLine('[DATA] Generating synthetic training data...', 'system'); |
| | |
| | trainingData = []; |
| | validationData = []; |
| | |
| | |
| | for (let i = 0; i < 1000; i++) { |
| | const features = [ |
| | Math.random(), |
| | Math.random(), |
| | Math.random(), |
| | (Math.random() - 0.5) * 2, |
| | (Math.random() - 0.5) * 2 |
| | ]; |
| | |
| | |
| | const stability = (features[1] > 0.3 && Math.abs(features[3]) < 0.5) ? 1 : 0; |
| | |
| | if (i < 800) { |
| | trainingData.push({features, label: stability}); |
| | } else { |
| | validationData.push({features, label: stability}); |
| | } |
| | } |
| | |
| | printLine(`[DATA] Generated ${trainingData.length} training samples`, 'success'); |
| | printLine(`[DATA] Generated ${validationData.length} validation samples`, 'success'); |
| | } |
| | |
| | async function trainModelStep() { |
| | if (!tfModel || !trainingActive || trainingData.length === 0) return; |
| | |
| | try { |
| | |
| | const batchSize = 32; |
| | const batchStart = currentBatch * batchSize; |
| | const batchEnd = Math.min(batchStart + batchSize, trainingData.length); |
| | |
| | if (batchStart >= trainingData.length) { |
| | currentBatch = 0; |
| | epochCount++; |
| | printLine(`[TRAINING] Epoch ${epochCount} completed`, 'system'); |
| | updateTrainingUI(); |
| | return; |
| | } |
| | |
| | const batchData = trainingData.slice(batchStart, batchEnd); |
| | |
| | |
| | const features = batchData.map(d => d.features); |
| | const labels = batchData.map(d => d.label); |
| | |
| | const xs = tf.tensor2d(features); |
| | const ys = tf.tensor2d(labels, [labels.length, 1]); |
| | |
| | |
| | const history = await tfModel.fit(xs, ys, { |
| | batchSize: batchSize, |
| | epochs: 1, |
| | shuffle: true, |
| | verbose: 0 |
| | }); |
| | |
| | |
| | const loss = history.history.loss[0]; |
| | const accuracy = history.history.acc ? history.history.acc[0] : 0; |
| | |
| | trainingLoss = loss; |
| | trainingAccuracy = accuracy; |
| | |
| | |
| | capturedData.trainingLog.push({ |
| | epoch: epochCount, |
| | batch: currentBatch, |
| | loss: loss, |
| | accuracy: accuracy, |
| | timestamp: Date.now() |
| | }); |
| | |
| | |
| | updateTrainingUI(); |
| | |
| | |
| | xs.dispose(); |
| | ys.dispose(); |
| | |
| | currentBatch++; |
| | |
| | } catch (error) { |
| | printLine(`[TRAINING] Error: ${error.message}`, 'error'); |
| | } |
| | } |
| | |
| | function updateTrainingUI() { |
| | document.getElementById('trainingStatus').textContent = trainingActive ? 'TRAINING' : 'IDLE'; |
| | document.getElementById('epochDisplay').textContent = epochCount; |
| | document.getElementById('lossDisplay').textContent = trainingLoss.toFixed(4); |
| | document.getElementById('accuracyDisplay').textContent = (trainingAccuracy * 100).toFixed(1) + '%'; |
| | document.getElementById('batchDisplay').textContent = currentBatch; |
| | |
| | const progress = ((currentBatch * 32) / trainingData.length) * 100; |
| | document.getElementById('trainingProgress').style.width = progress + '%'; |
| | } |
| | |
| | |
| | function captureFrameData() { |
| | if (!particles || !simulationRunning) return; |
| | |
| | const positions = particles.geometry.attributes.position.array; |
| | const velocities = particles.userData.velocities; |
| | |
| | |
| | if (frameCount % 60 === 0) { |
| | capturedData.positions.push(Float32Array.from(positions)); |
| | capturedData.velocities.push(Float32Array.from(velocities)); |
| | capturedData.timestamps.push(Date.now()); |
| | capturedData.modelStates.push({ |
| | epoch: epochCount, |
| | loss: trainingLoss, |
| | accuracy: trainingAccuracy |
| | }); |
| | |
| | document.getElementById('dataCount').textContent = capturedData.positions.length; |
| | |
| | if (capturedData.positions.length % 10 === 0) { |
| | printLine(`[CAPTURE] Stored ${capturedData.positions.length} data frames`, 'system'); |
| | } |
| | } |
| | } |
| | |
| | function captureThreeJSFrame() { |
| | if (!renderer) return; |
| | |
| | const canvas = document.getElementById('threeCanvas'); |
| | const dataURL = canvas.toDataURL('image/png'); |
| | |
| | capturedData.frames.push({ |
| | timestamp: Date.now(), |
| | epoch: epochCount, |
| | dataURL: dataURL, |
| | metrics: { |
| | loss: trainingLoss, |
| | accuracy: trainingAccuracy, |
| | fps: fps |
| | } |
| | }); |
| | |
| | printLine(`[CAPTURE] Screenshot captured (epoch ${epochCount})`, 'system'); |
| | } |
| | |
| | |
| | async function initThreeJS() { |
| | printLine('[THREE.JS] Initializing 3D visualization...', 'system'); |
| | |
| | try { |
| | |
| | scene = new THREE.Scene(); |
| | scene.background = new THREE.Color(0x000022); |
| | |
| | |
| | camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000); |
| | camera.position.set(0, 50, 100); |
| | |
| | |
| | const canvas = document.getElementById('threeCanvas'); |
| | renderer = new THREE.WebGLRenderer({ |
| | canvas, |
| | antialias: true, |
| | powerPreference: "high-performance" |
| | }); |
| | renderer.setSize(canvas.clientWidth, canvas.clientHeight); |
| | renderer.setPixelRatio(window.devicePixelRatio); |
| | |
| | |
| | controls = new THREE.OrbitControls(camera, renderer.domElement); |
| | controls.enableDamping = true; |
| | controls.dampingFactor = 0.05; |
| | |
| | |
| | const ambientLight = new THREE.AmbientLight(0x0044aa, 0.5); |
| | scene.add(ambientLight); |
| | |
| | const directionalLight = new THREE.DirectionalLight(0x00ffff, 0.8); |
| | directionalLight.position.set(10, 20, 15); |
| | scene.add(directionalLight); |
| | |
| | |
| | createOcean(); |
| | |
| | |
| | createIons(); |
| | |
| | |
| | initPhysicsKernel(); |
| | |
| | printLine('[THREE.JS] Visualization ready', 'success'); |
| | return true; |
| | |
| | } catch (error) { |
| | printLine(`[THREE.JS] Error: ${error.message}`, 'error'); |
| | return false; |
| | } |
| | } |
| | |
| | function createOcean() { |
| | const geometry = new THREE.PlaneGeometry(200, 200, 64, 64); |
| | const material = new THREE.MeshPhongMaterial({ |
| | color: 0x0066ff, |
| | transparent: true, |
| | opacity: 0.7, |
| | wireframe: false |
| | }); |
| | |
| | ocean = new THREE.Mesh(geometry, material); |
| | ocean.rotation.x = -Math.PI / 2; |
| | scene.add(ocean); |
| | } |
| | |
| | function createIons() { |
| | const geometry = new THREE.BufferGeometry(); |
| | const positions = new Float32Array(particleCount * 3); |
| | const colors = new Float32Array(particleCount * 3); |
| | |
| | for (let i = 0; i < particleCount; i++) { |
| | const i3 = i * 3; |
| | |
| | |
| | const radius = 50 + Math.random() * 30; |
| | const theta = Math.random() * Math.PI * 2; |
| | const phi = Math.acos(2 * Math.random() - 1); |
| | |
| | positions[i3] = radius * Math.sin(phi) * Math.cos(theta); |
| | positions[i3 + 1] = radius * Math.sin(phi) * Math.sin(theta); |
| | positions[i3 + 2] = radius * Math.cos(phi); |
| | |
| | |
| | colors[i3] = 0.2 + positions[i3] / 100; |
| | colors[i3 + 1] = 0.4 + positions[i3 + 1] / 100; |
| | colors[i3 + 2] = 0.8 + positions[i3 + 2] / 100; |
| | } |
| | |
| | geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3)); |
| | geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3)); |
| | |
| | const material = new THREE.PointsMaterial({ |
| | size: 2.0, |
| | vertexColors: true, |
| | transparent: true, |
| | opacity: 0.8, |
| | blending: THREE.AdditiveBlending |
| | }); |
| | |
| | particles = new THREE.Points(geometry, material); |
| | scene.add(particles); |
| | |
| | |
| | particles.userData.velocities = new Float32Array(particleCount * 3); |
| | particles.userData.originalPositions = positions.slice(); |
| | |
| | for (let i = 0; i < particleCount * 3; i++) { |
| | particles.userData.velocities[i] = (Math.random() - 0.5) * 0.2; |
| | } |
| | |
| | printLine(`[IONS] Created ${particleCount.toLocaleString()} particles`, 'success'); |
| | } |
| | |
| | function initPhysicsKernel() { |
| | try { |
| | physicsKernel = gpu.createKernel(function(positions, velocities, time) { |
| | const i = this.thread.x * 3; |
| | |
| | |
| | const noise = Math.sin(time + positions[i]) * 0.05; |
| | |
| | return [ |
| | positions[i] + velocities[i] + noise, |
| | positions[i + 1] + velocities[i + 1] + noise, |
| | positions[i + 2] + velocities[i + 2] + noise |
| | ]; |
| | }).setOutput([particleCount]); |
| | |
| | printLine('[GPU.JS] Physics kernel initialized', 'success'); |
| | } catch (error) { |
| | printLine('[GPU.JS] Using CPU fallback for physics', 'warning'); |
| | physicsKernel = null; |
| | } |
| | } |
| | |
| | function updateSimulation(deltaTime) { |
| | if (!simulationRunning || !particles || !ocean) return; |
| | |
| | simulationTime += deltaTime; |
| | |
| | |
| | frameCount++; |
| | const currentTime = performance.now(); |
| | if (currentTime - lastFrameTime >= 1000) { |
| | fps = Math.round((frameCount * 1000) / (currentTime - lastFrameTime)); |
| | frameCount = 0; |
| | lastFrameTime = currentTime; |
| | |
| | document.getElementById('fpsCounter').textContent = fps; |
| | document.getElementById('simTime').textContent = simulationTime.toFixed(1) + 's'; |
| | } |
| | |
| | |
| | updateOcean(deltaTime); |
| | |
| | |
| | updateIons(deltaTime); |
| | |
| | |
| | captureFrameData(); |
| | |
| | |
| | controls.update(); |
| | } |
| | |
| | function updateOcean(deltaTime) { |
| | const positionAttribute = ocean.geometry.attributes.position; |
| | const time = simulationTime; |
| | |
| | for (let i = 0; i < positionAttribute.count; i++) { |
| | const i3 = i * 3; |
| | const x = positionAttribute.array[i3]; |
| | const z = positionAttribute.array[i3 + 2]; |
| | |
| | const wave = Math.sin(x * 0.05 + time) * 2 + |
| | Math.cos(z * 0.03 + time * 0.7) * 1.5; |
| | |
| | positionAttribute.array[i3 + 1] = wave; |
| | } |
| | |
| | positionAttribute.needsUpdate = true; |
| | } |
| | |
| | function updateIons(deltaTime) { |
| | const positions = particles.geometry.attributes.position.array; |
| | const velocities = particles.userData.velocities; |
| | |
| | if (physicsKernel) { |
| | |
| | try { |
| | const result = physicsKernel(positions, velocities, simulationTime); |
| | |
| | for (let i = 0; i < particleCount; i++) { |
| | const i3 = i * 3; |
| | const newPos = result[i]; |
| | |
| | positions[i3] = newPos[0]; |
| | positions[i3 + 1] = newPos[1]; |
| | positions[i3 + 2] = newPos[2]; |
| | |
| | |
| | const dx = positions[i3]; |
| | const dy = positions[i3 + 1]; |
| | const dz = positions[i3 + 2]; |
| | const distance = Math.sqrt(dx * dx + dy * dy + dz * dz); |
| | |
| | if (distance > 80) { |
| | const force = 0.01; |
| | velocities[i3] -= dx * force; |
| | velocities[i3 + 1] -= dy * force; |
| | velocities[i3 + 2] -= dz * force; |
| | } |
| | } |
| | } catch (error) { |
| | |
| | updateIonsCPU(deltaTime); |
| | } |
| | } else { |
| | updateIonsCPU(deltaTime); |
| | } |
| | |
| | particles.geometry.attributes.position.needsUpdate = true; |
| | } |
| | |
| | function updateIonsCPU(deltaTime) { |
| | const positions = particles.geometry.attributes.position.array; |
| | const velocities = particles.userData.velocities; |
| | |
| | for (let i = 0; i < particleCount; i++) { |
| | const i3 = i * 3; |
| | |
| | |
| | velocities[i3] += (Math.random() - 0.5) * 0.1 * deltaTime; |
| | velocities[i3 + 1] += (Math.random() - 0.5) * 0.1 * deltaTime; |
| | velocities[i3 + 2] += (Math.random() - 0.5) * 0.1 * deltaTime; |
| | |
| | |
| | velocities[i3] *= 0.99; |
| | velocities[i3 + 1] *= 0.99; |
| | velocities[i3 + 2] *= 0.99; |
| | |
| | |
| | positions[i3] += velocities[i3] * deltaTime * 30; |
| | positions[i3 + 1] += velocities[i3 + 1] * deltaTime * 30; |
| | positions[i3 + 2] += velocities[i3 + 2] * deltaTime * 30; |
| | |
| | |
| | const radius = Math.sqrt( |
| | positions[i3] * positions[i3] + |
| | positions[i3 + 1] * positions[i3 + 1] + |
| | positions[i3 + 2] * positions[i3 + 2] |
| | ); |
| | |
| | if (radius > 80) { |
| | velocities[i3] *= -0.5; |
| | velocities[i3 + 1] *= -0.5; |
| | velocities[i3 + 2] *= -0.5; |
| | } |
| | } |
| | } |
| | |
| | |
| | function animationLoop() { |
| | const currentTime = performance.now(); |
| | const deltaTime = (currentTime - (scene.userData.lastTime || currentTime)) / 1000; |
| | scene.userData.lastTime = currentTime; |
| | |
| | updateSimulation(deltaTime); |
| | |
| | if (trainingActive) { |
| | trainModelStep(); |
| | } |
| | |
| | renderer.render(scene, camera); |
| | animationId = requestAnimationFrame(animationLoop); |
| | } |
| | |
| | |
| | function printLine(text, type = 'output') { |
| | const line = document.createElement('div'); |
| | line.className = `terminal-line ${type}`; |
| | line.textContent = text; |
| | document.getElementById('terminal').appendChild(line); |
| | scrollTerminal(); |
| | } |
| | |
| | function printPrompt() { |
| | const prompt = document.createElement('div'); |
| | prompt.className = 'terminal-line prompt'; |
| | prompt.innerHTML = '$ <span id="currentLine"></span><span class="cursor">█</span>'; |
| | document.getElementById('terminal').appendChild(prompt); |
| | scrollTerminal(); |
| | } |
| | |
| | function scrollTerminal() { |
| | const terminal = document.getElementById('terminal'); |
| | terminal.scrollTop = terminal.scrollHeight; |
| | } |
| | |
| | function clearTerminal() { |
| | document.getElementById('terminal').innerHTML = ''; |
| | printLine('[SYSTEM] Terminal cleared', 'system'); |
| | printPrompt(); |
| | } |
| | |
| | function showHelp() { |
| | printLine('Available commands:', 'system'); |
| | printLine(' help - Show this help message'); |
| | printLine(' run - Start simulation'); |
| | printLine(' pause - Pause simulation'); |
| | printLine(' train [epochs]- Toggle/start training (optional epochs)'); |
| | printLine(' stop - Stop training'); |
| | printLine(' capture - Capture screenshot'); |
| | printLine(' status - Show system status'); |
| | printLine(' export - Export all data as ZIP'); |
| | printLine(' clear - Clear terminal'); |
| | printLine(' reset - Reset simulation'); |
| | } |
| | |
| | function handleCommand(command) { |
| | const parts = command.trim().split(' '); |
| | const cmd = parts[0].toLowerCase(); |
| | const args = parts.slice(1); |
| | |
| | switch(cmd) { |
| | case 'help': |
| | showHelp(); |
| | break; |
| | |
| | case 'run': |
| | runSimulation(); |
| | break; |
| | |
| | case 'pause': |
| | pauseSimulation(); |
| | break; |
| | |
| | case 'train': |
| | if (args[0]) { |
| | printLine(`[TRAINING] Training for ${args[0]} epochs...`, 'system'); |
| | } |
| | toggleTraining(); |
| | break; |
| | |
| | case 'stop': |
| | toggleTraining(false); |
| | break; |
| | |
| | case 'capture': |
| | captureThreeJSFrame(); |
| | break; |
| | |
| | case 'status': |
| | showStatus(); |
| | break; |
| | |
| | case 'export': |
| | exportEverything(); |
| | break; |
| | |
| | case 'clear': |
| | clearTerminal(); |
| | break; |
| | |
| | case 'reset': |
| | resetSimulation(); |
| | break; |
| | |
| | case 'model': |
| | printLine(`[MODEL] Architecture: 5→32→16→8→1`, 'system'); |
| | printLine(`[MODEL] Epochs: ${epochCount}`, 'output'); |
| | printLine(`[MODEL] Loss: ${trainingLoss.toFixed(4)}`, 'output'); |
| | printLine(`[MODEL] Accuracy: ${(trainingAccuracy * 100).toFixed(1)}%`, 'output'); |
| | break; |
| | |
| | case 'data': |
| | printLine(`[DATA] Captured frames: ${capturedData.positions.length}`, 'system'); |
| | printLine(`[DATA] Training samples: ${trainingData.length}`, 'output'); |
| | printLine(`[DATA] Validation samples: ${validationData.length}`, 'output'); |
| | break; |
| | |
| | case '': |
| | |
| | break; |
| | |
| | default: |
| | printLine(`Command not found: ${cmd}. Type 'help' for available commands.`, 'error'); |
| | break; |
| | } |
| | } |
| | |
| | function showStatus() { |
| | printLine('=== SYSTEM STATUS ===', 'system'); |
| | printLine(`Simulation: ${simulationRunning ? 'RUNNING' : 'PAUSED'}`); |
| | printLine(`Training: ${trainingActive ? 'ACTIVE' : 'INACTIVE'}`); |
| | printLine(`Epochs: ${epochCount}`); |
| | printLine(`Loss: ${trainingLoss.toFixed(4)}`); |
| | printLine(`Accuracy: ${(trainingAccuracy * 100).toFixed(1)}%`); |
| | printLine(`FPS: ${fps}`); |
| | printLine(`Sim Time: ${simulationTime.toFixed(1)}s`); |
| | printLine(`Ions: ${particleCount.toLocaleString()}`); |
| | printLine(`Captured Data: ${capturedData.positions.length} frames`); |
| | } |
| | |
| | |
| | function runSimulation() { |
| | if (!simulationRunning) { |
| | simulationRunning = true; |
| | document.getElementById('runBtn').classList.add('active'); |
| | document.getElementById('liveDot').classList.add('active'); |
| | document.getElementById('statusText').textContent = 'RUNNING'; |
| | document.getElementById('simStatus').textContent = 'RUNNING'; |
| | |
| | if (!animationId) { |
| | scene.userData.lastTime = performance.now(); |
| | animationId = requestAnimationFrame(animationLoop); |
| | } |
| | |
| | printLine('[SIMULATION] Started real-time quantum simulation', 'success'); |
| | } |
| | } |
| | |
| | function pauseSimulation() { |
| | simulationRunning = false; |
| | document.getElementById('runBtn').classList.remove('active'); |
| | document.getElementById('liveDot').classList.remove('active'); |
| | document.getElementById('statusText').textContent = 'PAUSED'; |
| | document.getElementById('simStatus').textContent = 'PAUSED'; |
| | |
| | printLine('[SIMULATION] Paused', 'system'); |
| | } |
| | |
| | function toggleTraining(start = true) { |
| | if (start && !trainingActive) { |
| | trainingActive = true; |
| | document.getElementById('trainBtn').classList.add('active'); |
| | printLine('[TRAINING] Started real-time neural training', 'success'); |
| | printLine('[TRAINING] Using live particle data as input', 'output'); |
| | } else if (!start && trainingActive) { |
| | trainingActive = false; |
| | document.getElementById('trainBtn').classList.remove('active'); |
| | printLine('[TRAINING] Stopped', 'system'); |
| | } else { |
| | trainingActive = !trainingActive; |
| | document.getElementById('trainBtn').classList.toggle('active'); |
| | printLine(`[TRAINING] ${trainingActive ? 'Started' : 'Stopped'}`, 'system'); |
| | } |
| | |
| | updateTrainingUI(); |
| | } |
| | |
| | function resetSimulation() { |
| | simulationRunning = false; |
| | trainingActive = false; |
| | simulationTime = 0; |
| | epochCount = 0; |
| | trainingLoss = 0; |
| | trainingAccuracy = 0; |
| | currentBatch = 0; |
| | |
| | document.getElementById('runBtn').classList.remove('active'); |
| | document.getElementById('trainBtn').classList.remove('active'); |
| | document.getElementById('liveDot').classList.remove('active'); |
| | document.getElementById('statusText').textContent = 'STANDBY'; |
| | document.getElementById('simStatus').textContent = 'STANDBY'; |
| | |
| | |
| | if (particles && particles.userData.originalPositions) { |
| | const positions = particles.geometry.attributes.position.array; |
| | const original = particles.userData.originalPositions; |
| | for (let i = 0; i < positions.length; i++) { |
| | positions[i] = original[i]; |
| | } |
| | particles.geometry.attributes.position.needsUpdate = true; |
| | } |
| | |
| | capturedData = { |
| | positions: [], |
| | velocities: [], |
| | trainingLog: [], |
| | frames: [], |
| | modelStates: [], |
| | timestamps: [] |
| | }; |
| | |
| | updateTrainingUI(); |
| | document.getElementById('dataCount').textContent = '0'; |
| | |
| | printLine('[SYSTEM] Full reset complete', 'system'); |
| | } |
| | |
| | |
| | async function exportEverything() { |
| | printLine('[EXPORT] Creating unified package...', 'system'); |
| | |
| | try { |
| | const zip = new JSZip(); |
| | |
| | |
| | const modelMetadata = { |
| | name: "IonicQuantumSimulator_v7.0", |
| | version: "7.0", |
| | export_date: new Date().toISOString(), |
| | epochs_trained: epochCount, |
| | final_loss: trainingLoss, |
| | final_accuracy: trainingAccuracy, |
| | particle_count: particleCount, |
| | simulation_time: simulationTime, |
| | features: ["position_x", "position_y", "position_z", "velocity_x", "velocity_y"], |
| | architecture: "5→32→16→8→1", |
| | optimizer: "adam", |
| | learning_rate: 0.001, |
| | batch_size: 32 |
| | }; |
| | zip.file("model_metadata.json", JSON.stringify(modelMetadata, null, 2)); |
| | |
| | |
| | zip.file("training_log.json", JSON.stringify(capturedData.trainingLog, null, 2)); |
| | |
| | |
| | const particleData = { |
| | metadata: { |
| | frames: capturedData.positions.length, |
| | particles_per_frame: particleCount, |
| | total_positions: capturedData.positions.length * particleCount * 3, |
| | timestamps: capturedData.timestamps |
| | }, |
| | positions: capturedData.positions.map(arr => Array.from(arr)), |
| | velocities: capturedData.velocities.map(arr => Array.from(arr)), |
| | model_states: capturedData.modelStates |
| | }; |
| | zip.file("particle_data.json", JSON.stringify(particleData, null, 2)); |
| | |
| | |
| | if (capturedData.frames.length > 0) { |
| | const framesFolder = zip.folder("screenshots"); |
| | capturedData.frames.forEach((frame, index) => { |
| | const base64Data = frame.dataURL.split(',')[1]; |
| | framesFolder.file(`frame_${index}_epoch_${frame.epoch}.png`, base64Data, {base64: true}); |
| | }); |
| | } |
| | |
| | |
| | if (tfModel) { |
| | const weights = await tfModel.save(tf.io.withSaveHandler(async (artifacts) => { |
| | const weightData = { |
| | modelTopology: artifacts.modelTopology, |
| | weightSpecs: artifacts.weightSpecs, |
| | weightData: Array.from(new Uint8Array(artifacts.weightData)) |
| | }; |
| | return weightData; |
| | })); |
| | |
| | zip.file("tfjs_model/model.json", JSON.stringify(weights.modelTopology, null, 2)); |
| | zip.file("tfjs_model/weights.bin", new Blob([new Uint8Array(weights.weightData)])); |
| | } |
| | |
| | |
| | const readme = generateReadme(); |
| | zip.file("README.md", readme); |
| | |
| | |
| | const terminalContent = document.getElementById('terminal').innerText; |
| | zip.file("terminal_log.txt", terminalContent); |
| | |
| | |
| | const config = { |
| | simulation: { |
| | ion_count: particleCount, |
| | ocean_size: 200, |
| | time_step: 0.016, |
| | physics_engine: physicsKernel ? "GPU.js" : "CPU" |
| | }, |
| | neural_network: { |
| | input_shape: [5], |
| | output_shape: [1], |
| | layers: [32, 16, 8], |
| | activation: "relu", |
| | output_activation: "sigmoid" |
| | }, |
| | export_info: { |
| | version: "7.0", |
| | format: "JSON/ZIP", |
| | total_size: "varies", |
| | compatible_with: "TensorFlow.js, Three.js" |
| | } |
| | }; |
| | zip.file("config.json", JSON.stringify(config, null, 2)); |
| | |
| | |
| | const content = await zip.generateAsync({type: "blob"}); |
| | const filename = `ionicsphere_export_v7.0_${Date.now()}.zip`; |
| | saveAs(content, filename); |
| | |
| | printLine(`[EXPORT] Package created: ${filename}`, 'success'); |
| | printLine(`[EXPORT] Files: 8, Size: ${Math.round(content.size / 1024 / 1024 * 10) / 10}MB`, 'output'); |
| | printLine('[EXPORT] Includes: model, data, screenshots, logs', 'output'); |
| | |
| | } catch (error) { |
| | printLine(`[EXPORT] Error: ${error.message}`, 'error'); |
| | } |
| | } |
| | |
| | function generateReadme() { |
| | return `# Ionic Sphere Quantum Simulator v7.0 |
| | ## Real-Time Neural Training System |
| | |
| | **Model Name:** IonicQuantumSimulator_v7.0 |
| | **Version:** 7.0 |
| | **Export Date:** ${new Date().toISOString()} |
| | |
| | ### Training Summary |
| | - **Total Epochs:** ${epochCount} |
| | - **Final Loss:** ${trainingLoss.toFixed(4)} |
| | - **Final Accuracy:** ${(trainingAccuracy * 100).toFixed(1)}% |
| | - **Training Samples:** ${trainingData.length} |
| | - **Simulation Time:** ${simulationTime.toFixed(1)}s |
| | |
| | ### Dataset Information |
| | This package contains real-time captured data from the quantum ionic simulation: |
| | |
| | **Particle Data:** |
| | - Frames captured: ${capturedData.positions.length} |
| | - Particles per frame: ${particleCount} |
| | - Total position samples: ${capturedData.positions.length * particleCount * 3} |
| | - Time range: ${capturedData.timestamps.length > 0 ? `${Math.round((capturedData.timestamps[capturedData.timestamps.length-1] - capturedData.timestamps[0])/1000)}s` : 'N/A'} |
| | |
| | **Features Captured:** |
| | 1. Position (x, y, z) - normalized coordinates |
| | 2. Velocity (x, y) - movement vectors |
| | 3. Timestamp - simulation time |
| | 4. Model state - neural network parameters at capture time |
| | |
| | ### Model Architecture |
| | \`\`\` |
| | Input(5) → Dense(32, relu) → Dropout(0.2) |
| | → Dense(16, relu) |
| | → Dense(8, relu) |
| | → Output(1, sigmoid) |
| | \`\`\` |
| | |
| | ### Training Configuration |
| | - **Optimizer:** Adam (learning_rate=0.001) |
| | - **Loss Function:** Binary Crossentropy |
| | - **Batch Size:** 32 |
| | - **Validation Split:** 20% |
| | - **Shuffle:** True |
| | |
| | ### Simulation Parameters |
| | - **Ion Count:** ${particleCount.toLocaleString()} |
| | - **Ocean Size:** 200x200 units |
| | - **Physics Engine:** ${physicsKernel ? 'GPU.js accelerated' : 'CPU based'} |
| | - **Render Engine:** Three.js r128 |
| | - **Target FPS:** 60 |
| | |
| | ### File Structure |
| | \`\`\` |
| | ionicsphere_export_v7.0_*.zip/ |
| | ├── model_metadata.json # Model configuration and stats |
| | ├── training_log.json # Loss/accuracy per epoch |
| | ├── particle_data.json # Captured particle positions/velocities |
| | ├── screenshots/ # PNG frames from simulation |
| | │ ├── frame_0_*.png |
| | │ └── ... |
| | ├── tfjs_model/ # TensorFlow.js model files |
| | │ ├── model.json |
| | │ └── weights.bin |
| | ├── README.md # This file |
| | ├── terminal_log.txt # CLI interaction history |
| | └── config.json # System configuration |
| | \`\`\` |
| | |
| | ### Usage Instructions |
| | |
| | **1. Load Model in TensorFlow.js:** |
| | \`\`\`javascript |
| | async function loadModel() { |
| | const model = await tf.loadLayersModel('tfjs_model/model.json'); |
| | const weights = await fetch('tfjs_model/weights.bin'); |
| | // Load weights and make predictions |
| | } |
| | \`\`\` |
| | |
| | **2. Analyze Particle Data:** |
| | \`\`\`javascript |
| | const data = JSON.parse(particleDataJson); |
| | const positions = data.positions; // Array of position frames |
| | const velocities = data.velocities; // Array of velocity frames |
| | \`\`\` |
| | |
| | **3. Reproduce Simulation:** |
| | - Use Three.js with provided particle data |
| | - Apply same physics parameters |
| | - Feed data into neural network for stability predictions |
| | |
| | ### Citation |
| | If you use this data in research, please cite: |
| | \`\`\`bibtex |
| | @dataset{ionic_sphere_2024, |
| | title={Real-Time Quantum Ionic Simulation Dataset}, |
| | author={IONICSPHERE Research Team}, |
| | year={2024}, |
| | publisher={IONICSPHERE v7.0}, |
| | url={https://github.com/ionicsphere/simulator} |
| | } |
| | \`\`\` |
| | |
| | ### License |
| | Research Use Only - Attribution Required |
| | |
| | ### Contact |
| | For questions or access to newer versions, visit the project repository.`; |
| | } |
| | |
| | |
| | function setupCommandInput() { |
| | const input = document.getElementById('commandInput'); |
| | const currentLine = document.getElementById('currentLine'); |
| | |
| | input.focus(); |
| | |
| | input.addEventListener('keydown', (e) => { |
| | if (e.key === 'Enter') { |
| | const command = input.value.trim(); |
| | |
| | if (command) { |
| | |
| | const prompts = document.querySelectorAll('.terminal-line.prompt'); |
| | if (prompts.length > 0) { |
| | prompts[prompts.length - 1].remove(); |
| | } |
| | |
| | |
| | printLine(`$ ${command}`, 'prompt'); |
| | |
| | |
| | handleCommand(command); |
| | |
| | |
| | commandHistory.push(command); |
| | historyIndex = commandHistory.length; |
| | |
| | |
| | input.value = ''; |
| | currentLine.textContent = ''; |
| | printPrompt(); |
| | } |
| | } else if (e.key === 'ArrowUp') { |
| | if (commandHistory.length > 0) { |
| | historyIndex = Math.max(0, historyIndex - 1); |
| | input.value = commandHistory[historyIndex] || ''; |
| | currentLine.textContent = input.value; |
| | } |
| | e.preventDefault(); |
| | } else if (e.key === 'ArrowDown') { |
| | if (commandHistory.length > 0) { |
| | historyIndex = Math.min(commandHistory.length, historyIndex + 1); |
| | input.value = commandHistory[historyIndex] || ''; |
| | currentLine.textContent = input.value; |
| | } |
| | e.preventDefault(); |
| | } else if (e.key === 'Tab') { |
| | e.preventDefault(); |
| | |
| | const commands = ['help', 'run', 'pause', 'train', 'stop', 'capture', 'status', 'export', 'clear', 'reset', 'model', 'data']; |
| | const current = input.value.trim(); |
| | |
| | for (const cmd of commands) { |
| | if (cmd.startsWith(current)) { |
| | input.value = cmd; |
| | currentLine.textContent = cmd; |
| | break; |
| | } |
| | } |
| | } |
| | }); |
| | |
| | input.addEventListener('input', () => { |
| | currentLine.textContent = input.value; |
| | }); |
| | } |
| | |
| | |
| | async function initialize() { |
| | printLine('[SYSTEM] Booting IONICSPHERE v7.0...', 'system'); |
| | |
| | try { |
| | |
| | printLine('[TENSORFLOW] Initializing...', 'system'); |
| | await tf.ready(); |
| | printLine('[TENSORFLOW] Backend: ' + tf.getBackend(), 'success'); |
| | |
| | |
| | await createNeuralModel(); |
| | |
| | |
| | await generateTrainingData(); |
| | |
| | |
| | await initThreeJS(); |
| | |
| | |
| | setupCommandInput(); |
| | |
| | |
| | scene.userData.lastTime = performance.now(); |
| | animationId = requestAnimationFrame(animationLoop); |
| | |
| | |
| | document.getElementById('statusText').textContent = 'READY'; |
| | document.getElementById('gpuStatus').textContent = physicsKernel ? 'ACTIVE' : 'CPU'; |
| | |
| | printLine('[SYSTEM] Ready. Type "help" for commands.', 'success'); |
| | printLine('[SYSTEM] Real-time training: train/stop', 'output'); |
| | printLine('[SYSTEM] Data export: export', 'output'); |
| | |
| | } catch (error) { |
| | printLine(`[ERROR] Initialization failed: ${error.message}`, 'error'); |
| | } |
| | } |
| | |
| | function handleResize() { |
| | if (camera && renderer) { |
| | const canvas = document.getElementById('threeCanvas'); |
| | camera.aspect = canvas.clientWidth / canvas.clientHeight; |
| | camera.updateProjectionMatrix(); |
| | renderer.setSize(canvas.clientWidth, canvas.clientHeight); |
| | } |
| | } |
| | |
| | |
| | window.addEventListener('load', initialize); |
| | window.addEventListener('resize', handleResize); |
| | |
| | |
| | setTimeout(() => { |
| | if (!simulationRunning) { |
| | runSimulation(); |
| | } |
| | }, 2000); |
| | </script> |
| | </body> |
| | </html> |
