| <!DOCTYPE html> |
| <html lang="en"> |
| <head> |
| <meta charset="UTF-8"> |
| <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=5.0, user-scalable=yes"> |
| <title>WAVE BENDER IDE v5.0 - BETA TEST by webXOS</title> |
| <meta name="theme-color" content="#000000"> |
| <style> |
| * { margin: 0; padding: 0; box-sizing: border-box; } |
| |
| body { |
| background: #000; |
| color: #0f0; |
| font-family: 'Courier New', monospace; |
| overflow: hidden; |
| height: 100vh; |
| } |
| |
| |
| .crt-overlay { |
| position: fixed; |
| top: 0; |
| left: 0; |
| width: 100%; |
| height: 100%; |
| pointer-events: none; |
| z-index: 9999; |
| } |
| |
| .crt-scanlines { |
| position: absolute; |
| width: 100%; |
| height: 100%; |
| background: linear-gradient( |
| to bottom, |
| transparent 50%, |
| rgba(0, 255, 0, 0.03) 50% |
| ); |
| background-size: 100% 4px; |
| animation: scanlines 8s linear infinite; |
| } |
| |
| .crt-glitch { |
| position: absolute; |
| width: 100%; |
| height: 100%; |
| background: linear-gradient( |
| 90deg, |
| rgba(0, 255, 0, 0.02) 1px, |
| transparent 1px |
| ); |
| background-size: 3px 100%; |
| animation: glitch 3s infinite; |
| } |
| |
| @keyframes scanlines { |
| 0% { background-position: 0 0; } |
| 100% { background-position: 0 100%; } |
| } |
| |
| @keyframes glitch { |
| 0%, 100% { transform: translateX(0); opacity: 1; } |
| 5% { transform: translateX(-2px); opacity: 0.8; } |
| 10% { transform: translateX(2px); opacity: 0.9; } |
| 15% { transform: translateX(-1px); opacity: 0.7; } |
| 95% { transform: translateX(0); opacity: 1; } |
| } |
| |
| |
| #main-container { |
| display: flex; |
| height: 100vh; |
| padding: 10px; |
| gap: 10px; |
| } |
| |
| |
| #control-panel { |
| width: 320px; |
| background: rgba(0, 20, 0, 0.85); |
| border: 3px solid #0f0; |
| padding: 20px; |
| display: flex; |
| flex-direction: column; |
| gap: 20px; |
| overflow-y: auto; |
| box-shadow: 0 0 30px rgba(0, 255, 0, 0.2); |
| position: relative; |
| z-index: 10; |
| } |
| |
| |
| .title-section { |
| text-align: center; |
| padding-bottom: 15px; |
| border-bottom: 2px solid #0f0; |
| margin-bottom: 15px; |
| } |
| |
| .main-title { |
| font-size: 28px; |
| color: #0f0; |
| text-shadow: 0 0 15px #0f0; |
| margin-bottom: 5px; |
| letter-spacing: 2px; |
| } |
| |
| .version-badge { |
| background: #0f0; |
| color: #000; |
| padding: 3px 10px; |
| font-size: 12px; |
| border-radius: 3px; |
| display: inline-block; |
| margin-bottom: 10px; |
| } |
| |
| .subtitle { |
| font-size: 11px; |
| color: #0a0; |
| opacity: 0.9; |
| line-height: 1.4; |
| } |
| |
| |
| .control-group { |
| background: rgba(0, 30, 0, 0.4); |
| border: 1px solid #0a0; |
| padding: 15px; |
| margin-bottom: 15px; |
| border-radius: 3px; |
| } |
| |
| .group-title { |
| color: #0ff; |
| font-size: 14px; |
| margin-bottom: 12px; |
| text-transform: uppercase; |
| letter-spacing: 1px; |
| display: flex; |
| align-items: center; |
| gap: 8px; |
| } |
| |
| .group-title::before { |
| content: ">"; |
| color: #0f0; |
| } |
| |
| |
| .slider-container { |
| margin-bottom: 12px; |
| } |
| |
| .slider-label { |
| display: flex; |
| justify-content: space-between; |
| color: #0a0; |
| font-size: 12px; |
| margin-bottom: 6px; |
| } |
| |
| .slider-value { |
| color: #0ff; |
| font-weight: bold; |
| } |
| |
| input[type="range"] { |
| width: 100%; |
| height: 6px; |
| -webkit-appearance: none; |
| background: #002200; |
| border: 1px solid #0a0; |
| border-radius: 3px; |
| outline: none; |
| } |
| |
| input[type="range"]::-webkit-slider-thumb { |
| -webkit-appearance: none; |
| width: 18px; |
| height: 18px; |
| background: #0f0; |
| border: 2px solid #000; |
| border-radius: 50%; |
| cursor: pointer; |
| box-shadow: 0 0 10px #0f0; |
| transition: all 0.2s; |
| } |
| |
| input[type="range"]::-webkit-slider-thumb:hover { |
| background: #0ff; |
| box-shadow: 0 0 15px #0ff; |
| } |
| |
| |
| .button-grid { |
| display: grid; |
| grid-template-columns: repeat(2, 1fr); |
| gap: 10px; |
| margin-top: 15px; |
| } |
| |
| .cyber-button { |
| padding: 12px 15px; |
| background: #000; |
| border: 2px solid; |
| color: inherit; |
| font-family: 'Courier New', monospace; |
| font-size: 13px; |
| font-weight: bold; |
| cursor: pointer; |
| text-transform: uppercase; |
| letter-spacing: 1px; |
| transition: all 0.3s; |
| position: relative; |
| overflow: hidden; |
| z-index: 1; |
| } |
| |
| .cyber-button::before { |
| content: ''; |
| position: absolute; |
| top: 0; |
| left: -100%; |
| width: 100%; |
| height: 100%; |
| background: linear-gradient(90deg, transparent, rgba(255,255,255,0.1), transparent); |
| transition: left 0.5s; |
| z-index: -1; |
| } |
| |
| .cyber-button:hover::before { |
| left: 100%; |
| } |
| |
| .cyber-button:hover { |
| transform: translateY(-2px); |
| box-shadow: 0 5px 15px currentColor; |
| } |
| |
| .cyber-button:active { |
| transform: translateY(0); |
| } |
| |
| .cyber-button.primary { |
| border-color: #0ff; |
| color: #0ff; |
| } |
| |
| .cyber-button.primary:hover { |
| background: #0ff; |
| color: #000; |
| } |
| |
| .cyber-button.secondary { |
| border-color: #0f0; |
| color: #0f0; |
| } |
| |
| .cyber-button.secondary:hover { |
| background: #0f0; |
| color: #000; |
| } |
| |
| .cyber-button.warning { |
| border-color: #ff0; |
| color: #ff0; |
| } |
| |
| .cyber-button.warning:hover { |
| background: #ff0; |
| color: #000; |
| } |
| |
| .cyber-button.danger { |
| border-color: #f00; |
| color: #f00; |
| } |
| |
| .cyber-button.danger:hover { |
| background: #f00; |
| color: #fff; |
| } |
| |
| |
| .toggle-container { |
| display: flex; |
| align-items: center; |
| justify-content: space-between; |
| margin-bottom: 10px; |
| } |
| |
| .toggle-label { |
| color: #0a0; |
| font-size: 13px; |
| } |
| |
| .toggle-switch { |
| position: relative; |
| width: 50px; |
| height: 24px; |
| } |
| |
| .toggle-switch input { |
| opacity: 0; |
| width: 0; |
| height: 0; |
| } |
| |
| .toggle-slider { |
| position: absolute; |
| cursor: pointer; |
| top: 0; |
| left: 0; |
| right: 0; |
| bottom: 0; |
| background-color: #002200; |
| border: 1px solid #0a0; |
| transition: .4s; |
| border-radius: 34px; |
| } |
| |
| .toggle-slider:before { |
| position: absolute; |
| content: ""; |
| height: 16px; |
| width: 16px; |
| left: 4px; |
| bottom: 3px; |
| background-color: #0a0; |
| transition: .4s; |
| border-radius: 50%; |
| } |
| |
| input:checked + .toggle-slider { |
| background-color: #0f0; |
| } |
| |
| input:checked + .toggle-slider:before { |
| transform: translateX(26px); |
| background-color: #000; |
| } |
| |
| |
| .telemetry-panel { |
| background: rgba(0, 20, 0, 0.6); |
| border: 1px solid #0a0; |
| padding: 15px; |
| border-radius: 3px; |
| } |
| |
| .telemetry-grid { |
| display: grid; |
| grid-template-columns: repeat(2, 1fr); |
| gap: 10px; |
| margin-top: 10px; |
| } |
| |
| .telemetry-card { |
| background: rgba(0, 40, 0, 0.5); |
| border: 1px solid #0a0; |
| padding: 10px; |
| border-radius: 3px; |
| } |
| |
| .telemetry-label { |
| color: #0a0; |
| font-size: 10px; |
| margin-bottom: 5px; |
| text-transform: uppercase; |
| } |
| |
| .telemetry-value { |
| color: #0f0; |
| font-size: 18px; |
| font-weight: bold; |
| font-family: 'Courier New', monospace; |
| text-shadow: 0 0 5px #0f0; |
| } |
| |
| |
| .training-stats { |
| display: grid; |
| grid-template-columns: repeat(3, 1fr); |
| gap: 10px; |
| margin-top: 10px; |
| } |
| |
| .stat-card { |
| text-align: center; |
| padding: 10px; |
| background: rgba(0, 30, 0, 0.4); |
| border: 1px solid #0ff; |
| border-radius: 3px; |
| } |
| |
| .stat-value { |
| font-size: 20px; |
| color: #0ff; |
| font-weight: bold; |
| margin-bottom: 3px; |
| } |
| |
| .stat-label { |
| font-size: 9px; |
| color: #0aa; |
| text-transform: uppercase; |
| } |
| |
| |
| #viz-panel { |
| flex: 1; |
| background: rgba(0, 10, 0, 0.9); |
| border: 3px solid #0f0; |
| position: relative; |
| overflow: hidden; |
| box-shadow: 0 0 30px rgba(0, 255, 0, 0.2); |
| } |
| |
| #renderCanvas { |
| width: 100%; |
| height: 100%; |
| display: block; |
| } |
| |
| |
| .overlay-controls { |
| position: absolute; |
| top: 15px; |
| right: 15px; |
| display: flex; |
| gap: 10px; |
| z-index: 100; |
| } |
| |
| .overlay-button { |
| width: 40px; |
| height: 40px; |
| background: rgba(0, 20, 0, 0.8); |
| border: 2px solid #0ff; |
| color: #0ff; |
| cursor: pointer; |
| display: flex; |
| align-items: center; |
| justify-content: center; |
| font-size: 18px; |
| transition: all 0.3s; |
| } |
| |
| .overlay-button:hover { |
| background: #0ff; |
| color: #000; |
| box-shadow: 0 0 15px #0ff; |
| } |
| |
| |
| .training-info { |
| position: absolute; |
| top: 15px; |
| left: 15px; |
| background: rgba(0, 20, 0, 0.85); |
| border: 2px solid #f0f; |
| padding: 12px 20px; |
| font-size: 14px; |
| color: #f0f; |
| z-index: 100; |
| text-transform: uppercase; |
| letter-spacing: 1px; |
| box-shadow: 0 0 15px rgba(255, 0, 255, 0.3); |
| } |
| |
| .training-progress { |
| position: absolute; |
| bottom: 200px; |
| left: 20px; |
| right: 20px; |
| height: 10px; |
| background: #002200; |
| border: 1px solid #0a0; |
| border-radius: 5px; |
| overflow: hidden; |
| z-index: 100; |
| } |
| |
| .progress-fill { |
| height: 100%; |
| background: linear-gradient(90deg, #0f0, #0ff); |
| width: 0%; |
| transition: width 0.5s; |
| box-shadow: 0 0 10px #0f0; |
| } |
| |
| |
| .graph-panel { |
| position: absolute; |
| bottom: 15px; |
| left: 15px; |
| right: 15px; |
| height: 170px; |
| background: rgba(0, 20, 0, 0.95); |
| border: 2px solid #0f0; |
| padding: 15px; |
| z-index: 100; |
| box-shadow: 0 0 20px rgba(0, 255, 0, 0.3); |
| } |
| |
| .graph-header { |
| display: flex; |
| justify-content: space-between; |
| align-items: center; |
| margin-bottom: 10px; |
| } |
| |
| .graph-title { |
| color: #0ff; |
| font-size: 14px; |
| text-transform: uppercase; |
| letter-spacing: 1px; |
| } |
| |
| .graph-controls { |
| display: flex; |
| gap: 10px; |
| } |
| |
| .graph-canvas-container { |
| width: 100%; |
| height: calc(100% - 30px); |
| background: rgba(0, 10, 0, 0.8); |
| border: 1px solid #0a0; |
| position: relative; |
| } |
| |
| #graphCanvas { |
| width: 100%; |
| height: 100%; |
| display: block; |
| } |
| |
| |
| .status-bar { |
| position: absolute; |
| bottom: 0; |
| left: 0; |
| right: 0; |
| background: rgba(0, 30, 0, 0.95); |
| border-top: 2px solid #0f0; |
| padding: 10px 20px; |
| display: flex; |
| justify-content: space-between; |
| align-items: center; |
| z-index: 101; |
| font-size: 12px; |
| } |
| |
| .status-item { |
| display: flex; |
| align-items: center; |
| gap: 10px; |
| } |
| |
| .status-led { |
| width: 10px; |
| height: 10px; |
| border-radius: 50%; |
| background: #0f0; |
| animation: pulse 2s infinite; |
| box-shadow: 0 0 10px #0f0; |
| } |
| |
| .status-led.active { background: #0f0; animation: pulse 1s infinite; } |
| .status-led.warning { background: #ff0; animation: pulse 0.5s infinite; } |
| .status-led.error { background: #f00; animation: pulse 0.3s infinite; } |
| |
| @keyframes pulse { |
| 0%, 100% { opacity: 1; } |
| 50% { opacity: 0.3; } |
| } |
| |
| |
| .terminal-panel { |
| background: rgba(0, 10, 0, 0.95); |
| border: 2px solid #0f0; |
| padding: 15px; |
| height: 200px; |
| overflow-y: auto; |
| margin-top: 15px; |
| border-radius: 3px; |
| } |
| |
| .terminal-line { |
| margin-bottom: 4px; |
| padding: 2px 0; |
| border-bottom: 1px solid rgba(0, 255, 0, 0.1); |
| font-size: 11px; |
| line-height: 1.4; |
| } |
| |
| .terminal-time { |
| color: #0a0; |
| margin-right: 8px; |
| } |
| |
| .terminal-content.system { color: #0ff; } |
| .terminal-content.info { color: #0f0; } |
| .terminal-content.warning { color: #ff0; } |
| .terminal-content.error { color: #f00; } |
| .terminal-content.success { color: #0f0; font-weight: bold; } |
| .terminal-content.dataset { color: #f0f; } |
| .terminal-content.training { color: #0ff; } |
| |
| |
| .modal-overlay { |
| position: fixed; |
| top: 0; |
| left: 0; |
| right: 0; |
| bottom: 0; |
| background: rgba(0, 0, 0, 0.85); |
| z-index: 1000; |
| display: none; |
| align-items: center; |
| justify-content: center; |
| } |
| |
| .modal-overlay.active { |
| display: flex; |
| animation: fadeIn 0.3s; |
| } |
| |
| @keyframes fadeIn { |
| from { opacity: 0; } |
| to { opacity: 1; } |
| } |
| |
| .modal-container { |
| background: rgba(0, 20, 0, 0.95); |
| border: 3px solid #0f0; |
| width: 600px; |
| max-width: 90%; |
| max-height: 90%; |
| overflow-y: auto; |
| padding: 30px; |
| box-shadow: 0 0 50px rgba(0, 255, 0, 0.3); |
| } |
| |
| .modal-header { |
| text-align: center; |
| margin-bottom: 25px; |
| } |
| |
| .modal-title { |
| color: #0ff; |
| font-size: 22px; |
| margin-bottom: 10px; |
| text-transform: uppercase; |
| letter-spacing: 2px; |
| } |
| |
| .modal-subtitle { |
| color: #0a0; |
| font-size: 13px; |
| } |
| |
| .export-options { |
| margin: 20px 0; |
| } |
| |
| .export-option { |
| margin-bottom: 15px; |
| padding: 10px; |
| background: rgba(0, 30, 0, 0.5); |
| border: 1px solid #0a0; |
| border-radius: 3px; |
| } |
| |
| .export-option label { |
| color: #0a0; |
| font-size: 14px; |
| display: flex; |
| align-items: center; |
| gap: 10px; |
| cursor: pointer; |
| } |
| |
| .export-option input[type="checkbox"] { |
| width: 20px; |
| height: 20px; |
| accent-color: #0f0; |
| cursor: pointer; |
| } |
| |
| .modal-actions { |
| display: flex; |
| gap: 15px; |
| margin-top: 30px; |
| } |
| |
| .progress-container { |
| margin: 20px 0; |
| background: rgba(0, 30, 0, 0.5); |
| border: 1px solid #0a0; |
| padding: 10px; |
| border-radius: 3px; |
| } |
| |
| .progress-bar { |
| height: 10px; |
| background: #002200; |
| border: 1px solid #0a0; |
| border-radius: 5px; |
| overflow: hidden; |
| margin-bottom: 10px; |
| } |
| |
| .progress-fill { |
| height: 100%; |
| background: linear-gradient(90deg, #0f0, #0ff); |
| width: 0%; |
| transition: width 0.3s; |
| box-shadow: 0 0 10px #0f0; |
| } |
| |
| .progress-text { |
| color: #0ff; |
| font-size: 12px; |
| text-align: center; |
| } |
| |
| |
| .training-badges { |
| display: flex; |
| flex-wrap: wrap; |
| gap: 8px; |
| margin-top: 10px; |
| } |
| |
| .training-badge { |
| background: rgba(0, 255, 255, 0.1); |
| border: 1px solid #0ff; |
| color: #0ff; |
| padding: 4px 10px; |
| font-size: 10px; |
| border-radius: 3px; |
| text-transform: uppercase; |
| } |
| |
| |
| @media (max-width: 1200px) { |
| #main-container { |
| flex-direction: column; |
| } |
| |
| #control-panel { |
| width: 100%; |
| height: 400px; |
| } |
| |
| #viz-panel { |
| height: calc(100vh - 430px); |
| } |
| } |
| |
| @media (max-width: 768px) { |
| .telemetry-grid, .training-stats { |
| grid-template-columns: 1fr; |
| } |
| |
| .button-grid { |
| grid-template-columns: 1fr; |
| } |
| |
| .status-bar { |
| flex-direction: column; |
| gap: 10px; |
| padding: 10px; |
| } |
| |
| .graph-panel { |
| height: 150px; |
| } |
| } |
| |
| |
| .loading-screen { |
| position: fixed; |
| top: 0; |
| left: 0; |
| right: 0; |
| bottom: 0; |
| background: #000; |
| display: flex; |
| flex-direction: column; |
| align-items: center; |
| justify-content: center; |
| z-index: 10000; |
| } |
| |
| .loading-logo { |
| font-size: 48px; |
| color: #0f0; |
| text-shadow: 0 0 20px #0f0; |
| margin-bottom: 20px; |
| letter-spacing: 5px; |
| } |
| |
| .loading-bar { |
| width: 300px; |
| height: 4px; |
| background: #002200; |
| border: 1px solid #0a0; |
| border-radius: 2px; |
| overflow: hidden; |
| margin-top: 20px; |
| } |
| |
| .loading-progress { |
| height: 100%; |
| background: #0f0; |
| width: 0%; |
| transition: width 0.3s; |
| } |
| </style> |
| </head> |
| <body> |
| |
| <div class="loading-screen" id="loadingScreen"> |
| <div class="loading-logo">WAVE BENDER BETA</div> |
| <div>IDE BETA v5.0 - Loading Training System</div> |
| <div class="loading-bar"> |
| <div class="loading-progress" id="loadingProgress"></div> |
| </div> |
| </div> |
| |
| |
| <div class="crt-overlay"> |
| <div class="crt-scanlines"></div> |
| <div class="crt-glitch"></div> |
| </div> |
| |
| |
| <div id="main-container"> |
| |
| <div id="control-panel"> |
| |
| <div class="title-section"> |
| <div class="main-title">WAVE BENDER IDE</div> |
| <div class="version-badge">v5.0 - TRAINING DATASET GENERATOR</div> |
| <div class="subtitle"> |
| Synthetic Telemetry & SLAM Training System<br> |
| Generate ML-ready datasets for drone autonomy |
| </div> |
| </div> |
| |
| |
| <div class="control-group"> |
| <div class="group-title">GENERATION PARAMETERS</div> |
| |
| <div class="slider-container"> |
| <div class="slider-label"> |
| <span>Dataset Complexity</span> |
| <span class="slider-value" id="complexityValue">7</span> |
| </div> |
| <input type="range" id="complexitySlider" min="1" max="10" value="7" step="1"> |
| </div> |
| |
| <div class="slider-container"> |
| <div class="slider-label"> |
| <span>Signal Noise Level</span> |
| <span class="slider-value" id="noiseValue">2.5</span> |
| </div> |
| <input type="range" id="noiseSlider" min="0" max="5" value="2.5" step="0.1"> |
| </div> |
| |
| <div class="slider-container"> |
| <div class="slider-label"> |
| <span>Oscillation Frequency</span> |
| <span class="slider-value" id="frequencyValue">1.8</span> |
| </div> |
| <input type="range" id="frequencySlider" min="0.5" max="3" value="1.8" step="0.1"> |
| </div> |
| |
| <div class="slider-container"> |
| <div class="slider-label"> |
| <span>Sample Rate (Hz)</span> |
| <span class="slider-value" id="sampleRateValue">100</span> |
| </div> |
| <input type="range" id="sampleRateSlider" min="10" max="200" value="100" step="10"> |
| </div> |
| </div> |
| |
| |
| <div class="control-group"> |
| <div class="group-title">SLAM TRAINING CONFIG</div> |
| |
| <div class="toggle-container"> |
| <span class="toggle-label">Center Region Obstacles</span> |
| <label class="toggle-switch"> |
| <input type="checkbox" id="centerObstaclesToggle" checked> |
| <span class="toggle-slider"></span> |
| </label> |
| </div> |
| |
| <div class="toggle-container"> |
| <span class="toggle-label">Dynamic Obstacle Movement</span> |
| <label class="toggle-switch"> |
| <input type="checkbox" id="dynamicObstaclesToggle" checked> |
| <span class="toggle-slider"></span> |
| </label> |
| </div> |
| |
| <div class="toggle-container"> |
| <span class="toggle-label">Collision Avoidance Training</span> |
| <label class="toggle-switch"> |
| <input type="checkbox" id="avoidanceTrainingToggle" checked> |
| <span class="toggle-slider"></span> |
| </label> |
| </div> |
| |
| <div class="button-grid"> |
| <button id="addObstacleBtn" class="cyber-button secondary">ADD OBSTACLE</button> |
| <button id="resetObstaclesBtn" class="cyber-button warning">RESET OBSTACLES</button> |
| <button id="autoPilotBtn" class="cyber-button primary">AUTO PILOT</button> |
| <button id="trainingModeBtn" class="cyber-button" style="border-color:#f0f;color:#f0f;">TRAINING MODE</button> |
| </div> |
| </div> |
| |
| |
| <div class="telemetry-panel"> |
| <div class="group-title">REAL-TIME TELEMETRY</div> |
| <div class="telemetry-grid"> |
| <div class="telemetry-card"> |
| <div class="telemetry-label">TIMESTAMP</div> |
| <div class="telemetry-value" id="telemetryTime">00:00:00</div> |
| </div> |
| <div class="telemetry-card"> |
| <div class="telemetry-label">ALTITUDE</div> |
| <div class="telemetry-value" id="telemetryAlt">10.0m</div> |
| </div> |
| <div class="telemetry-card"> |
| <div class="telemetry-label">VELOCITY</div> |
| <div class="telemetry-value" id="telemetryVel">0.0m/s</div> |
| </div> |
| <div class="telemetry-card"> |
| <div class="telemetry-label">BATTERY</div> |
| <div class="telemetry-value" id="telemetryBat">100%</div> |
| </div> |
| </div> |
| |
| <div class="training-stats"> |
| <div class="stat-card"> |
| <div class="stat-value" id="statObstacles">15</div> |
| <div class="stat-label">OBSTACLES</div> |
| </div> |
| <div class="stat-card"> |
| <div class="stat-value" id="statAvoidances">0</div> |
| <div class="stat-label">AVOIDANCES</div> |
| </div> |
| <div class="stat-card"> |
| <div class="stat-value" id="statPoints">0</div> |
| <div class="stat-label">DATA POINTS</div> |
| </div> |
| </div> |
| </div> |
| |
| |
| <div class="button-grid"> |
| <button id="startBtn" class="cyber-button primary">START TRAINING</button> |
| <button id="stopBtn" class="cyber-button danger" disabled>STOP TRAINING</button> |
| <button id="exportBtn" class="cyber-button secondary">EXPORT DATASET</button> |
| <button id="resetBtn" class="cyber-button warning">RESET SYSTEM</button> |
| </div> |
| |
| |
| <div class="training-badges"> |
| <div class="training-badge">SLAM TRAINING</div> |
| <div class="training-badge">OBSTACLE AVOIDANCE</div> |
| <div class="training-badge">REAL-TIME TELEMETRY</div> |
| <div class="training-badge">ML DATASET GENERATION</div> |
| </div> |
| |
| |
| <div class="terminal-panel" id="terminal"> |
| <div class="terminal-line"> |
| <span class="terminal-time">[00:00:00]</span> |
| <span class="terminal-content system">WAVE BENDER IDE v5.0 INITIALIZED</span> |
| </div> |
| <div class="terminal-line"> |
| <span class="terminal-time">[00:00:00]</span> |
| <span class="terminal-content system">Training Dataset Generator Ready</span> |
| </div> |
| <div class="terminal-line"> |
| <span class="terminal-time">[00:00:00]</span> |
| <span class="terminal-content training">SLAM Training Mode: ACTIVE</span> |
| </div> |
| <div class="terminal-line"> |
| <span class="terminal-time">[00:00:00]</span> |
| <span class="terminal-content dataset">Ready to generate ML training datasets</span> |
| </div> |
| </div> |
| </div> |
| |
| |
| <div id="viz-panel"> |
| <canvas id="renderCanvas"></canvas> |
| |
| |
| <div class="training-info"> |
| CENTER REGION OBSTACLE TRAINING - SLAM DATASET GENERATION |
| </div> |
| |
| |
| <div class="overlay-controls"> |
| <button class="overlay-button" id="fullscreenBtn" title="Fullscreen">⛶</button> |
| <button class="overlay-button" id="cameraResetBtn" title="Reset Camera">↺</button> |
| <button class="overlay-button" id="gridToggleBtn" title="Toggle Grid">#</button> |
| </div> |
| |
| |
| <div class="training-progress"> |
| <div class="progress-fill" id="trainingProgress"></div> |
| </div> |
| |
| |
| <div class="graph-panel"> |
| <div class="graph-header"> |
| <div class="graph-title">REAL-TIME TELEMETRY SIGNALS</div> |
| <div class="graph-controls"> |
| <button class="cyber-button secondary" style="padding:5px 10px;font-size:11px;" id="clearGraphBtn">CLEAR</button> |
| <button class="cyber-button secondary" style="padding:5px 10px;font-size:11px;" id="pauseGraphBtn">PAUSE</button> |
| </div> |
| </div> |
| <div class="graph-canvas-container"> |
| <canvas id="graphCanvas"></canvas> |
| </div> |
| </div> |
| |
| |
| <div class="status-bar"> |
| <div class="status-item"> |
| <div class="status-led inactive" id="statusGen"></div> |
| <span>TRAINING: PAUSED</span> |
| </div> |
| <div class="status-item"> |
| <div class="status-led active" id="status3D"></div> |
| <span>3D VISUALIZATION: ACTIVE</span> |
| </div> |
| <div class="status-item"> |
| <div class="status-led active" id="statusSLAM"></div> |
| <span>SLAM: TRAINING MODE</span> |
| </div> |
| <div class="status-item"> |
| <div class="status-led active" id="statusWASM"></div> |
| <span>COMPUTE: ONLINE</span> |
| </div> |
| <div class="status-item"> |
| <span id="statusFPS">FPS: 60</span> |
| </div> |
| <div class="status-item"> |
| <span>webXOS | HF DATASET READY</span> |
| </div> |
| </div> |
| </div> |
| </div> |
| |
| |
| <div class="modal-overlay" id="exportModal"> |
| <div class="modal-container"> |
| <div class="modal-header"> |
| <div class="modal-title">EXPORT TRAINING DATASET</div> |
| <div class="modal-subtitle">Generate complete ML-ready dataset package for Hugging Face</div> |
| </div> |
| |
| <div class="export-options"> |
| <div class="export-option"> |
| <label> |
| <input type="checkbox" id="exportTelemetry" checked> |
| <span>Complete Telemetry Dataset (JSONL/CSV)</span> |
| </label> |
| </div> |
| <div class="export-option"> |
| <label> |
| <input type="checkbox" id="exportSLAM" checked> |
| <span>SLAM Training Data (Obstacle Detection & Avoidance)</span> |
| </label> |
| </div> |
| <div class="export-option"> |
| <label> |
| <input type="checkbox" id="exportGraphs" checked> |
| <span>Signal Graphs & Visualizations</span> |
| </label> |
| </div> |
| <div class="export-option"> |
| <label> |
| <input type="checkbox" id="exportMetadata" checked> |
| <span>Dataset Metadata & Documentation</span> |
| </label> |
| </div> |
| <div class="export-option"> |
| <label> |
| <input type="checkbox" id="exportTrainingStats" checked> |
| <span>Training Statistics & Epoch Data</span> |
| </label> |
| </div> |
| </div> |
| |
| <div class="progress-container"> |
| <div class="progress-bar" id="exportProgressBar"> |
| <div class="progress-fill" id="exportProgressFill"></div> |
| </div> |
| <div class="progress-text" id="exportStatus">Ready to export...</div> |
| </div> |
| |
| <div class="modal-actions"> |
| <button id="exportCancel" class="cyber-button warning" style="flex:1;">CANCEL</button> |
| <button id="exportConfirm" class="cyber-button primary" style="flex:2;">GENERATE COMPLETE DATASET .ZIP</button> |
| </div> |
| </div> |
| </div> |
| |
| |
| <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script> |
| <script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.7.1/jszip.min.js"></script> |
| <script src="https://cdnjs.cloudflare.com/ajax/libs/FileSaver.js/2.0.5/FileSaver.min.js"></script> |
| |
| <script> |
| |
| |
| |
| |
| |
| const AppState = { |
| |
| isTraining: false, |
| isAutoPilot: false, |
| isPaused: false, |
| trainingStartTime: 0, |
| currentTime: 0, |
| frameCount: 0, |
| fps: 60, |
| lastFpsUpdate: 0, |
| |
| |
| params: { |
| complexity: 7, |
| noise: 2.5, |
| frequency: 1.8, |
| sampleRate: 100 |
| }, |
| |
| |
| dataset: { |
| telemetry: [], |
| slamData: [], |
| trainingEpochs: [], |
| statistics: { |
| totalPoints: 0, |
| obstaclesDetected: 0, |
| avoidanceManeuvers: 0, |
| trainingProgress: 0 |
| } |
| }, |
| |
| |
| graphs: { |
| acceleration: [], |
| altitude: [], |
| battery: [], |
| velocity: [], |
| maxPoints: 300, |
| isPaused: false |
| }, |
| |
| |
| slam: { |
| obstacles: [], |
| centerRegion: true, |
| dynamicMovement: true, |
| avoidanceTraining: true, |
| currentEpoch: 1 |
| } |
| }; |
| |
| |
| const Scene3D = { |
| scene: null, |
| camera: null, |
| renderer: null, |
| drone: null, |
| obstacles: [], |
| centerGrid: null |
| }; |
| |
| |
| let graphCtx = null; |
| let graphWidth = 0; |
| let graphHeight = 0; |
| |
| |
| let animationFrameId = null; |
| let trainingInterval = null; |
| let autoPilotInterval = null; |
| let obstacleInterval = null; |
| |
| |
| |
| |
| |
| async function init() { |
| try { |
| |
| simulateLoading(); |
| |
| |
| await initThreeJS(); |
| initGraphCanvas(); |
| initTrainingSystem(); |
| initEventListeners(); |
| |
| |
| setTimeout(() => { |
| document.getElementById('loadingScreen').style.opacity = '0'; |
| setTimeout(() => { |
| document.getElementById('loadingScreen').style.display = 'none'; |
| }, 300); |
| |
| logMessage("System initialization complete", "system"); |
| logMessage("Training dataset generator ready", "training"); |
| logMessage("Start training to generate ML datasets", "dataset"); |
| |
| |
| animate(); |
| }, 1500); |
| |
| } catch (error) { |
| console.error("Initialization error:", error); |
| logMessage(`Initialization failed: ${error.message}`, "error"); |
| } |
| } |
| |
| function simulateLoading() { |
| const progress = document.getElementById('loadingProgress'); |
| let width = 0; |
| |
| const steps = [ |
| { msg: "Loading 3D Visualization Engine", duration: 300 }, |
| { msg: "Initializing WebAssembly Compute Core", duration: 400 }, |
| { msg: "Setting Up SLAM Training System", duration: 350 }, |
| { msg: "Preparing Dataset Generation", duration: 250 }, |
| { msg: "Finalizing Training Interface", duration: 200 } |
| ]; |
| |
| steps.forEach((step, index) => { |
| setTimeout(() => { |
| width = ((index + 1) / steps.length) * 100; |
| progress.style.width = `${width}%`; |
| document.querySelector('.loading-screen div:nth-child(2)').textContent = step.msg; |
| }, step.duration); |
| }); |
| } |
| |
| |
| |
| |
| |
| async function initThreeJS() { |
| try { |
| |
| Scene3D.scene = new THREE.Scene(); |
| Scene3D.scene.background = new THREE.Color(0x000000); |
| Scene3D.scene.fog = new THREE.Fog(0x000000, 50, 300); |
| |
| |
| const canvas = document.getElementById('renderCanvas'); |
| Scene3D.camera = new THREE.PerspectiveCamera( |
| 60, canvas.clientWidth / canvas.clientHeight, 0.1, 1000 |
| ); |
| Scene3D.camera.position.set(40, 30, 50); |
| Scene3D.camera.lookAt(0, 0, 0); |
| |
| |
| Scene3D.renderer = new THREE.WebGLRenderer({ |
| canvas: canvas, |
| antialias: true, |
| alpha: true |
| }); |
| Scene3D.renderer.setSize(canvas.clientWidth, canvas.clientHeight); |
| Scene3D.renderer.shadowMap.enabled = true; |
| Scene3D.renderer.shadowMap.type = THREE.PCFSoftShadowMap; |
| |
| |
| const ambientLight = new THREE.AmbientLight(0x00ff00, 0.1); |
| Scene3D.scene.add(ambientLight); |
| |
| const directionalLight = new THREE.DirectionalLight(0x00ff00, 0.6); |
| directionalLight.position.set(20, 40, 30); |
| directionalLight.castShadow = true; |
| Scene3D.scene.add(directionalLight); |
| |
| |
| const mainGrid = new THREE.GridHelper(100, 20, 0x004400, 0x002200); |
| Scene3D.scene.add(mainGrid); |
| |
| Scene3D.centerGrid = new THREE.GridHelper(40, 10, 0xff0000, 0x660000); |
| Scene3D.centerGrid.position.y = 0.1; |
| Scene3D.scene.add(Scene3D.centerGrid); |
| |
| |
| const axes = new THREE.AxesHelper(25); |
| Scene3D.scene.add(axes); |
| |
| |
| createDrone(); |
| |
| |
| createTrainingObstacles(); |
| |
| logMessage("3D visualization engine initialized", "success"); |
| |
| } catch (error) { |
| throw new Error(`3D initialization failed: ${error.message}`); |
| } |
| } |
| |
| function createDrone() { |
| const droneGroup = new THREE.Group(); |
| |
| |
| const bodyGeometry = new THREE.BoxGeometry(3, 0.5, 3); |
| const bodyMaterial = new THREE.MeshPhongMaterial({ |
| color: 0x00ff00, |
| emissive: 0x004400, |
| shininess: 100 |
| }); |
| const body = new THREE.Mesh(bodyGeometry, bodyMaterial); |
| body.castShadow = true; |
| droneGroup.add(body); |
| |
| |
| const armGeometry = new THREE.BoxGeometry(6, 0.3, 0.3); |
| const armMaterial = new THREE.MeshPhongMaterial({ color: 0x008800 }); |
| |
| for (let i = 0; i < 4; i++) { |
| const arm = new THREE.Mesh(armGeometry, armMaterial); |
| arm.rotation.y = (Math.PI / 2) * i; |
| arm.position.y = 0.25; |
| arm.castShadow = true; |
| droneGroup.add(arm); |
| |
| |
| const motorGeometry = new THREE.CylinderGeometry(0.8, 0.8, 0.5, 8); |
| const motorMaterial = new THREE.MeshPhongMaterial({ color: 0x00aa00 }); |
| const motor = new THREE.Mesh(motorGeometry, motorMaterial); |
| motor.position.set(armGeometry.parameters.width / 2, 0.5, 0); |
| motor.rotation.x = Math.PI / 2; |
| arm.add(motor); |
| |
| |
| const propGeometry = new THREE.BoxGeometry(3, 0.1, 0.3); |
| const propMaterial = new THREE.MeshPhongMaterial({ color: 0x00ff00 }); |
| const propeller = new THREE.Mesh(propGeometry, propMaterial); |
| propeller.position.y = 0.8; |
| motor.add(propeller); |
| |
| if (!droneGroup.propellers) droneGroup.propellers = []; |
| droneGroup.propellers.push(propeller); |
| } |
| |
| |
| const ledGeometry = new THREE.SphereGeometry(0.2, 8, 8); |
| const ledPositions = [ |
| { x: 1.2, y: 0.5, z: 1.2, color: 0xff0000 }, |
| { x: -1.2, y: 0.5, z: 1.2, color: 0x00ff00 }, |
| { x: -1.2, y: 0.5, z: -1.2, color: 0x0000ff }, |
| { x: 1.2, y: 0.5, z: -1.2, color: 0xffff00 } |
| ]; |
| |
| ledPositions.forEach(pos => { |
| const ledMaterial = new THREE.MeshBasicMaterial({ |
| color: pos.color, |
| emissive: pos.color, |
| emissiveIntensity: 0.5 |
| }); |
| const led = new THREE.Mesh(ledGeometry, ledMaterial); |
| led.position.set(pos.x, pos.y, pos.z); |
| droneGroup.add(led); |
| }); |
| |
| droneGroup.position.set(0, 10, 0); |
| Scene3D.drone = droneGroup; |
| Scene3D.scene.add(droneGroup); |
| } |
| |
| function createTrainingObstacles() { |
| |
| Scene3D.obstacles.forEach(obstacle => Scene3D.scene.remove(obstacle)); |
| Scene3D.obstacles = []; |
| AppState.slam.obstacles = []; |
| |
| |
| for (let i = 0; i < 15; i++) { |
| createObstacle(i); |
| } |
| |
| updateObstacleCount(); |
| startObstacleAnimation(); |
| } |
| |
| function createObstacle(id) { |
| const types = ['sphere', 'cube', 'cylinder', 'cone']; |
| const colors = [0xff0000, 0xff8800, 0xffff00, 0xff00ff]; |
| |
| const type = types[Math.floor(Math.random() * types.length)]; |
| const color = colors[Math.floor(Math.random() * colors.length)]; |
| const trainingWeight = 1 + Math.random() * 2; |
| |
| let geometry; |
| switch(type) { |
| case 'sphere': geometry = new THREE.SphereGeometry(2 + Math.random() * 3, 8, 8); break; |
| case 'cube': geometry = new THREE.BoxGeometry(3 + Math.random() * 4, 3 + Math.random() * 4, 3 + Math.random() * 4); break; |
| case 'cylinder': geometry = new THREE.CylinderGeometry(1.5, 1.5, 4 + Math.random() * 4, 8); break; |
| case 'cone': geometry = new THREE.ConeGeometry(2, 4 + Math.random() * 4, 8); break; |
| } |
| |
| const material = new THREE.MeshPhongMaterial({ |
| color: color, |
| emissive: color, |
| emissiveIntensity: 0.3, |
| transparent: true, |
| opacity: 0.8 |
| }); |
| |
| const obstacle = new THREE.Mesh(geometry, material); |
| obstacle.castShadow = true; |
| |
| |
| const x = (Math.random() - 0.5) * 30; |
| const y = 5 + Math.random() * 20; |
| const z = (Math.random() - 0.5) * 30; |
| obstacle.position.set(x, y, z); |
| |
| |
| obstacle.userData = { |
| id: id, |
| type: type, |
| trainingWeight: trainingWeight, |
| detected: false, |
| avoidanceCount: 0, |
| floatSpeed: 0.2 + Math.random() * 0.8, |
| floatHeight: y, |
| floatOffset: Math.random() * Math.PI * 2 |
| }; |
| |
| Scene3D.scene.add(obstacle); |
| Scene3D.obstacles.push(obstacle); |
| AppState.slam.obstacles.push({ |
| id: id, |
| position: { x, y, z }, |
| type: type, |
| trainingWeight: trainingWeight |
| }); |
| |
| return obstacle; |
| } |
| |
| function startObstacleAnimation() { |
| if (obstacleInterval) clearInterval(obstacleInterval); |
| |
| obstacleInterval = setInterval(() => { |
| if (!AppState.slam.dynamicMovement) return; |
| |
| const time = Date.now() * 0.001; |
| Scene3D.obstacles.forEach(obstacle => { |
| if (obstacle.userData) { |
| obstacle.position.y = obstacle.userData.floatHeight + |
| Math.sin(time * obstacle.userData.floatSpeed + |
| obstacle.userData.floatOffset) * 3; |
| obstacle.rotation.y += 0.01; |
| obstacle.rotation.x += 0.005; |
| } |
| }); |
| }, 50); |
| } |
| |
| |
| |
| |
| |
| function initGraphCanvas() { |
| const canvas = document.getElementById('graphCanvas'); |
| graphCtx = canvas.getContext('2d'); |
| graphWidth = canvas.width = canvas.clientWidth; |
| graphHeight = canvas.height = canvas.clientHeight; |
| |
| |
| AppState.graphs.acceleration = []; |
| AppState.graphs.altitude = []; |
| AppState.graphs.battery = []; |
| AppState.graphs.velocity = []; |
| |
| drawEmptyGraph(); |
| } |
| |
| function drawEmptyGraph() { |
| if (!graphCtx) return; |
| |
| const ctx = graphCtx; |
| const width = graphWidth; |
| const height = graphHeight; |
| |
| |
| ctx.fillStyle = '#001100'; |
| ctx.fillRect(0, 0, width, height); |
| |
| |
| ctx.strokeStyle = '#003300'; |
| ctx.lineWidth = 1; |
| |
| |
| for (let x = 0; x < width; x += 40) { |
| ctx.beginPath(); |
| ctx.moveTo(x, 0); |
| ctx.lineTo(x, height); |
| ctx.stroke(); |
| } |
| |
| |
| for (let y = 0; y < height; y += 30) { |
| ctx.beginPath(); |
| ctx.moveTo(0, y); |
| ctx.lineTo(width, y); |
| ctx.stroke(); |
| } |
| |
| |
| ctx.fillStyle = '#00ff00'; |
| ctx.font = '10px Courier New'; |
| ctx.fillText('Time →', width - 50, height - 5); |
| ctx.fillText('↑ Signal Value', 5, 15); |
| } |
| |
| function updateGraph() { |
| if (!graphCtx || AppState.graphs.isPaused) return; |
| |
| const ctx = graphCtx; |
| const width = graphWidth; |
| const height = graphHeight; |
| |
| |
| ctx.fillStyle = '#001100'; |
| ctx.fillRect(0, 0, width, height); |
| |
| |
| ctx.strokeStyle = '#003300'; |
| ctx.lineWidth = 1; |
| |
| |
| for (let x = 0; x < width; x += 40) { |
| ctx.beginPath(); |
| ctx.moveTo(x, 0); |
| ctx.lineTo(x, height); |
| ctx.stroke(); |
| } |
| |
| |
| for (let y = 0; y < height; y += 30) { |
| ctx.beginPath(); |
| ctx.moveTo(0, y); |
| ctx.lineTo(width, y); |
| ctx.stroke(); |
| } |
| |
| |
| if (AppState.graphs.acceleration.length > 1) { |
| drawSignal(ctx, AppState.graphs.acceleration, 0xff8c00, -10, 10); |
| drawSignal(ctx, AppState.graphs.altitude, 0x00ff00, 0, 30); |
| drawSignal(ctx, AppState.graphs.battery, 0x0088ff, 0, 100); |
| drawSignal(ctx, AppState.graphs.velocity, 0x00ffff, 0, 20); |
| } |
| |
| |
| drawTrainingInfo(ctx); |
| } |
| |
| function drawSignal(ctx, data, color, minVal, maxVal) { |
| if (data.length < 2) return; |
| |
| const width = graphWidth; |
| const height = graphHeight; |
| const range = maxVal - minVal; |
| |
| |
| const r = (color >> 16) & 255; |
| const g = (color >> 8) & 255; |
| const b = color & 255; |
| |
| |
| ctx.strokeStyle = `rgba(${r}, ${g}, ${b}, 0.8)`; |
| ctx.lineWidth = 2; |
| ctx.beginPath(); |
| |
| const xStep = width / (data.length - 1); |
| |
| for (let i = 0; i < data.length; i++) { |
| const x = i * xStep; |
| const normalized = (data[i] - minVal) / range; |
| const clamped = Math.max(0, Math.min(1, normalized)); |
| const y = height - clamped * height * 0.8 - 10; |
| |
| if (i === 0) { |
| ctx.moveTo(x, y); |
| } else { |
| ctx.lineTo(x, y); |
| } |
| } |
| |
| ctx.stroke(); |
| } |
| |
| function drawTrainingInfo(ctx) { |
| const width = graphWidth; |
| const height = graphHeight; |
| const progress = AppState.dataset.statistics.trainingProgress; |
| |
| |
| ctx.fillStyle = '#003300'; |
| ctx.fillRect(0, height - 5, width, 5); |
| |
| ctx.fillStyle = '#0f0'; |
| ctx.fillRect(0, height - 5, width * progress, 5); |
| |
| |
| ctx.fillStyle = '#0ff'; |
| ctx.font = '10px Courier New'; |
| ctx.fillText( |
| `Training: ${Math.round(progress * 100)}% | ` + |
| `Epoch: ${AppState.slam.currentEpoch} | ` + |
| `Avoidances: ${AppState.dataset.statistics.avoidanceManeuvers}`, |
| 10, height - 10 |
| ); |
| } |
| |
| function addGraphData(accel, alt, bat, vel) { |
| if (AppState.graphs.isPaused) return; |
| |
| AppState.graphs.acceleration.push(accel); |
| AppState.graphs.altitude.push(alt); |
| AppState.graphs.battery.push(bat); |
| AppState.graphs.velocity.push(vel); |
| |
| |
| if (AppState.graphs.acceleration.length > AppState.graphs.maxPoints) { |
| AppState.graphs.acceleration.shift(); |
| AppState.graphs.altitude.shift(); |
| AppState.graphs.battery.shift(); |
| AppState.graphs.velocity.shift(); |
| } |
| } |
| |
| |
| |
| |
| |
| function initTrainingSystem() { |
| logMessage("Training system initialized", "training"); |
| document.getElementById('statusSLAM').className = "status-led active"; |
| document.getElementById('statusWASM').className = "status-led active"; |
| } |
| |
| function startTraining() { |
| if (AppState.isTraining) return; |
| |
| AppState.isTraining = true; |
| AppState.trainingStartTime = Date.now(); |
| AppState.currentTime = 0; |
| |
| |
| AppState.dataset = { |
| telemetry: [], |
| slamData: [], |
| trainingEpochs: [], |
| statistics: { |
| totalPoints: 0, |
| obstaclesDetected: 0, |
| avoidanceManeuvers: 0, |
| trainingProgress: 0 |
| } |
| }; |
| |
| |
| document.getElementById('startBtn').disabled = true; |
| document.getElementById('stopBtn').disabled = false; |
| document.getElementById('statusGen').className = "status-led active"; |
| |
| |
| AppState.graphs.acceleration = []; |
| AppState.graphs.altitude = []; |
| AppState.graphs.battery = []; |
| AppState.graphs.velocity = []; |
| |
| |
| trainingInterval = setInterval(generateTrainingData, 1000 / AppState.params.sampleRate); |
| |
| logMessage("Training started", "success"); |
| logMessage(`Sample rate: ${AppState.params.sampleRate}Hz`, "info"); |
| logMessage("Generating ML training dataset...", "dataset"); |
| } |
| |
| function stopTraining() { |
| if (!AppState.isTraining) return; |
| |
| AppState.isTraining = false; |
| clearInterval(trainingInterval); |
| |
| |
| document.getElementById('startBtn').disabled = false; |
| document.getElementById('stopBtn').disabled = true; |
| document.getElementById('statusGen').className = "status-led inactive"; |
| |
| const duration = (Date.now() - AppState.trainingStartTime) / 1000; |
| const points = AppState.dataset.statistics.totalPoints; |
| const avoidances = AppState.dataset.statistics.avoidanceManeuvers; |
| |
| logMessage(`Training stopped after ${duration.toFixed(1)}s`, "warning"); |
| logMessage(`Dataset: ${points.toLocaleString()} data points`, "dataset"); |
| logMessage(`Avoidance maneuvers: ${avoidances}`, "training"); |
| logMessage(`Training progress: ${Math.round(AppState.dataset.statistics.trainingProgress * 100)}%`, "training"); |
| |
| if (points > 0) { |
| logMessage("Ready to export training dataset", "success"); |
| } |
| } |
| |
| function generateTrainingData() { |
| const params = AppState.params; |
| const timestamp = AppState.currentTime; |
| |
| |
| const baseFreq = params.frequency; |
| const noiseLevel = params.noise; |
| |
| |
| let accelX = Math.sin(timestamp * baseFreq * 2) * 3; |
| accelX += Math.sin(timestamp * baseFreq * 5) * 1.5; |
| accelX += (Math.random() - 0.5) * noiseLevel * 2; |
| |
| if (Math.random() < 0.02 * params.complexity) { |
| accelX += (Math.random() * 4 - 2); |
| } |
| |
| let accelY = Math.sin(timestamp * baseFreq * 1.8) * 2.5; |
| accelY += Math.cos(timestamp * baseFreq * 3) * 1.2; |
| accelY += (Math.random() - 0.5) * noiseLevel * 1.8; |
| |
| let accelZ = Math.sin(timestamp * baseFreq * 2.2) * 2.8; |
| accelZ += Math.sin(timestamp * baseFreq * 4.5) * 1.3; |
| accelZ += (Math.random() - 0.5) * noiseLevel * 1.5; |
| |
| |
| let gyroX = Math.sin(timestamp * baseFreq * 3) * 2; |
| gyroX += (Math.random() - 0.5) * noiseLevel * 3; |
| |
| let gyroY = Math.cos(timestamp * baseFreq * 2.7) * 2.2; |
| gyroY += (Math.random() - 0.5) * noiseLevel * 2.5; |
| |
| let gyroZ = Math.sin(timestamp * baseFreq * 3.3) * 1.8; |
| gyroZ += (Math.random() - 0.5) * noiseLevel * 2.2; |
| |
| |
| let altitude = 10 + Math.sin(timestamp * baseFreq * 0.5) * 5; |
| altitude += Math.sin(timestamp * baseFreq * 0.2) * 8; |
| altitude += (Math.random() - 0.5) * noiseLevel * 0.5; |
| |
| |
| let velocity = Math.abs(Math.sin(timestamp * baseFreq * 0.8)) * 15; |
| velocity += (Math.random() - 0.5) * noiseLevel; |
| |
| |
| let battery = 100 - (timestamp * 0.02); |
| battery += Math.sin(timestamp * baseFreq * 0.3) * 2; |
| battery += (Math.random() - 0.5) * noiseLevel * 0.3; |
| battery = Math.max(0, Math.min(100, battery)); |
| |
| |
| let temperature = 25 + Math.sin(timestamp * baseFreq * 0.4) * 10; |
| temperature += (Math.random() - 0.5) * noiseLevel * 2; |
| |
| |
| let gpsLat = 40.7128 + Math.sin(timestamp * 0.1) * 0.001; |
| let gpsLon = -74.0060 + Math.cos(timestamp * 0.1) * 0.001; |
| |
| |
| let signalStrength = 80 + Math.sin(timestamp * baseFreq * 0.6) * 15; |
| signalStrength += (Math.random() - 0.5) * noiseLevel * 5; |
| signalStrength = Math.max(0, Math.min(100, signalStrength)); |
| |
| |
| const telemetryPoint = { |
| timestamp: timestamp, |
| acceleration: { x: accelX, y: accelY, z: accelZ }, |
| gyroscope: { x: gyroX, y: gyroY, z: gyroZ }, |
| altitude: altitude, |
| velocity: velocity, |
| battery: battery, |
| temperature: temperature, |
| gps: { lat: gpsLat, lon: gpsLon }, |
| signalStrength: signalStrength |
| }; |
| |
| AppState.dataset.telemetry.push(telemetryPoint); |
| AppState.dataset.statistics.totalPoints++; |
| |
| |
| addGraphData(accelX, altitude, battery, velocity); |
| |
| |
| updateDronePosition(altitude, accelX, accelY, accelZ); |
| |
| |
| if (AppState.slam.avoidanceTraining) { |
| processSLAMTraining(timestamp); |
| } |
| |
| |
| updateTelemetryDisplay(timestamp, altitude, velocity, battery, accelX); |
| updateStatistics(); |
| updateTrainingProgress(); |
| |
| |
| updateGraph(); |
| |
| |
| AppState.currentTime += 1 / AppState.params.sampleRate; |
| } |
| |
| function processSLAMTraining(timestamp) { |
| if (!Scene3D.drone) return; |
| |
| const dronePos = Scene3D.drone.position; |
| let nearestDistance = Infinity; |
| let nearestObstacle = null; |
| |
| |
| Scene3D.obstacles.forEach(obstacle => { |
| const distance = dronePos.distanceTo(obstacle.position); |
| |
| if (distance < nearestDistance) { |
| nearestDistance = distance; |
| nearestObstacle = obstacle; |
| } |
| |
| |
| if (distance < 8 && !obstacle.userData.detected) { |
| obstacle.userData.detected = true; |
| AppState.dataset.statistics.obstaclesDetected++; |
| |
| |
| const detectionData = { |
| type: 'detection', |
| timestamp: timestamp, |
| obstacleId: obstacle.userData.id, |
| distance: distance, |
| position: { |
| x: obstacle.position.x, |
| y: obstacle.position.y, |
| z: obstacle.position.z |
| }, |
| trainingWeight: obstacle.userData.trainingWeight |
| }; |
| |
| AppState.dataset.slamData.push(detectionData); |
| |
| logMessage(`Obstacle #${obstacle.userData.id} detected at ${distance.toFixed(1)}m`, "training"); |
| } |
| |
| |
| if (distance < 5) { |
| obstacle.userData.avoidanceCount++; |
| |
| |
| const avoidDirection = new THREE.Vector3() |
| .subVectors(dronePos, obstacle.position) |
| .normalize(); |
| |
| const avoidanceForce = 0.2 * (8 - distance); |
| Scene3D.drone.position.add(avoidDirection.multiplyScalar(avoidanceForce)); |
| Scene3D.drone.position.y += avoidanceForce * 0.15; |
| |
| |
| flashDrone(); |
| |
| |
| const avoidanceData = { |
| type: 'avoidance', |
| timestamp: timestamp, |
| obstacleId: obstacle.userData.id, |
| distance: distance, |
| maneuver: 'evasive', |
| success: true, |
| avoidanceCount: obstacle.userData.avoidanceCount |
| }; |
| |
| AppState.dataset.slamData.push(avoidanceData); |
| |
| AppState.dataset.statistics.avoidanceManeuvers++; |
| document.getElementById('statAvoidances').textContent = |
| AppState.dataset.statistics.avoidanceManeuvers; |
| |
| if (obstacle.userData.avoidanceCount === 1) { |
| logMessage(`Avoidance maneuver for obstacle #${obstacle.userData.id}`, "warning"); |
| } |
| } |
| }); |
| |
| |
| const totalObstacles = Scene3D.obstacles.length; |
| const detectedObstacles = Scene3D.obstacles.filter(o => o.userData.detected).length; |
| const detectionProgress = detectedObstacles / totalObstacles; |
| const avoidanceProgress = Math.min(1, AppState.dataset.statistics.avoidanceManeuvers / (totalObstacles * 2)); |
| |
| AppState.dataset.statistics.trainingProgress = (detectionProgress * 0.6 + avoidanceProgress * 0.4); |
| |
| |
| if (detectedObstacles >= totalObstacles * 0.8 && |
| AppState.dataset.statistics.avoidanceManeuvers >= totalObstacles) { |
| completeTrainingEpoch(); |
| } |
| } |
| |
| function completeTrainingEpoch() { |
| AppState.slam.currentEpoch++; |
| |
| AppState.dataset.trainingEpochs.push({ |
| epoch: AppState.slam.currentEpoch, |
| timestamp: AppState.currentTime, |
| obstaclesDetected: AppState.dataset.statistics.obstaclesDetected, |
| avoidanceManeuvers: AppState.dataset.statistics.avoidanceManeuvers, |
| trainingProgress: AppState.dataset.statistics.trainingProgress |
| }); |
| |
| logMessage(`Training Epoch ${AppState.slam.currentEpoch - 1} completed!`, "success"); |
| logMessage(`${AppState.dataset.statistics.obstaclesDetected} obstacles detected`, "training"); |
| logMessage(`${AppState.dataset.statistics.avoidanceManeuvers} avoidance maneuvers`, "training"); |
| |
| |
| Scene3D.obstacles.forEach(obstacle => { |
| obstacle.userData.detected = false; |
| }); |
| AppState.dataset.statistics.obstaclesDetected = 0; |
| } |
| |
| function updateDronePosition(altitude, accelX, accelY, accelZ) { |
| if (!Scene3D.drone) return; |
| |
| Scene3D.drone.position.y = altitude; |
| Scene3D.drone.position.x += accelX * 0.01; |
| Scene3D.drone.position.z += accelZ * 0.01; |
| |
| Scene3D.drone.rotation.x += accelY * 0.01; |
| Scene3D.drone.rotation.z += accelX * 0.005; |
| |
| |
| if (Scene3D.drone.propellers) { |
| Scene3D.drone.propellers.forEach(propeller => { |
| propeller.rotation.y += 0.5; |
| }); |
| } |
| } |
| |
| function flashDrone() { |
| if (!Scene3D.drone) return; |
| |
| const originalColor = 0x00ff00; |
| Scene3D.drone.children.forEach(child => { |
| if (child.material && child.material.color) { |
| child.material.color.setHex(0xff0000); |
| child.material.emissive.setHex(0xff0000); |
| } |
| }); |
| |
| setTimeout(() => { |
| if (Scene3D.drone) { |
| Scene3D.drone.children.forEach(child => { |
| if (child.material && child.material.color) { |
| child.material.color.setHex(originalColor); |
| child.material.emissive.setHex(0x004400); |
| } |
| }); |
| } |
| }, 200); |
| } |
| |
| |
| |
| |
| |
| function updateTelemetryDisplay(time, alt, vel, bat, accelX) { |
| document.getElementById('telemetryTime').textContent = formatTime(time); |
| document.getElementById('telemetryAlt').textContent = alt.toFixed(1) + 'm'; |
| document.getElementById('telemetryVel').textContent = vel.toFixed(1) + 'm/s'; |
| document.getElementById('telemetryBat').textContent = bat.toFixed(0) + '%'; |
| } |
| |
| function updateStatistics() { |
| document.getElementById('statPoints').textContent = |
| AppState.dataset.statistics.totalPoints.toLocaleString(); |
| document.getElementById('statObstacles').textContent = |
| Scene3D.obstacles.length; |
| |
| |
| const progress = AppState.dataset.statistics.trainingProgress; |
| document.getElementById('trainingProgress').style.width = `${progress * 100}%`; |
| } |
| |
| function updateTrainingProgress() { |
| |
| const progress = AppState.dataset.statistics.trainingProgress; |
| |
| } |
| |
| function updateObstacleCount() { |
| document.getElementById('statObstacles').textContent = Scene3D.obstacles.length; |
| } |
| |
| function formatTime(seconds) { |
| const hrs = Math.floor(seconds / 3600); |
| const mins = Math.floor((seconds % 3600) / 60); |
| const secs = Math.floor(seconds % 60); |
| return `${hrs.toString().padStart(2, '0')}:${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`; |
| } |
| |
| function logMessage(message, type = "info") { |
| const terminal = document.getElementById('terminal'); |
| const line = document.createElement('div'); |
| line.className = 'terminal-line'; |
| |
| const time = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' }); |
| line.innerHTML = `<span class="terminal-time">[${time}]</span> |
| <span class="terminal-content ${type}">${message}</span>`; |
| |
| terminal.appendChild(line); |
| terminal.scrollTop = terminal.scrollHeight; |
| } |
| |
| |
| |
| |
| |
| function showExportModal() { |
| if (AppState.dataset.statistics.totalPoints === 0) { |
| logMessage("No training data to export", "error"); |
| return; |
| } |
| |
| document.getElementById('exportModal').classList.add('active'); |
| } |
| |
| function hideExportModal() { |
| document.getElementById('exportModal').classList.remove('active'); |
| document.getElementById('exportProgressFill').style.width = "0%"; |
| document.getElementById('exportStatus').textContent = "Ready to export..."; |
| } |
| |
| async function exportDataset() { |
| const options = { |
| telemetry: document.getElementById('exportTelemetry').checked, |
| slam: document.getElementById('exportSLAM').checked, |
| graphs: document.getElementById('exportGraphs').checked, |
| metadata: document.getElementById('exportMetadata').checked, |
| trainingStats: document.getElementById('exportTrainingStats').checked |
| }; |
| |
| if (!Object.values(options).some(v => v)) { |
| logMessage("No export options selected", "error"); |
| return; |
| } |
| |
| const zip = new JSZip(); |
| const progressBar = document.getElementById('exportProgressFill'); |
| const statusText = document.getElementById('exportStatus'); |
| |
| let progress = 0; |
| const totalSteps = Object.values(options).filter(v => v).length; |
| let currentStep = 0; |
| |
| function updateProgress(message) { |
| currentStep++; |
| progress = (currentStep / totalSteps) * 100; |
| progressBar.style.width = `${progress}%`; |
| statusText.textContent = message; |
| } |
| |
| try { |
| |
| if (options.telemetry) { |
| updateProgress("Exporting telemetry data..."); |
| |
| |
| let jsonlContent = ""; |
| let csvContent = "timestamp,acceleration_x,acceleration_y,acceleration_z,gyroscope_x,gyroscope_y,gyroscope_z,altitude,velocity,battery,temperature,gps_lat,gps_lon,signal_strength\n"; |
| |
| AppState.dataset.telemetry.forEach((point, index) => { |
| |
| const telemetryRecord = { |
| id: index, |
| timestamp: point.timestamp || 0.0, |
| acceleration_x: point.acceleration?.x || 0.0, |
| acceleration_y: point.acceleration?.y || 0.0, |
| acceleration_z: point.acceleration?.z || 0.0, |
| gyroscope_x: point.gyroscope?.x || 0.0, |
| gyroscope_y: point.gyroscope?.y || 0.0, |
| gyroscope_z: point.gyroscope?.z || 0.0, |
| altitude: point.altitude || 0.0, |
| velocity: point.velocity || 0.0, |
| battery: point.battery || 0.0, |
| temperature: point.temperature || 0.0, |
| gps_lat: point.gps?.lat || 0.0, |
| gps_lon: point.gps?.lon || 0.0, |
| signal_strength: point.signalStrength || 0.0 |
| }; |
| jsonlContent += JSON.stringify(telemetryRecord) + "\n"; |
| |
| |
| csvContent += `${point.timestamp || 0},${point.acceleration?.x || 0},${point.acceleration?.y || 0},${point.acceleration?.z || 0},${point.gyroscope?.x || 0},${point.gyroscope?.y || 0},${point.gyroscope?.z || 0},${point.altitude || 0},${point.velocity || 0},${point.battery || 0},${point.temperature || 0},${point.gps?.lat || 0},${point.gps?.lon || 0},${point.signalStrength || 0}\n`; |
| }); |
| |
| zip.file("telemetry/telemetry.jsonl", jsonlContent); |
| zip.file("telemetry/telemetry.csv", csvContent); |
| zip.file("telemetry/telemetry_schema.json", JSON.stringify({ |
| timestamp: "float64", |
| acceleration_x: "float64", |
| acceleration_y: "float64", |
| acceleration_z: "float64", |
| gyroscope_x: "float64", |
| gyroscope_y: "float64", |
| gyroscope_z: "float64", |
| altitude: "float64", |
| velocity: "float64", |
| battery: "float64", |
| temperature: "float64", |
| gps_lat: "float64", |
| gps_lon: "float64", |
| signal_strength: "float64" |
| }, null, 2)); |
| |
| await new Promise(r => setTimeout(r, 300)); |
| } |
| |
| |
| if (options.slam) { |
| updateProgress("Exporting SLAM training data..."); |
| |
| |
| const slamDir = zip.folder("slam"); |
| |
| |
| const obstaclesArray = AppState.slam.obstacles.map(obs => ({ |
| obstacle_id: obs.id || 0, |
| position_x: obs.position?.x || 0.0, |
| position_y: obs.position?.y || 0.0, |
| position_z: obs.position?.z || 0.0, |
| type: obs.type || 'unknown', |
| training_weight: obs.trainingWeight || 1.0, |
| dataset_id: "wave_bender_slam_obstacles" |
| })); |
| |
| slamDir.file("obstacles.json", JSON.stringify(obstaclesArray, null, 2)); |
| |
| |
| const detections = AppState.dataset.slamData.filter(d => d.type === 'detection'); |
| const detectionsArray = detections.map(det => ({ |
| detection_id: det.obstacleId || 0, |
| timestamp: det.timestamp || 0.0, |
| obstacle_id: det.obstacleId || 0, |
| distance: det.distance || 0.0, |
| position_x: det.position?.x || 0.0, |
| position_y: det.position?.y || 0.0, |
| position_z: det.position?.z || 0.0, |
| training_weight: det.trainingWeight || 1.0, |
| dataset_id: "wave_bender_slam_detections" |
| })); |
| |
| slamDir.file("detections.json", JSON.stringify(detectionsArray, null, 2)); |
| |
| |
| const avoidances = AppState.dataset.slamData.filter(d => d.type === 'avoidance'); |
| const avoidancesArray = avoidances.map(av => ({ |
| avoidance_id: av.obstacleId || 0, |
| timestamp: av.timestamp || 0.0, |
| obstacle_id: av.obstacleId || 0, |
| distance: av.distance || 0.0, |
| maneuver: av.maneuver || 'evasive', |
| success: av.success !== undefined ? av.success : true, |
| avoidance_count: av.avoidanceCount || 0, |
| dataset_id: "wave_bender_slam_avoidances" |
| })); |
| |
| slamDir.file("avoidances.json", JSON.stringify(avoidancesArray, null, 2)); |
| |
| |
| const trainingParams = { |
| complexity: AppState.params.complexity || 0, |
| noise: AppState.params.noise || 0.0, |
| frequency: AppState.params.frequency || 0.0, |
| sample_rate: AppState.params.sampleRate || 0, |
| center_region_training: AppState.slam.centerRegion || false, |
| dynamic_obstacles: AppState.slam.dynamicMovement || false, |
| avoidance_training: AppState.slam.avoidanceTraining || false, |
| dataset_id: "wave_bender_training_params" |
| }; |
| |
| slamDir.file("training_params.json", JSON.stringify(trainingParams, null, 2)); |
| |
| await new Promise(r => setTimeout(r, 300)); |
| } |
| |
| |
| if (options.trainingStats) { |
| updateProgress("Exporting training statistics..."); |
| |
| |
| const statsDir = zip.folder("statistics"); |
| |
| |
| let epochsArray = AppState.dataset.trainingEpochs.map(epoch => ({ |
| epoch_number: epoch.epoch || 0, |
| timestamp: epoch.timestamp || 0.0, |
| obstacles_detected: epoch.obstaclesDetected || 0, |
| avoidance_maneuvers: epoch.avoidanceManeuvers || 0, |
| training_progress: epoch.trainingProgress || 0.0, |
| dataset_id: "wave_bender_training_epochs" |
| })); |
| |
| |
| if (epochsArray.length === 0) { |
| epochsArray = [{ |
| epoch_number: 0, |
| timestamp: 0.0, |
| obstacles_detected: 0, |
| avoidance_maneuvers: 0, |
| training_progress: 0.0, |
| dataset_id: "wave_bender_training_epochs" |
| }]; |
| } |
| |
| statsDir.file("epochs.json", JSON.stringify(epochsArray, null, 2)); |
| |
| |
| const statisticsData = [{ |
| total_points: AppState.dataset.statistics.totalPoints || 0, |
| obstacles_detected: AppState.dataset.statistics.obstaclesDetected || 0, |
| avoidance_maneuvers: AppState.dataset.statistics.avoidanceManeuvers || 0, |
| training_progress: AppState.dataset.statistics.trainingProgress || 0.0, |
| total_obstacles: Scene3D.obstacles.length || 0, |
| total_detections: AppState.dataset.slamData.filter(d => d.type === 'detection').length || 0, |
| total_avoidances: AppState.dataset.slamData.filter(d => d.type === 'avoidance').length || 0, |
| current_epoch: AppState.slam.currentEpoch || 1, |
| generation_time: AppState.currentTime || 0.0, |
| dataset_id: "wave_bender_statistics_summary" |
| }]; |
| |
| statsDir.file("summary.json", JSON.stringify(statisticsData, null, 2)); |
| |
| await new Promise(r => setTimeout(r, 300)); |
| } |
| |
| |
| if (options.graphs) { |
| updateProgress("Exporting graph data..."); |
| |
| const graphsDir = zip.folder("graphs"); |
| |
| const graphData = { |
| acceleration: AppState.graphs.acceleration, |
| altitude: AppState.graphs.altitude, |
| battery: AppState.graphs.battery, |
| velocity: AppState.graphs.velocity, |
| timestamps: AppState.graphs.acceleration.map((_, i) => i * 0.1), |
| dataset_id: "wave_bender_graph_data" |
| }; |
| |
| graphsDir.file("graph_data.json", JSON.stringify(graphData, null, 2)); |
| await new Promise(r => setTimeout(r, 300)); |
| } |
| |
| |
| if (options.metadata) { |
| updateProgress("Creating Hugging Face dataset configuration..."); |
| |
| const metaDir = zip.folder("metadata"); |
| |
| |
| const datasetCard = { |
| language: ["en"], |
| license: "mit", |
| annotations_creators: ["machine-generated"], |
| task_categories: ["autonomous-driving", "robot-navigation"], |
| task_ids: ["obstacle-avoidance", "slam", "drone-telemetry"], |
| pretty_name: "WAVE BENDER Drone Telemetry & SLAM Dataset", |
| dataset_info: { |
| splits: { |
| telemetry: AppState.dataset.telemetry.length, |
| slam_obstacles: AppState.slam.obstacles.length, |
| slam_detections: AppState.dataset.slamData.filter(d => d.type === 'detection').length, |
| slam_avoidances: AppState.dataset.slamData.filter(d => d.type === 'avoidance').length, |
| training_epochs: AppState.dataset.trainingEpochs.length, |
| statistics: 1 |
| } |
| }, |
| size_categories: ["10K<n<100K"], |
| tags: [ |
| "drone", |
| "telemetry", |
| "slam", |
| "obstacle-avoidance", |
| "synthetic-data", |
| "machine-learning", |
| "autonomous-systems" |
| ], |
| dataset_id: "wave_bender_v5.0" |
| }; |
| |
| metaDir.file("dataset_card.json", JSON.stringify(datasetCard, null, 2)); |
| |
| |
| const readme = `# WAVE BENDER IDE - Training Dataset |
| |
| ## Dataset Overview |
| Generated by WAVE BENDER IDE v5.0 - Web-based Drone Telemetry & SLAM Training Dataset Generator |
| |
| **📊 Dataset Statistics:** |
| - **Total Telemetry Points**: ${AppState.dataset.statistics.totalPoints.toLocaleString()} |
| - **Training Duration**: ${AppState.currentTime.toFixed(1)} seconds |
| - **Sample Rate**: ${AppState.params.sampleRate} Hz |
| - **Training Epochs**: ${AppState.slam.currentEpoch - 1} |
| - **Obstacles Detected**: ${AppState.dataset.statistics.obstaclesDetected} |
| - **Avoidance Maneuvers**: ${AppState.dataset.statistics.avoidanceManeuvers} |
| - **Training Progress**: ${Math.round(AppState.dataset.statistics.trainingProgress * 100)}% |
| |
| ## 🚀 Loading the Dataset in Hugging Face |
| |
| ### CORRECT WAY - Load each dataset separately: |
| \`\`\`python |
| from datasets import Dataset, DatasetDict |
| import json |
| |
| # Load telemetry data (separate dataset) |
| telemetry_dataset = Dataset.from_json("telemetry/telemetry.jsonl") |
| |
| # Load SLAM data (separate datasets) |
| obstacles_dataset = Dataset.from_json("slam/obstacles.json") |
| detections_dataset = Dataset.from_json("slam/detections.json") |
| avoidances_dataset = Dataset.from_json("slam/avoidances.json") |
| |
| # Load training data (separate datasets) |
| epochs_dataset = Dataset.from_json("statistics/epochs.json") |
| stats_dataset = Dataset.from_json("statistics/summary.json") |
| |
| # Create DatasetDict with SEPARATE datasets (no schema conflicts!) |
| dataset_dict = DatasetDict({ |
| 'telemetry': telemetry_dataset, |
| 'slam_obstacles': obstacles_dataset, |
| 'slam_detections': detections_dataset, |
| 'slam_avoidances': avoidances_dataset, |
| 'training_epochs': epochs_dataset, |
| 'statistics': stats_dataset |
| }) |
| \`\`\` |
| |
| ## ✅ NO ARROWINVALID ERRORS - Why this works: |
| |
| 1. **Separate Files**: Each data type is in its own file with consistent schema |
| 2. **Separate Datasets**: Each file is loaded as a separate Dataset |
| 3. **No Schema Mixing**: Different schemas don't conflict because they're separate |
| 4. **Always Valid**: Empty arrays still have consistent schemas |
| |
| ## 📁 Directory Structure |
| \`\`\` |
| wave_bender_dataset.zip/ |
| ├── telemetry/ |
| │ ├── telemetry.jsonl # Telemetry data (JSON Lines) |
| │ ├── telemetry.csv # Telemetry data (CSV) |
| │ └── telemetry_schema.json |
| ├── slam/ |
| │ ├── obstacles.json # Obstacle definitions |
| │ ├── detections.json # Detection events |
| │ ├── avoidances.json # Avoidance maneuvers |
| │ └── training_params.json |
| ├── statistics/ |
| │ ├── epochs.json # Epoch progression |
| │ └── summary.json # Statistics summary |
| ├── graphs/ |
| │ └── graph_data.json |
| ├── metadata/ |
| │ ├── dataset_card.json |
| │ └── README.md |
| └── huggingface_loader.py |
| \`\`\` |
| |
| ## 🎯 Training Configuration |
| - **Complexity**: ${AppState.params.complexity}/10 |
| - **Noise Level**: ${AppState.params.noise}/5 |
| - **Frequency**: ${AppState.params.frequency} Hz |
| - **Center Region Training**: ${AppState.slam.centerRegion ? 'Yes' : 'No'} |
| - **Dynamic Obstacles**: ${AppState.slam.dynamicMovement ? 'Yes' : 'No'} |
| - **Avoidance Training**: ${AppState.slam.avoidanceTraining ? 'Yes' : 'No'} |
| |
| ## 🔧 Fixed ArrowInvalid Errors |
| This export structure completely eliminates ArrowInvalid errors by: |
| |
| 1. **Separating different schema types** into different directories |
| 2. **Never mixing schemas** in the same file |
| 3. **Always providing consistent schemas**, even for empty data |
| 4. **Using unique dataset_id fields** to prevent confusion |
| |
| ## 📝 Citation |
| \`\`\` |
| @dataset{wave_bender_dataset_2024, |
| title = {WAVE BENDER IDE v5.0 - Drone Telemetry & SLAM Training Dataset}, |
| author = {webXOS}, |
| year = {2024}, |
| url = {https://huggingface.co/datasets/webxos/wave_bender_dataset}, |
| note = {Synthetic dataset for drone autonomy training} |
| } |
| \`\`\` |
| |
| --- |
| **Generated**: ${new Date().toISOString()} |
| **WAVE BENDER IDE v5.0** | **Hugging Face Compatible** | **ArrowInvalid Fixed**`; |
| |
| metaDir.file("README.md", readme); |
| |
| |
| const loaderScript = `#!/usr/bin/env python3 |
| """ |
| Hugging Face Dataset Loader for WAVE BENDER IDE v5.0 |
| This script loads the dataset WITHOUT ArrowInvalid errors. |
| """ |
| |
| import json |
| from datasets import Dataset, DatasetDict |
| import os |
| |
| def load_wave_bender_dataset(dataset_path): |
| """ |
| Load WAVE BENDER dataset from extracted directory. |
| |
| Args: |
| dataset_path (str): Path to extracted dataset directory |
| |
| Returns: |
| DatasetDict: Dictionary of datasets |
| """ |
| |
| datasets = {} |
| |
| # Load telemetry data |
| telemetry_file = os.path.join(dataset_path, "telemetry", "telemetry.jsonl") |
| if os.path.exists(telemetry_file): |
| datasets['telemetry'] = Dataset.from_json(telemetry_file) |
| print(f"Loaded telemetry data: {len(datasets['telemetry'])} records") |
| |
| # Load SLAM data |
| slam_path = os.path.join(dataset_path, "slam") |
| |
| obstacles_file = os.path.join(slam_path, "obstacles.json") |
| if os.path.exists(obstacles_file): |
| datasets['slam_obstacles'] = Dataset.from_json(obstacles_file) |
| print(f"Loaded SLAM obstacles: {len(datasets['slam_obstacles'])} records") |
| |
| detections_file = os.path.join(slam_path, "detections.json") |
| if os.path.exists(detections_file): |
| datasets['slam_detections'] = Dataset.from_json(detections_file) |
| print(f"Loaded SLAM detections: {len(datasets['slam_detections'])} records") |
| |
| avoidances_file = os.path.join(slam_path, "avoidances.json") |
| if os.path.exists(avoidances_file): |
| datasets['slam_avoidances'] = Dataset.from_json(avoidances_file) |
| print(f"Loaded SLAM avoidances: {len(datasets['slam_avoidances'])} records") |
| |
| # Load training data |
| stats_path = os.path.join(dataset_path, "statistics") |
| |
| epochs_file = os.path.join(stats_path, "epochs.json") |
| if os.path.exists(epochs_file): |
| datasets['training_epochs'] = Dataset.from_json(epochs_file) |
| print(f"Loaded training epochs: {len(datasets['training_epochs'])} records") |
| |
| summary_file = os.path.join(stats_path, "summary.json") |
| if os.path.exists(summary_file): |
| datasets['statistics'] = Dataset.from_json(summary_file) |
| print("Loaded statistics summary") |
| |
| # Create DatasetDict |
| dataset_dict = DatasetDict(datasets) |
| |
| print(f"\\n✅ Dataset loaded successfully with {len(datasets)} components") |
| print("✅ No ArrowInvalid errors - all schemas are separate and consistent") |
| |
| return dataset_dict |
| |
| if __name__ == "__main__": |
| # Example usage |
| dataset = load_wave_bender_dataset("./extracted_dataset") |
| print(f"\\nDataset structure: {list(dataset.keys())}")`; |
| |
| zip.file("huggingface_loader.py", loaderScript); |
| |
| await new Promise(r => setTimeout(r, 300)); |
| } |
| |
| |
| updateProgress("Creating final package..."); |
| const content = await zip.generateAsync({ type: "blob" }); |
| |
| |
| const timestamp = new Date().toISOString().replace(/[:.]/g, '-'); |
| saveAs(content, `wave_bender_hf_fixed_v5_${timestamp}.zip`); |
| |
| updateProgress("Export complete!"); |
| logMessage(`Dataset exported successfully (${formatFileSize(content.size)})`, "success"); |
| logMessage("✅ ARROWINVALID ERRORS FIXED - Separate schemas prevent conflicts", "success"); |
| logMessage("✅ Each data type in separate directory", "dataset"); |
| logMessage("✅ Ready for Hugging Face Datasets", "success"); |
| |
| setTimeout(() => { |
| hideExportModal(); |
| }, 2000); |
| |
| } catch (error) { |
| console.error("Export error:", error); |
| statusText.textContent = "Export failed!"; |
| logMessage(`Export failed: ${error.message}`, "error"); |
| } |
| } |
| |
| function formatFileSize(bytes) { |
| if (bytes === 0) return '0 B'; |
| const k = 1024; |
| const sizes = ['B', 'KB', 'MB', 'GB']; |
| const i = Math.floor(Math.log(bytes) / Math.log(k)); |
| return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i]; |
| } |
| |
| |
| |
| |
| |
| function initEventListeners() { |
| |
| document.getElementById('complexitySlider').addEventListener('input', function() { |
| AppState.params.complexity = parseInt(this.value); |
| document.getElementById('complexityValue').textContent = this.value; |
| }); |
| |
| document.getElementById('noiseSlider').addEventListener('input', function() { |
| AppState.params.noise = parseFloat(this.value); |
| document.getElementById('noiseValue').textContent = this.value; |
| }); |
| |
| document.getElementById('frequencySlider').addEventListener('input', function() { |
| AppState.params.frequency = parseFloat(this.value); |
| document.getElementById('frequencyValue').textContent = this.value; |
| }); |
| |
| document.getElementById('sampleRateSlider').addEventListener('input', function() { |
| AppState.params.sampleRate = parseInt(this.value); |
| document.getElementById('sampleRateValue').textContent = this.value; |
| }); |
| |
| |
| document.getElementById('centerObstaclesToggle').addEventListener('change', function() { |
| AppState.slam.centerRegion = this.checked; |
| Scene3D.centerGrid.visible = this.checked; |
| }); |
| |
| document.getElementById('dynamicObstaclesToggle').addEventListener('change', function() { |
| AppState.slam.dynamicMovement = this.checked; |
| }); |
| |
| document.getElementById('avoidanceTrainingToggle').addEventListener('change', function() { |
| AppState.slam.avoidanceTraining = this.checked; |
| }); |
| |
| |
| document.getElementById('startBtn').addEventListener('click', startTraining); |
| document.getElementById('stopBtn').addEventListener('click', stopTraining); |
| document.getElementById('exportBtn').addEventListener('click', showExportModal); |
| document.getElementById('resetBtn').addEventListener('click', resetSystem); |
| document.getElementById('fullscreenBtn').addEventListener('click', toggleFullscreen); |
| document.getElementById('cameraResetBtn').addEventListener('click', resetCamera); |
| document.getElementById('gridToggleBtn').addEventListener('click', toggleGrid); |
| document.getElementById('addObstacleBtn').addEventListener('click', addObstacle); |
| document.getElementById('resetObstaclesBtn').addEventListener('click', createTrainingObstacles); |
| document.getElementById('autoPilotBtn').addEventListener('click', toggleAutoPilot); |
| document.getElementById('trainingModeBtn').addEventListener('click', toggleTrainingMode); |
| document.getElementById('clearGraphBtn').addEventListener('click', clearGraph); |
| document.getElementById('pauseGraphBtn').addEventListener('click', toggleGraphPause); |
| |
| |
| document.getElementById('exportCancel').addEventListener('click', hideExportModal); |
| document.getElementById('exportConfirm').addEventListener('click', exportDataset); |
| |
| |
| window.addEventListener('resize', onWindowResize); |
| |
| |
| document.addEventListener('keydown', handleKeyboardShortcuts); |
| } |
| |
| function addObstacle() { |
| const newId = Scene3D.obstacles.length; |
| createObstacle(newId); |
| updateObstacleCount(); |
| logMessage(`Added obstacle #${newId + 1} to training environment`, "training"); |
| } |
| |
| function resetSystem() { |
| stopTraining(); |
| if (AppState.isAutoPilot) toggleAutoPilot(); |
| |
| |
| AppState.dataset = { |
| telemetry: [], |
| slamData: [], |
| trainingEpochs: [], |
| statistics: { |
| totalPoints: 0, |
| obstaclesDetected: 0, |
| avoidanceManeuvers: 0, |
| trainingProgress: 0 |
| } |
| }; |
| |
| AppState.currentTime = 0; |
| AppState.slam.currentEpoch = 1; |
| |
| |
| if (Scene3D.drone) { |
| Scene3D.drone.position.set(0, 10, 0); |
| Scene3D.drone.rotation.set(0, 0, 0); |
| } |
| |
| |
| AppState.graphs.acceleration = []; |
| AppState.graphs.altitude = []; |
| AppState.graphs.battery = []; |
| AppState.graphs.velocity = []; |
| drawEmptyGraph(); |
| |
| |
| updateTelemetryDisplay(0, 10, 0, 100, 0); |
| updateStatistics(); |
| document.getElementById('statAvoidances').textContent = '0'; |
| |
| logMessage("System reset", "system"); |
| logMessage("Ready for new training session", "training"); |
| } |
| |
| function toggleFullscreen() { |
| if (!document.fullscreenElement) { |
| document.documentElement.requestFullscreen(); |
| } else { |
| document.exitFullscreen(); |
| } |
| } |
| |
| function resetCamera() { |
| if (Scene3D.camera) { |
| Scene3D.camera.position.set(40, 30, 50); |
| Scene3D.camera.lookAt(0, 0, 0); |
| } |
| } |
| |
| function toggleGrid() { |
| if (Scene3D.centerGrid) { |
| Scene3D.centerGrid.visible = !Scene3D.centerGrid.visible; |
| } |
| } |
| |
| function toggleAutoPilot() { |
| AppState.isAutoPilot = !AppState.isAutoPilot; |
| const btn = document.getElementById('autoPilotBtn'); |
| |
| if (AppState.isAutoPilot) { |
| btn.classList.add('active'); |
| btn.textContent = 'MANUAL CONTROL'; |
| logMessage("Auto-pilot mode activated", "success"); |
| |
| autoPilotInterval = setInterval(() => { |
| if (Scene3D.drone) { |
| const time = AppState.currentTime; |
| const radius = 12; |
| const speed = 0.08; |
| |
| const targetX = Math.cos(time * speed) * radius; |
| const targetZ = Math.sin(time * speed) * radius; |
| |
| Scene3D.drone.position.x += (targetX - Scene3D.drone.position.x) * 0.05; |
| Scene3D.drone.position.z += (targetZ - Scene3D.drone.position.z) * 0.05; |
| } |
| }, 50); |
| } else { |
| btn.classList.remove('active'); |
| btn.textContent = 'AUTO PILOT'; |
| logMessage("Auto-pilot mode deactivated", "warning"); |
| |
| if (autoPilotInterval) { |
| clearInterval(autoPilotInterval); |
| autoPilotInterval = null; |
| } |
| } |
| } |
| |
| function toggleTrainingMode() { |
| const btn = document.getElementById('trainingModeBtn'); |
| const isActive = btn.classList.contains('active'); |
| |
| if (isActive) { |
| btn.classList.remove('active'); |
| btn.textContent = 'TRAINING MODE'; |
| AppState.slam.avoidanceTraining = false; |
| logMessage("Training mode deactivated", "warning"); |
| } else { |
| btn.classList.add('active'); |
| btn.textContent = 'TRAINING ACTIVE'; |
| AppState.slam.avoidanceTraining = true; |
| logMessage("Training mode activated", "success"); |
| } |
| } |
| |
| function clearGraph() { |
| AppState.graphs.acceleration = []; |
| AppState.graphs.altitude = []; |
| AppState.graphs.battery = []; |
| AppState.graphs.velocity = []; |
| drawEmptyGraph(); |
| logMessage("Graphs cleared", "info"); |
| } |
| |
| function toggleGraphPause() { |
| AppState.graphs.isPaused = !AppState.graphs.isPaused; |
| const btn = document.getElementById('pauseGraphBtn'); |
| btn.textContent = AppState.graphs.isPaused ? 'RESUME' : 'PAUSE'; |
| logMessage(`Graph ${AppState.graphs.isPaused ? 'paused' : 'resumed'}`, "info"); |
| } |
| |
| function onWindowResize() { |
| if (Scene3D.renderer && Scene3D.camera) { |
| const canvas = document.getElementById('renderCanvas'); |
| Scene3D.camera.aspect = canvas.clientWidth / canvas.clientHeight; |
| Scene3D.camera.updateProjectionMatrix(); |
| Scene3D.renderer.setSize(canvas.clientWidth, canvas.clientHeight); |
| } |
| |
| |
| const graphCanvas = document.getElementById('graphCanvas'); |
| graphWidth = graphCanvas.width = graphCanvas.clientWidth; |
| graphHeight = graphCanvas.height = graphCanvas.clientHeight; |
| |
| if (AppState.isTraining) { |
| updateGraph(); |
| } else { |
| drawEmptyGraph(); |
| } |
| } |
| |
| function handleKeyboardShortcuts(e) { |
| |
| if (e.code === 'Space') { |
| e.preventDefault(); |
| if (AppState.isTraining) { |
| stopTraining(); |
| } else { |
| startTraining(); |
| } |
| } |
| |
| |
| if (e.code === 'Escape' && document.fullscreenElement) { |
| document.exitFullscreen(); |
| } |
| |
| |
| if (e.code === 'KeyR' && e.ctrlKey) { |
| e.preventDefault(); |
| resetSystem(); |
| } |
| |
| |
| if (e.code === 'KeyE' && e.ctrlKey) { |
| e.preventDefault(); |
| showExportModal(); |
| } |
| } |
| |
| |
| |
| |
| |
| function animate(currentTime) { |
| animationFrameId = requestAnimationFrame(animate); |
| |
| |
| AppState.frameCount++; |
| if (currentTime - AppState.lastFpsUpdate >= 1000) { |
| AppState.fps = Math.round((AppState.frameCount * 1000) / (currentTime - AppState.lastFpsUpdate)); |
| AppState.frameCount = 0; |
| AppState.lastFpsUpdate = currentTime; |
| document.getElementById('statusFPS').textContent = `FPS: ${AppState.fps}`; |
| } |
| |
| |
| if (Scene3D.renderer && Scene3D.scene && Scene3D.camera) { |
| Scene3D.renderer.render(Scene3D.scene, Scene3D.camera); |
| } |
| } |
| |
| |
| |
| |
| |
| window.addEventListener('load', init); |
| |
| </script> |
| </body> |
| </html> |
|
|
